mocha-macruby 0.9.8.20100129120100

data/lib/mocha/central.rb

@@ -0,0 +1,27 @@
+module Mocha
+  
+  class Central
+  
+    attr_accessor :stubba_methods
+  
+    def initialize
+      self.stubba_methods = []
+    end
+   
+    def stub(method)
+      unless stubba_methods.include?(method)
+        method.stub 
+        stubba_methods.push(method)
+      end
+    end
+    
+    def unstub_all
+      while stubba_methods.length > 0
+        method = stubba_methods.pop
+        method.unstub
+      end
+    end
+
+  end
+
+end

data/lib/mocha/change_state_side_effect.rb

@@ -0,0 +1,19 @@
+module Mocha
+
+  class ChangeStateSideEffect
+  
+    def initialize(state)
+      @state = state
+    end
+  
+    def perform
+      @state.activate
+    end
+  
+    def mocha_inspect
+      "then #{@state.mocha_inspect}"
+    end
+  
+  end
+
+end

data/lib/mocha/class_method.rb

@@ -0,0 +1,117 @@
+require 'mocha/metaclass'
+
+module Mocha
+
+  class ClassMethod
+  
+    attr_reader :stubbee, :method
+    
+    def initialize(stubbee, method)
+      @stubbee = stubbee
+      @method = RUBY_VERSION < '1.9' ? method.to_s : method.to_sym
+    end
+    
+    def stub
+      hide_original_method
+      define_new_method
+    end
+    
+    def unstub
+      remove_new_method
+      restore_original_method
+      stubbee.reset_mocha
+    end
+    
+    def mock
+      stubbee.mocha
+    end
+    
+    def hide_original_method
+      if method_exists?(method)
+        begin
+          stubbee.__metaclass__.send(:alias_method, hidden_method, method)
+        rescue NameError
+          # deal with nasties like ActiveRecord::Associations::AssociationProxy
+        end
+      end
+    end
+    
+    def define_new_method
+      body = if macruby_method?
+        macruby_method
+      else
+        %{
+          def #{method}(*args, &block)
+            mocha.method_missing(:#{method}, *args, &block)
+          end
+        }
+      end
+      stubbee.__metaclass__.class_eval(body, __FILE__, __LINE__)
+    end
+    
+    def remove_new_method
+      stubbee.__metaclass__.send(:remove_method, method)
+    end
+    
+    def restore_original_method
+      if method_exists?(hidden_method)
+        begin
+          stubbee.__metaclass__.send(:alias_method, method, hidden_method)
+          stubbee.__metaclass__.send(:remove_method, hidden_method)
+        rescue NameError
+          # deal with nasties like ActiveRecord::Associations::AssociationProxy
+        end
+      end
+    end
+    
+    def hidden_method
+      if RUBY_VERSION < '1.9'
+        method_name = method.to_s.gsub(/\W/) { |s| "_substituted_character_#{s[0]}_" }
+      else
+        method_name = method.to_s.gsub(/\W/) { |s| "_substituted_character_#{s.ord}_" }
+      end
+      hidden_method = "__stubba__#{method_name}__stubba__"
+      RUBY_VERSION < '1.9' ? hidden_method.to_s : hidden_method.to_sym
+    end
+    
+    def eql?(other)
+      return false unless (other.class == self.class)
+      (stubbee.object_id == other.stubbee.object_id) and (method == other.method)
+    end
+    
+    alias_method :==, :eql?
+    
+    def to_s
+      "#{stubbee}.#{method}"
+    end
+    
+    def method_exists?(method)
+      symbol = method.to_sym
+      metaclass = stubbee.__metaclass__
+      metaclass.public_method_defined?(symbol) || metaclass.protected_method_defined?(symbol) || metaclass.private_method_defined?(symbol)
+    end
+    
+    def macruby_method?
+      method.to_s.include?(':')
+    end
+    
+    def macruby_method
+      parts = method.to_s.split(':')
+      
+      signature = "#{parts.shift}(param0"
+      parts.each_with_index { |part, index| signature << ", #{part}: param#{index + 1}" }
+      signature << ", &block)"
+      
+      %{
+        def #{signature}                                                            # def method(param0, withExtraParam: param1, &block)
+          mocha.method_missing(                                                     #   mocha.method_missing(
+            '#{method}'.to_sym,                                                     #     'method:withExtraParam:'.to_sym,
+            #{Array.new(parts.length + 1) { |index| "param#{index}" }.join(', ')},  #     param0, param1,
+            &block)                                                                 #     &block)
+        end                                                                         # end
+      }
+    end
+    
+  end
+  
+end

data/lib/mocha/configuration.rb

@@ -0,0 +1,79 @@
+module Mocha # :nodoc:
+  
+  # Configuration settings
+  class Configuration
+    
+    DEFAULTS = { :stubbing_method_unnecessarily => :allow, :stubbing_method_on_non_mock_object => :allow, :stubbing_non_existent_method => :allow, :stubbing_non_public_method => :allow }
+    
+    class << self
+    
+      # :call-seq: allow(action, &block)
+      #
+      # Allow the specified <tt>action</tt> (as a symbol).
+      # The <tt>actions</tt> currently available are <tt>:stubbing_method_unnecessarily, :stubbing_method_on_non_mock_object, :stubbing_non_existent_method, :stubbing_non_public_method</tt>.
+      # If given a block, the configuration for the action will only be changed for the duration of the block, and will then be restored to the previous value.
+      def allow(action, &block)
+        change_config action, :allow, &block
+      end
+    
+      def allow?(action) # :nodoc:
+        configuration[action] == :allow
+      end
+    
+      # :call-seq: warn_when(action, &block)
+      #
+      # Warn if the specified <tt>action</tt> (as a symbol) is attempted.
+      # The <tt>actions</tt> currently available are <tt>:stubbing_method_unnecessarily, :stubbing_method_on_non_mock_object, :stubbing_non_existent_method, :stubbing_non_public_method</tt>.
+      # If given a block, the configuration for the action will only be changed for the duration of the block, and will then be restored to the previous value.
+      def warn_when(action, &block)
+        change_config action, :warn, &block
+      end
+    
+      def warn_when?(action) # :nodoc:
+        configuration[action] == :warn
+      end
+    
+      # :call-seq: prevent(action, &block)
+      #
+      # Raise a StubbingError if the specified <tt>action</tt> (as a symbol) is attempted.
+      # The <tt>actions</tt> currently available are <tt>:stubbing_method_unnecessarily, :stubbing_method_on_non_mock_object, :stubbing_non_existent_method, :stubbing_non_public_method</tt>.
+      # If given a block, the configuration for the action will only be changed for the duration of the block, and will then be restored to the previous value.
+      def prevent(action, &block)
+        change_config action, :prevent, &block
+      end
+    
+      def prevent?(action) # :nodoc:
+        configuration[action] == :prevent
+      end
+    
+      def reset_configuration # :nodoc:
+        @configuration = nil
+      end
+    
+      private
+    
+      def configuration # :nodoc:
+        @configuration ||= DEFAULTS.dup
+      end
+
+      def change_config(action, new_value, &block) # :nodoc:
+        if block_given?
+          temporarily_change_config action, new_value, &block
+        else
+          configuration[action] = new_value
+        end
+      end
+
+      def temporarily_change_config(action, new_value, &block) # :nodoc:
+        original_value = configuration[action]
+        configuration[action] = new_value
+        yield
+      ensure
+        configuration[action] = original_value
+      end
+    
+    end
+    
+  end
+  
+end

data/lib/mocha/deprecation.rb

@@ -0,0 +1,22 @@
+module Mocha
+  
+  class Deprecation
+    
+    class << self
+      
+      attr_accessor :mode, :messages
+      
+      def warning(message)
+        @messages << message
+        $stderr.puts "Mocha deprecation warning: #{message}" unless mode == :disabled
+        $stderr.puts caller.join("\n  ") if mode == :debug
+      end
+
+    end
+  
+    self.mode = :enabled
+    self.messages = []
+    
+  end
+   
+end

data/lib/mocha/exception_raiser.rb

@@ -0,0 +1,17 @@
+module Mocha # :nodoc:
+  
+  class ExceptionRaiser # :nodoc:
+    
+    def initialize(exception, message)
+      @exception, @message = exception, message
+    end
+    
+    def evaluate
+      raise @exception, @exception.to_s if @exception.is_a?(Module) && @exception.ancestors.include?(Interrupt)
+      raise @exception, @message if @message
+      raise @exception
+    end
+    
+  end
+  
+end

data/lib/mocha/expectation.rb

@@ -0,0 +1,476 @@
+require 'mocha/method_matcher'
+require 'mocha/parameters_matcher'
+require 'mocha/expectation_error'
+require 'mocha/return_values'
+require 'mocha/exception_raiser'
+require 'mocha/yield_parameters'
+require 'mocha/is_a'
+require 'mocha/in_state_ordering_constraint'
+require 'mocha/change_state_side_effect'
+require 'mocha/cardinality'
+
+module Mocha # :nodoc:
+  
+  # Methods on expectations returned from Mock#expects, Mock#stubs, Object#expects and Object#stubs.
+  class Expectation
+  
+    # :call-seq: times(range) -> expectation
+    #
+    # Modifies expectation so that the number of calls to the expected method must be within a specific +range+.
+    #
+    # +range+ can be specified as an exact integer or as a range of integers
+    #   object = mock()
+    #   object.expects(:expected_method).times(3)
+    #   3.times { object.expected_method }
+    #   # => verify succeeds
+    #
+    #   object = mock()
+    #   object.expects(:expected_method).times(3)
+    #   2.times { object.expected_method }
+    #   # => verify fails
+    #
+    #   object = mock()
+    #   object.expects(:expected_method).times(2..4)
+    #   3.times { object.expected_method }
+    #   # => verify succeeds
+    #
+    #   object = mock()
+    #   object.expects(:expected_method).times(2..4)
+    #   object.expected_method
+    #   # => verify fails
+    def times(range)
+      @cardinality = Cardinality.times(range)
+      self
+    end
+  
+    # :call-seq: twice() -> expectation
+    #
+    # Modifies expectation so that the expected method must be called exactly twice.
+    #   object = mock()
+    #   object.expects(:expected_method).twice
+    #   object.expected_method
+    #   object.expected_method
+    #   # => verify succeeds
+    #
+    #   object = mock()
+    #   object.expects(:expected_method).twice
+    #   object.expected_method
+    #   object.expected_method
+    #   object.expected_method
+    #   # => verify fails
+    #
+    #   object = mock()
+    #   object.expects(:expected_method).twice
+    #   object.expected_method
+    #   # => verify fails
+    def twice
+      @cardinality = Cardinality.exactly(2)
+      self
+    end
+  
+    # :call-seq: once() -> expectation
+    #
+    # Modifies expectation so that the expected method must be called exactly once.
+    # Note that this is the default behaviour for an expectation, but you may wish to use it for clarity/emphasis.
+    #   object = mock()
+    #   object.expects(:expected_method).once
+    #   object.expected_method
+    #   # => verify succeeds
+    #
+    #   object = mock()
+    #   object.expects(:expected_method).once
+    #   object.expected_method
+    #   object.expected_method
+    #   # => verify fails
+    #
+    #   object = mock()
+    #   object.expects(:expected_method).once
+    #   # => verify fails
+    def once
+      @cardinality = Cardinality.exactly(1)
+      self
+    end
+  
+    # :call-seq: never() -> expectation
+    #
+    # Modifies expectation so that the expected method must never be called.
+    #   object = mock()
+    #   object.expects(:expected_method).never
+    #   object.expected_method
+    #   # => verify fails
+    #
+    #   object = mock()
+    #   object.expects(:expected_method).never
+    #   object.expected_method
+    #   # => verify succeeds
+    def never
+      @cardinality = Cardinality.exactly(0)
+      self
+    end
+  
+    # :call-seq: at_least(minimum_number_of_times) -> expectation
+    #
+    # Modifies expectation so that the expected method must be called at least a +minimum_number_of_times+.
+    #   object = mock()
+    #   object.expects(:expected_method).at_least(2)
+    #   3.times { object.expected_method }
+    #   # => verify succeeds
+    #
+    #   object = mock()
+    #   object.expects(:expected_method).at_least(2)
+    #   object.expected_method
+    #   # => verify fails
+    def at_least(minimum_number_of_times)
+      @cardinality = Cardinality.at_least(minimum_number_of_times)
+      self
+    end
+  
+    # :call-seq: at_least_once() -> expectation
+    #
+    # Modifies expectation so that the expected method must be called at least once.
+    #   object = mock()
+    #   object.expects(:expected_method).at_least_once
+    #   object.expected_method
+    #   # => verify succeeds
+    #
+    #   object = mock()
+    #   object.expects(:expected_method).at_least_once
+    #   # => verify fails
+    def at_least_once
+      at_least(1)
+      self
+    end
+  
+    # :call-seq: at_most(maximum_number_of_times) -> expectation
+    #
+    # Modifies expectation so that the expected method must be called at most a +maximum_number_of_times+.
+    #   object = mock()
+    #   object.expects(:expected_method).at_most(2)
+    #   2.times { object.expected_method }
+    #   # => verify succeeds
+    #
+    #   object = mock()
+    #   object.expects(:expected_method).at_most(2)
+    #   3.times { object.expected_method }
+    #   # => verify fails
+    def at_most(maximum_number_of_times)
+      @cardinality = Cardinality.at_most(maximum_number_of_times)
+      self
+    end
+  
+    # :call-seq: at_most_once() -> expectation
+    #
+    # Modifies expectation so that the expected method must be called at most once.
+    #   object = mock()
+    #   object.expects(:expected_method).at_most_once
+    #   object.expected_method
+    #   # => verify succeeds
+    #
+    #   object = mock()
+    #   object.expects(:expected_method).at_most_once
+    #   2.times { object.expected_method }
+    #   # => verify fails
+    def at_most_once()
+      at_most(1)
+      self
+    end
+  
+    # :call-seq: with(*expected_parameters, &matching_block) -> expectation
+    #
+    # Modifies expectation so that the expected method must be called with +expected_parameters+.
+    #   object = mock()
+    #   object.expects(:expected_method).with(:param1, :param2)
+    #   object.expected_method(:param1, :param2)
+    #   # => verify succeeds
+    #
+    #   object = mock()
+    #   object.expects(:expected_method).with(:param1, :param2)
+    #   object.expected_method(:param3)
+    #   # => verify fails
+    # May be used with parameter matchers in Mocha::ParameterMatchers.
+    #
+    # If a +matching_block+ is given, the block is called with the parameters passed to the expected method.
+    # The expectation is matched if the block evaluates to +true+.
+    #   object = mock()
+    #   object.expects(:expected_method).with() { |value| value % 4 == 0 }
+    #   object.expected_method(16)
+    #   # => verify succeeds
+    #
+    #   object = mock()
+    #   object.expects(:expected_method).with() { |value| value % 4 == 0 }
+    #   object.expected_method(17)
+    #   # => verify fails
+    def with(*expected_parameters, &matching_block)
+      @parameters_matcher = ParametersMatcher.new(expected_parameters, &matching_block)
+      self
+    end
+  
+    # :call-seq: yields(*parameters) -> expectation
+    #
+    # Modifies expectation so that when the expected method is called, it yields with the specified +parameters+.
+    #   object = mock()
+    #   object.expects(:expected_method).yields('result')
+    #   yielded_value = nil
+    #   object.expected_method { |value| yielded_value = value }
+    #   yielded_value # => 'result'
+    # May be called multiple times on the same expectation for consecutive invocations. Also see Expectation#then.
+    #   object = mock()
+    #   object.stubs(:expected_method).yields(1).then.yields(2)
+    #   yielded_values_from_first_invocation = []
+    #   yielded_values_from_second_invocation = []
+    #   object.expected_method { |value| yielded_values_from_first_invocation << value } # first invocation
+    #   object.expected_method { |value| yielded_values_from_second_invocation << value } # second invocation
+    #   yielded_values_from_first_invocation # => [1]
+    #   yielded_values_from_second_invocation # => [2]
+    def yields(*parameters)
+      @yield_parameters.add(*parameters)
+      self
+    end
+    
+    # :call-seq: multiple_yields(*parameter_groups) -> expectation
+    #
+    # Modifies expectation so that when the expected method is called, it yields multiple times per invocation with the specified +parameter_groups+.
+    #   object = mock()
+    #   object.expects(:expected_method).multiple_yields(['result_1', 'result_2'], ['result_3'])
+    #   yielded_values = []
+    #   object.expected_method { |*values| yielded_values << values }
+    #   yielded_values # => [['result_1', 'result_2'], ['result_3]]
+    # May be called multiple times on the same expectation for consecutive invocations. Also see Expectation#then.
+    #   object = mock()
+    #   object.stubs(:expected_method).multiple_yields([1, 2], [3]).then.multiple_yields([4], [5, 6])
+    #   yielded_values_from_first_invocation = []
+    #   yielded_values_from_second_invocation = []
+    #   object.expected_method { |*values| yielded_values_from_first_invocation << values } # first invocation
+    #   object.expected_method { |*values| yielded_values_from_second_invocation << values } # second invocation
+    #   yielded_values_from_first_invocation # => [[1, 2], [3]]
+    #   yielded_values_from_second_invocation # => [[4], [5, 6]]
+    def multiple_yields(*parameter_groups)
+      @yield_parameters.multiple_add(*parameter_groups)
+      self
+    end
+    
+    # :call-seq: returns(value) -> expectation
+    #            returns(*values) -> expectation
+    #
+    # Modifies expectation so that when the expected method is called, it returns the specified +value+.
+    #   object = mock()
+    #   object.stubs(:stubbed_method).returns('result')
+    #   object.stubbed_method # => 'result'
+    #   object.stubbed_method # => 'result'
+    # If multiple +values+ are given, these are returned in turn on consecutive calls to the method.
+    #   object = mock()
+    #   object.stubs(:stubbed_method).returns(1, 2)
+    #   object.stubbed_method # => 1
+    #   object.stubbed_method # => 2
+    # May be called multiple times on the same expectation. Also see Expectation#then.
+    #   object = mock()
+    #   object.stubs(:expected_method).returns(1, 2).then.returns(3)
+    #   object.expected_method # => 1
+    #   object.expected_method # => 2
+    #   object.expected_method # => 3
+    # May be called in conjunction with Expectation#raises on the same expectation.
+    #   object = mock()
+    #   object.stubs(:expected_method).returns(1, 2).then.raises(Exception)
+    #   object.expected_method # => 1
+    #   object.expected_method # => 2
+    #   object.expected_method # => raises exception of class Exception1
+    # Note that in Ruby a method returning multiple values is exactly equivalent to a method returning an Array of those values.
+    #   object = mock()
+    #   object.stubs(:expected_method).returns([1, 2])
+    #   x, y = object.expected_method
+    #   x # => 1
+    #   y # => 2
+    def returns(*values)
+      @return_values += ReturnValues.build(*values)
+      self
+    end
+  
+    # :call-seq: raises(exception = RuntimeError, message = nil) -> expectation
+    #
+    # Modifies expectation so that when the expected method is called, it raises the specified +exception+ with the specified +message+.
+    #   object = mock()
+    #   object.expects(:expected_method).raises(Exception, 'message')
+    #   object.expected_method # => raises exception of class Exception and with message 'message'
+    # May be called multiple times on the same expectation. Also see Expectation#then.
+    #   object = mock()
+    #   object.stubs(:expected_method).raises(Exception1).then.raises(Exception2)
+    #   object.expected_method # => raises exception of class Exception1
+    #   object.expected_method # => raises exception of class Exception2
+    # May be called in conjunction with Expectation#returns on the same expectation.
+    #   object = mock()
+    #   object.stubs(:expected_method).raises(Exception).then.returns(2, 3)
+    #   object.expected_method # => raises exception of class Exception1
+    #   object.expected_method # => 2
+    #   object.expected_method # => 3
+    def raises(exception = RuntimeError, message = nil)
+      @return_values += ReturnValues.new(ExceptionRaiser.new(exception, message))
+      self
+    end
+
+    # :call-seq: then() -> expectation
+    #            then(state_machine.is(state)) -> expectation
+    #
+    # <tt>then()</tt> is used as syntactic sugar to improve readability. It has no effect on state of the expectation.
+    #   object = mock()
+    #   object.stubs(:expected_method).returns(1, 2).then.raises(Exception).then.returns(4)
+    #   object.expected_method # => 1
+    #   object.expected_method # => 2
+    #   object.expected_method # => raises exception of class Exception
+    #   object.expected_method # => 4
+    #
+    # <tt>then(state_machine.is(state))</tt> is used to change the +state_machine+ to the specified +state+ when the invocation occurs.
+    #
+    # See also API#states, StateMachine and Expectation#when.
+    #   power = states('power').starts_as('off')
+    #
+    #   radio = mock('radio')
+    #   radio.expects(:switch_on).then(power.is('on'))
+    #   radio.expects(:select_channel).with('BBC Radio 4').when(power.is('on'))
+    #   radio.expects(:adjust_volume).with(+5).when(power.is('on'))
+    #   radio.expects(:select_channel).with('BBC World Service').when(power.is('on'))
+    #   radio.expects(:adjust_volume).with(-5).when(power.is('on'))
+    #   radio.expects(:switch_off).then(power.is('off'))
+    def then(*parameters)
+      if parameters.length == 1
+        state = parameters.first
+        add_side_effect(ChangeStateSideEffect.new(state))
+      end
+      self
+    end
+    
+    # :call-seq: when(state_machine.is(state)) -> exception
+    #
+    # Constrains the expectation to occur only when the +state_machine+ is in the named +state+.
+    #
+    # See also API#states, StateMachine#starts_as and Expectation#then.
+    #   power = states('power').starts_as('off')
+    #
+    #   radio = mock('radio')
+    #   radio.expects(:switch_on).then(power.is('on'))
+    #   radio.expects(:select_channel).with('BBC Radio 4').when(power.is('on'))
+    #   radio.expects(:adjust_volume).with(+5).when(power.is('on'))
+    #   radio.expects(:select_channel).with('BBC World Service').when(power.is('on'))
+    #   radio.expects(:adjust_volume).with(-5).when(power.is('on'))
+    #   radio.expects(:switch_off).then(power.is('off'))
+    def when(state_predicate)
+      add_ordering_constraint(InStateOrderingConstraint.new(state_predicate))
+      self
+    end
+    
+    # :call-seq: in_sequence(*sequences) -> expectation
+    #
+    # Constrains this expectation so that it must be invoked at the current point in the sequence.
+    #
+    # To expect a sequence of invocations, write the expectations in order and add the in_sequence(sequence) clause to each one.
+    #
+    # Expectations in a sequence can have any invocation count.
+    #
+    # If an expectation in a sequence is stubbed, rather than expected, it can be skipped in the sequence.
+    #
+    # See also API#sequence.
+    #   breakfast = sequence('breakfast')
+    #
+    #   egg = mock('egg')
+    #   egg.expects(:crack).in_sequence(breakfast)
+    #   egg.expects(:fry).in_sequence(breakfast)
+    #   egg.expects(:eat).in_sequence(breakfast)
+    def in_sequence(*sequences)
+      sequences.each { |sequence| add_in_sequence_ordering_constraint(sequence) }
+      self
+    end
+    
+    # :stopdoc:
+    
+    attr_reader :backtrace
+
+    def initialize(mock, expected_method_name, backtrace = nil)
+      @mock = mock
+      @method_matcher = MethodMatcher.new(expected_method_name.to_sym)
+      @parameters_matcher = ParametersMatcher.new
+      @ordering_constraints = []
+      @side_effects = []
+      @cardinality, @invocation_count = Cardinality.exactly(1), 0
+      @return_values = ReturnValues.new
+      @yield_parameters = YieldParameters.new
+      @backtrace = backtrace || caller
+    end
+    
+    def add_ordering_constraint(ordering_constraint)
+      @ordering_constraints << ordering_constraint
+    end
+    
+    def add_in_sequence_ordering_constraint(sequence)
+      sequence.constrain_as_next_in_sequence(self)
+    end
+    
+    def add_side_effect(side_effect)
+      @side_effects << side_effect
+    end
+    
+    def perform_side_effects
+      @side_effects.each { |side_effect| side_effect.perform }
+    end
+    
+    def in_correct_order?
+      @ordering_constraints.all? { |ordering_constraint| ordering_constraint.allows_invocation_now? }
+    end
+    
+    def matches_method?(method_name)
+      @method_matcher.match?(method_name)
+    end
+    
+    def match?(actual_method_name, *actual_parameters)
+      @method_matcher.match?(actual_method_name) && @parameters_matcher.match?(actual_parameters) && in_correct_order?
+    end
+    
+    def invocations_allowed?
+      @cardinality.invocations_allowed?(@invocation_count)
+    end
+
+    def satisfied?
+      @cardinality.satisfied?(@invocation_count)
+    end
+  
+    def invoke
+      @invocation_count += 1
+      perform_side_effects()
+      if block_given? then
+        @yield_parameters.next_invocation.each do |yield_parameters|
+          yield(*yield_parameters)
+        end
+      end
+      @return_values.next
+    end
+
+    def verified?(assertion_counter = nil)
+      assertion_counter.increment if assertion_counter && @cardinality.needs_verifying?
+      @cardinality.verified?(@invocation_count)
+    end
+    
+    def used?
+      @cardinality.used?(@invocation_count)
+    end
+    
+    def mocha_inspect
+      message = "#{@cardinality.mocha_inspect}, "
+      message << case @invocation_count
+        when 0 then "not yet invoked"
+        when 1 then "already invoked once"
+        when 2 then "already invoked twice"
+        else "already invoked #{@invocation_count} times"
+      end
+      message << ": "
+      message << method_signature
+      message << "; #{@ordering_constraints.map { |oc| oc.mocha_inspect }.join("; ")}" unless @ordering_constraints.empty?
+      message
+    end
+    
+    def method_signature
+      "#{@mock.mocha_inspect}.#{@method_matcher.mocha_inspect}#{@parameters_matcher.mocha_inspect}"
+    end
+      
+    # :startdoc:
+    
+  end
+
+end