sshp 0.0.1

data/vendor/ruby/1.9.1/gems/rspec-mocks-2.13.1/spec/rspec/mocks/hash_including_matcher_spec.rb

@@ -0,0 +1,90 @@
+require 'spec_helper'
+
+module RSpec
+  module Mocks
+    module ArgumentMatchers
+      describe HashIncludingMatcher do
+
+        it "describes itself properly" do
+          expect(HashIncludingMatcher.new(:a => 1).description).to eq "hash_including(:a=>1)"
+        end
+
+        describe "passing" do
+          it "matches the same hash" do
+            expect(hash_including(:a => 1)).to eq({:a => 1})
+          end
+
+          it "matches a hash with extra stuff" do
+            expect(hash_including(:a => 1)).to eq({:a => 1, :b => 2})
+          end
+
+          describe "when matching against other matchers" do
+            it "matches an int against anything()" do
+              expect(hash_including(:a => anything, :b => 2)).to eq({:a => 1, :b => 2})
+            end
+
+            it "matches a string against anything()" do
+              expect(hash_including(:a => anything, :b => 2)).to eq({:a => "1", :b => 2})
+            end
+          end
+
+          describe "when passed only keys or keys mixed with key/value pairs" do
+            it "matches if the key is present" do
+              expect(hash_including(:a)).to eq({:a => 1, :b => 2})
+            end
+
+            it "matches if more keys are present" do
+              expect(hash_including(:a, :b)).to eq({:a => 1, :b => 2, :c => 3})
+            end
+
+            it "matches a string against a given key" do
+              expect(hash_including(:a)).to eq({:a => "1", :b => 2})
+            end
+
+            it "matches if passed one key and one key/value pair" do
+              expect(hash_including(:a, :b => 2)).to eq({:a => 1, :b => 2})
+            end
+
+            it "matches if passed many keys and one key/value pair" do
+              expect(hash_including(:a, :b, :c => 3)).to eq({:a => 1, :b => 2, :c => 3, :d => 4})
+            end
+
+            it "matches if passed many keys and many key/value pairs" do
+              expect(hash_including(:a, :b, :c => 3, :e => 5)).to eq({:a => 1, :b => 2, :c => 3, :d => 4, :e => 5})
+            end
+          end
+        end
+
+        describe "failing" do
+          it "does not match a non-hash" do
+            expect(hash_including(:a => 1)).not_to eq 1
+          end
+
+          it "does not match a hash with a missing key" do
+            expect(hash_including(:a => 1)).not_to eq(:b => 2)
+          end
+
+          it "does not match a hash with a missing key" do
+            expect(hash_including(:a)).not_to eq(:b => 2)
+          end
+
+          it "does not match an empty hash with a given key" do
+            expect(hash_including(:a)).not_to eq({})
+          end
+
+          it "does not match a hash with a missing key when one pair is matching" do
+            expect(hash_including(:a, :b => 2)).not_to eq(:b => 2)
+          end
+
+          it "does not match a hash with an incorrect value" do
+            expect(hash_including(:a => 1, :b => 2)).not_to eq(:a => 1, :b => 3)
+          end
+
+          it "does not match when values are nil but keys are different" do
+            expect(hash_including(:a => nil)).not_to eq(:b => nil)
+          end
+        end
+      end
+    end
+  end
+end

data/vendor/ruby/1.9.1/gems/rspec-mocks-2.13.1/spec/rspec/mocks/instance_method_stasher_spec.rb

@@ -0,0 +1,58 @@
+require 'spec_helper'
+
+module RSpec
+  module Mocks
+    describe InstanceMethodStasher do
+      class ExampleClass
+        def hello
+          :hello_defined_on_class
+        end
+      end
+
+      def singleton_class_for(obj)
+        class << obj; self; end
+      end
+
+      it "stashes the current implementation of an instance method so it can be temporarily replaced" do
+        obj = Object.new
+        def obj.hello; :hello_defined_on_singleton_class; end;
+
+        stashed_method = InstanceMethodStasher.new(singleton_class_for(obj), :hello)
+        stashed_method.stash
+
+        def obj.hello; :overridden_hello; end
+        expect(obj.hello).to eql :overridden_hello
+
+        stashed_method.restore
+        expect(obj.hello).to eql :hello_defined_on_singleton_class
+      end
+
+      it "stashes private instance methods" do
+        obj = Object.new
+        def obj.hello; :hello_defined_on_singleton_class; end;
+        singleton_class_for(obj).__send__(:private, :hello)
+
+        stashed_method = InstanceMethodStasher.new(singleton_class_for(obj), :hello)
+        stashed_method.stash
+
+        def obj.hello; :overridden_hello; end
+        stashed_method.restore
+        expect(obj.send(:hello)).to eql :hello_defined_on_singleton_class
+      end
+
+      it "only stashes methods directly defined on the given class, not its ancestors" do
+        obj = ExampleClass.new
+
+        stashed_method = InstanceMethodStasher.new(singleton_class_for(obj), :hello)
+        stashed_method.stash
+
+        def obj.hello; :overridden_hello; end;
+        expect(obj.hello).to eql :overridden_hello
+
+        stashed_method.restore
+        expect(obj.hello).to eql :overridden_hello
+      end
+    end
+  end
+end
+

data/vendor/ruby/1.9.1/gems/rspec-mocks-2.13.1/spec/rspec/mocks/mock_ordering_spec.rb

@@ -0,0 +1,103 @@
+require 'spec_helper'
+
+module RSpec
+  module Mocks
+
+    describe "ordering" do
+      before { @double = double("test double") }
+      after  { @double.rspec_reset }
+
+      it "passes when messages are received in order" do
+        @double.should_receive(:one).ordered
+        @double.should_receive(:two).ordered
+        @double.should_receive(:three).ordered
+        @double.one
+        @double.two
+        @double.three
+      end
+
+      it "passes when messages are received in order across objects" do
+        a = double("a")
+        b = double("b")
+        a.should_receive(:one).ordered
+        b.should_receive(:two).ordered
+        a.should_receive(:three).ordered
+        a.one
+        b.two
+        a.three
+      end
+
+      it "fails when messages are received out of order (2nd message 1st)" do
+        @double.should_receive(:one).ordered
+        @double.should_receive(:two).ordered
+        expect {
+          @double.two
+        }.to raise_error(RSpec::Mocks::MockExpectationError, "Double \"test double\" received :two out of order")
+      end
+
+      it "fails when messages are received out of order (3rd message 1st)" do
+        @double.should_receive(:one).ordered
+        @double.should_receive(:two).ordered
+        @double.should_receive(:three).ordered
+        @double.one
+        expect {
+          @double.three
+        }.to raise_error(RSpec::Mocks::MockExpectationError, "Double \"test double\" received :three out of order")
+      end
+
+      it "fails when messages are received out of order (3rd message 2nd)" do
+        @double.should_receive(:one).ordered
+        @double.should_receive(:two).ordered
+        @double.should_receive(:three).ordered
+        @double.one
+        expect {
+          @double.three
+        }.to raise_error(RSpec::Mocks::MockExpectationError, "Double \"test double\" received :three out of order")
+      end
+
+      it "fails when messages are out of order across objects" do
+        a = double("test double")
+        b = double("another test double")
+        a.should_receive(:one).ordered
+        b.should_receive(:two).ordered
+        a.should_receive(:three).ordered
+        a.one
+        expect {
+          a.three
+        }.to raise_error(RSpec::Mocks::MockExpectationError, "Double \"test double\" received :three out of order")
+        a.rspec_reset
+        b.rspec_reset
+      end
+
+      it "ignores order of non ordered messages" do
+        @double.should_receive(:ignored_0)
+        @double.should_receive(:ordered_1).ordered
+        @double.should_receive(:ignored_1)
+        @double.should_receive(:ordered_2).ordered
+        @double.should_receive(:ignored_2)
+        @double.should_receive(:ignored_3)
+        @double.should_receive(:ordered_3).ordered
+        @double.should_receive(:ignored_4)
+        @double.ignored_3
+        @double.ordered_1
+        @double.ignored_0
+        @double.ordered_2
+        @double.ignored_4
+        @double.ignored_2
+        @double.ordered_3
+        @double.ignored_1
+        @double.rspec_verify
+      end
+
+      it "supports duplicate messages" do
+        @double.should_receive(:a).ordered
+        @double.should_receive(:b).ordered
+        @double.should_receive(:a).ordered
+
+        @double.a
+        @double.b
+        @double.a
+      end
+    end
+  end
+end

data/vendor/ruby/1.9.1/gems/rspec-mocks-2.13.1/spec/rspec/mocks/mock_space_spec.rb

@@ -0,0 +1,58 @@
+require 'spec_helper'
+require 'rspec/mocks'
+
+module RSpec
+  module Mocks
+    describe Space do
+      before :each do
+        @space = RSpec::Mocks::Space.new
+        klazz = Class.new do
+          def rspec_verify
+            @verified = true
+          end
+          def verified?
+            @verified
+          end
+          def rspec_reset
+            @reset = true
+          end
+          def reset?
+            @reset
+          end
+        end
+        @m1 = klazz.new
+        @m2 = klazz.new
+      end
+      it "verifies all mocks within" do
+        @space.add(@m1)
+        @space.add(@m2)
+        @space.verify_all
+        expect(@m1).to be_verified
+        expect(@m2).to be_verified
+      end
+      it "resets all mocks within" do
+        @space.add(m1 = double("mock1"))
+        @space.add(m2 = double("mock2"))
+        m1.should_receive(:rspec_reset)
+        m2.should_receive(:rspec_reset)
+        @space.reset_all
+      end
+      it "clears internal mocks on reset_all" do
+        @space.add(double("mock"))
+        @space.reset_all
+        expect(@space.instance_eval { receivers.empty? }).to be_true
+      end
+      it "resets the ordering" do
+        @space.reset_all
+        expect(@space.expectation_ordering).to be_empty
+      end
+      it "only adds an instance once" do
+        @space.add(m1 = double("mock1"))
+        @space.add(m1)
+        m1.should_receive(:rspec_verify)
+        @space.verify_all
+      end
+    end
+  end
+end
+    

data/vendor/ruby/1.9.1/gems/rspec-mocks-2.13.1/spec/rspec/mocks/mock_spec.rb

@@ -0,0 +1,734 @@
+require 'spec_helper'
+
+module RSpec
+  module Mocks
+    describe Mock do
+      before(:each) { @double = double("test double") }
+      after(:each)  { @double.rspec_reset }
+
+      it "has method_missing as private" do
+        expect(RSpec::Mocks::Mock.private_instance_methods).to include_method(:method_missing)
+      end
+
+      it "does not respond_to? method_missing (because it's private)" do
+        expect(RSpec::Mocks::Mock.new).not_to respond_to(:method_missing)
+      end
+
+      it "reports line number of expectation of unreceived message" do
+        expected_error_line = __LINE__; @double.should_receive(:wont_happen).with("x", 3)
+        begin
+          @double.rspec_verify
+          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
+          @double.rspec_verify
+          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)
+        @double.rspec_verify
+      end
+
+      it "warns when should_not_receive is followed by and_return" do
+        RSpec::Mocks.should_receive(:warn_deprecation).
+          with(/`and_return` with `should_not_receive` is deprecated/)
+
+        @double.should_not_receive(:do_something).and_return(1)
+      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"
+        @double.rspec_verify
+      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\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\n    received: 1 time|
+        )
+      end
+
+      it "passes when receiving message specified as not to be received with wrong args" do
+        @double.should_not_receive(:not_expected).with("unexpected text")
+        @double.not_expected "really unexpected text"
+        @double.rspec_verify
+      end
+
+      it "allows block to calculate return values" do
+        @double.should_receive(:something).with("a","b","c").and_return { |a,b,c| c+b+a }
+        expect(@double.something("a","b","c")).to eq "cba"
+        @double.rspec_verify
+      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"
+        @double.rspec_verify
+      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
+        @double.rspec_verify
+      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
+        @double.rspec_verify
+      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")
+          @double.rspec_verify
+        }.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")
+          @double.rspec_verify
+        }.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)
+            @double.rspec_verify
+          }.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"
+        @double.rspec_verify
+      end
+
+      it "fails if expectation block fails" do
+        @double.should_receive(:something) do |bool|
+          expect(bool).to be_true
+        end
+
+        expect {
+          @double.something false
+        }.to raise_error(RSpec::Expectations::ExpectationNotMetError)
+      end
+
+      context "with Ruby > 1.8.6", :unless => RUBY_VERSION.to_s == '1.8.6' do
+        it "passes proc to expectation block without an argument" do
+          # We eval this because Ruby 1.8.6's syntax parser barfs on { |&block| ... }
+          # and prevents the entire spec suite from running.
+          eval("@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
+          eval("@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
+          eval("@double.stub(:foo) {|&block| expect(block.call).to eq(:bar)}")
+          @double.foo { :bar }
+        end
+
+        it "passes proc to stub block with an argument" do
+          eval("@double.stub(:foo) {|arg, &block| expect(block.call).to eq(:bar)}")
+          @double.foo(:arg) { :bar }
+        end
+      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\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
+        @double.rspec_verify
+      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
+        @double.rspec_verify
+      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 []
+        @double.rspec_verify
+      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 [ [], [] ]
+        @double.rspec_verify
+      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]
+        @double.rspec_verify
+      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"]]
+        @double.rspec_verify
+      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"]
+        @double.rspec_verify
+      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]]
+        @double.rspec_verify
+      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
+        @double.rspec_verify
+      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"]
+        @double.rspec_verify
+      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'
+        @double.rspec_verify
+      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]]
+        @double.rspec_verify
+      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
+
+      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'
+        @double.rspec_verify
+      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")
+
+        @double.rspec_verify
+      end
+
+      it "clears expectations after verify" do
+        @double.should_receive(:foobar)
+        @double.foobar
+        @double.rspec_verify
+        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)
+        double.rspec_reset
+        double.rspec_verify #should throw if reset didn't work
+      end
+
+      it "works even after method_missing starts raising NameErrors instead of NoMethodErrors" do
+        # Object#method_missing throws either NameErrors or NoMethodErrors.
+        #
+        # On a fresh ruby program Object#method_missing:
+        #  * raises a NoMethodError when called directly
+        #  * raises a NameError when called indirectly
+        #
+        # Once Object#method_missing has been called at least once (on any object)
+        # it starts behaving differently:
+        #  * raises a NameError when called directly
+        #  * raises a NameError when called indirectly
+        #
+        # There was a bug in Mock#method_missing that relied on the fact
+        # that calling Object#method_missing directly raises a NoMethodError.
+        # This example tests that the bug doesn't exist anymore.
+
+
+        # Ensures that method_missing always raises NameErrors.
+        a_method_that_doesnt_exist rescue
+
+
+        @double.should_receive(:foobar)
+        @double.foobar
+        @double.rspec_verify
+
+        expect { @double.foobar }.to_not raise_error(NameError)
+        expect { @double.foobar }.to raise_error(RSpec::Mocks::MockExpectationError)
+      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)
+        @double.rspec_verify
+      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)
+        @double.rspec_verify
+      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)
+        non_double.rspec_verify
+      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)
+        @double.rspec_verify
+      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)
+        @double.rspec_verify
+      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 }
+        @double.rspec_verify
+      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)
+
+        @double.rspec_verify
+      end
+
+      it "assigns stub return values" do
+        double = RSpec::Mocks::Mock.new('name', :message => :response)
+        expect(double.message).to eq :response
+      end
+
+    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 #any_number_of_times" do
+        @double.should_receive(:foo).any_number_of_times { add_call }
+
+        (1..7).each { @double.foo }
+
+        expect(@calls).to eq 7
+      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 "string representation generated by #to_str" do
+      it "looks the same as #to_s" do
+        double = double("Foo")
+        expect(double.to_str).to eq double.to_s
+      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
+            @double.rspec_reset
+          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
+            @double.rspec_reset
+          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
+            @double.rspec_reset
+          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/)
+            @double.rspec_reset
+          end
+        end
+      end
+    end
+
+  end
+end