redcar 0.3.2dev → 0.3.3

data/lib/openssl/mocha/examples/mocha.rb

@@ -0,0 +1,26 @@
+class Enterprise
+
+  def initialize(dilithium)
+    @dilithium = dilithium
+  end
+
+  def go(warp_factor)
+    warp_factor.times { @dilithium.nuke(:anti_matter) }
+  end
+
+end
+
+require 'test/unit'
+require 'rubygems'
+require 'mocha'
+
+class EnterpriseTest < Test::Unit::TestCase
+
+  def test_should_boldly_go
+    dilithium = mock()
+    dilithium.expects(:nuke).with(:anti_matter).at_least_once  # auto-verified at end of test
+    enterprise = Enterprise.new(dilithium)
+    enterprise.go(2)
+  end
+
+end

data/lib/openssl/mocha/examples/stubba.rb

@@ -0,0 +1,65 @@
+class Order
+
+  attr_accessor :shipped_on
+
+  def total_cost
+    line_items.inject(0) { |total, line_item| total + line_item.price } + shipping_cost
+  end
+
+  def total_weight
+    line_items.inject(0) { |total, line_item| total + line_item.weight }
+  end
+
+  def shipping_cost
+    total_weight * 5 + 10
+  end
+
+  class << self
+
+    def find_all
+      # Database.connection.execute('select * from orders...
+    end
+  
+    def number_shipped_since(date)
+      find_all.select { |order| order.shipped_on > date }.size
+    end
+
+    def unshipped_value
+      find_all.inject(0) { |total, order| order.shipped_on ? total : total + order.total_cost }
+    end
+
+  end
+
+end
+
+require 'test/unit'
+require 'rubygems'
+require 'mocha'
+
+class OrderTest < Test::Unit::TestCase
+
+  # illustrates stubbing instance method
+  def test_should_calculate_shipping_cost_based_on_total_weight
+    order = Order.new
+    order.stubs(:total_weight).returns(10)
+    assert_equal 60, order.shipping_cost
+  end
+
+  # illustrates stubbing class method
+  def test_should_count_number_of_orders_shipped_after_specified_date
+    now = Time.now; week_in_secs = 7 * 24 * 60 * 60
+    order_1 = Order.new; order_1.shipped_on = now - 1 * week_in_secs
+    order_2 = Order.new; order_2.shipped_on = now - 3 * week_in_secs
+    Order.stubs(:find_all).returns([order_1, order_2])
+    assert_equal 1, Order.number_shipped_since(now - 2 * week_in_secs)
+  end
+
+  # illustrates stubbing instance method for all instances of a class
+  def test_should_calculate_value_of_unshipped_orders
+    Order.stubs(:find_all).returns([Order.new, Order.new, Order.new])
+    Order.any_instance.stubs(:shipped_on).returns(nil)
+    Order.any_instance.stubs(:total_cost).returns(10)
+    assert_equal 30, Order.unshipped_value
+  end
+
+end

data/lib/openssl/mocha/init.rb

@@ -0,0 +1,3 @@
+if ENV['RAILS_ENV'] == 'test' then
+  require 'mocha'
+end

data/lib/openssl/mocha/lib/mocha.rb

@@ -0,0 +1,19 @@
+require 'mocha_standalone'
+require 'mocha/test_case_adapter'
+
+require 'test/unit/testcase'
+
+module Test
+
+  module Unit
+
+    class TestCase
+  
+      include Mocha::Standalone
+      include Mocha::TestCaseAdapter
+      
+    end
+
+  end
+
+end

data/lib/openssl/mocha/lib/mocha/any_instance_method.rb

@@ -0,0 +1,35 @@
+require 'mocha/class_method'
+
+module Mocha
+
+  class AnyInstanceMethod < ClassMethod
+  
+    def unstub
+      remove_new_method
+      restore_original_method
+      stubbee.any_instance.reset_mocha
+    end
+    
+    def mock
+      stubbee.any_instance.mocha
+    end
+   
+    def hide_original_method
+      stubbee.class_eval "alias_method :#{hidden_method}, :#{method}" if stubbee.method_defined?(method)
+    end
+
+    def define_new_method
+      stubbee.class_eval "def #{method}(*args, &block); self.class.any_instance.mocha.method_missing(:#{method}, *args, &block); end"
+    end
+
+    def remove_new_method
+      stubbee.class_eval "remove_method :#{method}"
+    end
+
+    def restore_original_method
+      stubbee.class_eval "alias_method :#{method}, :#{hidden_method}; remove_method :#{hidden_method}" if stubbee.method_defined?(hidden_method)
+    end
+
+  end
+  
+end

data/lib/openssl/mocha/lib/mocha/auto_verify.rb

@@ -0,0 +1,111 @@
+require 'mocha/mock'
+
+module Mocha # :nodoc:
+  
+  # Methods added to TestCase allowing creation of traditional mock objects.
+  #
+  # Mocks created this way will have their expectations automatically verified at the end of the test.
+  #
+  # See Mock for methods on mock objects.
+  module AutoVerify
+  
+    def mocks # :nodoc:
+      @mocks ||= []
+    end
+  
+    def reset_mocks # :nodoc:
+      @mocks = nil
+    end
+    
+    # :call-seq: mock(name) -> mock object
+    #            mock(expected_methods = {}) -> mock object
+    #            mock(name, expected_methods = {}) -> mock object
+    #
+    # Creates a mock object.
+    #
+    # +name+ is a +String+ identifier for the mock object.
+    #
+    # +expected_methods+ is a +Hash+ with expected method name symbols as keys and corresponding return values as values.
+    #
+    # Note that (contrary to expectations set up by #stub) these expectations <b>must</b> be fulfilled during the test.
+    #   def test_product
+    #     product = mock('ipod_product', :manufacturer => 'ipod', :price => 100)
+    #     assert_equal 'ipod', product.manufacturer
+    #     assert_equal 100, product.price
+    #     # an error will be raised unless both Product#manufacturer and Product#price have been called
+    #   end 
+    def mock(*args)
+      name, expectations = name_and_expectations_from_args(args)
+      mock = Mock.new(false, name)
+      mock.expects(expectations)
+      mocks << mock
+      mock
+    end
+  
+    # :call-seq: stub(name) -> mock object
+    #            stub(stubbed_methods = {}) -> mock object
+    #            stub(name, stubbed_methods = {}) -> mock object
+    #
+    # Creates a mock object.
+    #
+    # +name+ is a +String+ identifier for the mock object.
+    #
+    # +stubbed_methods+ is a +Hash+ with stubbed method name symbols as keys and corresponding return values as values.
+    #
+    # Note that (contrary to expectations set up by #mock) these expectations <b>need not</b> be fulfilled during the test.
+    #   def test_product
+    #     product = stub('ipod_product', :manufacturer => 'ipod', :price => 100)
+    #     assert_equal 'ipod', product.manufacturer
+    #     assert_equal 100, product.price
+    #     # an error will not be raised even if Product#manufacturer and Product#price have not been called
+    #   end
+    def stub(*args)
+      name, expectations = name_and_expectations_from_args(args)
+      mock = Mock.new(false, name)
+      mock.stubs(expectations)
+      mocks << mock
+      mock
+    end
+  
+    # :call-seq: stub_everything(name) -> mock object
+    #            stub_everything(stubbed_methods = {}) -> mock object
+    #            stub_everything(name, stubbed_methods = {}) -> mock object
+    #
+    # Creates a mock object that accepts calls to any method.
+    #
+    # By default it will return +nil+ for any method call.
+    #
+    # +name+ and +stubbed_methods+ work in the same way as for #stub.
+    #   def test_product
+    #     product = stub_everything('ipod_product', :price => 100)
+    #     assert_nil product.manufacturer
+    #     assert_nil product.any_old_method
+    #     assert_equal 100, product.price
+    #   end
+    def stub_everything(*args)
+      name, expectations = name_and_expectations_from_args(args)
+      mock = Mock.new(true, name)
+      mock.stubs(expectations)
+      mocks << mock
+      mock
+    end
+    
+    def verify_mocks # :nodoc:
+      mocks.each { |mock| mock.verify { yield if block_given? } }
+    end
+
+    def teardown_mocks # :nodoc:
+      reset_mocks
+    end
+  
+  private
+
+    def name_and_expectations_from_args(args) # :nodoc:
+      name = args.first.is_a?(String) ? args.delete_at(0) : nil
+      expectations = args.first || {}
+      [name, expectations]
+    end
+  
+  end
+  
+end

data/lib/openssl/mocha/lib/mocha/central.rb

@@ -0,0 +1,35 @@
+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 verify_all(&block)
+      unique_mocks.each { |mock| mock.verify(&block) }
+    end
+    
+    def unique_mocks
+      stubba_methods.inject({}) { |mocks, method| mocks[method.mock.__id__] = method.mock; mocks }.values
+    end
+  
+    def unstub_all
+      while stubba_methods.size > 0
+        method = stubba_methods.pop
+        method.unstub
+      end
+    end
+
+  end
+
+end

data/lib/openssl/mocha/lib/mocha/class_method.rb

@@ -0,0 +1,62 @@
+require 'mocha/metaclass'
+
+module Mocha
+
+  class ClassMethod
+  
+    attr_reader :stubbee, :method
+   
+    def initialize(stubbee, method)
+      @stubbee, @method = stubbee, method
+    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
+      stubbee.__metaclass__.class_eval "alias_method :#{hidden_method}, :#{method}" if stubbee.__metaclass__.method_defined?(method)
+    end
+  
+    def define_new_method
+      stubbee.__metaclass__.class_eval "def #{method}(*args, &block); mocha.method_missing(:#{method}, *args, &block); end"
+    end
+  
+    def remove_new_method
+      stubbee.__metaclass__.class_eval "remove_method :#{method}"
+    end
+  
+    def restore_original_method
+      stubbee.__metaclass__.class_eval "alias_method :#{method}, :#{hidden_method}; remove_method :#{hidden_method}" if stubbee.__metaclass__.method_defined?(hidden_method)
+    end
+  
+    def hidden_method
+      method_name = method.to_s.gsub(/\W/) {|s| "_substituted_character_#{s[0]}_" }
+      "__stubba__#{method_name}__stubba__"
+    end  
+  
+    def eql?(other)
+      return false unless (other.class == self.class)
+      (stubbee == other.stubbee) and (method == other.method)
+    end
+  
+    alias_method :==, :eql?
+  
+    def to_s
+      "#{stubbee}.#{method}"
+    end
+
+  end
+  
+end

data/lib/openssl/mocha/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/openssl/mocha/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 == Interrupt
+      raise @exception, @message if @message
+      raise @exception
+    end
+    
+  end
+  
+end

data/lib/openssl/mocha/lib/mocha/expectation.rb

@@ -0,0 +1,382 @@
+require 'mocha/infinite_range'
+require 'mocha/pretty_parameters'
+require 'mocha/expectation_error'
+require 'mocha/return_values'
+require 'mocha/exception_raiser'
+require 'mocha/yield_parameters'
+require 'mocha/is_a'
+
+module Mocha # :nodoc:
+  
+  # Methods on expectations returned from Mock#expects, Mock#stubs, Object#expects and Object#stubs.
+  class Expectation
+  
+    # :stopdoc:
+    
+    class AlwaysEqual
+      def ==(other)
+        true
+      end
+    end
+  
+    attr_reader :method_name, :backtrace
+
+    def initialize(mock, method_name, backtrace = nil)
+      @mock, @method_name = mock, method_name
+      @expected_count = 1
+      @parameters, @parameter_block = AlwaysEqual.new, nil
+      @invoked_count, @return_values = 0, ReturnValues.new
+      @backtrace = backtrace || caller
+      @yield_parameters = YieldParameters.new
+      @final_expectation = false
+    end
+    
+    def match?(method_name, *arguments)
+      return false unless @method_name == method_name
+      if @parameter_block then
+        return false unless @parameter_block.call(*arguments)
+      else
+        return false unless (@parameters == arguments)
+      end
+      return true
+    end
+    
+    def invocations_allowed?
+      if @expected_count.is_a?(Range) then
+        @invoked_count < @expected_count.last
+      else
+        @invoked_count < @expected_count
+      end
+    end
+
+    # :startdoc:
+    
+    # :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)
+      @expected_count = range
+      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()
+      times(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
+      times(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)
+      times(Range.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)
+      times(Range.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(*arguments, &parameter_block) -> expectation
+    #
+    # Modifies expectation so that the expected method must be called with specified +arguments+.
+    #   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 +parameter_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(*arguments, &parameter_block)
+      @parameters, @parameter_block = arguments, parameter_block
+      class << @parameters; def to_s; join(', '); end; end
+      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
+    # :call-seq: 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
+    # If +value+ is a +Proc+, then the expected method will return the result of calling <tt>Proc#call</tt>.
+    #
+    # This usage is _deprecated_.
+    # Use explicit multiple return values and/or multiple expectations instead.
+    #
+    # A +Proc+ instance will be treated the same as any other value in a future release.
+    #   object = mock()
+    #   object.stubs(:stubbed_method).returns(lambda { rand(100) })
+    #   object.stubbed_method # => 41
+    #   object.stubbed_method # => 77
+    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
+    #
+    # Syntactic sugar to improve readability. 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
+    def then
+      self
+    end
+    
+    # :stopdoc:
+    
+    def invoke
+      @invoked_count += 1
+      if block_given? then
+        @yield_parameters.next_invocation.each do |yield_parameters|
+          yield(*yield_parameters)
+        end
+      end
+      @return_values.next
+    end
+
+    def verify
+      yield(self) if block_given?
+      unless (@expected_count === @invoked_count) then
+        error = ExpectationError.new(error_message(@expected_count, @invoked_count))
+        error.set_backtrace(filtered_backtrace)
+        raise error
+      end
+    end
+    
+    def mocha_lib_directory
+      File.expand_path(File.join(File.dirname(__FILE__), "..")) + File::SEPARATOR
+    end
+    
+    def filtered_backtrace
+      backtrace.reject { |location| Regexp.new(mocha_lib_directory).match(File.expand_path(location)) }
+    end
+  
+    def method_signature
+      return "#{method_name}" if @parameters.__is_a__(AlwaysEqual)
+      "#{@method_name}(#{PrettyParameters.new(@parameters).pretty})"
+    end
+    
+    def error_message(expected_count, actual_count)
+      "#{@mock.mocha_inspect}.#{method_signature} - expected calls: #{expected_count.mocha_inspect}, actual calls: #{actual_count}"
+    end
+  
+    # :startdoc:
+    
+  end
+
+end