opal-rspec 0.6.2 → 0.7.0.rc.1

data/rspec-mocks/spec/rspec/mocks/matchers/receive_message_chain_spec.rb

@@ -1,227 +0,0 @@
-module RSpec::Mocks::Matchers
-  RSpec.describe "receive_message_chain" do
-    let(:object) { double(:object) }
-
-    context "with only the expect syntax enabled" do
-      include_context "with syntax", :expect
-
-      it "errors with a negative allowance" do
-        expect {
-          allow(object).not_to receive_message_chain(:to_a)
-        }.to raise_error(RSpec::Mocks::NegationUnsupportedError)
-      end
-
-      it "errors with a negative expectation" do
-        expect {
-          expect(object).not_to receive_message_chain(:to_a)
-        }.to raise_error(RSpec::Mocks::NegationUnsupportedError)
-      end
-
-      it "errors with a negative any_instance expectation" do
-        expect {
-          expect_any_instance_of(Object).not_to receive_message_chain(:to_a)
-        }.to raise_error(RSpec::Mocks::NegationUnsupportedError)
-      end
-
-      it "errors with a negative any_instance allowance" do
-        expect {
-          allow_any_instance_of(Object).not_to receive_message_chain(:to_a)
-        }.to raise_error(RSpec::Mocks::NegationUnsupportedError)
-      end
-
-      it "works with a do block" do
-        allow(object).to receive_message_chain(:to_a, :length) do
-          3
-        end
-
-        expect(object.to_a.length).to eq(3)
-      end
-
-      it "works with a {} block" do
-        allow(object).to receive_message_chain(:to_a, :length) { 3 }
-
-        expect(object.to_a.length).to eq(3)
-      end
-
-      it "gives the { } block prescedence over the do block" do
-        allow(object).to receive_message_chain(:to_a, :length) { 3 } do
-          4
-        end
-
-        expect(object.to_a.length).to eq(3)
-      end
-
-      it "works with and_return" do
-        allow(object).to receive_message_chain(:to_a, :length).and_return(3)
-
-        expect(object.to_a.length).to eq(3)
-      end
-
-      it "can constrain the return value by the argument to the last call" do
-        allow(object).to receive_message_chain(:one, :plus).with(1) { 2 }
-        allow(object).to receive_message_chain(:one, :plus).with(2) { 3 }
-        expect(object.one.plus(1)).to eq(2)
-        expect(object.one.plus(2)).to eq(3)
-      end
-
-      it "works with and_call_original", :pending => "See https://github.com/rspec/rspec-mocks/pull/467#issuecomment-28631621" do
-        list = [1, 2, 3]
-        expect(list).to receive_message_chain(:to_a, :length).and_call_original
-        expect(list.to_a.length).to eq(3)
-      end
-
-      it "fails with and_call_original when the entire chain is not called", :pending => "See https://github.com/rspec/rspec-mocks/pull/467#issuecomment-28631621" do
-        list = [1, 2, 3]
-        expect(list).to receive_message_chain(:to_a, :length).and_call_original
-        expect(list.to_a).to eq([1, 2, 3])
-      end
-
-      it "works with and_raise" do
-        allow(object).to receive_message_chain(:to_a, :length).and_raise(StandardError.new("hi"))
-
-        expect { object.to_a.length }.to raise_error(StandardError, "hi")
-      end
-
-      it "works with and_throw" do
-        allow(object).to receive_message_chain(:to_a, :length).and_throw(:nope)
-
-        expect { object.to_a.length }.to throw_symbol(:nope)
-      end
-
-      it "works with and_yield" do
-        allow(object).to receive_message_chain(:to_a, :length).and_yield(3)
-
-        expect { |blk| object.to_a.length(&blk) }.to yield_with_args(3)
-      end
-
-      it "works with a string of messages to chain" do
-        allow(object).to receive_message_chain("to_a.length").and_yield(3)
-
-        expect { |blk| object.to_a.length(&blk) }.to yield_with_args(3)
-      end
-
-      it "works with a hash return as the last argument in the chain" do
-        allow(object).to receive_message_chain(:to_a, :length => 3)
-
-        expect(object.to_a.length).to eq(3)
-      end
-
-      it "accepts any number of arguments to the stubbed messages" do
-        allow(object).to receive_message_chain(:msg1, :msg2).and_return(:return_value)
-
-        expect(object.msg1("nonsense", :value).msg2("another", :nonsense, 3.0, "value")).to eq(:return_value)
-      end
-
-      it "accepts any number of arguments to the stubbed messages with an inline hash return value" do
-        allow(object).to receive_message_chain(:msg1, :msg2 => :return_value)
-
-        expect(object.msg1("nonsense", :value).msg2("another", :nonsense, 3.0, "value")).to eq(:return_value)
-      end
-
-      it "raises when expect is used and some of the messages in the chain aren't called" do
-        expect {
-          expect(object).to receive_message_chain(:to_a, :farce, :length => 3)
-          object.to_a
-          verify_all
-        }.to raise_error(RSpec::Mocks::MockExpectationError)
-      end
-
-      it "raises when expect is used and all but the last message in the chain are called" do
-        expect {
-          expect(object).to receive_message_chain(:foo, :bar, :baz)
-          object.foo.bar
-          verify_all
-        }.to raise_error(RSpec::Mocks::MockExpectationError)
-      end
-
-      it "does not raise when expect is used and the entire chain is called" do
-        expect {
-          expect(object).to receive_message_chain(:to_a, :length => 3)
-          object.to_a.length
-          verify_all
-        }.not_to raise_error
-      end
-
-      it "works with allow_any_instance" do
-        o = Object.new
-
-        allow_any_instance_of(Object).to receive_message_chain(:to_a, :length => 3)
-
-        expect(o.to_a.length).to eq(3)
-      end
-
-      it "stubs already stubbed instances when using `allow_any_instance_of`" do
-        o = Object.new
-        allow(o).to receive(:foo).and_return(dbl = double)
-        expect(o.foo).to be(dbl)
-
-        allow_any_instance_of(Object).to receive_message_chain(:foo, :bar).and_return("bazz")
-        expect(o.foo.bar).to eq("bazz")
-      end
-
-      it "fails when with expect_any_instance_of is used and the entire chain is not called" do
-        expect {
-          expect_any_instance_of(Object).to receive_message_chain(:to_a, :length => 3)
-          verify_all
-        }.to raise_error(RSpec::Mocks::MockExpectationError)
-      end
-
-      it "affects previously stubbed instances when `expect_any_instance_of` is called" do
-        o = Object.new
-        allow(o).to receive(:foo).and_return(double)
-
-        expect_any_instance_of(Object).to receive_message_chain(:foo, :bar => 3)
-        expect(o.foo.bar).to eq(3)
-      end
-
-      it "passes when with expect_any_instance_of is used and the entire chain is called" do
-        o = Object.new
-
-        expect_any_instance_of(Object).to receive_message_chain(:to_a, :length => 3)
-        o.to_a.length
-      end
-
-      it "works with expect where the first level of the chain is already expected" do
-        o = Object.new
-        expect(o).to receive(:foo).and_return(double)
-        expect(o).to receive_message_chain(:foo, :bar, :baz)
-
-        o.foo.bar.baz
-      end
-
-      it "works with allow where the first level of the chain is already expected" do
-        o = Object.new
-        expect(o).to receive(:foo).and_return(double)
-        allow(o).to receive_message_chain(:foo, :bar, :baz).and_return(3)
-
-        expect(o.foo.bar.baz).to eq(3)
-      end
-
-      it "works with expect where the first level of the chain is already stubbed" do
-        o = Object.new
-        allow(o).to receive(:foo).and_return(double)
-        expect(o).to receive_message_chain(:foo, :bar, :baz)
-
-        o.foo.bar.baz
-      end
-
-      it "works with allow where the first level of the chain is already stubbed" do
-        o = Object.new
-        allow(o).to receive(:foo).and_return(double)
-        allow(o).to receive_message_chain(:foo, :bar, :baz).and_return(3)
-
-        expect(o.foo.bar.baz).to eq(3)
-      end
-    end
-
-    context "when the expect and should syntaxes are enabled" do
-      include_context "with syntax", [:expect, :should]
-
-      it "stubs the message correctly" do
-        allow(object).to receive_message_chain(:to_a, :length)
-
-        expect { object.to_a.length }.not_to raise_error
-      end
-    end
-  end
-end

data/rspec-mocks/spec/rspec/mocks/matchers/receive_messages_spec.rb

@@ -1,148 +0,0 @@
-module RSpec
-  module Mocks
-    RSpec.shared_examples "complains when given blocks" do
-      it "complains if a { } block is given" do
-        expect {
-          target.to receive_messages(:a => 1) { "implementation" }
-        }.to raise_error "Implementation blocks aren't supported with `receive_messages`"
-      end
-
-      it "complains if a do; end; block is given" do
-        expect {
-          target.to receive_messages(:a => 1) do
-            "implementation"
-          end
-        }.to raise_error "Implementation blocks aren't supported with `receive_messages`"
-      end
-    end
-
-    RSpec.shared_examples "handles partially mocked objects correctly" do
-      let(:obj) { Struct.new(:a).new('original') }
-
-      it "resets partially mocked objects correctly" do
-        target.to receive_messages(:a => 1, :b => 2)
-
-        expect {
-          reset obj
-        }.to change { obj.a }.from(1).to("original")
-      end
-    end
-
-    RSpec.describe "allow(...).to receive_messages(:a => 1, :b => 2)" do
-      let(:obj) { double "Object" }
-      let(:target) { allow(obj) }
-
-      it "allows the object to respond to multiple messages" do
-        allow(obj).to receive_messages(:a => 1, :b => 2)
-        expect(obj.a).to eq 1
-        expect(obj.b).to eq 2
-      end
-
-      it_behaves_like "complains when given blocks"
-      it_behaves_like "handles partially mocked objects correctly"
-    end
-
-    RSpec.describe "allow_any_instance_of(...).to receive_messages(:a => 1, :b => 2)" do
-      let(:obj) { Object.new }
-      let(:target) { allow_any_instance_of(Object) }
-
-      it "allows the object to respond to multiple messages" do
-        allow_any_instance_of(Object).to receive_messages(:a => 1, :b => 2)
-        expect(obj.a).to eq 1
-        expect(obj.b).to eq 2
-      end
-
-      it "updates stubs on instances with existing stubs" do
-        allow(obj).to receive(:a).and_return(3)
-        expect(obj.a).to eq(3)
-
-        allow_any_instance_of(Object).to receive_messages(:a => 1, :b => 2)
-        expect(obj.a).to eq 1
-        expect(obj.b).to eq 2
-      end
-
-      it_behaves_like "complains when given blocks"
-    end
-
-    RSpec.describe "expect(...).to receive_messages(:a => 1, :b => 2)" do
-      let(:obj) { double "Object" }
-      let(:target) { expect(obj) }
-
-      let(:expectation_error) do
-        failure = nil
-        begin
-          verify_all
-        rescue RSpec::Mocks::MockExpectationError => error
-          failure = error
-        end
-        failure
-      end
-
-      it "sets up multiple expectations" do
-        expect(obj).to receive_messages(:a => 1, :b => 2)
-        obj.a
-        expect { verify_all }.to raise_error RSpec::Mocks::MockExpectationError
-      end
-
-      it 'fails with a sensible message' do
-        expect(obj).to receive_messages(:a => 1, :b => 2)
-        obj.b
-        expect(expectation_error.to_s).to eq %Q{(Double "Object").a(no args)\n    expected: 1 time with any arguments\n    received: 0 times}
-      end
-
-      it 'fails with the correct location' do
-        expect(obj).to receive_messages(:a => 1, :b => 2); line = __LINE__
-        expect(expectation_error.backtrace[0]).to match(/#{__FILE__}:#{line}/)
-      end
-
-      it_behaves_like "complains when given blocks"
-      it_behaves_like "handles partially mocked objects correctly"
-    end
-
-    RSpec.describe "expect_any_instance_of(...).to receive_messages(:a => 1, :b => 2)" do
-      let(:obj) { Object.new }
-      let(:target) { expect_any_instance_of(Object) }
-
-      it "sets up multiple expectations" do
-        expect_any_instance_of(Object).to receive_messages(:a => 1, :b => 2)
-        obj.a
-        expect { RSpec::Mocks.space.verify_all }.to raise_error RSpec::Mocks::MockExpectationError
-        RSpec::Mocks.space.reset_all
-      end
-
-      it_behaves_like "complains when given blocks"
-    end
-
-    RSpec.describe "negative expectation failure" do
-      let(:obj) { Object.new }
-
-      example "allow(...).to_not receive_messages(:a => 1, :b => 2)" do
-        expect { allow(obj).to_not receive_messages(:a => 1, :b => 2) }.to(
-          raise_error "`allow(...).to_not receive_messages` is not supported "+
-                      "since it doesn't really make sense. What would it even mean?"
-        )
-      end
-
-      example "allow_any_instance_of(...).to_not receive_messages(:a => 1, :b => 2)" do
-        expect { allow_any_instance_of(obj).to_not receive_messages(:a => 1, :b => 2) }.to(
-          raise_error "`allow_any_instance_of(...).to_not receive_messages` is not supported "+
-                      "since it doesn't really make sense. What would it even mean?"
-        )
-      end
-
-      example "expect(...).to_not receive_messages(:a => 1, :b => 2)" do
-        expect { expect(obj).to_not receive_messages(:a => 1, :b => 2) }.to(
-          raise_error "`expect(...).to_not receive_messages` is not supported "+
-                      "since it doesn't really make sense. What would it even mean?"
-        )
-      end
-
-      example "expect_any_instance_of(...).to_not receive_messages(:a => 1, :b => 2)" do
-        expect { expect_any_instance_of(obj).to_not receive_messages(:a => 1, :b => 2) }.to(
-          raise_error "`expect_any_instance_of(...).to_not receive_messages` is not supported "+
-                      "since it doesn't really make sense. What would it even mean?"
-        )
-      end
-    end
-  end
-end

data/rspec-mocks/spec/rspec/mocks/matchers/receive_spec.rb

@@ -1,525 +0,0 @@
-module RSpec
-  module Mocks
-    RSpec.describe Matchers::Receive do
-      include_context "with syntax", :expect
-
-      describe "expectations/allowances on any instance recorders" do
-        include_context "with syntax", [:expect, :should]
-
-        it "warns about allow(Klass.any_instance).to receive..." do
-          expect(RSpec).to receive(:warning).with(/allow.*any_instance.*is probably not what you meant.*allow_any_instance_of.*instead/)
-          allow(Object.any_instance).to receive(:foo)
-        end
-
-        it "includes the correct call site in the allow warning" do
-          expect_warning_with_call_site(__FILE__, __LINE__ + 1)
-          allow(Object.any_instance).to receive(:foo)
-        end
-
-        it "warns about expect(Klass.any_instance).to receive..." do
-          expect(RSpec).to receive(:warning).with(/expect.*any_instance.*is probably not what you meant.*expect_any_instance_of.*instead/)
-          any_instance_proxy = Object.any_instance
-          expect(any_instance_proxy).to receive(:foo)
-          any_instance_proxy.foo
-        end
-
-        it "includes the correct call site in the expect warning" do
-          any_instance_proxy = Object.any_instance
-          expect_warning_with_call_site(__FILE__, __LINE__ + 1)
-          expect(any_instance_proxy).to receive(:foo)
-          any_instance_proxy.foo
-        end
-      end
-
-      shared_examples "a receive matcher" do |*options|
-        it 'allows the caller to configure how the subject responds' do
-          wrapped.to receive(:foo).and_return(5)
-          expect(receiver.foo).to eq(5)
-        end
-
-        it 'allows the caller to constrain the received arguments' do
-          wrapped.to receive(:foo).with(:a)
-          receiver.foo(:a)
-
-          expect {
-            receiver.foo(:b)
-          }.to raise_error(/received :foo with unexpected arguments/)
-        end
-
-        it 'allows the caller to constrain the received arguments by matcher' do
-          wrapped.to receive(:foo).with an_instance_of Fixnum
-          expect {
-            receiver.foo(1.1)
-          }.to raise_error(/expected.*\(an instance of Fixnum\)/)
-          receiver.foo(1)
-        end
-
-        it 'allows a `do...end` block implementation to be provided' do
-          wrapped.to receive(:foo) do
-            4
-          end
-
-          expect(receiver.foo).to eq(4)
-        end
-
-        it 'allows chaining off a `do...end` block implementation to be provided' do
-          wrapped.to receive(:foo) do
-            4
-          end.and_return(6)
-
-          expect(receiver.foo).to eq(6)
-        end
-
-        it 'allows a `{ ... }` block implementation to be provided' do
-          wrapped.to receive(:foo) { 5 }
-          expect(receiver.foo).to eq(5)
-        end
-
-        it 'gives precedence to a `{ ... }` block when both forms are provided ' +
-           'since that form actually binds to `receive`' do
-          wrapped.to receive(:foo) { :curly } do
-            :do_end
-          end
-
-          expect(receiver.foo).to eq(:curly)
-        end
-
-        it 'does not support other matchers', :unless => options.include?(:allow_other_matchers) do
-          expect {
-            wrapped.to eq(3)
-          }.to raise_error(UnsupportedMatcherError)
-        end
-
-        it 'does not get confused by messages being passed as strings and symbols' do
-          wrapped.to receive(:foo).with(1) { :a }
-          wrapped.to receive("foo").with(2) { :b }
-
-          expect(receiver.foo(1)).to eq(:a)
-          expect(receiver.foo(2)).to eq(:b)
-        end
-
-        it 'allows do...end blocks to be passed to the fluent interface methods without getting a warning' do
-          expect(RSpec).not_to receive(:warning)
-
-          wrapped.to receive(:foo).with(1) do
-            :a
-          end
-
-          expect(receiver.foo(1)).to eq(:a)
-        end
-
-        it 'makes { } blocks trump do...end blocks when passed to a fluent interface method' do
-          wrapped.to receive(:foo).with(1) { :curly } do
-            :do_end
-          end
-
-          expect(receiver.foo(1)).to eq(:curly)
-        end
-      end
-
-      shared_examples "an expect syntax allowance" do |*options|
-        it_behaves_like "a receive matcher", *options
-
-        it 'does not expect the message to be received' do
-          wrapped.to receive(:foo)
-          expect { verify_all }.not_to raise_error
-        end
-      end
-
-      shared_examples "an expect syntax negative allowance" do
-        it 'is disabled since this expression is confusing' do
-          expect {
-            wrapped.not_to receive(:foo)
-          }.to raise_error(/not_to receive` is not supported/)
-
-          expect {
-            wrapped.to_not receive(:foo)
-          }.to raise_error(/to_not receive` is not supported/)
-        end
-      end
-
-      shared_examples "an expect syntax expectation" do |*options|
-        it_behaves_like "a receive matcher", *options
-
-        it 'sets up a message expectation that passes if the message is received' do
-          wrapped.to receive(:foo)
-          receiver.foo
-          verify_all
-        end
-
-        it 'sets up a message expectation that fails if the message is not received' do
-          wrapped.to receive(:foo)
-
-          expect {
-            verify_all
-          }.to raise_error(RSpec::Mocks::MockExpectationError)
-        end
-
-        it "reports the line number of expectation of unreceived message", :pending => options.include?(:does_not_report_line_num) do
-          expected_error_line = __LINE__; wrapped.to receive(:foo)
-
-          expect {
-            verify_all
-          }.to raise_error { |e|
-            expect(e.backtrace.first).to match(/#{File.basename(__FILE__)}:#{expected_error_line}/)
-          }
-        end
-      end
-
-      shared_examples "an expect syntax negative expectation" do
-        it 'sets up a negaive message expectation that passes if the message is not received' do
-          wrapped.not_to receive(:foo)
-          verify_all
-        end
-
-        it 'sets up a negative message expectation that fails if the message is received' do
-          wrapped.not_to receive(:foo)
-
-          expect {
-            receiver.foo
-          }.to raise_error(/expected: 0 times.*received: 1 time/m)
-        end
-
-        it 'supports `to_not` as an alias for `not_to`' do
-          wrapped.to_not receive(:foo)
-
-          expect {
-            receiver.foo
-          }.to raise_error(/expected: 0 times.*received: 1 time/m)
-        end
-
-        it 'allows the caller to constrain the received arguments' do
-          wrapped.not_to receive(:foo).with(:a)
-          def receiver.method_missing(*a); end # a poor man's stub...
-
-          expect {
-            receiver.foo(:b)
-          }.not_to raise_error
-
-          expect {
-            receiver.foo(:a)
-          }.to raise_error(/expected: 0 times.*received: 1 time/m)
-        end
-
-        it 'prevents confusing double-negative expressions involving `never`' do
-          expect {
-            wrapped.not_to receive(:foo).never
-          }.to raise_error(/trying to negate it again/)
-
-          expect {
-            wrapped.to_not receive(:foo).never
-          }.to raise_error(/trying to negate it again/)
-        end
-      end
-
-      shared_examples "resets partial mocks cleanly" do
-        let(:klass)  { Struct.new(:foo) }
-        let(:object) { klass.new :bar }
-
-        it "removes the method double" do
-          target.to receive(:foo).and_return(:baz)
-          expect { reset object }.to change { object.foo }.from(:baz).to(:bar)
-        end
-
-        context "on a frozen object" do
-          it "warns about being unable to remove the method double" do
-            target.to receive(:foo).and_return(:baz)
-            expect_warning_without_call_site(/rspec-mocks was unable to restore the original `foo` method on #{object.inspect}/)
-            object.freeze
-            reset object
-          end
-
-          it "includes the spec location in the warning" do
-            line = __LINE__ - 1
-            target.to receive(:foo).and_return(:baz)
-            expect_warning_without_call_site(/#{RSpec::Core::Metadata.relative_path(__FILE__)}:#{line}/)
-            object.freeze
-            reset object
-          end
-        end
-      end
-
-      shared_examples "resets partial mocks of any instance cleanly" do
-        let(:klass)  { Struct.new(:foo) }
-        let(:object) { klass.new :bar }
-
-        it "removes the method double" do
-          target.to receive(:foo).and_return(:baz)
-          expect {
-            verify_all
-          }.to change { object.foo }.from(:baz).to(:bar)
-        end
-      end
-
-      describe "allow(...).to receive" do
-        it_behaves_like "an expect syntax allowance" do
-          let(:receiver) { double }
-          let(:wrapped)  { allow(receiver) }
-        end
-        it_behaves_like "resets partial mocks cleanly" do
-          let(:target) { allow(object) }
-        end
-      end
-
-      describe "allow(...).not_to receive" do
-        it_behaves_like "an expect syntax negative allowance" do
-          let(:wrapped) { allow(double) }
-        end
-      end
-
-      describe "allow_any_instance_of(...).to receive" do
-        it_behaves_like "an expect syntax allowance" do
-          let(:klass)    { Class.new }
-          let(:wrapped)  { allow_any_instance_of(klass) }
-          let(:receiver) { klass.new }
-        end
-
-        it_behaves_like "resets partial mocks of any instance cleanly" do
-          let(:target) { allow_any_instance_of(klass) }
-        end
-      end
-
-      describe "allow_any_instance_of(...).not_to receive" do
-        it_behaves_like "an expect syntax negative allowance" do
-          let(:wrapped) { allow_any_instance_of(Class.new) }
-        end
-      end
-
-      describe "expect(...).to receive" do
-        it_behaves_like "an expect syntax expectation", :allow_other_matchers do
-          let(:receiver) { double }
-          let(:wrapped)  { expect(receiver) }
-
-          it 'sets up a message expectation that formats argument matchers correctly' do
-            wrapped.to receive(:foo).with an_instance_of Fixnum
-            expect { verify_all }.to(
-              raise_error(/expected: 1 time with arguments: \(an instance of Fixnum\)\n\s+received: 0 times$/)
-            )
-          end
-        end
-        it_behaves_like "resets partial mocks cleanly" do
-          let(:target) { expect(object) }
-        end
-
-        context "ordered with receive counts" do
-          let(:dbl) { double(:one => 1, :two => 2) }
-
-          it "passes with exact receive counts when the ordering is correct" do
-            expect(dbl).to receive(:one).twice.ordered
-            expect(dbl).to receive(:two).once.ordered
-
-            dbl.one
-            dbl.one
-            dbl.two
-          end
-
-          it "fails with exact receive counts when the ordering is incorrect" do
-            expect {
-              expect(dbl).to receive(:one).twice.ordered
-              expect(dbl).to receive(:two).once.ordered
-
-              dbl.one
-              dbl.two
-              dbl.one
-            }.to raise_error(/out of order/)
-
-            reset_all
-          end
-
-          it "passes with at least when the ordering is correct" do
-            expect(dbl).to receive(:one).at_least(2).times.ordered
-            expect(dbl).to receive(:two).once.ordered
-
-            dbl.one
-            dbl.one
-            dbl.one
-            dbl.two
-          end
-
-          pending "fails with at least when the ordering is incorrect" do
-            expect {
-              expect(dbl).to receive(:one).at_least(2).times.ordered
-              expect(dbl).to receive(:two).once.ordered
-
-              dbl.one
-              dbl.two
-            }.to raise_error
-
-            reset_all
-          end
-
-          it "passes with at most when the ordering is correct" do
-            expect(dbl).to receive(:one).at_most(2).times.ordered
-            expect(dbl).to receive(:two).once.ordered
-
-            dbl.one
-            dbl.two
-          end
-
-          pending "fails with at most when the ordering is incorrect" do
-            expect {
-              expect(dbl).to receive(:one).at_most(2).times.ordered
-              expect(dbl).to receive(:two).once.ordered
-
-              dbl.one
-              dbl.one
-              dbl.one
-              dbl.two
-            }.to raise_error
-
-            reset_all
-          end
-        end
-      end
-
-      describe "expect_any_instance_of(...).to receive" do
-        it_behaves_like "an expect syntax expectation", :does_not_report_line_num do
-          let(:klass)    { Class.new }
-          let(:wrapped)  { expect_any_instance_of(klass) }
-          let(:receiver) { klass.new }
-
-          it 'sets up a message expectation that formats argument matchers correctly' do
-            wrapped.to receive(:foo).with an_instance_of Fixnum
-            expect { verify_all }.to raise_error(/should have received the following message\(s\) but didn't/)
-          end
-        end
-        it_behaves_like "resets partial mocks of any instance cleanly" do
-          let(:target) { expect_any_instance_of(klass) }
-        end
-      end
-
-      describe "expect(...).not_to receive" do
-        it_behaves_like "an expect syntax negative expectation" do
-          let(:receiver) { double }
-          let(:wrapped)  { expect(receiver) }
-        end
-      end
-
-      describe "expect_any_instance_of(...).not_to receive" do
-        it_behaves_like "an expect syntax negative expectation" do
-          let(:klass)    { Class.new }
-          let(:wrapped)  { expect_any_instance_of(klass) }
-          let(:receiver) { klass.new }
-        end
-      end
-
-      shared_examples "using rspec-mocks in another test framework" do
-        it 'can use the `expect` syntax' do
-          dbl = double
-
-          framework.new.instance_exec do
-            expect(dbl).to receive(:foo).and_return(3)
-          end
-
-          expect(dbl.foo).to eq(3)
-        end
-
-        it 'expects the method to be called when `expect` is used' do
-          dbl = double
-
-          framework.new.instance_exec do
-            expect(dbl).to receive(:foo)
-          end
-
-          expect { verify dbl }.to raise_error(RSpec::Mocks::MockExpectationError)
-        end
-
-        it 'supports `expect(...).not_to receive`' do
-          dbl = double
-
-          framework.new.instance_exec do
-            expect(dbl).not_to receive(:foo)
-          end
-
-          expect { dbl.foo }.to raise_error(RSpec::Mocks::MockExpectationError)
-        end
-
-        it 'supports `expect(...).to_not receive`' do
-          dbl = double
-
-          framework.new.instance_exec do
-            expect(dbl).to_not receive(:foo)
-          end
-
-          expect { dbl.foo }.to raise_error(RSpec::Mocks::MockExpectationError)
-        end
-      end
-
-      context "when used in a test framework without rspec-expectations" do
-        let(:framework) do
-          Class.new do
-            include RSpec::Mocks::ExampleMethods
-
-            def eq(value)
-              double("MyMatcher")
-            end
-          end
-        end
-
-        it_behaves_like "using rspec-mocks in another test framework"
-
-        it 'cannot use `expect` with another matcher' do
-          expect {
-            framework.new.instance_exec do
-              expect(3).to eq(3)
-            end
-          }.to raise_error(/only the `receive` or `receive_messages` matchers are supported with `expect\(...\).to`/)
-        end
-
-        it 'can toggle the available syntax' do
-          expect(framework.new).to respond_to(:expect)
-          RSpec::Mocks.configuration.syntax = :should
-          expect(framework.new).not_to respond_to(:expect)
-          RSpec::Mocks.configuration.syntax = :expect
-          expect(framework.new).to respond_to(:expect)
-        end
-
-        after { RSpec::Mocks.configuration.syntax = :expect }
-      end
-
-      context "when rspec-expectations is included in the test framework first" do
-        before do
-          # the examples here assume `expect` is define in RSpec::Matchers...
-          expect(RSpec::Matchers.method_defined?(:expect)).to be_truthy
-        end
-
-        let(:framework) do
-          Class.new do
-            include RSpec::Matchers
-            include RSpec::Mocks::ExampleMethods
-          end
-        end
-
-        it_behaves_like "using rspec-mocks in another test framework"
-
-        it 'can use `expect` with any matcher' do
-          framework.new.instance_exec do
-            expect(3).to eq(3)
-          end
-        end
-      end
-
-      context "when rspec-expectations is included in the test framework last" do
-        before do
-          # the examples here assume `expect` is define in RSpec::Matchers...
-          expect(RSpec::Matchers.method_defined?(:expect)).to be_truthy
-        end
-
-        let(:framework) do
-          Class.new do
-            include RSpec::Mocks::ExampleMethods
-            include RSpec::Matchers
-          end
-        end
-
-        it_behaves_like "using rspec-mocks in another test framework"
-
-        it 'can use `expect` with any matcher' do
-          framework.new.instance_exec do
-            expect(3).to eq(3)
-          end
-        end
-      end
-    end
-  end
-end