rspec-mocks 3.0.0.beta2 → 3.0.0.rc1

data/spec/rspec/mocks/combining_implementation_instructions_spec.rb

@@ -1,204 +0,0 @@
-require 'spec_helper'
-
-module RSpec
-  module Mocks
-    describe "Combining implementation instructions" do
-      it 'can combine and_yield and and_return' do
-        dbl = double
-        dbl.stub(:foo).and_yield(5).and_return(3)
-
-        expect { |b|
-          expect(dbl.foo(&b)).to eq(3)
-        }.to yield_with_args(5)
-      end
-
-      describe "combining and_yield, a block implementation and and_return" do
-        def verify_combined_implementation
-          dbl = double
-          (yield dbl).and_yield(5).and_return(3)
-
-          expect { |b|
-            expect(dbl.foo(:arg, &b)).to eq(3)
-          }.to yield_with_args(5)
-
-          expect(@block_called).to be_truthy
-        end
-
-        it 'works when passing a block to `stub`' do
-          verify_combined_implementation do |dbl|
-            dbl.stub(:foo) { @block_called = true }
-          end
-        end
-
-        it 'works when passing a block to `with`' do
-          verify_combined_implementation do |dbl|
-            dbl.stub(:foo).with(:arg) { @block_called = true }
-          end
-        end
-
-        it 'works when passing a block to `exactly`' do
-          verify_combined_implementation do |dbl|
-            dbl.should_receive(:foo).exactly(:once) { @block_called = true }
-          end
-        end
-
-        it 'works when passing a block to `at_least`' do
-          verify_combined_implementation do |dbl|
-            dbl.should_receive(:foo).at_least(:once) { @block_called = true }
-          end
-        end
-
-        it 'works when passing a block to `at_most`' do
-          verify_combined_implementation do |dbl|
-            dbl.should_receive(:foo).at_most(:once) { @block_called = true }
-          end
-        end
-
-        it 'works when passing a block to `times`' do
-          verify_combined_implementation do |dbl|
-            dbl.should_receive(:foo).exactly(1).times { @block_called = true }
-          end
-        end
-
-        it 'works when passing a block to `once`' do
-          verify_combined_implementation do |dbl|
-            dbl.should_receive(:foo).once { @block_called = true }
-          end
-        end
-
-        it 'works when passing a block to `twice`' do
-          the_double = nil
-
-          verify_combined_implementation do |dbl|
-            the_double = dbl
-            dbl.should_receive(:foo).twice { @block_called = true }
-          end
-
-          the_double.foo { |a| } # to ensure it is called twice
-        end
-
-        it 'works when passing a block to `ordered`' do
-          verify_combined_implementation do |dbl|
-            dbl.should_receive(:foo).ordered { @block_called = true }
-          end
-        end
-      end
-
-      it 'can combine and_yield and and_raise' do
-        dbl = double
-        dbl.stub(:foo).and_yield(5).and_raise("boom")
-
-        expect { |b|
-          expect { dbl.foo(&b) }.to raise_error("boom")
-        }.to yield_with_args(5)
-      end
-
-      it 'can combine and_yield, a block implementation and and_raise' do
-        dbl = double
-        block_called = false
-        dbl.stub(:foo) { block_called = true }.and_yield(5).and_raise("boom")
-
-        expect { |b|
-          expect { dbl.foo(&b) }.to raise_error("boom")
-        }.to yield_with_args(5)
-
-        expect(block_called).to be_truthy
-      end
-
-      it 'can combine and_yield and and_throw' do
-        dbl = double
-        dbl.stub(:foo).and_yield(5).and_throw(:bar)
-
-        expect { |b|
-          expect { dbl.foo(&b) }.to throw_symbol(:bar)
-        }.to yield_with_args(5)
-      end
-
-      it 'can combine and_yield, a block implementation and and_throw' do
-        dbl = double
-        block_called = false
-        dbl.stub(:foo) { block_called = true }.and_yield(5).and_throw(:bar)
-
-        expect { |b|
-          expect { dbl.foo(&b) }.to throw_symbol(:bar)
-        }.to yield_with_args(5)
-
-        expect(block_called).to be_truthy
-      end
-
-      it 'returns `nil` from all terminal actions to discourage further configuration' do
-        expect(double.stub(:foo).and_return(1)).to be_nil
-        expect(double.stub(:foo).and_raise("boom")).to be_nil
-        expect(double.stub(:foo).and_throw(:foo)).to be_nil
-      end
-
-      it 'allows the terminal action to be overriden' do
-        dbl = double
-        stubbed_double = dbl.stub(:foo)
-
-        stubbed_double.and_return(1)
-        expect(dbl.foo).to eq(1)
-
-        stubbed_double.and_return(3)
-        expect(dbl.foo).to eq(3)
-
-        stubbed_double.and_raise("boom")
-        expect { dbl.foo }.to raise_error("boom")
-
-        stubbed_double.and_throw(:bar)
-        expect { dbl.foo }.to throw_symbol(:bar)
-      end
-
-      it 'allows the inner implementation block to be overriden' do
-        allow(RSpec).to receive(:warning)
-        dbl = double
-        stubbed_double = dbl.stub(:foo)
-
-        stubbed_double.with(:arg) { :with_block }
-        expect(dbl.foo(:arg)).to eq(:with_block)
-
-        stubbed_double.at_least(:once) { :at_least_block }
-        expect(dbl.foo(:arg)).to eq(:at_least_block)
-      end
-
-      it 'warns when the inner implementation block is overriden' do
-        expect(RSpec).to receive(:warning).with(/overriding a previous stub implementation of `foo`.*#{__FILE__}:#{__LINE__ + 1}/)
-        double.stub(:foo).with(:arg) { :with_block }.at_least(:once) { :at_least_block }
-      end
-
-      it "does not warn about overriding the stub when `:with` is chained off the block" do
-        expect(RSpec).not_to receive(:warning)
-
-        obj = Object.new
-        stub = obj.stub(:foo) { }
-        stub.with(1)
-      end
-
-      it 'can combine and_call_original, with, and_return' do
-        obj = Struct.new(:value).new('original')
-        obj.stub(:value).and_call_original
-        obj.stub(:value).with(:arg).and_return('value')
-        expect(obj.value).to eq 'original'
-        expect(obj.value(:arg)).to eq 'value'
-      end
-
-      it 'raises an error if `and_call_original` is followed by any other instructions' do
-        allow(RSpec).to receive(:warning)
-        dbl = [1, 2, 3]
-        stubbed = dbl.stub(:size)
-        stubbed.and_call_original
-
-        msg_fragment = /cannot be modified further/
-
-        expect { stubbed.and_yield }.to raise_error(msg_fragment)
-        expect { stubbed.and_return(1) }.to raise_error(msg_fragment)
-        expect { stubbed.and_raise("a") }.to raise_error(msg_fragment)
-        expect { stubbed.and_throw(:bar) }.to raise_error(msg_fragment)
-
-        expect { stubbed.once { } }.to raise_error(msg_fragment)
-
-        expect(dbl.size).to eq(3)
-      end
-    end
-  end
-end

data/spec/rspec/mocks/configuration_spec.rb

@@ -1,242 +0,0 @@
-require 'spec_helper'
-
-module RSpec
-  module Mocks
-    describe Configuration do
-      let(:config) { Configuration.new }
-      let(:mod_1)  { Module.new }
-      let(:mod_2)  { Module.new }
-
-      def instance_methods_of(mod)
-        mod_1.instance_methods.map(&:to_sym)
-      end
-
-      it 'adds stub and should_receive to the given modules' do
-        expect(instance_methods_of(mod_1)).not_to include(:stub, :should_receive)
-        expect(instance_methods_of(mod_2)).not_to include(:stub, :should_receive)
-
-        config.add_stub_and_should_receive_to(mod_1, mod_2)
-
-        expect(instance_methods_of(mod_1)).to include(:stub, :should_receive)
-        expect(instance_methods_of(mod_2)).to include(:stub, :should_receive)
-      end
-
-      shared_examples_for "configuring the syntax" do
-        def sandboxed
-          orig_syntax = RSpec::Mocks.configuration.syntax
-          yield
-        ensure
-          configure_syntax(orig_syntax)
-        end
-
-        around(:each) { |ex| sandboxed(&ex) }
-        let(:dbl) { double }
-        let(:should_methods)       { [:should_receive, :stub, :should_not_receive] }
-        let(:should_class_methods) { [:any_instance] }
-        let(:expect_methods)      { [:receive, :allow, :expect_any_instance_of, :allow_any_instance_of] }
-
-        it 'defaults to enabling both the :should and :expect syntaxes' do
-          expect(dbl).to respond_to(*should_methods)
-          expect(self).to respond_to(*expect_methods)
-        end
-
-        context 'when configured to :expect' do
-          before { configure_syntax :expect }
-
-          it 'removes the should methods from every object' do
-            expect(dbl).not_to respond_to(*should_methods)
-          end
-
-          it 'removes `any_instance` from every class' do
-            expect(Class.new).not_to respond_to(*should_class_methods)
-          end
-
-          it 'adds the expect methods to the example group context' do
-            expect(self).to respond_to(*expect_methods)
-          end
-
-          it 'reports that the syntax is :expect' do
-            expect(configured_syntax).to eq([:expect])
-          end
-
-          it 'is a no-op when configured a second time' do
-            expect(Syntax.default_should_syntax_host).not_to receive(:method_undefined)
-            expect(::RSpec::Mocks::ExampleMethods).not_to receive(:method_added)
-            configure_syntax :expect
-          end
-        end
-
-        context 'when configured to :should' do
-          before { configure_syntax :should }
-
-          it 'adds the should methods to every object' do
-            expect(dbl).to respond_to(*should_methods)
-          end
-
-          it 'adds `any_instance` to every class' do
-            expect(Class.new).to respond_to(*should_class_methods)
-          end
-
-          it 'removes the expect methods from the example group context' do
-            expect(self).not_to respond_to(*expect_methods)
-          end
-
-          it 'reports that the syntax is :should' do
-            expect(configured_syntax).to eq([:should])
-          end
-
-          it "does not warn about the should syntax" do
-            RSpec.should_not_receive(:deprecate)
-            Object.new.should_not_receive(:bees)
-          end
-
-          it 'is a no-op when configured a second time' do
-            Syntax.default_should_syntax_host.should_not_receive(:method_added)
-            ::RSpec::Mocks::ExampleMethods.should_not_receive(:method_undefined)
-            configure_syntax :should
-          end
-        end
-
-        context 'when configured to [:should, :expect]' do
-          before { configure_syntax [:should, :expect] }
-
-          it 'adds the should methods to every object' do
-            expect(dbl).to respond_to(*should_methods)
-          end
-
-          it 'adds `any_instance` to every class' do
-            expect(Class.new).to respond_to(*should_class_methods)
-          end
-
-          it 'adds the expect methods to the example group context' do
-            expect(self).to respond_to(*expect_methods)
-          end
-
-          it 'reports that both syntaxes are enabled' do
-            expect(configured_syntax).to eq([:should, :expect])
-          end
-
-          it "does not warn about the should syntax" do
-            RSpec.should_not_receive(:deprecate)
-            Object.new.should_not_receive(:bees)
-          end
-        end
-
-        context "by default" do
-          before do
-            configure_default_syntax
-          end
-
-          let(:expected_arguments) {
-            [
-              /Using.*without explicitly enabling/,
-              {:replacement=>"the new `:expect` syntax or explicitly enable `:should`"}
-            ]
-          }
-
-          it "it warns about should once, regardless of how many times it is called" do
-            expect(RSpec).to receive(:deprecate).with(*expected_arguments)
-            o = Object.new
-            o2 = Object.new
-            o.should_receive(:bees)
-            o2.should_receive(:bees)
-
-            o.bees
-            o2.bees
-          end
-
-          it "warns about should not once, regardless of how many times it is called" do
-            expect(RSpec).to receive(:deprecate).with(*expected_arguments)
-            o = Object.new
-            o2 = Object.new
-            o.should_not_receive(:bees)
-            o2.should_not_receive(:bees)
-          end
-
-          it "warns about stubbing once, regardless of how many times it is called" do
-            expect(RSpec).to receive(:deprecate).with(*expected_arguments)
-            o = Object.new
-            o2 = Object.new
-
-            o.stub(:faces)
-            o2.stub(:faces)
-          end
-
-          it "warns about unstubbing once, regardless of how many times it is called" do
-            expect(RSpec).to receive(:deprecate).with(/Using.*without explicitly enabling/,
-              {:replacement => "`allow(...).to_receive(...).and_call_original` or explicitly enable `:should`"})
-            o = Object.new
-            o2 = Object.new
-
-            allow(o).to receive(:faces)
-            allow(o2).to receive(:faces)
-
-            o.unstub(:faces)
-            o2.unstub(:faces)
-          end
-
-
-          it "doesn't warn about stubbing after a reset and setting should" do
-            expect(RSpec).not_to receive(:deprecate)
-            RSpec::Mocks.configuration.reset_syntaxes_to_default
-            RSpec::Mocks.configuration.syntax = :should
-            o = Object.new
-            o2 = Object.new
-            o.stub(:faces)
-            o2.stub(:faces)
-          end
-
-          it "includes the call site in the deprecation warning" do
-            obj = Object.new
-            expect_deprecation_with_call_site(__FILE__, __LINE__ + 1)
-            obj.stub(:faces)
-          end
-        end
-      end
-
-      describe "configuring rspec-mocks directly" do
-        it_behaves_like "configuring the syntax" do
-          def configure_syntax(syntax)
-            RSpec::Mocks.configuration.syntax = syntax
-          end
-
-          def configured_syntax
-            RSpec::Mocks.configuration.syntax
-          end
-
-          def configure_default_syntax
-            RSpec::Mocks.configuration.reset_syntaxes_to_default
-          end
-        end
-      end
-
-      describe "configuring using the rspec-core config API" do
-        it_behaves_like "configuring the syntax" do
-          def configure_syntax(syntax)
-            RSpec.configure do |rspec|
-              rspec.mock_with :rspec do |c|
-                c.syntax = syntax
-              end
-            end
-          end
-
-          def configured_syntax
-            RSpec.configure do |rspec|
-              rspec.mock_with :rspec do |c|
-                return c.syntax
-              end
-            end
-          end
-
-          def configure_default_syntax
-            RSpec.configure do |rspec|
-              rspec.mock_with :rspec do |c|
-                c.reset_syntaxes_to_default
-              end
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/spec/rspec/mocks/double_spec.rb

@@ -1,874 +0,0 @@
-require 'spec_helper'
-
-module RSpec
-  module Mocks
-    describe Double do
-      before(:each) { @double = double("test double") }
-      after(:each)  { reset @double }
-
-      it "has method_missing as private" do
-        expect(RSpec::Mocks::Double.private_instance_methods).to include_method(:method_missing)
-      end
-
-      it "does not respond_to? method_missing (because it's private)" do
-        expect(RSpec::Mocks::Double.new).not_to respond_to(:method_missing)
-      end
-
-      it "uses 'Double' in failure messages" do
-        double = double('name')
-        expect { double.foo }.to raise_error(/Double "name" received/)
-      end
-
-      it "hides internals in its inspect representation" do
-        m = double('cup')
-        expect(m.inspect).to match(/#<RSpec::Mocks::Double:0x[a-f0-9.]+ @name="cup">/)
-      end
-
-      it 'does not blow up when resetting standard object methods' do
-        dbl = double(:tainted? => true)
-        expect(dbl.tainted?).to eq(true)
-        expect { reset dbl }.not_to raise_error
-      end
-
-      it 'does not get string vs symbol messages confused' do
-        dbl = double("foo" => 1)
-        allow(dbl).to receive(:foo).and_return(2)
-        expect(dbl.foo).to eq(2)
-        expect { reset dbl }.not_to raise_error
-      end
-
-      it 'allows string representation of methods in constructor' do
-        dbl = double('foo' => 1)
-        expect(dbl.foo).to eq(1)
-      end
-
-      it 'allows setter methods to be stubbed' do
-        dbl = double('foo=' => 1)
-
-        # Note the specified return value is thrown away. This is a Ruby semantics
-        # thing. You cannot change the return value of assignment.
-        expect(dbl.foo = "bar").to eq("bar")
-      end
-
-      it 'allows `send` to be stubbed' do
-        dbl = double
-        allow(dbl).to receive(:send).and_return("received")
-        expect(dbl.send(:some_msg)).to eq("received")
-      end
-
-      context "after it has been torn down" do
-        let(:dbl) { double }
-
-        before do
-          expect(dbl).to receive(:foo).at_least(:once)
-          allow(dbl).to receive(:bar)
-          dbl.foo
-
-          RSpec::Mocks.verify
-          RSpec::Mocks.teardown
-          RSpec::Mocks.setup
-        end
-
-        it 'disallows previously mocked methods' do
-          expect { dbl.foo }.to raise_error(ExpiredTestDoubleError)
-        end
-
-        it 'disallows previously stubbed methods' do
-          expect { dbl.bar }.to raise_error(ExpiredTestDoubleError)
-        end
-
-        it 'disallows stubbing new methods (with receive)' do
-          expect {
-            allow(dbl).to receive(:bazz)
-          }.to raise_error(ExpiredTestDoubleError)
-        end
-
-        it 'disallows stubbing new methods (with receive_messages)' do
-          expect {
-            allow(dbl).to receive_messages(:bazz => 3)
-          }.to raise_error(ExpiredTestDoubleError)
-        end
-
-        it 'disallows stubbing new message chains' do
-          expect {
-            allow(dbl).to receive_message_chain(:bazz, :bam, :goo)
-          }.to raise_error(ExpiredTestDoubleError)
-        end
-
-        it 'disallows mocking new methods' do
-          expect {
-            expect(dbl).to receive(:bazz)
-          }.to raise_error(ExpiredTestDoubleError)
-        end
-
-        it 'disallows being turned into a null object' do
-          expect { dbl.as_null_object }.to raise_error(ExpiredTestDoubleError)
-        end
-
-        it 'disallows being checked for nullness' do
-          expect { dbl.null_object? }.to raise_error(ExpiredTestDoubleError)
-        end
-      end
-
-      it "reports line number of expectation of unreceived message" do
-        expected_error_line = __LINE__; @double.should_receive(:wont_happen).with("x", 3)
-        begin
-          verify @double
-          violated
-        rescue RSpec::Mocks::MockExpectationError => e
-          # NOTE - this regexp ended w/ $, but jruby adds extra info at the end of the line
-          expect(e.backtrace[0]).to match(/#{File.basename(__FILE__)}:#{expected_error_line}/)
-        end
-      end
-
-      it "reports line number of expectation of unreceived message after #should_receive after similar stub" do
-        @double.stub(:wont_happen)
-        expected_error_line = __LINE__; @double.should_receive(:wont_happen).with("x", 3)
-        begin
-          verify @double
-          violated
-        rescue RSpec::Mocks::MockExpectationError => e
-          # NOTE - this regexp ended w/ $, but jruby adds extra info at the end of the line
-          expect(e.backtrace[0]).to match(/#{File.basename(__FILE__)}:#{expected_error_line}/)
-        end
-      end
-
-      it "passes when not receiving message specified as not to be received" do
-        @double.should_not_receive(:not_expected)
-        verify @double
-      end
-
-      it "prevents confusing double-negative expressions involving `never`" do
-        expect {
-          @double.should_not_receive(:not_expected).never
-        }.to raise_error(/trying to negate it again/)
-      end
-
-      it "warns when `and_return` is called on a negative expectation" do
-        expect {
-          @double.should_not_receive(:do_something).and_return(1)
-        }.to raise_error(/not supported/)
-
-        expect {
-          expect(@double).not_to receive(:do_something).and_return(1)
-        }.to raise_error(/not supported/)
-
-        expect {
-          expect(@double).to receive(:do_something).never.and_return(1)
-        }.to raise_error(/not supported/)
-      end
-
-      it "passes when receiving message specified as not to be received with different args" do
-        @double.should_not_receive(:message).with("unwanted text")
-        @double.should_receive(:message).with("other text")
-        @double.message "other text"
-        verify @double
-      end
-
-      it "fails when receiving message specified as not to be received" do
-        @double.should_not_receive(:not_expected)
-        expect {
-          @double.not_expected
-          violated
-        }.to raise_error(
-          RSpec::Mocks::MockExpectationError,
-          %Q|(Double "test double").not_expected(no args)\n    expected: 0 times with any arguments\n    received: 1 time|
-        )
-      end
-
-      it "fails when receiving message specified as not to be received with args" do
-        @double.should_not_receive(:not_expected).with("unexpected text")
-        expect {
-          @double.not_expected("unexpected text")
-          violated
-        }.to raise_error(
-          RSpec::Mocks::MockExpectationError,
-          %Q|(Double "test double").not_expected("unexpected text")\n    expected: 0 times with arguments: ("unexpected text")\n    received: 1 time with arguments: ("unexpected text")|
-        )
-      end
-
-      it "fails when array arguments do not match" do
-        @double.should_not_receive(:not_expected).with(["do not want"])
-        expect {
-          @double.not_expected(["do not want"])
-          violated
-        }.to raise_error(
-          RSpec::Mocks::MockExpectationError,
-          %Q|(Double "test double").not_expected(["do not want"])\n    expected: 0 times with arguments: (["do not want"])\n    received: 1 time with arguments: (["do not want"])|
-        )
-      end
-
-      context "when specifying a message should not be received with specific args" do
-        context "using `should_not_receive`" do
-          it 'passes when receiving the message with different args' do
-            @double.should_not_receive(:not_expected).with("unexpected text")
-            @double.not_expected "really unexpected text"
-            verify @double
-          end
-        end
-
-        context "using `should_receive().never`" do
-          it 'passes when receiving the message with different args' do
-            @double.should_receive(:not_expected).with("unexpected text").never
-            @double.not_expected "really unexpected text"
-            verify @double
-          end
-        end
-      end
-
-      it 'does not get confused when `should_not_received` is used with a string and symbol message' do
-        @double.stub(:foo) { 3 }
-        @double.should_not_receive(:foo).with(1)
-        @double.should_not_receive("foo").with(2)
-
-        expect(@double.foo).to eq(3)
-        verify @double
-      end
-
-      it 'does not get confused when `should_received` is used with a string and symbol message' do
-        @double.should_receive(:foo).with(1)
-        @double.should_receive("foo").with(2)
-
-        @double.foo(1)
-        @double.foo(2)
-
-        verify @double
-      end
-
-      it "allows parameter as return value" do
-        @double.should_receive(:something).with("a","b","c").and_return("booh")
-        expect(@double.something("a","b","c")).to eq "booh"
-        verify @double
-      end
-
-      it "returns the previously stubbed value if no return value is set" do
-        @double.stub(:something).with("a","b","c").and_return(:stubbed_value)
-        @double.should_receive(:something).with("a","b","c")
-        expect(@double.something("a","b","c")).to eq :stubbed_value
-        verify @double
-      end
-
-      it "returns nil if no return value is set and there is no previously stubbed value" do
-        @double.should_receive(:something).with("a","b","c")
-        expect(@double.something("a","b","c")).to be_nil
-        verify @double
-      end
-
-      it "raises exception if args don't match when method called" do
-        @double.should_receive(:something).with("a","b","c").and_return("booh")
-        expect {
-          @double.something("a","d","c")
-          violated
-        }.to raise_error(RSpec::Mocks::MockExpectationError, "Double \"test double\" received :something with unexpected arguments\n  expected: (\"a\", \"b\", \"c\")\n       got: (\"a\", \"d\", \"c\")")
-      end
-
-      describe "even when a similar expectation with different arguments exist" do
-        it "raises exception if args don't match when method called, correctly reporting the offending arguments" do
-          @double.should_receive(:something).with("a","b","c").once
-          @double.should_receive(:something).with("z","x","c").once
-          expect {
-            @double.something("a","b","c")
-            @double.something("z","x","g")
-          }.to raise_error(RSpec::Mocks::MockExpectationError, "Double \"test double\" received :something with unexpected arguments\n  expected: (\"z\", \"x\", \"c\")\n       got: (\"z\", \"x\", \"g\")")
-        end
-      end
-
-      it "raises exception if args don't match when method called even when the method is stubbed" do
-        @double.stub(:something)
-        @double.should_receive(:something).with("a","b","c")
-        expect {
-          @double.something("a","d","c")
-          verify @double
-        }.to raise_error(RSpec::Mocks::MockExpectationError, "Double \"test double\" received :something with unexpected arguments\n  expected: (\"a\", \"b\", \"c\")\n       got: (\"a\", \"d\", \"c\")")
-      end
-
-      it "raises exception if args don't match when method called even when using null_object" do
-        @double = double("test double").as_null_object
-        @double.should_receive(:something).with("a","b","c")
-        expect {
-          @double.something("a","d","c")
-          verify @double
-        }.to raise_error(RSpec::Mocks::MockExpectationError, "Double \"test double\" received :something with unexpected arguments\n  expected: (\"a\", \"b\", \"c\")\n       got: (\"a\", \"d\", \"c\")")
-      end
-
-      describe 'with a method that has a default argument' do
-        it "raises an exception if the arguments don't match when the method is called, correctly reporting the offending arguments" do
-          def @double.method_with_default_argument(arg={}); end
-          @double.should_receive(:method_with_default_argument).with({})
-
-          expect {
-            @double.method_with_default_argument(nil)
-            verify @double
-          }.to raise_error(RSpec::Mocks::MockExpectationError, "Double \"test double\" received :method_with_default_argument with unexpected arguments\n  expected: ({})\n       got: (nil)")
-        end
-      end
-
-      it "fails if unexpected method called" do
-        expect {
-          @double.something("a","b","c")
-          violated
-        }.to raise_error(RSpec::Mocks::MockExpectationError, "Double \"test double\" received unexpected message :something with (\"a\", \"b\", \"c\")")
-      end
-
-      it "uses block for expectation if provided" do
-        @double.should_receive(:something) do | a, b |
-          expect(a).to eq "a"
-          expect(b).to eq "b"
-          "booh"
-        end
-        expect(@double.something("a", "b")).to eq "booh"
-        verify @double
-      end
-
-      it "fails if expectation block fails" do
-        @double.should_receive(:something) do |bool|
-          expect(bool).to be_truthy
-        end
-
-        expect {
-          @double.something false
-        }.to raise_error(RSpec::Expectations::ExpectationNotMetError)
-      end
-
-      it "is wrappable in an array" do
-        with_isolated_stderr do
-          expect( Array(@double) ).to eq([@double])
-        end
-      end
-
-      it "is wrappable in an array when a null object" do
-        with_isolated_stderr do
-          expect( Array(@double.as_null_object) ).to eq [@double]
-        end
-      end
-
-      it "responds to to_ary as a null object" do
-        expect(@double.as_null_object.to_ary).to eq nil
-      end
-
-      it "responds to to_a as a null object" do
-        if RUBY_VERSION.to_f > 1.8
-          expect(@double.as_null_object.to_a).to eq nil
-        else
-          with_isolated_stderr do
-            expect(@double.as_null_object.to_a).to eq [@double]
-          end
-        end
-      end
-
-      it "passes proc to expectation block without an argument" do
-        @double.should_receive(:foo) { |&block| expect(block.call).to eq(:bar) }
-        @double.foo { :bar }
-      end
-
-      it "passes proc to expectation block with an argument" do
-        @double.should_receive(:foo) { |arg, &block| expect(block.call).to eq(:bar) }
-        @double.foo(:arg) { :bar }
-      end
-
-      it "passes proc to stub block without an argurment" do
-        @double.stub(:foo) { |&block| expect(block.call).to eq(:bar) }
-        @double.foo { :bar }
-      end
-
-      it "passes proc to stub block with an argument" do
-        @double.stub(:foo) { |arg, &block| expect(block.call).to eq(:bar) }
-        @double.foo(:arg) { :bar }
-      end
-
-      it "fails right away when method defined as never is received" do
-        @double.should_receive(:not_expected).never
-        expect { @double.not_expected }.
-          to raise_error(RSpec::Mocks::MockExpectationError,
-                         %Q|(Double "test double").not_expected(no args)\n    expected: 0 times with any arguments\n    received: 1 time|
-        )
-      end
-
-      it "raises RuntimeError by default" do
-        @double.should_receive(:something).and_raise
-        expect { @double.something }.to raise_error(RuntimeError)
-      end
-
-      it "raises RuntimeError with a message by default" do
-        @double.should_receive(:something).and_raise("error message")
-        expect { @double.something }.to raise_error(RuntimeError, "error message")
-      end
-
-      it "raises an exception of a given type without an error message" do
-        @double.should_receive(:something).and_raise(StandardError)
-        expect { @double.something }.to raise_error(StandardError)
-      end
-
-      it "raises an exception of a given type with a message" do
-        @double.should_receive(:something).and_raise(RuntimeError, "error message")
-        expect { @double.something }.to raise_error(RuntimeError, "error message")
-      end
-
-      it "raises a given instance of an exception" do
-        @double.should_receive(:something).and_raise(RuntimeError.new("error message"))
-        expect { @double.something }.to raise_error(RuntimeError, "error message")
-      end
-
-      class OutOfGas < StandardError
-        attr_reader :amount, :units
-        def initialize(amount, units)
-          @amount = amount
-          @units  = units
-        end
-      end
-
-      it "raises a given instance of an exception with arguments other than the standard 'message'" do
-        @double.should_receive(:something).and_raise(OutOfGas.new(2, :oz))
-
-        begin
-          @double.something
-          fail "OutOfGas was not raised"
-        rescue OutOfGas => e
-          expect(e.amount).to eq 2
-          expect(e.units).to eq :oz
-        end
-      end
-
-      it "does not raise when told to if args dont match" do
-        @double.should_receive(:something).with(2).and_raise(RuntimeError)
-        expect {
-          @double.something 1
-        }.to raise_error(RSpec::Mocks::MockExpectationError)
-      end
-
-      it "throws when told to" do
-        @double.should_receive(:something).and_throw(:blech)
-        expect {
-          @double.something
-        }.to throw_symbol(:blech)
-      end
-
-      it "ignores args on any args" do
-        @double.should_receive(:something).at_least(:once).with(any_args)
-        @double.something
-        @double.something 1
-        @double.something "a", 2
-        @double.something [], {}, "joe", 7
-        verify @double
-      end
-
-      it "fails on no args if any args received" do
-        @double.should_receive(:something).with(no_args())
-        expect {
-          @double.something 1
-        }.to raise_error(RSpec::Mocks::MockExpectationError, "Double \"test double\" received :something with unexpected arguments\n  expected: (no args)\n       got: (1)")
-      end
-
-      it "fails when args are expected but none are received" do
-        @double.should_receive(:something).with(1)
-        expect {
-          @double.something
-        }.to raise_error(RSpec::Mocks::MockExpectationError, "Double \"test double\" received :something with unexpected arguments\n  expected: (1)\n       got: (no args)")
-      end
-
-      it "returns value from block by default" do
-        @double.stub(:method_that_yields).and_yield
-        value = @double.method_that_yields { :returned_obj }
-        expect(value).to eq :returned_obj
-        verify @double
-      end
-
-      it "yields 0 args to blocks that take a variable number of arguments" do
-        @double.should_receive(:yield_back).with(no_args()).once.and_yield
-        a = nil
-        @double.yield_back {|*x| a = x}
-        expect(a).to eq []
-        verify @double
-      end
-
-      it "yields 0 args multiple times to blocks that take a variable number of arguments" do
-        @double.should_receive(:yield_back).once.with(no_args()).once.and_yield.
-                                                                    and_yield
-        b = []
-        @double.yield_back {|*a| b << a}
-        expect(b).to eq [ [], [] ]
-        verify @double
-      end
-
-      it "yields one arg to blocks that take a variable number of arguments" do
-        @double.should_receive(:yield_back).with(no_args()).once.and_yield(99)
-        a = nil
-        @double.yield_back {|*x| a = x}
-        expect(a).to eq [99]
-        verify @double
-      end
-
-      it "yields one arg 3 times consecutively to blocks that take a variable number of arguments" do
-        @double.should_receive(:yield_back).once.with(no_args()).once.and_yield(99).
-                                                                    and_yield(43).
-                                                                    and_yield("something fruity")
-        b = []
-        @double.yield_back {|*a| b << a}
-        expect(b).to eq [[99], [43], ["something fruity"]]
-        verify @double
-      end
-
-      it "yields many args to blocks that take a variable number of arguments" do
-        @double.should_receive(:yield_back).with(no_args()).once.and_yield(99, 27, "go")
-        a = nil
-        @double.yield_back {|*x| a = x}
-        expect(a).to eq [99, 27, "go"]
-        verify @double
-      end
-
-      it "yields many args 3 times consecutively to blocks that take a variable number of arguments" do
-        @double.should_receive(:yield_back).once.with(no_args()).once.and_yield(99, :green, "go").
-                                                                    and_yield("wait", :amber).
-                                                                    and_yield("stop", 12, :red)
-        b = []
-        @double.yield_back {|*a| b << a}
-        expect(b).to eq [[99, :green, "go"], ["wait", :amber], ["stop", 12, :red]]
-        verify @double
-      end
-
-      it "yields single value" do
-        @double.should_receive(:yield_back).with(no_args()).once.and_yield(99)
-        a = nil
-        @double.yield_back {|x| a = x}
-        expect(a).to eq 99
-        verify @double
-      end
-
-      it "yields single value 3 times consecutively" do
-        @double.should_receive(:yield_back).once.with(no_args()).once.and_yield(99).
-                                                                    and_yield(43).
-                                                                    and_yield("something fruity")
-        b = []
-        @double.yield_back {|a| b << a}
-        expect(b).to eq [99, 43, "something fruity"]
-        verify @double
-      end
-
-      it "yields two values" do
-        @double.should_receive(:yield_back).with(no_args()).once.and_yield('wha', 'zup')
-        a, b = nil
-        @double.yield_back {|x,y| a=x; b=y}
-        expect(a).to eq 'wha'
-        expect(b).to eq 'zup'
-        verify @double
-      end
-
-      it "yields two values 3 times consecutively" do
-        @double.should_receive(:yield_back).once.with(no_args()).once.and_yield('wha', 'zup').
-                                                                    and_yield('not', 'down').
-                                                                    and_yield(14, 65)
-        c = []
-        @double.yield_back {|a,b| c << [a, b]}
-        expect(c).to eq [['wha', 'zup'], ['not', 'down'], [14, 65]]
-        verify @double
-      end
-
-      it "fails when calling yielding method with wrong arity" do
-        @double.should_receive(:yield_back).with(no_args()).once.and_yield('wha', 'zup')
-        expect {
-          @double.yield_back {|a|}
-        }.to raise_error(RSpec::Mocks::MockExpectationError, "Double \"test double\" yielded |\"wha\", \"zup\"| to block with arity of 1")
-      end
-
-      if kw_args_supported?
-        it 'fails when calling yielding method with invalid kw args' do
-          @double.should_receive(:yield_back).and_yield(:x => 1, :y => 2)
-          expect {
-            eval("@double.yield_back { |x: 1| }")
-          }.to raise_error(RSpec::Mocks::MockExpectationError,
-                           'Double "test double" yielded |{:x=>1, :y=>2}| to block with optional keyword args (:x)')
-        end
-      end
-
-      it "fails when calling yielding method consecutively with wrong arity" do
-        @double.should_receive(:yield_back).once.with(no_args()).once.and_yield('wha', 'zup').
-                                                                    and_yield('down').
-                                                                    and_yield(14, 65)
-        expect {
-          c = []
-          @double.yield_back {|a,b| c << [a, b]}
-        }.to raise_error(RSpec::Mocks::MockExpectationError, "Double \"test double\" yielded |\"down\"| to block with arity of 2")
-      end
-
-      it "fails when calling yielding method without block" do
-        @double.should_receive(:yield_back).with(no_args()).once.and_yield('wha', 'zup')
-        expect {
-          @double.yield_back
-        }.to raise_error(RSpec::Mocks::MockExpectationError, "Double \"test double\" asked to yield |[\"wha\", \"zup\"]| but no block was passed")
-      end
-
-      it "is able to double send" do
-        @double.should_receive(:send).with(any_args)
-        @double.send 'hi'
-        verify @double
-      end
-
-      it "is able to raise from method calling yielding double" do
-        @double.should_receive(:yield_me).and_yield 44
-
-        expect {
-          @double.yield_me do |x|
-            raise "Bang"
-          end
-        }.to raise_error(StandardError, "Bang")
-
-        verify @double
-      end
-
-      it "clears expectations after verify" do
-        @double.should_receive(:foobar)
-        @double.foobar
-        verify @double
-        expect {
-          @double.foobar
-        }.to raise_error(RSpec::Mocks::MockExpectationError, %q|Double "test double" received unexpected message :foobar with (no args)|)
-      end
-
-      it "restores objects to their original state on rspec_reset" do
-        double = double("this is a double")
-        double.should_receive(:blah)
-        reset double
-        verify double #should throw if reset didn't work
-      end
-
-      it "temporarily replaces a method stub on a double" do
-        @double.stub(:msg).and_return(:stub_value)
-        @double.should_receive(:msg).with(:arg).and_return(:double_value)
-        expect(@double.msg(:arg)).to equal(:double_value)
-        expect(@double.msg).to equal(:stub_value)
-        expect(@double.msg).to equal(:stub_value)
-        verify @double
-      end
-
-      it "does not require a different signature to replace a method stub" do
-        @double.stub(:msg).and_return(:stub_value)
-        @double.should_receive(:msg).and_return(:double_value)
-        expect(@double.msg(:arg)).to equal(:double_value)
-        expect(@double.msg).to equal(:stub_value)
-        expect(@double.msg).to equal(:stub_value)
-        verify @double
-      end
-
-      it "raises an error when a previously stubbed method has a negative expectation" do
-        @double.stub(:msg).and_return(:stub_value)
-        @double.should_not_receive(:msg)
-        expect { @double.msg(:arg) }.to raise_error(RSpec::Mocks::MockExpectationError)
-      end
-
-      it "temporarily replaces a method stub on a non-double" do
-        non_double = Object.new
-        non_double.stub(:msg).and_return(:stub_value)
-        non_double.should_receive(:msg).with(:arg).and_return(:double_value)
-        expect(non_double.msg(:arg)).to equal(:double_value)
-        expect(non_double.msg).to equal(:stub_value)
-        expect(non_double.msg).to equal(:stub_value)
-        verify non_double
-      end
-
-      it "returns the stubbed value when no new value specified" do
-        @double.stub(:msg).and_return(:stub_value)
-        @double.should_receive(:msg)
-        expect(@double.msg).to equal(:stub_value)
-        verify @double
-      end
-
-      it "returns the stubbed value when stubbed with args and no new value specified" do
-        @double.stub(:msg).with(:arg).and_return(:stub_value)
-        @double.should_receive(:msg).with(:arg)
-        expect(@double.msg(:arg)).to equal(:stub_value)
-        verify @double
-      end
-
-      it "does not mess with the stub's yielded values when also doubleed" do
-        @double.stub(:yield_back).and_yield(:stub_value)
-        @double.should_receive(:yield_back).and_yield(:double_value)
-        @double.yield_back{|v| expect(v).to eq :double_value }
-        @double.yield_back{|v| expect(v).to eq :stub_value }
-        verify @double
-      end
-
-      it "can yield multiple times when told to do so" do
-        @double.stub(:foo).and_yield(:stub_value)
-        @double.should_receive(:foo).and_yield(:first_yield).and_yield(:second_yield)
-
-        expect { |b| @double.foo(&b) }.to yield_successive_args(:first_yield, :second_yield)
-        expect { |b| @double.foo(&b) }.to yield_with_args(:stub_value)
-
-        verify @double
-      end
-
-      it "assigns stub return values" do
-        double = RSpec::Mocks::Double.new('name', :message => :response)
-        expect(double.message).to eq :response
-      end
-
-      describe "a double message receiving a block" do
-        before(:each) do
-          @double = double("double")
-          @calls = 0
-        end
-
-        def add_call
-          @calls = @calls + 1
-        end
-
-        it "calls the block after #should_receive" do
-          @double.should_receive(:foo) { add_call }
-
-          @double.foo
-
-          expect(@calls).to eq 1
-        end
-
-        it "calls the block after #should_receive after a similar stub" do
-          @double.stub(:foo).and_return(:bar)
-          @double.should_receive(:foo) { add_call }
-
-          @double.foo
-
-          expect(@calls).to eq 1
-        end
-
-        it "calls the block after #once" do
-          @double.should_receive(:foo).once { add_call }
-
-          @double.foo
-
-          expect(@calls).to eq 1
-        end
-
-        it "calls the block after #twice" do
-          @double.should_receive(:foo).twice { add_call }
-
-          @double.foo
-          @double.foo
-
-          expect(@calls).to eq 2
-        end
-
-        it "calls the block after #times" do
-          @double.should_receive(:foo).exactly(10).times { add_call }
-
-          (1..10).each { @double.foo }
-
-          expect(@calls).to eq 10
-        end
-
-        it "calls the block after #ordered" do
-          @double.should_receive(:foo).ordered { add_call }
-          @double.should_receive(:bar).ordered { add_call }
-
-          @double.foo
-          @double.bar
-
-          expect(@calls).to eq 2
-        end
-      end
-
-      describe 'string representation generated by #to_s' do
-        it 'does not contain < because that might lead to invalid HTML in some situations' do
-          double = double("Dog")
-          valid_html_str = "#{double}"
-          expect(valid_html_str).not_to include('<')
-        end
-      end
-
-      describe "#to_str", :unless => RUBY_VERSION == '1.9.2' do
-        it "should not respond to #to_str to avoid being coerced to strings by the runtime" do
-          double = double("Foo")
-          expect { double.to_str }.to raise_error(
-            RSpec::Mocks::MockExpectationError,
-            'Double "Foo" received unexpected message :to_str with (no args)')
-        end
-      end
-
-      describe "double created with no name" do
-        it "does not use a name in a failure message" do
-          double = double()
-          expect {double.foo}.to raise_error(/Double received/)
-        end
-
-        it "does respond to initially stubbed methods" do
-          double = double(:foo => "woo", :bar => "car")
-          expect(double.foo).to eq "woo"
-          expect(double.bar).to eq "car"
-        end
-      end
-
-      describe "==" do
-        it "sends '== self' to the comparison object" do
-          first = double('first')
-          second = double('second')
-
-          first.should_receive(:==).with(second)
-          second == first
-        end
-      end
-
-      describe "with" do
-        before { @double = double('double') }
-        context "with args" do
-          context "with matching args" do
-            it "passes" do
-              @double.should_receive(:foo).with('bar')
-              @double.foo('bar')
-            end
-          end
-
-          context "with non-matching args" do
-            it "fails" do
-              @double.should_receive(:foo).with('bar')
-              expect do
-                @double.foo('baz')
-              end.to raise_error
-              reset @double
-            end
-          end
-
-          context "with non-matching doubles" do
-            it "fails" do
-              d1 = double('1')
-              d2 = double('2')
-              @double.should_receive(:foo).with(d1)
-              expect do
-                @double.foo(d2)
-              end.to raise_error
-              reset @double
-            end
-          end
-
-          context "with non-matching doubles as_null_object" do
-            it "fails" do
-              d1 = double('1').as_null_object
-              d2 = double('2').as_null_object
-              @double.should_receive(:foo).with(d1)
-              expect do
-                @double.foo(d2)
-              end.to raise_error
-              reset @double
-            end
-          end
-        end
-
-        context "with a block" do
-          context "with matching args" do
-            it "returns the result of the block" do
-              @double.should_receive(:foo).with('bar') { 'baz' }
-              expect(@double.foo('bar')).to eq('baz')
-            end
-          end
-
-          context "with non-matching args" do
-            it "fails" do
-              @double.should_receive(:foo).with('bar') { 'baz' }
-              expect do
-                expect(@double.foo('wrong')).to eq('baz')
-              end.to raise_error(/received :foo with unexpected arguments/)
-              reset @double
-            end
-          end
-        end
-      end
-    end
-  end
-end