rspec-mocks 2.8.0.rc1 → 2.8.0.rc2

data/lib/rspec/mocks/argument_expectation.rb

@@ -1,5 +1,6 @@
 module RSpec
   module Mocks
+    # @api private
     class ArgumentExpectation
       attr_reader :args
       

data/lib/rspec/mocks/argument_matchers.rb

@@ -1,12 +1,12 @@
 module RSpec
   module Mocks
 
-    # ArgumentMatchers are messages that you can include in message
+    # ArgumentMatchers are placeholders that you can include in message
     # expectations to match arguments against a broader check than simple
     # equality.
     #
-    # With the exception of any_args() and no_args(), the matchers
-    # are all positional - they match against the arg in the given position.
+    # With the exception of `any_args` and `no_args`, they all match against
+    # the arg in same position in the argument list.
     module ArgumentMatchers
 
       class AnyArgsMatcher
@@ -36,8 +36,7 @@ module RSpec
         end
 
         def ==(value)
-          return value =~ @regexp unless value.is_a?(Regexp)
-          value == @regexp
+          Regexp === value ? value == @regexp : value =~ @regexp
         end
       end
 
@@ -46,7 +45,7 @@ module RSpec
         end
 
         def ==(value)
-          TrueClass === value || FalseClass === value
+          [true,false].include?(value)
         end
       end
 
@@ -56,12 +55,9 @@ module RSpec
         end
 
         def ==(actual)
-          @expected.each do | key, value |
-            return false unless actual.has_key?(key) && value == actual[key]
-          end
-          true
+          @expected.all? {|k,v| actual.has_key?(k) && v == actual[k]}
         rescue NoMethodError
-          return false
+          false
         end
 
         def description
@@ -69,18 +65,15 @@ module RSpec
         end
       end
       
-      class HashNotIncludingMatcher
+      class HashExcludingMatcher
         def initialize(expected)
           @expected = expected
         end
 
         def ==(actual)
-          @expected.each do | key, value |
-            return false if actual.has_key?(key) && value == actual[key]
-          end
-          true
+          @expected.none? {|k,v| actual.has_key?(k) && v == actual[k]}
         rescue NoMethodError
-          return false
+          false
         end
 
         def description
@@ -94,7 +87,7 @@ module RSpec
         end
 
         def ==(value)
-          @methods_to_respond_to.all? { |sym| value.respond_to?(sym) }
+          @methods_to_respond_to.all? {|sym| value.respond_to?(sym)}
         end
       end
 
@@ -138,10 +131,11 @@ module RSpec
         end
       end
 
-      # Passes if object receives :message with any args at all. This is
-      # really a more explicit variation of object.should_receive(:message)
+      # Passes if object receives `:message` with any args at all. This is
+      # really a more explicit variation of `object.should_receive(:message)`
+      #
+      # @example
       #
-      # == Examples
       #   object.should_receive(:message).with(any_args())
       def any_args
         AnyArgsMatcher.new
@@ -149,7 +143,8 @@ module RSpec
       
       # Passes as long as there is an argument.
       #
-      # == Examples
+      # @example
+      #
       #   object.should_receive(:message).with(anything())
       def anything
         AnyArgMatcher.new(nil)
@@ -157,7 +152,8 @@ module RSpec
       
       # Passes if no arguments are passed along with the message
       #
-      # == Examples
+      # @example
+      #
       #   object.should_receive(:message).with(no_args)
       def no_args
         NoArgsMatcher.new
@@ -165,25 +161,28 @@ module RSpec
       
       # Passes if the argument responds to the specified messages.
       #
-      # == Examples
+      # @example
+      #
       #   object.should_receive(:message).with(duck_type(:hello))
       #   object.should_receive(:message).with(duck_type(:hello, :goodbye))
       def duck_type(*args)
         DuckTypeMatcher.new(*args)
       end
 
-      # == Examples
-      #   object.should_receive(:message).with(boolean())
-      #
       # Passes if the argument is boolean.
+      #
+      # @example
+      #
+      #   object.should_receive(:message).with(boolean())
       def boolean
         BooleanMatcher.new(nil)
       end
       
-      # Passes if the argument is a hash that includes the specified key(s) or key/value
-      # pairs. If the hash includes other keys, it will still pass.
+      # Passes if the argument is a hash that includes the specified key(s) or
+      # key/value pairs. If the hash includes other keys, it will still pass.
+      #
+      # @example
       #
-      # == Examples
       #   object.should_receive(:message).with(hash_including(:key => val))
       #   object.should_receive(:message).with(hash_including(:key))
       #   object.should_receive(:message).with(hash_including(:key, :key2 => val2))
@@ -191,24 +190,28 @@ module RSpec
         HashIncludingMatcher.new(anythingize_lonely_keys(*args))
       end
       
-      # Passes if the argument is a hash that doesn't include the specified key(s) or key/value
+      # Passes if the argument is a hash that doesn't include the specified
+      # key(s) or key/value
+      #
+      # @example
       #
-      # == Examples
-      #   object.should_receive(:message).with(hash_not_including(:key => val))
-      #   object.should_receive(:message).with(hash_not_including(:key))
-      #   object.should_receive(:message).with(hash_not_including(:key, :key2 => :val2))
-      def hash_not_including(*args)
-        HashNotIncludingMatcher.new(anythingize_lonely_keys(*args))
+      #   object.should_receive(:message).with(hash_excluding(:key => val))
+      #   object.should_receive(:message).with(hash_excluding(:key))
+      #   object.should_receive(:message).with(hash_excluding(:key, :key2 => :val2))
+      def hash_excluding(*args)
+        HashExcludingMatcher.new(anythingize_lonely_keys(*args))
       end
+
+      alias_method :hash_not_including, :hash_excluding
       
-      # Passes if arg.instance_of?(klass)
+      # Passes if `arg.instance_of?(klass)`
       def instance_of(klass)
         InstanceOf.new(klass)
       end
       
       alias_method :an_instance_of, :instance_of
       
-      # Passes if arg.kind_of?(klass)
+      # Passes if `arg.kind_of?(klass)`
       def kind_of(klass)
         KindOf.new(klass)
       end

data/lib/rspec/mocks/error_generator.rb

@@ -1,55 +1,65 @@
 module RSpec
   module Mocks
+    # @private
     class ErrorGenerator
       attr_writer :opts
-      
+
       def initialize(target, name, options={})
         @declared_as = options[:__declared_as] || 'Mock'
         @target = target
         @name = name
       end
-      
+
+      # @private
       def opts
         @opts ||= {}
       end
 
+      # @private
       def raise_unexpected_message_error(sym, *args)
         __raise "#{intro} received unexpected message :#{sym}#{arg_message(*args)}"
       end
-      
+
+      # @private
       def raise_unexpected_message_args_error(expectation, *args)
         expected_args = format_args(*expectation.expected_args)
         actual_args = format_args(*args)
         __raise "#{intro} received #{expectation.sym.inspect} with unexpected arguments\n  expected: #{expected_args}\n       got: #{actual_args}"
       end
-      
+
+      # @private
       def raise_similar_message_args_error(expectation, *args)
         expected_args = format_args(*expectation.expected_args)
         actual_args = args.collect {|a| format_args(*a)}.join(", ")
         __raise "#{intro} received #{expectation.sym.inspect} with unexpected arguments\n  expected: #{expected_args}\n       got: #{actual_args}"
       end
-      
+
+      # @private
       def raise_expectation_error(sym, expected_received_count, actual_received_count, *args)
         __raise "(#{intro}).#{sym}#{format_args(*args)}\n    expected: #{count_message(expected_received_count)}\n    received: #{count_message(actual_received_count)}"
       end
-      
+
+      # @private
       def raise_out_of_order_error(sym)
         __raise "#{intro} received :#{sym} out of order"
       end
-      
+
+      # @private
       def raise_block_failed_error(sym, detail)
         __raise "#{intro} received :#{sym} but passed block failed with: #{detail}"
       end
-      
+
+      # @private
       def raise_missing_block_error(args_to_yield)
         __raise "#{intro} asked to yield |#{arg_list(*args_to_yield)}| but no block was passed"
       end
-      
+
+      # @private
       def raise_wrong_arity_error(args_to_yield, arity)
         __raise "#{intro} yielded |#{arg_list(*args_to_yield)}| to block with arity of #{arity}"
       end
-      
-    private
+
+      private
 
       def intro
         if @name
@@ -64,16 +74,16 @@ module RSpec
           "nil"
         end
       end
-      
+
       def __raise(message)
         message = opts[:message] unless opts[:message].nil?
         Kernel::raise(RSpec::Mocks::MockExpectationError, message)
       end
-      
+
       def arg_message(*args)
         " with " + format_args(*args)
       end
-      
+
       def format_args(*args)
         args.empty? ? "(no args)" : "(" + arg_list(*args) + ")"
       end
@@ -81,7 +91,7 @@ module RSpec
       def arg_list(*args)
         args.collect {|arg| arg.respond_to?(:description) ? arg.description : arg.inspect}.join(", ")
       end
-      
+
       def count_message(count)
         return "at least #{pretty_print(count.abs)}" if count < 0
         return pretty_print(count)

data/lib/rspec/mocks/errors.rb

@@ -1,8 +1,10 @@
 module RSpec
   module Mocks
+    # @private
     class MockExpectationError < Exception
     end
     
+    # @private
     class AmbiguousReturnError < StandardError
     end
   end

data/lib/rspec/mocks/{spec_methods.rb → example_methods.rb}

@@ -5,37 +5,38 @@ module RSpec
 
       # Creates an instance of RSpec::Mocks::Mock.
       #
-      # +name+ is used for failure reporting, so you should use the role that
+      # `name` is used for failure reporting, so you should use the role that
       # the mock is playing in the example.
       #
-      # Use +stubs+ to declare one or more method stubs in one statement.
+      # Use `stubs` to declare one or more method stubs in one statement.
       #
-      # == Examples
+      # @example
       #
       #   book = double("book", :title => "The RSpec Book")
-      #   book.title => "The RSpec Book"
+      #   book.title #=> "The RSpec Book"
       #
-      #   card = double("card", :suit => "Spades", :rank => "A"
-      #   card.suit => "Spades"
-      #   card.rank => "A"
+      #   card = double("card", :suit => "Spades", :rank => "A")
+      #   card.suit  #=> "Spades"
+      #   card.rank  #=> "A"
       def double(*args)
         declare_double('Double', *args)
       end
 
-      # Just like double, but use double
+      # Just like double
       def mock(*args)
         declare_double('Mock', *args)
       end
 
-      # Just like double, but use double
+      # Just like double
       def stub(*args)
         declare_double('Stub', *args)
       end
 
       # Disables warning messages about expectations being set on nil.
       #
-      # By default warning messages are issued when expectations are set on nil.  This is to
-      # prevent false-positives and to catch potential bugs early on.
+      # By default warning messages are issued when expectations are set on
+      # nil.  This is to prevent false-positives and to catch potential bugs
+      # early on.
       def allow_message_expectations_on_nil
         Proxy.allow_message_expectations_on_nil
       end

data/lib/rspec/mocks/extensions/instance_exec.rb

@@ -1,7 +1,10 @@
 module RSpec
   module Mocks
+    # @private
     module InstanceExec
       unless respond_to?(:instance_exec)
+        # @private
+        #
         # based on Bounded Spec InstanceExec (Mauricio Fernandez)
         # http://eigenclass.org/hiki/bounded+space+instance_exec
         # - uses singleton_class of matcher instead of global

data/lib/rspec/mocks/message_expectation.rb

@@ -1,13 +1,15 @@
 module RSpec
   module Mocks
 
-    class BaseExpectation
+    class MessageExpectation
+      # @private
       attr_reader :sym
       attr_writer :expected_received_count, :method_block, :expected_from
       protected :expected_received_count=, :method_block=, :expected_from=
       attr_accessor :error_generator
       protected :error_generator, :error_generator=
-      
+
+      # @private
       def initialize(error_generator, expectation_ordering, expected_from, sym, method_block, expected_received_count=1, opts={}, &implementation)
         @error_generator = error_generator
         @error_generator.opts = opts
@@ -20,7 +22,7 @@ module RSpec
         @args_expectation = ArgumentExpectation.new(ArgumentMatchers::AnyArgsMatcher.new)
         @consecutive = false
         @exception_to_raise = nil
-        @symbol_to_throw = nil
+        @args_to_throw = []
         @order_group = expectation_ordering
         @at_least = nil
         @at_most = nil
@@ -31,7 +33,8 @@ module RSpec
         @return_block = implementation
         @eval_context = nil
       end
-      
+
+      # @private
       def build_child(expected_from, method_block, expected_received_count, opts={})
         child = clone
         child.expected_from = expected_from
@@ -44,80 +47,140 @@ module RSpec
         child.clone_args_to_yield(*@args_to_yield)
         child
       end
-      
+
+      # @private
       def expected_args
         @args_expectation.args
       end
 
+      # @overload and_return(value)
+      # @overload and_return(first_value, second_value)
+      # @overload and_return(&block)
+      #
+      # Tells the object to return a value when it receives the message.  Given
+      # more than one value, the first value is returned the first time the
+      # message is received, the second value is returned the next time, etc,
+      # etc.
+      #
+      # If the message is received more times than there are values, the last
+      # value is received for every subsequent call.
+      #
+      # The block format is still supported, but is unofficially deprecated in
+      # favor of just passing a block to the stub method.
+      #
+      # @example
+      #
+      #   counter.stub(:count).and_return(1)
+      #   counter.count # => 1
+      #   counter.count # => 1
+      #
+      #   counter.stub(:count).and_return(1,2,3)
+      #   counter.count # => 1
+      #   counter.count # => 2
+      #   counter.count # => 3
+      #   counter.count # => 3
+      #   counter.count # => 3
+      #   # etc
+      #
+      #   # Supported, but ...
+      #   counter.stub(:count).and_return { 1 }
+      #   counter.count # => 1
+      #
+      #   # ... this is prefered
+      #   counter.stub(:count) { 1 }
+      #   counter.count # => 1
       def and_return(*values, &return_block)
         Kernel::raise AmbiguousReturnError unless @method_block.nil?
         case values.size
-          when 0 then value = nil
-          when 1 then value = values[0]
+        when 0 then value = nil
+        when 1 then value = values[0]
         else
           value = values
           @consecutive = true
           @expected_received_count = values.size if !ignoring_args? &&
-                                                    @expected_received_count < values.size
+            @expected_received_count < values.size
         end
         @return_block = block_given? ? return_block : lambda { value }
       end
-      
-      # Tells the mock or stub to raise an exception when the message
-      # is received.
+
+      # @overload and_raise
+      # @overload and_raise(ExceptionClass)
+      # @overload and_raise(exception_instance)
+      #
+      # Tells the object to raise an exception when the message is received.
       #
-      # == Warning
+      # @note
       #
-      # When you pass an exception class, the MessageExpectation will
-      # raise an instance of it, creating it with +new+. If the exception
-      # class initializer requires any parameters, you must pass in an
-      # instance and not the class.
+      #   When you pass an exception class, the MessageExpectation will raise
+      #   an instance of it, creating it with `new`. If the exception class
+      #   initializer requires any parameters, you must pass in an instance and
+      #   not the class.
       #
-      # == Examples
-      #   and_raise()
-      #   and_raise(Exception) #any exception class
-      #   and_raise(exception) #any exception object
+      # @example
+      #
+      #   car.stub(:go).and_raise
+      #   car.stub(:go).and_raise(OutOfGas)
+      #   car.stub(:go).and_raise(OutOfGas.new(2, :oz))
       def and_raise(exception=Exception)
         @exception_to_raise = exception
       end
-      
-      def and_throw(symbol)
-        @symbol_to_throw = symbol
+
+      # @overload and_throw(symbol)
+      # @overload and_throw(symbol, object)
+      #
+      # Tells the object to throw a symbol (with the object if that form is
+      # used) when the message is received.
+      #
+      # @example
+      #
+      #   car.stub(:go).and_throw(:out_of_gas)
+      #   car.stub(:go).and_throw(:out_of_gas, :level => 0.1)
+      def and_throw(symbol, object = nil)
+        @args_to_throw << symbol
+        @args_to_throw << object if object
       end
-      
+
+      # Tells the object to yield one or more args to a block when the message
+      # is received.
+      #
+      # @example
+      #
+      #   stream.stub(:open).and_yield(StringIO.new)
       def and_yield(*args, &block)
         if @args_to_yield_were_cloned
           @args_to_yield.clear
           @args_to_yield_were_cloned = false
         end
-        
+
         if block
           @eval_context = Object.new
           @eval_context.extend RSpec::Mocks::InstanceExec
           yield @eval_context
         end
-        
+
         @args_to_yield << args
         self
       end
-      
+
+      # @private
       def matches?(sym, *args)
         @sym == sym and @args_expectation.args_match?(*args)
       end
-      
+
+      # @private
       def invoke(*args, &block)
         if @expected_received_count == 0
           @failed_fast = true
           @actual_received_count += 1
           @error_generator.raise_expectation_error(@sym, @expected_received_count, @actual_received_count, *args)
         end
-        
+
         @order_group.handle_order_constraint self
 
         begin
-          Kernel::raise @exception_to_raise unless @exception_to_raise.nil?
-          Kernel::throw @symbol_to_throw unless @symbol_to_throw.nil?
-          
+          Kernel::raise(@exception_to_raise) unless @exception_to_raise.nil?
+          Kernel::throw(*@args_to_throw) unless @args_to_throw.empty?
+
           default_return_val = if !@method_block.nil?
                                  invoke_method_block(*args, &block)
                                elsif !@args_to_yield.empty? || @eval_context
@@ -125,7 +188,7 @@ module RSpec
                                else
                                  nil
                                end
-          
+
           if @consecutive
             invoke_consecutive_return_block(*args, &block)
           elsif @return_block
@@ -138,111 +201,61 @@ module RSpec
         end
       end
 
+      # @private
       def called_max_times?
         @expected_received_count != :any && @expected_received_count > 0 &&
           @actual_received_count >= @expected_received_count
       end
-      
-      protected
-
-      def invoke_method_block(*args, &block)
-        begin
-          @method_block.call(*args, &block)
-        rescue => detail
-          @error_generator.raise_block_failed_error(@sym, detail.message)
-        end
-      end
-      
-      def invoke_with_yield(&block)
-        if block.nil?
-          @error_generator.raise_missing_block_error @args_to_yield
-        end
-        value = nil
-        @args_to_yield.each do |args_to_yield_this_time|
-          if block.arity > -1 && args_to_yield_this_time.length != block.arity
-            @error_generator.raise_wrong_arity_error args_to_yield_this_time, block.arity
-          end
-          value = eval_block(*args_to_yield_this_time, &block)
-        end
-        value
-      end
-
-      def eval_block(*args, &block)
-        if @eval_context
-          @eval_context.instance_exec(*args, &block)
-        else
-          block.call(*args)
-        end
-      end
 
-      def invoke_consecutive_return_block(*args, &block)
-        value = invoke_return_block(*args, &block)
-        index = [@actual_received_count, value.size-1].min
-        value[index]
-      end
-      
-      def invoke_return_block(*args, &block)
-        args << block unless block.nil?
-        # Ruby 1.9 - when we set @return_block to return values
-        # regardless of arguments, any arguments will result in
-        # a "wrong number of arguments" error
-        @return_block.arity == 0 ? @return_block.call : @return_block.call(*args)
-      end
-      
-      def clone_args_to_yield(*args)
-        @args_to_yield = args.clone
-        @args_to_yield_were_cloned = true
-      end
-      
-      def failed_fast?
-        @failed_fast
-      end
-    end
-    
-    class MessageExpectation < BaseExpectation
-      
+      # @private
       def matches_name_but_not_args(sym, *args)
         @sym == sym and not @args_expectation.args_match?(*args)
       end
-       
+
+      # @private
       def verify_messages_received
-        return if expected_messages_received? || failed_fast?
-    
-        generate_error
+        generate_error unless expected_messages_received? || failed_fast?
       rescue RSpec::Mocks::MockExpectationError => error
         error.backtrace.insert(0, @expected_from)
         Kernel::raise error
       end
-      
+
+      # @private
       def expected_messages_received?
-        ignoring_args? || matches_exact_count? ||
-           matches_at_least_count? || matches_at_most_count?
+        ignoring_args? || matches_exact_count? || matches_at_least_count? || matches_at_most_count?
       end
-      
+
+      # @private
       def ignoring_args?
         @expected_received_count == :any
       end
-      
+
+      # @private
       def matches_at_least_count?
         @at_least && @actual_received_count >= @expected_received_count
       end
-      
+
+      # @private
       def matches_at_most_count?
         @at_most && @actual_received_count <= @expected_received_count
       end
-      
+
+      # @private
       def matches_exact_count?
         @expected_received_count == @actual_received_count
       end
-      
+
+      # @private
       def similar_messages
         @similar_messages ||= []
       end
 
+      # @private
       def advise(*args)
         similar_messages << args
       end
-      
+
+      # @private
       def generate_error
         if similar_messages.empty?
           @error_generator.raise_expectation_error(@sym, @expected_received_count, @actual_received_count, *@args_expectation.args)
@@ -251,107 +264,238 @@ module RSpec
         end
       end
 
+      # Constrains a stub or message expectation to invocations with specific
+      # arguments.
+      #
+      # With a stub, if the message might be received with other args as well,
+      # you should stub a default value first, and then stub or mock the same
+      # message using `with` to constrain to specific arguments.
+      #
+      # A message expectation will fail if the message is received with different
+      # arguments.
+      #
+      # @example
+      #
+      #   cart.stub(:add) { :failure }
+      #   cart.stub(:add).with(Book.new(:isbn => 1934356379)) { :success }
+      #   cart.add(Book.new(:isbn => 1234567890))
+      #   # => :failure
+      #   cart.add(Book.new(:isbn => 1934356379))
+      #   # => :success
+      #
+      #   cart.should_receive(:add).with(Book.new(:isbn => 1934356379)) { :success }
+      #   cart.add(Book.new(:isbn => 1234567890))
+      #   # => failed expectation
+      #   cart.add(Book.new(:isbn => 1934356379))
+      #   # => passes
       def with(*args, &block)
         @return_block = block if block_given? unless args.empty?
         @args_expectation = ArgumentExpectation.new(*args, &block)
         self
       end
-      
+
+      # Constrain a message expectation to be received a specific number of
+      # times.
+      #
+      # @example
+      #
+      #   dealer.should_recieve(:deal_card).exactly(10).times
       def exactly(n, &block)
         @method_block = block if block
         set_expected_received_count :exactly, n
         self
       end
-      
+
+      # Constrain a message expectation to be received at least a specific
+      # number of times.
+      #
+      # @example
+      #
+      #   dealer.should_recieve(:deal_card).at_least(9).times
       def at_least(n, &block)
         @method_block = block if block
         set_expected_received_count :at_least, n
         self
       end
-      
+
+      # Constrain a message expectation to be received at most a specific
+      # number of times.
+      #
+      # @example
+      #
+      #   dealer.should_recieve(:deal_card).at_most(10).times
       def at_most(n, &block)
         @method_block = block if block
         set_expected_received_count :at_most, n
         self
       end
 
+      # Syntactic sugar for `exactly`, `at_least` and `at_most`
+      #
+      # @example
+      #
+      #   dealer.should_recieve(:deal_card).exactly(10).times
+      #   dealer.should_recieve(:deal_card).at_least(10).times
+      #   dealer.should_recieve(:deal_card).at_most(10).times
       def times(&block)
         @method_block = block if block
         self
       end
-  
+
+
+      # Allows an expected message to be received any number of times.
       def any_number_of_times(&block)
         @method_block = block if block
         @expected_received_count = :any
         self
       end
-  
+
+      # Expect a message not to be received at all.
+      #
+      # @example
+      #
+      #   car.should_receive(:stop).never
       def never
         @expected_received_count = 0
         self
       end
-  
+
+      # Expect a message to be received exactly one time.
+      #
+      # @example
+      #
+      #   car.should_receive(:go).once
       def once(&block)
         @method_block = block if block
         set_expected_received_count :exactly, 1
         self
       end
-  
+
+      # Expect a message to be received exactly two times.
+      #
+      # @example
+      #
+      #   car.should_receive(:go).twice
       def twice(&block)
         @method_block = block if block
         set_expected_received_count :exactly, 2
         self
       end
-  
+
+      # Expect messages to be received in a specific order.
+      #
+      # @example
+      #
+      #   api.should_receive(:prepare).ordered
+      #   api.should_receive(:run).ordered
+      #   api.should_receive(:finish).ordered
       def ordered(&block)
         @method_block = block if block
         @order_group.register(self)
         @ordered = true
         self
       end
-      
+
+      # @private
       def negative_expectation_for?(sym)
         return false
       end
-      
+
+      # @private
       def actual_received_count_matters?
         @at_least || @at_most || @exactly
       end
 
+      # @private
       def increase_actual_received_count!
         @actual_received_count += 1
       end
 
       protected
-        def set_expected_received_count(relativity, n)
-          @at_least = (relativity == :at_least)
-          @at_most = (relativity == :at_most)
-          @exactly = (relativity == :exactly)
-          @expected_received_count = case n
-            when Numeric
-              n
-            when :once
-              1
-            when :twice
-              2
+
+      def invoke_method_block(*args, &block)
+        begin
+          @method_block.call(*args, &block)
+        rescue => detail
+          @error_generator.raise_block_failed_error(@sym, detail.message)
+        end
+      end
+
+      def invoke_with_yield(&block)
+        if block.nil?
+          @error_generator.raise_missing_block_error @args_to_yield
+        end
+        value = nil
+        @args_to_yield.each do |args_to_yield_this_time|
+          if block.arity > -1 && args_to_yield_this_time.length != block.arity
+            @error_generator.raise_wrong_arity_error args_to_yield_this_time, block.arity
           end
+          value = eval_block(*args_to_yield_this_time, &block)
         end
-        
-        def clear_actual_received_count!
-          @actual_received_count = 0
+        value
+      end
+
+      def eval_block(*args, &block)
+        if @eval_context
+          @eval_context.instance_exec(*args, &block)
+        else
+          block.call(*args)
         end
+      end
+
+      def invoke_consecutive_return_block(*args, &block)
+        value = invoke_return_block(*args, &block)
+        index = [@actual_received_count, value.size-1].min
+        value[index]
+      end
+
+      def invoke_return_block(*args, &block)
+        args << block unless block.nil?
+        # Ruby 1.9 - when we set @return_block to return values
+        # regardless of arguments, any arguments will result in
+        # a "wrong number of arguments" error
+        @return_block.arity == 0 ? @return_block.call : @return_block.call(*args)
+      end
+
+      def clone_args_to_yield(*args)
+        @args_to_yield = args.clone
+        @args_to_yield_were_cloned = true
+      end
+
+      def failed_fast?
+        @failed_fast
+      end
 
+      def set_expected_received_count(relativity, n)
+        @at_least = (relativity == :at_least)
+        @at_most = (relativity == :at_most)
+        @exactly = (relativity == :exactly)
+        @expected_received_count = case n
+                                   when Numeric
+                                     n
+                                   when :once
+                                     1
+                                   when :twice
+                                     2
+                                   end
+      end
+
+      def clear_actual_received_count!
+        @actual_received_count = 0
+      end
     end
-    
+
+    # @private
     class NegativeMessageExpectation < MessageExpectation
+      # @private
       def initialize(message, expectation_ordering, expected_from, sym, method_block)
         super(message, expectation_ordering, expected_from, sym, method_block, 0)
       end
-      
+
+      # @private
       def negative_expectation_for?(sym)
         return @sym == sym
       end
     end
-    
   end
 end