tuktuk-rails 0.0.6 → 0.0.7

data/vendor/bundle/ruby/2.0.0/gems/rspec-core-2.14.7/spec/rspec/core/filter_manager_spec.rb

@@ -0,0 +1,246 @@
+require 'spec_helper'
+
+module RSpec::Core
+  describe FilterManager do
+    def opposite(name)
+      name =~ /^in/ ? name.sub(/^(in)/,'ex') : name.sub(/^(ex)/,'in')
+    end
+
+    %w[include inclusions exclude exclusions].each_slice(2) do |name, type|
+      describe "##{name}" do
+        it "merges #{type}" do
+          filter_manager = FilterManager.new
+          filter_manager.exclusions.clear # defaults
+          filter_manager.send name, :foo => :bar
+          filter_manager.send name, :baz => :bam
+          expect(filter_manager.send(type)).to eq(:foo => :bar, :baz => :bam)
+        end
+
+        it "overrides previous #{type} with (via merge)" do
+          filter_manager = FilterManager.new
+          filter_manager.exclusions.clear # defaults
+          filter_manager.send name, :foo => 1
+          filter_manager.send name, :foo => 2
+          expect(filter_manager.send(type)).to eq(:foo => 2)
+        end
+
+        it "deletes matching opposites" do
+          filter_manager = FilterManager.new
+          filter_manager.exclusions.clear # defaults
+          filter_manager.send opposite(name), :foo => 1
+          filter_manager.send name, :foo => 2
+          expect(filter_manager.send(type)).to eq(:foo => 2)
+          expect(filter_manager.send(opposite(type))).to be_empty
+        end
+
+        if name == "include"
+          [:locations, :line_numbers, :full_description].each do |filter|
+            context "with :#{filter}" do
+              it "clears previous inclusions" do
+                filter_manager = FilterManager.new
+                filter_manager.include :foo => :bar
+                filter_manager.include filter => "value"
+                expect(filter_manager.inclusions).to eq({filter => "value"})
+              end
+
+              it "does nothing when :#{filter} previously set" do
+                filter_manager = FilterManager.new
+                filter_manager.include filter => "a_value"
+                filter_manager.include :foo => :bar
+                expect(filter_manager.inclusions).to eq(filter => "a_value")
+              end
+            end
+          end
+        end
+      end
+
+      describe "##{name}!" do
+        it "replaces existing #{type}" do
+          filter_manager = FilterManager.new
+          filter_manager.exclusions.clear # defaults
+          filter_manager.send name, :foo => 1, :bar => 2
+          filter_manager.send "#{name}!", :foo => 3
+          expect(filter_manager.send(type)).to eq(:foo => 3)
+        end
+
+        it "deletes matching opposites" do
+          filter_manager = FilterManager.new
+          filter_manager.exclusions.clear # defaults
+          filter_manager.send opposite(name), :foo => 1
+          filter_manager.send "#{name}!", :foo => 2
+          expect(filter_manager.send(type)).to eq(:foo => 2)
+          expect(filter_manager.send(opposite(type))).to be_empty
+        end
+      end
+
+      describe "##{name}_with_low_priority" do
+        it "ignores new #{type} if same key exists" do
+          filter_manager = FilterManager.new
+          filter_manager.exclusions.clear # defaults
+          filter_manager.send name, :foo => 1
+          filter_manager.send "#{name}_with_low_priority", :foo => 2
+          expect(filter_manager.send(type)).to eq(:foo => 1)
+        end
+
+        it "ignores new #{type} if same key exists in opposite" do
+          filter_manager = FilterManager.new
+          filter_manager.exclusions.clear # defaults
+          filter_manager.send opposite(name), :foo => 1
+          filter_manager.send "#{name}_with_low_priority", :foo => 1
+          expect(filter_manager.send(type)).to be_empty
+          expect(filter_manager.send(opposite(type))).to eq(:foo => 1)
+        end
+
+        it "keeps new #{type} if same key exists in opposite but values are different" do
+          filter_manager = FilterManager.new
+          filter_manager.exclusions.clear # defaults
+          filter_manager.send opposite(name), :foo => 1
+          filter_manager.send "#{name}_with_low_priority", :foo => 2
+          expect(filter_manager.send(type)).to eq(:foo => 2)
+          expect(filter_manager.send(opposite(type))).to eq(:foo => 1)
+        end
+      end
+    end
+
+    describe "#prune" do
+      def filterable_object_with(args = {})
+        object = double('a filterable object')
+        object.stub(:any_apply?) { |f| Metadata.new(args).any_apply?(f) }
+        object
+      end
+
+      it "includes objects with tags matching inclusions" do
+        included = filterable_object_with({:foo => :bar})
+        excluded = filterable_object_with
+        filter_manager = FilterManager.new
+        filter_manager.include :foo => :bar
+        expect(filter_manager.prune([included, excluded])).to eq([included])
+      end
+
+      it "excludes objects with tags matching exclusions" do
+        included = filterable_object_with
+        excluded = filterable_object_with({:foo => :bar})
+        filter_manager = FilterManager.new
+        filter_manager.exclude :foo => :bar
+        expect(filter_manager.prune([included, excluded])).to eq([included])
+      end
+
+      it "prefers exclusion when matches previously set inclusion" do
+        included = filterable_object_with
+        excluded = filterable_object_with({:foo => :bar})
+        filter_manager = FilterManager.new
+        filter_manager.include :foo => :bar
+        filter_manager.exclude :foo => :bar
+        expect(filter_manager.prune([included, excluded])).to eq([included])
+      end
+
+      it "prefers inclusion when matches previously set exclusion" do
+        included = filterable_object_with({:foo => :bar})
+        excluded = filterable_object_with
+        filter_manager = FilterManager.new
+        filter_manager.exclude :foo => :bar
+        filter_manager.include :foo => :bar
+        expect(filter_manager.prune([included, excluded])).to eq([included])
+      end
+
+      it "prefers previously set inclusion when exclusion matches but has lower priority" do
+        included = filterable_object_with({:foo => :bar})
+        excluded = filterable_object_with
+        filter_manager = FilterManager.new
+        filter_manager.include :foo => :bar
+        filter_manager.exclude_with_low_priority :foo => :bar
+        expect(filter_manager.prune([included, excluded])).to eq([included])
+      end
+
+      it "prefers previously set exclusion when inclusion matches but has lower priority" do
+        included = filterable_object_with
+        excluded = filterable_object_with({:foo => :bar})
+        filter_manager = FilterManager.new
+        filter_manager.exclude :foo => :bar
+        filter_manager.include_with_low_priority :foo => :bar
+        expect(filter_manager.prune([included, excluded])).to eq([included])
+      end
+    end
+
+    describe "#inclusions#description" do
+      it 'cleans up the description' do
+        project_dir = File.expand_path('.')
+        expect(lambda { }.inspect).to include(project_dir)
+        expect(lambda { }.inspect).to include(' (lambda)') if RUBY_VERSION > '1.9'
+        expect(lambda { }.inspect).to include('0x')
+
+        filter_manager = FilterManager.new
+        filter_manager.include :foo => lambda { }
+
+        expect(filter_manager.inclusions.description).not_to include(project_dir)
+        expect(filter_manager.inclusions.description).not_to include(' (lambda)')
+        expect(filter_manager.inclusions.description).not_to include('0x')
+      end
+    end
+
+    describe "#exclusions#description" do
+      it 'cleans up the description' do
+        project_dir = File.expand_path('.')
+        expect(lambda { }.inspect).to include(project_dir)
+        expect(lambda { }.inspect).to include(' (lambda)') if RUBY_VERSION > '1.9'
+        expect(lambda { }.inspect).to include('0x')
+
+        filter_manager = FilterManager.new
+        filter_manager.exclude :foo => lambda { }
+
+        expect(filter_manager.exclusions.description).not_to include(project_dir)
+        expect(filter_manager.exclusions.description).not_to include(' (lambda)')
+        expect(filter_manager.exclusions.description).not_to include('0x')
+      end
+
+      it 'returns `{}` when it only contains the default filters' do
+        filter_manager = FilterManager.new
+        expect(filter_manager.exclusions.description).to eq({}.inspect)
+      end
+
+      it 'includes other filters' do
+        filter_manager = FilterManager.new
+        filter_manager.exclude :foo => :bar
+        expect(filter_manager.exclusions.description).to eq({ :foo => :bar }.inspect)
+      end
+
+      it 'deprecates an overridden :if filter' do
+        expect(RSpec).to receive(:deprecate).with(/exclude\(:if/)
+        filter_manager = FilterManager.new
+        filter_manager.exclude :if => :custom_filter
+      end
+
+      it 'deprecates an :if filter overridden with low priority' do
+        expect(RSpec).to receive(:deprecate).with(/exclude\(:if/)
+        filter_manager = FilterManager.new
+        filter_manager.exclude_with_low_priority :if => :custom_filter
+      end
+
+      it 'deprecates an overridden :unless filter' do
+        expect(RSpec).to receive(:deprecate).with(/exclude\(:unless/)
+        filter_manager = FilterManager.new
+        filter_manager.exclude :unless => :custom_filter
+      end
+
+      it 'deprecates an :unless filter overridden with low priority' do
+        expect(RSpec).to receive(:deprecate).with(/exclude\(:unless/)
+        filter_manager = FilterManager.new
+        filter_manager.exclude_with_low_priority :unless => :custom_filter
+      end
+
+      it 'includes an overriden :if filter' do
+        allow(RSpec).to receive(:deprecate)
+        filter_manager = FilterManager.new
+        filter_manager.exclude :if => :custom_filter
+        expect(filter_manager.exclusions.description).to eq({ :if => :custom_filter }.inspect)
+      end
+
+      it 'includes an overriden :unless filter' do
+        allow(RSpec).to receive(:deprecate)
+        filter_manager = FilterManager.new
+        filter_manager.exclude :unless => :custom_filter
+        expect(filter_manager.exclusions.description).to eq({ :unless => :custom_filter }.inspect)
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.0.0/gems/rspec-core-2.14.7/spec/rspec/core/formatters/base_formatter_spec.rb

@@ -0,0 +1,108 @@
+require 'spec_helper'
+require 'rspec/core/formatters/base_formatter'
+
+describe RSpec::Core::Formatters::BaseFormatter do
+
+  let(:output)    { StringIO.new }
+  let(:formatter) { RSpec::Core::Formatters::BaseFormatter.new(output) }
+
+  describe "backtrace_line" do
+    it "trims current working directory" do
+      expect(formatter.__send__(:backtrace_line, File.expand_path(__FILE__))).to eq("./spec/rspec/core/formatters/base_formatter_spec.rb")
+    end
+
+    it "leaves the original line intact" do
+      original_line = File.expand_path(__FILE__)
+      formatter.__send__(:backtrace_line, original_line)
+      expect(original_line).to eq(File.expand_path(__FILE__))
+    end
+
+    it "deals gracefully with a security error" do
+      safely do
+        formatter.__send__(:backtrace_line, __FILE__)
+        # on some rubies, this doesn't raise a SecurityError; this test just
+        # assures that if it *does* raise an error, the error is caught inside
+      end
+    end
+  end
+
+  describe "read_failed_line" do
+    it "deals gracefully with a heterogeneous language stack trace" do
+      exception = double(:Exception, :backtrace => [
+        "at Object.prototypeMethod (foo:331:18)",
+        "at Array.forEach (native)",
+        "at a_named_javascript_function (/some/javascript/file.js:39:5)",
+        "/some/line/of/ruby.rb:14"
+      ])
+      example = double(:Example, :file_path => __FILE__)
+      expect {
+        formatter.send(:read_failed_line, exception, example)
+      }.not_to raise_error
+    end
+
+    it "deals gracefully with a security error" do
+      exception = double(:Exception, :backtrace => [ "#{__FILE__}:#{__LINE__}"])
+      example = double(:Example, :file_path => __FILE__)
+      safely do
+        expect {
+          formatter.send(:read_failed_line, exception, example)
+        }.not_to raise_error
+      end
+    end
+
+    context "when ruby reports a bogus line number in the stack trace" do
+      it "reports the filename and that it was unable to find the matching line" do
+        exception = double(:Exception, :backtrace => [ "#{__FILE__}:10000000" ])
+        example = double(:Example, :file_path => __FILE__)
+
+        msg = formatter.send(:read_failed_line, exception, example)
+        expect(msg).to include("Unable to find matching line")
+      end
+    end
+
+    context "when String alias to_int to_i" do
+      before do
+        String.class_eval do
+          alias :to_int :to_i
+        end
+      end
+
+      after do
+        String.class_eval do
+          undef to_int
+        end
+      end
+
+      it "doesn't hang when file exists" do
+        pending("This issue still exists on JRuby, but should be resolved shortly: https://github.com/rspec/rspec-core/issues/295", :if => RUBY_PLATFORM == 'java')
+        exception = double(:Exception, :backtrace => [ "#{__FILE__}:#{__LINE__}"])
+
+        example = double(:Example, :file_path => __FILE__)
+        expect(formatter.send(:read_failed_line, exception, example)).to eql(
+          %Q{        exception = double(:Exception, :backtrace => [ "\#{__FILE__}:\#{__LINE__}"])\n})
+      end
+
+    end
+  end
+
+  describe "#format_backtrace" do
+    let(:rspec_expectations_dir) { "/path/to/rspec-expectations/lib" }
+    let(:rspec_core_dir) { "/path/to/rspec-core/lib" }
+    let(:backtrace) do
+      [
+        "#{rspec_expectations_dir}/rspec/matchers/operator_matcher.rb:51:in `eval_match'",
+        "#{rspec_expectations_dir}/rspec/matchers/operator_matcher.rb:29:in `=='",
+        "./my_spec.rb:5",
+        "#{rspec_core_dir}/rspec/core/example.rb:52:in `run'",
+        "#{rspec_core_dir}/rspec/core/runner.rb:37:in `run'",
+        RSpec::Core::Runner::AT_EXIT_HOOK_BACKTRACE_LINE,
+        "./my_spec.rb:3"
+      ]
+    end
+
+    it "removes lines from rspec and lines that come before the invocation of the at_exit autorun hook" do
+      expect(formatter.format_backtrace(backtrace, double.as_null_object)).to eq(["./my_spec.rb:5"])
+    end
+  end
+
+end

data/vendor/bundle/ruby/2.0.0/gems/rspec-core-2.14.7/spec/rspec/core/formatters/base_text_formatter_spec.rb

@@ -0,0 +1,494 @@
+require 'spec_helper'
+require 'rspec/core/formatters/base_text_formatter'
+
+describe RSpec::Core::Formatters::BaseTextFormatter do
+  let(:output) { StringIO.new }
+  let(:formatter) { RSpec::Core::Formatters::BaseTextFormatter.new(output) }
+
+  describe "#summary_line" do
+    it "with 0s outputs pluralized (excluding pending)" do
+      expect(formatter.summary_line(0,0,0)).to eq("0 examples, 0 failures")
+    end
+
+    it "with 1s outputs singular (including pending)" do
+      expect(formatter.summary_line(1,1,1)).to eq("1 example, 1 failure, 1 pending")
+    end
+
+    it "with 2s outputs pluralized (including pending)" do
+      expect(formatter.summary_line(2,2,2)).to eq("2 examples, 2 failures, 2 pending")
+    end
+  end
+
+  describe "#dump_commands_to_rerun_failed_examples" do
+    it "includes command to re-run each failed example" do
+      group = RSpec::Core::ExampleGroup.describe("example group") do
+        it("fails") { fail }
+      end
+      line = __LINE__ - 2
+      group.run(formatter)
+      formatter.dump_commands_to_rerun_failed_examples
+      expect(output.string).to include("rspec #{RSpec::Core::Metadata::relative_path("#{__FILE__}:#{line}")} # example group fails")
+    end
+  end
+
+  describe "#dump_failures" do
+    let(:group) { RSpec::Core::ExampleGroup.describe("group name") }
+
+    before { RSpec.configuration.stub(:color_enabled?) { false } }
+
+    def run_all_and_dump_failures
+      group.run(formatter)
+      formatter.dump_failures
+    end
+
+    it "preserves formatting" do
+      group.example("example name") { expect("this").to eq("that") }
+
+      run_all_and_dump_failures
+
+      expect(output.string).to match(/group name example name/m)
+      expect(output.string).to match(/(\s+)expected: \"that\"\n\1     got: \"this\"/m)
+    end
+
+    context "with an exception without a message" do
+      it "does not throw NoMethodError" do
+        exception_without_message = Exception.new()
+        exception_without_message.stub(:message) { nil }
+        group.example("example name") { raise exception_without_message }
+        expect { run_all_and_dump_failures }.not_to raise_error
+      end
+
+      it "preserves ancestry" do
+        example = group.example("example name") { raise "something" }
+        run_all_and_dump_failures
+        expect(example.example_group.parent_groups.size).to eq 1
+      end
+    end
+
+    context "with an exception that has an exception instance as its message" do
+      it "does not raise NoMethodError" do
+        gonzo_exception = RuntimeError.new
+        gonzo_exception.stub(:message) { gonzo_exception }
+        group.example("example name") { raise gonzo_exception }
+        expect { run_all_and_dump_failures }.not_to raise_error
+      end
+    end
+
+    context "with an instance of an anonymous exception class" do
+      it "substitutes '(anonymous error class)' for the missing class name" do
+        exception = Class.new(StandardError).new
+        group.example("example name") { raise exception }
+        run_all_and_dump_failures
+        expect(output.string).to include('(anonymous error class)')
+      end
+    end
+
+    context "with an exception class other than RSpec" do
+      it "does not show the error class" do
+        group.example("example name") { raise NameError.new('foo') }
+        run_all_and_dump_failures
+        expect(output.string).to match(/NameError/m)
+      end
+    end
+
+    context "with a failed expectation (rspec-expectations)" do
+      it "does not show the error class" do
+        group.example("example name") { expect("this").to eq("that") }
+        run_all_and_dump_failures
+        expect(output.string).not_to match(/RSpec/m)
+      end
+    end
+
+    context "with a failed message expectation (rspec-mocks)" do
+      it "does not show the error class" do
+        group.example("example name") { "this".should_receive("that") }
+        run_all_and_dump_failures
+        expect(output.string).not_to match(/RSpec/m)
+      end
+    end
+
+    context 'for #share_examples_for' do
+      it 'outputs the name and location' do
+
+        group.share_examples_for 'foo bar' do
+          it("example name") { expect("this").to eq("that") }
+        end
+
+        line = __LINE__.next
+        group.it_should_behave_like('foo bar')
+
+        run_all_and_dump_failures
+
+        expect(output.string).to include(
+          'Shared Example Group: "foo bar" called from ' +
+            "./spec/rspec/core/formatters/base_text_formatter_spec.rb:#{line}"
+        )
+      end
+
+      context 'that contains nested example groups' do
+        it 'outputs the name and location' do
+          group.share_examples_for 'foo bar' do
+            describe 'nested group' do
+              it("example name") { expect("this").to eq("that") }
+            end
+          end
+
+          line = __LINE__.next
+          group.it_should_behave_like('foo bar')
+
+          run_all_and_dump_failures
+
+          expect(output.string).to include(
+            'Shared Example Group: "foo bar" called from ' +
+              "./spec/rspec/core/formatters/base_text_formatter_spec.rb:#{line}"
+          )
+        end
+      end
+    end
+
+    context 'for #share_as' do
+      before { allow(RSpec).to receive(:deprecate) }
+
+      it 'outputs the name and location' do
+
+        group.share_as :FooBar do
+          it("example name") { expect("this").to eq("that") }
+        end
+
+        line = __LINE__.next
+        group.send(:include, FooBar)
+
+        run_all_and_dump_failures
+
+        expect(output.string).to include(
+          'Shared Example Group: "FooBar" called from ' +
+            "./spec/rspec/core/formatters/base_text_formatter_spec.rb:#{line}"
+        )
+      end
+
+      context 'that contains nested example groups' do
+        it 'outputs the name and location' do
+
+          group.share_as :NestedFoo do
+            describe 'nested group' do
+              describe 'hell' do
+                it("example name") { expect("this").to eq("that") }
+              end
+            end
+          end
+
+          line = __LINE__.next
+          group.send(:include, NestedFoo)
+
+          run_all_and_dump_failures
+
+          expect(output.string).to include(
+            'Shared Example Group: "NestedFoo" called from ' +
+              "./spec/rspec/core/formatters/base_text_formatter_spec.rb:#{line}"
+          )
+        end
+      end
+    end
+  end
+
+  describe "#dump_pending" do
+    let(:group) { RSpec::Core::ExampleGroup.describe("group name") }
+
+    before { RSpec.configuration.stub(:color_enabled?) { false } }
+
+    def run_all_and_dump_pending
+      group.run(formatter)
+      formatter.dump_pending
+    end
+
+    context "with show_failures_in_pending_blocks setting enabled" do
+      before { RSpec.configuration.stub(:show_failures_in_pending_blocks?) { true } }
+
+      it "preserves formatting" do
+        group.example("example name") { pending { expect("this").to eq("that") } }
+
+        run_all_and_dump_pending
+
+        expect(output.string).to match(/group name example name/m)
+        expect(output.string).to match(/(\s+)expected: \"that\"\n\1     got: \"this\"/m)
+      end
+
+      context "with an exception without a message" do
+        it "does not throw NoMethodError" do
+          exception_without_message = Exception.new()
+          exception_without_message.stub(:message) { nil }
+          group.example("example name") { pending { raise exception_without_message } }
+          expect { run_all_and_dump_pending }.not_to raise_error
+        end
+      end
+
+      context "with an exception class other than RSpec" do
+        it "does not show the error class" do
+          group.example("example name") { pending { raise NameError.new('foo') } }
+          run_all_and_dump_pending
+          expect(output.string).to match(/NameError/m)
+        end
+      end
+
+      context "with a failed expectation (rspec-expectations)" do
+        it "does not show the error class" do
+          group.example("example name") { pending { expect("this").to eq("that") } }
+          run_all_and_dump_pending
+          expect(output.string).not_to match(/RSpec/m)
+        end
+      end
+
+      context "with a failed message expectation (rspec-mocks)" do
+        it "does not show the error class" do
+          group.example("example name") { pending { "this".should_receive("that") } }
+          run_all_and_dump_pending
+          expect(output.string).not_to match(/RSpec/m)
+        end
+      end
+
+      context 'for #share_examples_for' do
+        it 'outputs the name and location' do
+
+          group.share_examples_for 'foo bar' do
+            it("example name") { pending { expect("this").to eq("that") } }
+          end
+
+          line = __LINE__.next
+          group.it_should_behave_like('foo bar')
+
+          run_all_and_dump_pending
+
+          expect(output.string).to include(
+            'Shared Example Group: "foo bar" called from ' +
+            "./spec/rspec/core/formatters/base_text_formatter_spec.rb:#{line}"
+          )
+        end
+
+        context 'that contains nested example groups' do
+          it 'outputs the name and location' do
+            group.share_examples_for 'foo bar' do
+              describe 'nested group' do
+                it("example name") { pending { expect("this").to eq("that") } }
+              end
+            end
+
+            line = __LINE__.next
+            group.it_should_behave_like('foo bar')
+
+            run_all_and_dump_pending
+
+            expect(output.string).to include(
+              'Shared Example Group: "foo bar" called from ' +
+              "./spec/rspec/core/formatters/base_text_formatter_spec.rb:#{line}"
+            )
+          end
+        end
+      end
+
+      context 'for #share_as' do
+        before { allow(RSpec).to receive(:deprecate) }
+
+        it 'outputs the name and location' do
+
+          group.share_as :FooBar2 do
+            it("example name") { pending { expect("this").to eq("that") } }
+          end
+
+          line = __LINE__.next
+          group.send(:include, FooBar2)
+
+          run_all_and_dump_pending
+
+          expect(output.string).to include(
+            'Shared Example Group: "FooBar2" called from ' +
+            "./spec/rspec/core/formatters/base_text_formatter_spec.rb:#{line}"
+          )
+        end
+
+        context 'that contains nested example groups' do
+          it 'outputs the name and location' do
+
+            group.share_as :NestedFoo2 do
+              describe 'nested group' do
+                describe 'hell' do
+                  it("example name") { pending { expect("this").to eq("that") } }
+                end
+              end
+            end
+
+            line = __LINE__.next
+            group.send(:include, NestedFoo2)
+
+            run_all_and_dump_pending
+
+            expect(output.string).to include(
+              'Shared Example Group: "NestedFoo2" called from ' +
+              "./spec/rspec/core/formatters/base_text_formatter_spec.rb:#{line}"
+            )
+          end
+        end
+      end
+    end
+
+    context "with show_failures_in_pending_blocks setting disabled" do
+      before { RSpec.configuration.stub(:show_failures_in_pending_blocks?) { false } }
+
+      it "does not output the failure information" do
+        group.example("example name") { pending { expect("this").to eq("that") } }
+        run_all_and_dump_pending
+        expect(output.string).not_to match(/(\s+)expected: \"that\"\n\1     got: \"this\"/m)
+      end
+    end
+  end
+
+  describe "#dump_profile_slowest_examples" do
+    example_line_number = nil
+
+    before do
+      group = RSpec::Core::ExampleGroup.describe("group") do
+        # Use a sleep so there is some measurable time, to ensure
+        # the reported percent is 100%, not 0%.
+        example("example") { sleep 0.001 }
+        example_line_number = __LINE__ - 1
+      end
+      group.run(double('reporter').as_null_object)
+
+      formatter.stub(:examples) { group.examples }
+      RSpec.configuration.stub(:profile_examples) { 10 }
+    end
+
+    it "names the example" do
+      formatter.dump_profile_slowest_examples
+      expect(output.string).to match(/group example/m)
+    end
+
+    it "prints the time" do
+      formatter.dump_profile_slowest_examples
+      expect(output.string).to match(/0(\.\d+)? seconds/)
+    end
+
+    it "prints the path" do
+      formatter.dump_profile_slowest_examples
+      filename = __FILE__.split(File::SEPARATOR).last
+
+      expect(output.string).to match(/#{filename}\:#{example_line_number}/)
+    end
+
+    it "prints the percentage taken from the total runtime" do
+      formatter.dump_profile_slowest_examples
+      expect(output.string).to match(/, 100.0% of total time\):/)
+    end
+  end
+
+  describe "#dump_profile_slowest_example_groups" do
+    let(:group) do 
+      RSpec::Core::ExampleGroup.describe("slow group") do
+        # Use a sleep so there is some measurable time, to ensure
+        # the reported percent is 100%, not 0%.
+        example("example") { sleep 0.01 }
+      end 
+    end
+    let(:rpt) { double('reporter').as_null_object }
+
+    before do
+      group.run(rpt)
+      RSpec.configuration.stub(:profile_examples) { 10 }
+    end
+
+    context "with one example group" do
+      before { formatter.stub(:examples) { group.examples } }
+
+      it "doesn't profile a single example group" do
+        formatter.dump_profile_slowest_example_groups
+        expect(output.string).not_to match(/slowest example groups/)
+      end
+    end
+
+    context "with multiple example groups" do
+      before do
+        group2 = RSpec::Core::ExampleGroup.describe("fast group") do
+          example("example 1") { sleep 0.004 }
+          example("example 2") { sleep 0.007 }
+        end
+        group2.run(rpt)
+
+        formatter.stub(:examples) { group.examples + group2.examples }
+      end
+
+      it "prints the slowest example groups" do
+        formatter.dump_profile_slowest_example_groups
+        expect(output.string).to match(/slowest example groups/)
+      end
+
+      it "prints the time" do
+        formatter.dump_profile_slowest_example_groups
+        expect(output.string).to match(/0(\.\d+)? seconds/)
+      end
+
+      it "ranks the example groups by average time" do
+        formatter.dump_profile_slowest_example_groups
+        expect(output.string).to match(/slow group(.*)fast group/m)
+      end
+    end
+
+    it "depends on parent_groups to get the top level example group" do
+      ex = ""
+      group.describe("group 2") do 
+        describe "group 3" do
+          ex = example("nested example 1") 
+        end
+      end
+
+      expect(ex.example_group.parent_groups.last).to eq(group)
+    end
+  end
+
+  describe "custom_colors" do
+    it "uses the custom success color" do
+      RSpec.configure do |config|
+        config.color_enabled = true
+        config.tty = true
+        config.success_color = :cyan
+      end
+      formatter.dump_summary(0,1,0,0)
+      expect(output.string).to include("\e[36m")
+    end
+  end
+
+  describe "#colorize" do
+    it "accepts a VT100 integer code and formats the text with it" do
+       expect(formatter.colorize('abc', 32)).to eq "\e[32mabc\e[0m"
+    end
+
+    it "accepts a symbol as a color parameter and translates it to the correct integer code, then formats the text with it" do
+       expect(formatter.colorize('abc', :green)).to eq "\e[32mabc\e[0m"
+    end
+
+    it "accepts a non-default color symbol as a parameter and translates it to the correct integer code, then formats the text with it" do
+       expect(formatter.colorize('abc', :cyan)).to eq "\e[36mabc\e[0m"
+    end
+  end
+
+  described_class::VT100_COLORS.each do |name, number|
+    next if name == :black
+
+    describe "##{name}" do
+      before do
+        allow(RSpec.configuration).to receive(:color_enabled?) { true }
+        allow(RSpec).to receive(:deprecate)
+      end
+
+      it "prints the text using the color code for #{name}" do
+        expect(formatter.send(name, "text")).to eq("\e[#{number}mtext\e[0m")
+      end
+
+      it "prints a deprecation warning" do
+        expect(RSpec).to receive(:deprecate) {|*args|
+          expect(args.first).to match(/#{name}/)
+        }
+        formatter.send(name, "text")
+      end
+    end
+  end
+
+end