flexmock 0.1.1

data/CHANGELOG

@@ -0,0 +1,18 @@
+= Changes for FlexMock
+
+== Preversion 0.0.4
+
+* Added responds_to? and method support.
+
+== Version 0.0.3
+
+* Changed to a GEM package.
+
+== Version 0.0.2
+
+* Updated the documentation.
+* Fixed the install script.
+
+== Version 0.0.1
+
+* Initial Version

data/README

@@ -0,0 +1,214 @@
+= Flex Mock -- Making Mock Easy
+
+FlexMock is a simple mock object for unit testing.  The interface is
+simple, but still provides a good bit of flexibility.
+
+= Links
+
+<b>Documents</b>   :: http://onestepback.org/software/flexmock
+<b>Download</b>    :: Use RubyGems to download the flexmock gem from http://gems.rubyforge.org
+
+== Installation
+
+You can install FlexMock with the following command.
+
+ $ gem install flexmock
+
+== Simple Example
+
+We have a data acquisition class (+TemperatureSampler+) that reads a
+temperature sensor and returns an average of 3 readings.  We don't
+have a _real_ temperature to use for testing, so we mock one up with a
+mock object that responds to the +read_temperature+ message.
+
+Here's the complete example:
+
+  class TemperatureSampler
+    def initialize(sensor)
+      @sensor = sensor
+    end
+
+    def average_temp
+      total = (0...3).collect { @sensor.read_temperature }.inject { |i, s| i + s }
+      total / 3.0
+    end
+  end
+
+  class TestTemperatureSampler < Test::Unit::TestCase
+    def test_tempurature_sampler
+      readings = [10, 12, 14]
+      FlexMock.use("temp") do |sensor|
+        sensor = FlexMock.new
+        sensor.should_receive(:read_temperature).and_return { readings.shift }
+      sampler = TemperatureSampler.new(sensor)
+      assert_equal 12, sampler.average_temp
+    end
+  end
+
+== Quick Reference
+
+The following declarators may be used to create the proper
+expectations on a FlexMock object.
+
+* <tt>should_receive(<em>symbol</em>)</tt> -- Declares that a message
+  named <em>symbol</em> will be sent to the mock object.  Further
+  refinements on this expected message (called an expectation) may be
+  chained to the +should_receive+ call.
+* <tt>with(<em>arglist</em>)</tt> -- Declares that this expectation
+  matches messages that match the given argument list.  The
+  <tt>===</tt> operator is used on a argument by argument basis to
+  determine matching.  This means that most literal values match
+  literally, class values match any instance of a class and regular
+  expression match any matching string (after a +to_s+ conversion).
+* <tt>with_any_args</tt> -- Declares that this expectation matches the
+  message with any argument (default)
+* <tt>with_no_args</tt> -- Declares that this expectation matches
+  messages with no arguments
+* <tt>returns(<em>value</em>)</tt> -- Declares that the message will
+  return the given value (<tt>returns(nil)</tt> is the default).
+* <tt>returns { code ... }</tt> -- Declares that the message will
+  return whatever the block calculates.
+* <tt>zero_or_more_times</tt> -- Declares that the message is may be
+  sent zero or more times (default, equivalent to
+  <tt>at_least.never</tt>).
+* <tt>once</tt> -- Declares that the message is only sent once.
+  <tt>at_least</tt> / <tt>at_most</tt> modifiers are allowed.
+* <tt>twice</tt> -- Declares that the message is only sent twice.
+  <tt>at_least</tt> / <tt>at_most</tt> modifiers are allowed.
+* <tt>never</tt> -- Declares that the message is never sent.
+  <tt>at_least</tt> / <tt>at_most</tt> modifiers are allowed.
+* <tt>times(<em>n</em>)</tt> -- Declares that the message is sent
+  <em>n</em> times.  <tt>at_least</tt> / <tt>at_most</tt> modifiers
+  are allowed.
+* <tt>at_least</tt> -- Modifies the immediately following message
+  count declarator so that it means the message is sent at least that
+  number of times.  E.g. <tt>at_least.once</tt> means the message is
+  sent at least once during the test, but may be sent more often.
+  Both <tt>at_least</tt> and <tt>at_most</tt> may be specified on the
+  same expectation.
+* <tt>at_most</tt> -- Similar to <tt>at_least</tt>, but puts an upper
+  limit on the number of messages.  Both <tt>at_least</tt> and
+  <tt>at_most</tt> may be specified on the same expectation.
+* <tt>ordered</tt> -- Declares that the message is ordered and is
+  expected to be received in a certain position in a sequence of
+  messages.  The message should arrive after and previously declared
+  ordered messages and prior to any following declared ordered
+  messages.  Unordered messages are ignored when considering the
+  message order.
+* <tt>ordered(<em>n</em>)</tt> -- Declares that the message is ordered
+  with a specific order number.  Order numbers are normally supplied
+  sequentially starting with 1.  Explicitly ordered messages must have
+  a sequence number greater than the prior implicit order number.
+  Using explicit order allows messages to be grouped so that the order
+  of messages in a group (sharing an order number) can be received in
+  any sequence, but the order between groups is still maintained.  See
+  the explicit ordering example below.
+
+== Examples
+
+=== Expect multiple queries and a single update
+
+The queries my have any arguments.  The update must have a specific
+argument of 5.
+
+   FlexMock('db').use |db|
+     db.should_receive(:query).and_return([1,2,3])
+     db.should_recieve(:update).with(5).and_return(nil).once
+     # test code here
+   end
+
+=== Expect all queries before any updates
+
+All the query message must occur before any of the update messages.
+
+   FlexMock('db').use |db|
+     db.should_receive(:query).and_return([1,2,3]).ordered
+     db.should_recieve(:update).and_return(nil).ordered
+     # test code here
+   end
+
+=== Expect several queries with different parameters
+
+The queries should happen after startup but before finish.  The
+queries themselves may happen in any order (because they have the same
+order number).  The first two queries should happen exactly once, but
+the third query (which matches any query call with a four character
+parameter) may be called multiple times (but at least once).  Startup
+and finish must also happen exactly once.
+
+Also note that we use the +with+ method to match different arguement
+values to figure out what value to return.
+
+   FlexMock('db').use |db|
+     db.should_receive(:startup).once.ordered
+     db.should_receive(:query).with("CPWR").and_return(12.3).once.ordered(10)
+     db.should_receive(:query).with("MSFT").and_return(10.0).once.ordered(10)
+     db.should_receive(:query).with(/^....$/).and_return(3.3).at_least.once.ordered(10)
+     db.should_receive(:finish).once.ordered
+     # test code here
+   end
+
+=== Expect multiple calls, returning a different value each time
+
+Sometimes you need to return different values for each call to a
+mocked method.  This example shifts values out of a list for this
+effect.
+
+   FlexMock('file').use |file|
+     return_values = ["line 1\n", "line 2\n"]
+     file.should_receive(:gets).with_no_args.and_return { return_values.shift }
+     # test code here
+   end
+
+=== Ignore uninteresting messages
+
+Generally you need to mock only those methods that return an
+interesting value or wish to assert were sent in a particular manner.
+Use the +should_ignore_missing+ method to turn on missing method
+ignoring.
+
+   FlexMock('m').use |m|
+     m.should_recieve(:an_important_message).and_return(1).once
+     m.should_ignore_missing
+     # test code here
+   end
+
+<b>Note:</b> The original +mock_ignore_missing+ is now an alias for
++should_ignore_missing+.
+
+== Classic +mock_handle+ Interface
+
+FlexMock still supports the simple +mock_handle+ interface used in the
+original version of FlexMock.  +mock_handle+ is equivalent to the
+following:
+
+  def mock_handle(sym, expected_count=nil, &block)
+    self.should_receive(sym).times(expected_count).returns(&block)
+  end
+
+== Other Mock Objects
+
+ruby-mock      :: http://www.b13media.com/dev/ruby/mock.html
+test-unit-mock :: http://www.deveiate.org/code/Test-Unit-Mock.shtml
+
+== License
+
+Copyright 2003, 2004, 2005 by Jim Weirich (jim@weirichhouse.org).
+All rights reserved.
+
+Permission is granted for use, copying, modification, distribution,
+and distribution of modified versions of this work as long as the
+above copyright notice is included.
+
+
+= Other stuff
+
+Author::   Jim Weirich <jim@weirichhouse.org>
+Requires:: Ruby 1.8.x or later
+
+== Warranty
+
+This software is provided "as is" and without any express or
+implied warranties, including, without limitation, the implied
+warranties of merchantibility and fitness for a particular
+purpose.

data/Rakefile

@@ -0,0 +1,128 @@
+# Rakefile for flexmock        -*- ruby -*-
+
+require 'rubygems'
+require 'rake/gempackagetask'
+require 'rake/clean'
+require 'rake/rdoctask'
+require 'rake/testtask'
+
+CLOBBER.include("html", 'pkg')
+
+PKG_VERSION = '0.1.1'
+
+PKG_FILES = FileList[
+  '[A-Z]*',
+  'lib/**/*.rb', 
+  'test/**/*.rb',
+  '*.blurb',
+  'install.rb'
+]
+
+RDOC_FILES = FileList[
+  'README',
+  'CHANGELOG',
+  'lib/**/*.rb',
+  'doc/**/*.rdoc',
+  'test/*.rb'
+]
+
+
+task :default => [:test]
+
+# Test Targets -------------------------------------------------------
+
+Rake::TestTask.new do |t|
+  t.pattern = 'test/test*.rb'
+  t.verbose = true
+end
+
+# RDoc Target --------------------------------------------------------
+
+rd = Rake::RDocTask.new("rdoc") do |rdoc|
+  rdoc.rdoc_dir = 'html'
+  rdoc.template = 'doc/jamis.rb'
+#  rdoc.template = 'html'
+#  rdoc.template = 'kilmer'
+#  rdoc.template = 'css2'
+  rdoc.title    = "Flex Mock"
+  rdoc.options << '--line-numbers' << '--inline-source' << '--main' << 'README'
+  rdoc.rdoc_files.include('[A-Z][A-Z]*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+# Package Task -------------------------------------------------------
+
+if ! defined?(Gem)
+  puts "Package Target requires RubyGEMs"
+else
+  spec = Gem::Specification.new do |s|
+    
+    #### Basic information.
+
+    s.name = 'flexmock'
+    s.version = PKG_VERSION
+    s.summary = "Simple and Flexible Mock Objects for Testing"
+    s.description = %{
+      FlexMock is a extremely simple mock object class compatible
+      with the Test::Unit framework.  Although the FlexMock's 
+      interface is simple, it is very flexible.
+    }
+
+    #### Dependencies and requirements.
+    
+    #s.add_dependency('log4r', '> 1.0.4')
+    #s.requirements << ""
+    
+    #### Which files are to be included in this gem?  Everything!  (Except CVS directories.)
+
+    s.files = PKG_FILES.to_a
+
+    #### C code extensions.
+
+    #s.extensions << "ext/rmagic/extconf.rb"
+
+    #### Load-time details: library and application (you will need one or both).
+
+    s.require_path = 'lib'                         # Use these for libraries.
+    s.autorequire = 'flexmock'
+
+    #### Documentation and testing.
+
+    s.has_rdoc = true
+    s.extra_rdoc_files = rd.rdoc_files.reject { |fn| fn =~ /\.rb$/ }.to_a
+    s.rdoc_options <<
+      '--title' <<  'Flex Mock' <<
+      '--main' << 'README' <<
+      '--line-numbers'
+
+    #### Author and project details.
+
+    s.author = "Jim Weirich"
+    s.email = "jim@weirichhouse.org"
+    s.homepage = "http://http://onestepback.org"
+  end
+
+  Rake::GemPackageTask.new(spec) do |pkg|
+    pkg.need_zip = true
+    pkg.need_tar = true
+  end
+end
+
+require 'rake/contrib/publisher'
+require 'rake/contrib/sshpublisher'
+
+task :publish => [:rdoc] do
+  html_publisher = Rake::SshFreshDirPublisher.new(
+    'umlcoop',
+    'htdocs/software/flexmock',
+    'html')
+  blurb_publisher = Rake::SshFilePublisher.new(
+    'umlcoop',
+    'htdocs/software/flexmock',
+    '.',
+    'flexmock.blurb')
+  html_publisher.upload
+  blurb_publisher.upload
+end
+
+

data/flexmock.blurb

@@ -0,0 +1,10 @@
+name: flexmock
+document: http://onestepback.org/software/flexmock
+download: http://onestepback.org/packages/flexmock
+description: >
+    <p>FlexMock is the outcome of a frustrating evening of trying to
+    use the original mock object by Nat Pryce.  Nat's mock object is
+    really cool, but it assumes that we know the exact calling order
+    of all the methods to the mock object.  I really feel that
+    over-constrains the solution code.  This little quicky seems to
+    meet my needs fairly well.</p>

data/install.rb

@@ -0,0 +1,43 @@
+require 'rbconfig'
+require 'find'
+require 'ftools'
+
+include Config
+
+def indir(newdir)
+  olddir = Dir.pwd
+  Dir.chdir(newdir)
+  yield
+ensure
+  Dir.chdir(olddir)
+end
+
+$ruby = CONFIG['ruby_install_name']
+$sitedir = CONFIG["sitelibdir"]
+
+unless $sitedir
+  version = CONFIG["MAJOR"]+"."+CONFIG["MINOR"]
+  $libdir = File.join(CONFIG["libdir"], "ruby", version)
+  $sitedir = $:.find {|x| x =~ /site_ruby/}
+  if !$sitedir
+    $sitedir = File.join($libdir, "site_ruby")
+  elsif $sitedir !~ Regexp.quote(version)
+    $sitedir = File.join($sitedir, version)
+  end
+end
+
+# The library files
+
+file = 'flexmock.rb'
+
+indir('lib') do
+  Dir['**/*.rb'].each do |file|
+    File::install(
+      file,
+      File.join($sitedir, file),
+      0644,
+      true)
+  end
+end
+
+

data/lib/flexmock.rb

@@ -0,0 +1,485 @@
+#!/usr/bin/env ruby
+
+#---
+# Copyright 2003, 2004, 2005 by Jim Weirich (jim@weirichhouse.org).
+# All rights reserved.
+
+# Permission is granted for use, copying, modification, distribution,
+# and distribution of modified versions of this work as long as the
+# above copyright notice is included.
+#+++
+
+require 'test/unit'
+
+######################################################################
+# FlexMock is a flexible mock object suitable for using with Ruby's
+# Test::Unit unit test framework.  FlexMock has a simple interface
+# that's easy to remember, and leaves the hard stuff to all those
+# other mock object implementations.
+#
+# Basic Usage:
+#
+#   m = FlexMock.new("name")
+#   m.mock_handle(:meth) { |args| assert_stuff }
+#
+# Simplified Usage:
+#
+#   m = FlexMock.new("name")
+#   m.should_receive(:upcase).with("stuff").
+#     returns("STUFF")
+#   m.should_receive(:downcase).with(String).
+#     returns { |s| s.downcase }.once
+#
+class FlexMock
+  include Test::Unit::Assertions
+
+  attr_reader :mock_name
+  attr_accessor :mock_current_order
+
+  # Create a FlexMock object with the given name.  The name is used in
+  # error messages.
+  def initialize(name="unknown")
+    @mock_name = name
+    @expectations = Hash.new
+    @allocated_order = 0
+    @mock_current_order = 0
+  end
+  
+  # Handle all messages denoted by +sym+ by calling the given block
+  # and passing any parameters to the block.  If we know exactly how
+  # many calls are to be made to a particular method, we may check
+  # that by passing in the number of expected calls as a second
+  # paramter.
+  def mock_handle(sym, expected_count=nil, &block)
+    self.should_receive(sym).times(expected_count).returns(&block)
+  end
+
+  # Verify that each method that had an explicit expected count was
+  # actually called that many times.
+  def mock_verify
+    mock_wrap do
+      @expectations.each do |sym, handler|
+	handler.mock_verify
+      end
+    end
+  end
+
+  # Allocation a new order number from the mock.
+  def mock_allocate_order
+    @auto_allocate = true
+    @allocated_order += 1
+  end
+
+  # Allocation a new order number from the mock.
+  def mock_reallocate(n)
+    if @auto_allocate && n <= @allocated_order
+      FlexMock.failure "explicit order number #{n} must be greater than " +
+	@allocated_order.to_s
+    elsif (n < @allocated_order)
+      FlexMock.failure "explicit order number #{n} must be greater than or equal to " +
+	@allocated_order.to_s
+    end
+    @auto_allocate = false
+    @allocated_order = n
+  end
+
+  # Ignore all undefined (missing) method calls.
+  def should_ignore_missing
+    @ignore_missing = true
+  end
+  alias mock_ignore_missing should_ignore_missing
+
+  # Handle missing methods by attempting to look up a handler.
+  def method_missing(sym, *args, &block)
+    mock_wrap do
+      if handler = @expectations[sym]
+	args << block  if block_given?
+	handler.call(*args)
+      else
+	super(sym, *args, &block)  unless @ignore_missing
+      end
+    end
+  end
+
+  # Override the built-in respond_to? to include the mocked methods.
+  def respond_to?(sym)
+    super || (@expectations[sym] ? true : @ignore_missing)
+  end
+
+  # Override the built-in +method+ to include the mocked methods.
+  def method(sym)
+    @expectations[sym] || super
+  rescue NameError => ex
+    if @ignore_missing
+      proc { }
+    else
+      raise ex
+    end
+  end
+
+  # Declare that the mock object should receive a message with the
+  # given name.  An expectation object for the method name is returned
+  # as the result of this method.  Further expectation constraints can
+  # be added by chaining to the result.
+  #
+  # See Expectation for a list of declarators that can be used.
+  def should_receive(sym)
+    @expectations[sym] ||= ExpectationDirector.new(sym)
+    result = Expectation.new(self, sym)
+    @expectations[sym] << result
+    result
+  end
+
+  # Class method to make sure that verify is called at the end of a
+  # test.  One mock object will be created for each name given to the
+  # use method.  The mocks will be passed to the block as arguments.
+  # If no names are given, then a single anonymous mock object will be
+  # created.
+  #
+  # At the end of the use block, each mock object will be verified to
+  # make sure the proper number of calls have been made.
+  #
+  # Usage:
+  #
+  #   FlexMock.use("name") do |mock|    # Creates a mock named "name"
+  #     mock.should_receive(:meth).
+  #       returns(0).once
+  #   end                               # mock is verified here
+  #
+  def self.use(*names)
+    names = ["unknown"] if names.empty?
+    got_excecption = false
+    mocks = names.collect { |n| new(n) }
+    yield(*mocks)
+  rescue Exception => ex
+    got_exception = true
+    raise
+  ensure
+    mocks.each do |mock|
+      mock.mock_verify     unless got_exception
+    end
+  end
+
+  
+  # Class method to format a method name and argument list as a nice
+  # looking string.
+  def self.format_args(sym, args)
+    if args
+      "#{sym}(#{args.collect { |a| a.inspect }.join(', ')})"
+    else
+      "#{sym}(*args)"
+    end
+  end
+
+  # Class method to consistently form failure exceptions
+  def self.failure(msg)
+    fail Test::Unit::AssertionFailedError, msg
+  end
+
+  private
+
+  # Wrap a block of code so the any assertion errors are wrapped so
+  # that the mock name is added to the error message .
+  def mock_wrap(&block)
+    yield
+  rescue Test::Unit::AssertionFailedError => ex
+    raise Test::Unit::AssertionFailedError, 
+      "in mock '#{@mock_name}': #{ex.message}",
+      ex.backtrace
+  end
+
+  ####################################################################
+  # The expectation director is responsible for routing calls to the
+  # correct expectations for a given argument list.
+  #
+  class ExpectationDirector
+
+    # Create an ExpectationDirector for a mock object.
+    def initialize(sym)
+      @sym = sym
+      @expectations = []
+      @expected_order = nil
+    end
+
+    # Invoke the expectations for a given set of arguments.
+    def call(*args)
+      exp = @expectations.find { |e| e.match_args(args) } ||
+	@expectations.find { |e| e.expected_args.nil? }
+      if exp.nil?
+	FlexMock.failure "no matching handler found for " +
+	  FlexMock.format_args(@sym, args)
+      end
+      exp.verify_call(*args)
+    end
+
+    # Same as call.
+    def [](*args)
+      call(*args)
+    end
+
+    # Append an expectation to this director.
+    def <<(expectation)
+      @expectations << expectation
+    end
+
+    # Do the post test verification for this directory.  Check all the
+    # expectations.
+    def mock_verify
+      @expectations.each do |exp|
+	exp.mock_verify
+      end
+    end
+  end
+
+  ####################################################################
+  # Base class for all the count validators.
+  #
+  class CountValidator
+    include Test::Unit::Assertions
+    def initialize(sym, limit)
+      @sym = sym
+      @limit = limit
+    end
+  end
+
+  ####################################################################
+  # Validator for exact call counts.
+  #
+  class ExactCountValidator < CountValidator
+    # Validate that the method expectation was called exactly +n+
+    # times.
+    def validate(n)
+      assert_equal @limit, n, 
+	"method '#{@sym}' called incorrect number of times"
+    end
+  end
+
+  ####################################################################
+  # Validator for call counts greater than or equal to a limit.
+  #
+  class AtLeastCountValidator < CountValidator
+    # Validate the method expectation was called no more than +n+
+    # times.
+    def validate(n)
+      assert n >= @limit,
+	"Method '#{@sym}' should be called at least #{@limit} times,\n" +
+	"only called #{n} times"
+    end
+  end
+
+  ####################################################################
+  # Validator for call counts less than or equal to a limit.
+  #
+  class AtMostCountValidator < CountValidator
+    # Validate the method expectation was called at least +n+ times.
+    def validate(n)
+      assert n <= @limit,
+	"Method '#{@sym}' should be called at most #{@limit} times,\n" +
+	"only called #{n} times"
+    end
+  end
+
+  ####################################################################
+  # An Expectation is returned from each +should_receive+ message sent
+  # to mock object.  Each expectation records how a message matching
+  # the message name (argument to +should_receive+) and the argument
+  # list (given by +with+) should behave.  Mock expectations can be
+  # recorded by chaining the declaration methods defined in this
+  # class.
+  #
+  # For example:
+  #
+  #   mock.should_receive(:meth).with(args).and_returns(result)
+  #
+  class Expectation
+    include Test::Unit::Assertions
+
+    attr_reader :expected_args, :mock, :order_number
+
+    # Create an expectation for a method named +sym+.
+    def initialize(mock, sym)
+      @mock = mock
+      @sym = sym
+      @expected_args = nil
+      @count_validators = []
+      @count_validator_class = ExactCountValidator
+      @actual_count = 0
+      @return_value = nil
+      @return_block = lambda { @return_value }
+      @order_number = nil
+    end
+
+    def to_s
+      FlexMock.format_args(@sym, @expected_args)
+    end
+
+    # Verify the current call with the given arguments matches the
+    # expectations recorded in this object.
+    def verify_call(*args)
+      validate_order
+      @actual_count += 1
+      @return_block.call(*args)
+    end
+
+    # Validate that the order 
+    def validate_order
+      return if @order_number.nil?
+      if @order_number < @mock.mock_current_order
+	FlexMock.failure "method #{to_s} called out of order " +
+	  "(expected order #{@order_number}, was #{@mock.mock_current_order})"
+      end
+      @mock.mock_current_order = @order_number
+    end
+    private :validate_order
+
+    # Validate the correct number of calls have been made.  Called by
+    # the teardown process.
+    def mock_verify
+      @count_validators.each do |v|
+	v.validate(@actual_count)
+      end
+    end
+
+    # Does the argument list match this expectation's argument
+    # specification.
+    def match_args(args)
+      return false if @expected_args.nil?
+      return false if args.size != @expected_args.size
+      (0...args.size).all? { |i| match_arg(@expected_args[i], args[i]) }
+    end
+
+    # Does the expected argument match the corresponding actual value.
+    def match_arg(expected, actual)
+      expected === actual ||
+	expected === actual.to_s ||
+	expected == actual
+    end
+
+    # Declare that the method should expect the given argument list.
+    def with(*args)
+      @expected_args = args
+      self
+    end
+
+    # Declare that the method should be called with no arguments.
+    def with_no_args
+      with
+    end
+
+    # Declare that the method can be called with any number of
+    # arguments of any type.
+    def with_any_args
+      @expected_args = nil
+      self
+    end
+
+    # Declare that the method returns a particular value (when the
+    # argument list is matched).  If a block is given, it is evaluated
+    # on each call and its value is returned.  +and_return+ is an
+    # alias for +returns+.
+    #
+    # For example:
+    # 
+    #  mock.should_receive(:f).returns(12)   # returns 12
+    #
+    #  mock.should_receive(:f).with(String). # returns an
+    #    returns { |str| str.upcase }        # upcased string
+    #
+    def returns(value=nil, &block)
+      @return_block = block_given? ? block : lambda { value }
+      self
+    end
+    alias :and_return :returns	# :nodoc:
+
+    # Declare that the method may be called any number of times.
+    def zero_or_more_times
+      at_least.never
+    end
+
+    # Declare that the method is called +limit+ times with the
+    # declared argument list.  This may be modified by the +at_least+
+    # and +at_most+ declarators.
+    def times(limit)
+      @count_validators << @count_validator_class.new(@sym, limit) unless limit.nil?
+      @count_validator_class = ExactCountValidator
+      self
+    end
+
+    # Declare that the method is never expected to be called with the
+    # given argument list.  This may be modified by the +at_least+ and
+    # +at_most+ declarators.
+    def never
+      times(0)
+    end
+
+    # Declare that the method is expected to be called exactly once
+    # with the given argument list.  This may be modified by the
+    # +at_least+ and +at_most+ declarators.
+    def once
+      times(1)
+    end
+
+    # Declare that the method is expected to be called exactly twice
+    # with the given argument list.  This may be modified by the
+    # +at_least+ and +at_most+ declarators.
+    def twice
+      times(2)
+    end
+
+    # Modifies the next call count declarator (+times+, +never+,
+    # +once+ or +twice+) so that the declarator means the method is
+    # called at least that many times.
+    #
+    # E.g. method f must be called at least twice:
+    #
+    #   mock.should_receive(:f).at_least.twice
+    #
+    def at_least
+      @count_validator_class = AtLeastCountValidator
+      self
+    end
+
+    # Modifies the next call count declarator (+times+, +never+,
+    # +once+ or +twice+) so that the declarator means the method is
+    # called at most that many times.
+    #
+    # E.g. method f must be called no more than twice
+    #
+    #   mock.should_receive(:f).at_most.twice
+    #
+    def at_most
+      @count_validator_class = AtMostCountValidator
+      self
+    end
+
+    # Declare that the given method must be called in order.  All
+    # ordered method calls must be received in the order specified by
+    # the ordering of the +should_receive+ messages.  Receiving a
+    # methods out of the specified order will cause a test failure.
+    #
+    # If the user needs more fine control over ordering
+    # (e.g. specifying that a group of messages may be received in any
+    # order as long as they all come after another group of messages),
+    # a _order_ _number_ may be specified in the +ordered+ calls
+    #
+    # For example, in the following, messages +flip+ and +flop+ may be
+    # received in any order (because they have the same order number),
+    # but must occur strictly after +start+ but before +end+.
+    #
+    #    m = FlexMock.new
+    #    m.should_receive(:start).ordered
+    #    m.should_receive(:flip).ordered(10)
+    #    m.should_receive(:flop).ordered(10)
+    #    m.should_receive(:end).ordered
+    #
+    def ordered(order=nil)
+      if order.nil?
+	@order_number = @mock.mock_allocate_order
+      else
+	@order_number = order
+	@mock.mock_reallocate order
+      end
+      self
+    end
+  end
+end