rspec-expectations 2.11.3 → 3.11.0

data/spec/rspec/matchers/start_with_end_with_spec.rb

@@ -1,182 +0,0 @@
-require "spec_helper"
-
-describe "should start_with" do
-  it_behaves_like "an RSpec matcher", :valid_value => "ab", :invalid_value => "bc" do
-    let(:matcher) { start_with("a") }
-  end
-
-  context "with a string" do
-    it "passes if it matches the start of the actual string" do
-      "this string".should start_with "this str"
-    end
-
-    it "fails if it does not match the start of the actual string" do
-      expect {
-        "this string".should start_with "that str"
-      }.to fail_with("expected \"this string\" to start with \"that str\"")
-    end
-  end
-
-  context "with an array" do
-    it "passes if it is the first element of the array" do
-      [0, 1, 2].should start_with 0
-    end
-
-    it "passes if the first elements of the array match" do
-      [0, 1, 2].should start_with 0, 1
-    end
-
-    it "fails if it does not match the first element of the array" do
-      expect {
-        [0, 1, 2].should start_with 2
-      }.to fail_with("expected [0, 1, 2] to start with 2")
-    end
-
-    it "fails if it the first elements of the array do not match" do
-      expect {
-        [0, 1, 2].should start_with 1, 2
-      }.to fail_with("expected [0, 1, 2] to start with [1, 2]")
-    end
-  end
-
-  context "with an object that does not respond to :[]" do
-    it "raises an ArgumentError" do
-      expect { Object.new.should start_with 0 }.to raise_error(ArgumentError, /does not respond to :\[\]/)
-    end
-  end
-
-  context "with a hash" do
-    it "raises an ArgumentError if trying to match more than one element" do
-      expect{
-        {:a => 'b', :b => 'b', :c => 'c'}.should start_with({:a => 'b', :b => 'b'})
-      }.to raise_error(ArgumentError, /does not have ordered elements/)
-    end
-  end
-end
-
-describe "should_not start_with" do
-  context "with a string" do
-    it "passes if it does not match the start of the actual string" do
-      "this string".should_not start_with "that str"
-    end
-
-    it "fails if it does match the start of the actual string" do
-      expect {
-        "this string".should_not start_with "this str"
-      }.to fail_with("expected \"this string\" not to start with \"this str\"")
-    end
-  end
-
-  context "with an array" do
-    it "passes if it is not the first element of the array" do
-      [0, 1, 2].should_not start_with 2
-    end
-
-    it "passes if the first elements of the array do not match" do
-      [0, 1, 2].should_not start_with 1, 2
-    end
-
-    it "fails if it matches the first element of the array" do
-      expect {
-        [0, 1, 2].should_not start_with 0
-      }.to fail_with("expected [0, 1, 2] not to start with 0")
-    end
-
-    it "fails if it the first elements of the array match" do
-      expect {
-        [0, 1, 2].should_not start_with 0, 1
-      }.to fail_with("expected [0, 1, 2] not to start with [0, 1]")
-    end
-  end
-end
-
-describe "should end_with" do
-  it_behaves_like "an RSpec matcher", :valid_value => "ab", :invalid_value => "bc" do
-    let(:matcher) { end_with("b") }
-  end
-
-  context "with a string" do
-    it "passes if it matches the end of the actual string" do
-      "this string".should end_with "is string"
-    end
-
-    it "fails if it does not match the end of the actual string" do
-      expect {
-        "this string".should end_with "is stringy"
-      }.to fail_with("expected \"this string\" to end with \"is stringy\"")
-    end
-  end
-
-  context "with an array" do
-    it "passes if it is the last element of the array" do
-      [0, 1, 2].should end_with 2
-    end
-
-    it "passes if the last elements of the array match" do
-      [0, 1, 2].should end_with [1, 2]
-    end
-
-    it "fails if it does not match the last element of the array" do
-      expect {
-        [0, 1, 2].should end_with 1
-      }.to fail_with("expected [0, 1, 2] to end with 1")
-    end
-
-    it "fails if it the last elements of the array do not match" do
-      expect {
-        [0, 1, 2].should end_with [0, 1]
-      }.to fail_with("expected [0, 1, 2] to end with [0, 1]")
-    end
-  end
-
-  context "with an object that does not respond to :[]" do
-    it "should raise an error if expected value can't be indexed'" do
-      expect { Object.new.should end_with 0 }.to raise_error(ArgumentError, /does not respond to :\[\]/)
-    end
-  end
-
-  context "with a hash" do
-    it "raises an ArgumentError if trying to match more than one element" do
-      expect{
-        {:a => 'b', :b => 'b', :c => 'c'}.should end_with({:a => 'b', :b =>'b'})
-      }.to raise_error(ArgumentError, /does not have ordered elements/)
-    end
-  end
-
-end
-
-describe "should_not end_with" do
-  context "with a sting" do
-    it "passes if it does not match the end of the actual string" do
-      "this string".should_not end_with "stringy"
-    end
-
-    it "fails if it matches the end of the actual string" do
-      expect {
-        "this string".should_not end_with "string"
-      }.to fail_with("expected \"this string\" not to end with \"string\"")
-    end
-  end
-
-  context "an array" do
-    it "passes if it is not the last element of the array" do
-      [0, 1, 2].should_not end_with 1
-    end
-
-    it "passes if the last elements of the array do not match" do
-      [0, 1, 2].should_not end_with [0, 1]
-    end
-
-    it "fails if it matches the last element of the array" do
-      expect {
-        [0, 1, 2].should_not end_with 2
-      }.to fail_with("expected [0, 1, 2] not to end with 2")
-    end
-
-    it "fails if it the last elements of the array match" do
-      expect {
-        [0, 1, 2].should_not end_with [1, 2]
-      }.to fail_with("expected [0, 1, 2] not to end with [1, 2]")
-    end
-  end
-end

data/spec/rspec/matchers/throw_symbol_spec.rb

@@ -1,116 +0,0 @@
-require 'spec_helper'
-
-module RSpec::Matchers::BuiltIn
-  describe ThrowSymbol do
-    it_behaves_like("an RSpec matcher", :valid_value => lambda { throw :foo },
-                                        :invalid_value => lambda { }) do
-      let(:matcher) { throw_symbol(:foo) }
-    end
-
-    describe "with no args" do
-      before(:each) { @matcher = throw_symbol }
-
-      it "matches if any Symbol is thrown" do
-        @matcher.matches?(lambda{ throw :sym }).should be_true
-      end
-      it "matches if any Symbol is thrown with an arg" do
-        @matcher.matches?(lambda{ throw :sym, "argument" }).should be_true
-      end
-      it "does not match if no Symbol is thrown" do
-        @matcher.matches?(lambda{ }).should be_false
-      end
-      it "provides a failure message" do
-        @matcher.matches?(lambda{})
-        @matcher.failure_message_for_should.should == "expected a Symbol to be thrown, got nothing"
-      end
-      it "provides a negative failure message" do
-        @matcher.matches?(lambda{ throw :sym})
-        @matcher.failure_message_for_should_not.should == "expected no Symbol to be thrown, got :sym"
-      end
-    end
-
-    describe "with a symbol" do
-      before(:each) { @matcher = throw_symbol(:sym) }
-
-      it "matches if correct Symbol is thrown" do
-        @matcher.matches?(lambda{ throw :sym }).should be_true
-      end
-      it "matches if correct Symbol is thrown with an arg" do
-        @matcher.matches?(lambda{ throw :sym, "argument" }).should be_true
-      end
-      it "does not match if no Symbol is thrown" do
-        @matcher.matches?(lambda{ }).should be_false
-      end
-      it "does not match if correct Symbol is thrown" do
-        @matcher.matches?(lambda{ throw :other_sym }).should be_false
-      end
-      it "provides a failure message when no Symbol is thrown" do
-        @matcher.matches?(lambda{})
-        @matcher.failure_message_for_should.should == "expected :sym to be thrown, got nothing"
-      end
-      it "provides a failure message when wrong Symbol is thrown" do
-        @matcher.matches?(lambda{ throw :other_sym })
-        @matcher.failure_message_for_should.should == "expected :sym to be thrown, got :other_sym"
-      end
-      it "provides a negative failure message" do
-        @matcher.matches?(lambda{ throw :sym })
-        @matcher.failure_message_for_should_not.should == "expected :sym not to be thrown, got :sym"
-      end
-      it "only matches NameErrors raised by uncaught throws" do
-        expect {
-          @matcher.matches?(lambda{ sym }).should be_false
-        }.to raise_error(NameError)
-      end
-    end
-
-    describe "with a symbol and an arg" do
-      before(:each) { @matcher = throw_symbol(:sym, "a") }
-
-      it "matches if correct Symbol and args are thrown" do
-        @matcher.matches?(lambda{ throw :sym, "a" }).should be_true
-      end
-      it "does not match if nothing is thrown" do
-        @matcher.matches?(lambda{ }).should be_false
-      end
-      it "does not match if other Symbol is thrown" do
-        @matcher.matches?(lambda{ throw :other_sym, "a" }).should be_false
-      end
-      it "does not match if no arg is thrown" do
-        @matcher.matches?(lambda{ throw :sym }).should be_false
-      end
-      it "does not match if wrong arg is thrown" do
-        @matcher.matches?(lambda{ throw :sym, "b" }).should be_false
-      end
-      it "provides a failure message when no Symbol is thrown" do
-        @matcher.matches?(lambda{})
-        @matcher.failure_message_for_should.should == %q[expected :sym with "a" to be thrown, got nothing]
-      end
-      it "provides a failure message when wrong Symbol is thrown" do
-        @matcher.matches?(lambda{ throw :other_sym })
-        @matcher.failure_message_for_should.should == %q[expected :sym with "a" to be thrown, got :other_sym]
-      end
-      it "provides a failure message when wrong arg is thrown" do
-        @matcher.matches?(lambda{ throw :sym, "b" })
-        @matcher.failure_message_for_should.should == %q[expected :sym with "a" to be thrown, got :sym with "b"]
-      end
-      it "provides a failure message when no arg is thrown" do
-        @matcher.matches?(lambda{ throw :sym })
-        @matcher.failure_message_for_should.should == %q[expected :sym with "a" to be thrown, got :sym with no argument]
-      end
-      it "provides a negative failure message" do
-        @matcher.matches?(lambda{ throw :sym })
-        @matcher.failure_message_for_should_not.should == %q[expected :sym with "a" not to be thrown, got :sym with no argument]
-      end
-      it "only matches NameErrors raised by uncaught throws" do
-        expect {
-          @matcher.matches?(lambda{ sym }).should be_false
-        }.to raise_error(NameError)
-      end
-      it "raises other errors" do
-        expect {
-          @matcher.matches?(lambda { raise "Boom" })
-        }.to raise_error(/Boom/)
-      end
-    end
-  end
-end

data/spec/rspec/matchers/yield_spec.rb

@@ -1,402 +0,0 @@
-require 'spec_helper'
-
-module YieldHelpers
-  # these helpers are prefixed with an underscore to prevent
-  # collisions with the matchers (some of which have the same names)
-  def _dont_yield
-  end
-
-  def _yield_with_no_args
-    yield
-  end
-
-  def _yield_with_args(*args)
-    yield(*args)
-  end
-end
-
-class InstanceEvaler
-  include RSpec::Matchers::Extensions::InstanceEvalWithArgs
-
-  def yield_with_no_args(&block)
-    instance_eval_with_args(&block)
-  end
-
-  def yield_with_args(*args, &block)
-    instance_eval_with_args(*args, &block)
-  end
-
-  def each_arg(*args, &block)
-    args.each do |arg|
-      instance_eval_with_args(arg, &block)
-    end
-  end
-end
-
-describe "yield_control matcher" do
-  include YieldHelpers
-  extend  YieldHelpers
-
-  it_behaves_like "an RSpec matcher",
-      :valid_value => lambda { |b| _yield_with_no_args(&b) },
-      :invalid_value => lambda { |b| _dont_yield(&b) } do
-    let(:matcher) { yield_control }
-  end
-
-  it 'has a description' do
-    yield_control.description.should eq("yield control")
-  end
-
-  describe "expect {...}.to yield_control" do
-    it 'passes if the block yields, regardless of the number of yielded arguments' do
-      expect { |b| _yield_with_no_args(&b) }.to yield_control
-      expect { |b| _yield_with_args(1, 2, &b) }.to yield_control
-    end
-
-    it 'passes if the block yields using instance_eval' do
-      expect { |b| InstanceEvaler.new.yield_with_no_args(&b) }.to yield_control
-    end
-
-    it 'fails if the block does not yield' do
-      expect {
-        expect { |b| _dont_yield(&b) }.to yield_control
-      }.to fail_with(/expected given block to yield control/)
-    end
-
-    it 'raises an error if it yields multiple times' do
-      expect {
-        expect { |b| [1, 2].each(&b) }.to yield_control
-      }.to raise_error(/not designed.*yields multiple times/)
-    end
-  end
-
-  describe "expect {...}.not_to yield_control" do
-    it 'passes if the block does not yield' do
-      expect { |b| _dont_yield(&b) }.not_to yield_control
-    end
-
-    it 'fails if the block does yield' do
-      expect {
-        expect { |b| _yield_with_no_args(&b) }.not_to yield_control
-      }.to fail_with(/expected given block not to yield control/)
-    end
-
-    it 'fails if the expect block does not accept an argument' do
-      expect {
-        expect { }.not_to yield_control
-      }.to raise_error(/expect block must accept an argument/)
-    end
-
-    it 'raises an error if the expect block arg is not passed to a method as a block' do
-      expect {
-        expect { |b| }.not_to yield_control
-      }.to raise_error(/must pass the argument.*as a block/)
-    end
-  end
-end
-
-describe "yield_with_no_args matcher" do
-  include YieldHelpers
-  extend  YieldHelpers
-
-  it_behaves_like "an RSpec matcher",
-      :valid_value => lambda { |b| _yield_with_no_args(&b) },
-      :invalid_value => lambda { |b| _dont_yield(&b) } do
-    let(:matcher) { yield_with_no_args }
-  end
-
-  it 'has a description' do
-    yield_with_no_args.description.should eq("yield with no args")
-  end
-
-  describe "expect {...}.to yield_with_no_args" do
-    it 'passes if the block yields with no args' do
-      expect { |b| _yield_with_no_args(&b) }.to yield_with_no_args
-    end
-
-    it 'passes if the block yields with no args using instance_eval' do
-      expect { |b| InstanceEvaler.new.yield_with_no_args(&b) }.to yield_with_no_args
-    end
-
-    it 'fails if the block does not yield' do
-      expect {
-        expect { |b| _dont_yield(&b) }.to yield_with_no_args
-      }.to fail_with(/expected given block to yield with no arguments, but did not yield/)
-    end
-
-    it 'fails if the block yields with args' do
-      expect {
-        expect { |b| _yield_with_args(1, &b) }.to yield_with_no_args
-      }.to fail_with(/expected given block to yield with no arguments, but yielded with arguments/)
-    end
-
-    it 'raises an error if it yields multiple times' do
-      expect {
-        expect { |b| [1, 2].each(&b) }.to yield_with_no_args
-      }.to raise_error(/not designed.*yields multiple times/)
-    end
-  end
-
-  describe "expect {...}.not_to yield_with_no_args" do
-    it "passes if the block does not yield" do
-      expect { |b| _dont_yield(&b) }.not_to yield_with_no_args
-    end
-
-    it "passes if the block yields with args" do
-      expect { |b| _yield_with_args(1, &b) }.not_to yield_with_no_args
-    end
-
-    it "fails if the block yields with no args" do
-      expect {
-        expect { |b| _yield_with_no_args(&b) }.not_to yield_with_no_args
-      }.to fail_with(/expected given block not to yield with no arguments, but did/)
-    end
-
-    it 'fails if the expect block does not accept an argument' do
-      expect {
-        expect { }.not_to yield_with_no_args
-      }.to raise_error(/expect block must accept an argument/)
-    end
-
-    it 'raises an error if the expect block arg is not passed to a method as a block' do
-      expect {
-        expect { |b| }.not_to yield_with_no_args
-      }.to raise_error(/must pass the argument.*as a block/)
-    end
-  end
-end
-
-describe "yield_with_args matcher" do
-  include YieldHelpers
-  extend  YieldHelpers
-
-  it_behaves_like "an RSpec matcher",
-      :valid_value => lambda { |b| _yield_with_args(1, &b) },
-      :invalid_value => lambda { |b| _dont_yield(&b) } do
-    let(:matcher) { yield_with_args }
-  end
-
-  it 'has a description' do
-    yield_with_args.description.should eq("yield with args")
-    yield_with_args(1, 3).description.should eq("yield with args(1, 3)")
-  end
-
-  describe "expect {...}.to yield_with_args" do
-    it 'passes if the block yields with arguments' do
-      expect { |b| _yield_with_args(1, &b) }.to yield_with_args
-    end
-
-    it 'fails if the block does not yield' do
-      expect {
-        expect { |b| _dont_yield(&b) }.to yield_with_args
-      }.to fail_with(/expected given block to yield with arguments, but did not yield/)
-    end
-
-    it 'fails if the block yields with no arguments' do
-      expect {
-        expect { |b| _yield_with_no_args(&b) }.to yield_with_args
-      }.to fail_with(/expected given block to yield with arguments, but yielded with no arguments/)
-    end
-
-    it 'raises an error if it yields multiple times' do
-      expect {
-        expect { |b| [1, 2].each(&b) }.to yield_with_args
-      }.to raise_error(/not designed.*yields multiple times/)
-    end
-  end
-
-  describe "expect {...}.not_to yield_with_args" do
-    it 'fails if the block yields with arguments' do
-      expect {
-        expect { |b| _yield_with_args(1, &b) }.not_to yield_with_args
-      }.to fail_with(/expected given block not to yield with arguments, but did/)
-    end
-
-    it 'passes if the block does not yield' do
-      expect { |b| _dont_yield(&b) }.not_to yield_with_args
-    end
-
-    it 'passes if the block yields with no arguments' do
-      expect { |b| _yield_with_no_args(&b) }.not_to yield_with_args
-    end
-
-    it 'fails if the expect block does not accept an argument' do
-      expect {
-        expect { }.not_to yield_with_args
-      }.to raise_error(/expect block must accept an argument/)
-    end
-
-    it 'raises an error if the expect block arg is not passed to a method as a block' do
-      expect {
-        expect { |b| }.not_to yield_with_args
-      }.to raise_error(/must pass the argument.*as a block/)
-    end
-  end
-
-  describe "expect {...}.to yield_with_args(3, 17)" do
-    it 'passes if the block yields with the given arguments' do
-      expect { |b| _yield_with_args(3, 17, &b) }.to yield_with_args(3, 17)
-    end
-
-    it 'passes if the block yields with the given arguments using instance_eval' do
-      expect { |b| InstanceEvaler.new.yield_with_args(3, 17, &b) }.to yield_with_args(3, 17)
-    end
-
-    it 'fails if the block does not yield' do
-      expect {
-        expect { |b| _dont_yield(&b) }.to yield_with_args(3, 17)
-      }.to fail_with(/expected given block to yield with arguments, but did not yield/)
-    end
-
-    it 'fails if the block yields with no arguments' do
-      expect {
-        expect { |b| _yield_with_no_args(&b) }.to yield_with_args(3, 17)
-      }.to fail_with(/expected given block to yield with arguments, but yielded with unexpected arguments/)
-    end
-
-    it 'fails if the block yields with different arguments' do
-      expect {
-        expect { |b| _yield_with_args("a", "b", &b) }.to yield_with_args("a", "c")
-      }.to fail_with(/expected given block to yield with arguments, but yielded with unexpected arguments/)
-    end
-  end
-
-  describe "expect {...}.not_to yield_with_args(3, 17)" do
-    it 'passes if the block yields with different arguments' do
-      expect { |b| _yield_with_args("a", "b", &b) }.not_to yield_with_args("a", "c")
-    end
-
-    it 'fails if the block yields with the given arguments' do
-      expect {
-        expect { |b| _yield_with_args("a", "b", &b) }.not_to yield_with_args("a", "b")
-      }.to fail_with(/expected given block not to yield with arguments, but yielded with expected arguments/)
-    end
-  end
-
-  describe "expect {...}.to yield_with_args(/reg/, /ex/)" do
-    it "passes if the block yields strings matching the regexes" do
-      expect { |b| _yield_with_args("regular", "expression", &b) }.to yield_with_args(/reg/, /ex/)
-    end
-
-    it "fails if the block yields strings that do not match the regexes" do
-      expect {
-        expect { |b| _yield_with_args("no", "match", &b) }.to yield_with_args(/reg/, /ex/)
-      }.to fail_with(/expected given block to yield with arguments, but yielded with unexpected arguments/)
-    end
-  end
-
-  describe "expect {...}.to yield_with_args(String, Fixnum)" do
-    it "passes if the block yields objects of the given types" do
-      expect { |b| _yield_with_args("string", 15, &b) }.to yield_with_args(String, Fixnum)
-    end
-
-    it "passes if the block yields the given types" do
-      expect { |b| _yield_with_args(String, Fixnum, &b) }.to yield_with_args(String, Fixnum)
-    end
-
-    it "fails if the block yields objects of different types" do
-      expect {
-        expect { |b| _yield_with_args(15, "string", &b) }.to yield_with_args(String, Fixnum)
-      }.to fail_with(/expected given block to yield with arguments, but yielded with unexpected arguments/)
-    end
-  end
-end
-
-describe "yield_successive_args matcher" do
-  include YieldHelpers
-  extend  YieldHelpers
-
-  it_behaves_like "an RSpec matcher",
-      :valid_value => lambda { |b| [1, 2].each(&b) },
-      :invalid_value => lambda { |b| _dont_yield(&b) } do
-    let(:matcher) { yield_successive_args(1, 2) }
-  end
-
-  it 'has a description' do
-    yield_successive_args(1, 3).description.should eq("yield successive args(1, 3)")
-    yield_successive_args([:a, 1], [:b, 2]).description.should eq("yield successive args([:a, 1], [:b, 2])")
-  end
-
-  describe "expect {...}.to yield_successive_args([:a, 1], [:b, 2])" do
-    it 'passes when the block successively yields the given args' do
-      expect { |b| [ [:a, 1], [:b, 2] ].each(&b) }.to yield_successive_args([:a, 1], [:b, 2])
-    end
-
-    it 'fails when the block does not yield that many times' do
-      expect {
-        expect { |b| [[:a, 1]].each(&b) }.to yield_successive_args([:a, 1], [:b, 2])
-      }.to fail_with(/but yielded with unexpected arguments/)
-    end
-
-    it 'fails when the block yields the right number of times but with different arguments' do
-      expect {
-        expect { |b| [ [:a, 1], [:b, 3] ].each(&b) }.to yield_successive_args([:a, 1], [:b, 2])
-      }.to fail_with(/but yielded with unexpected arguments/)
-    end
-  end
-
-  describe "expect {...}.to yield_successive_args(1, 2, 3)" do
-    it 'passes when the block successively yields the given args' do
-      expect { |b| [1, 2, 3].each(&b) }.to yield_successive_args(1, 2, 3)
-    end
-
-    it 'passes when the block successively yields the given args using instance_eval' do
-      expect { |b| InstanceEvaler.new.each_arg(1, 2, 3, &b) }.to yield_successive_args(1, 2, 3)
-    end
-
-    it 'fails when the block does not yield the expected args' do
-      expect {
-        expect { |b| [1, 2, 4].each(&b) }.to yield_successive_args([:a, 1], [:b, 2])
-      }.to fail_with(/but yielded with unexpected arguments/)
-    end
-  end
-
-  describe "expect {...}.not_to yield_successive_args(1, 2, 3)" do
-    it 'passes when the block does not yield' do
-      expect { |b| _dont_yield(&b) }.not_to yield_successive_args(1, 2, 3)
-    end
-
-    it 'passes when the block yields the wrong number of times' do
-      expect { |b| [1, 2].each(&b) }.not_to yield_successive_args(1, 2, 3)
-    end
-
-    it 'passes when the block yields the wrong arguments' do
-      expect { |b| [1, 2, 4].each(&b) }.not_to yield_successive_args(1, 2, 3)
-    end
-
-    it 'fails when the block yields the given arguments' do
-      expect {
-        expect { |b| [1, 2, 3].each(&b) }.not_to yield_successive_args(1, 2, 3)
-      }.to fail_with(/expected given block not to yield successively/)
-    end
-
-    it 'fails if the expect block does not accept an argument' do
-      expect {
-        expect { }.not_to yield_successive_args(1, 2, 3)
-      }.to raise_error(/expect block must accept an argument/)
-    end
-
-    it 'raises an error if the expect block arg is not passed to a method as a block' do
-      expect {
-        expect { |b| }.not_to yield_successive_args(1, 2, 3)
-      }.to raise_error(/must pass the argument.*as a block/)
-    end
-  end
-
-  describe "expect {...}.to yield_successive_args(String, Fixnum)" do
-    it "passes if the block successively yields objects of the given types" do
-      expect { |b| ["string", 15].each(&b) }.to yield_successive_args(String, Fixnum)
-    end
-
-    it "passes if the block yields the given types" do
-      expect { |b| [String, Fixnum].each(&b) }.to yield_successive_args(String, Fixnum)
-    end
-
-    it "fails if the block yields objects of different types" do
-      expect {
-        expect { |b| [15, "string"].each(&b) }.to yield_successive_args(String, Fixnum)
-      }.to fail_with(/expected given block to yield successively with arguments/)
-    end
-  end
-end
-