mocha 0.10.5 → 1.13.0

data/test/unit/parameter_matchers/equals_test.rb

@@ -1,25 +0,0 @@
-require File.expand_path('../../../test_helper', __FILE__)
-
-require 'mocha/parameter_matchers/equals'
-require 'mocha/inspect'
-
-class EqualsTest < Test::Unit::TestCase
-
-  include Mocha::ParameterMatchers
-
-  def test_should_match_object_that_equals_value
-    matcher = equals('x')
-    assert matcher.matches?(['x'])
-  end
-
-  def test_should_not_match_object_that_does_not_equal_value
-    matcher = equals('x')
-    assert !matcher.matches?(['y'])
-  end
-
-  def test_should_describe_matcher
-    matcher = equals('x')
-    assert_equal "'x'", matcher.mocha_inspect
-  end
-
-end

data/test/unit/parameter_matchers/has_entries_test.rb

@@ -1,51 +0,0 @@
-require File.expand_path('../../../test_helper', __FILE__)
-
-require 'mocha/parameter_matchers/has_entries'
-require 'mocha/parameter_matchers/object'
-require 'mocha/inspect'
-
-class HasEntriesTest < Test::Unit::TestCase
-  
-  include Mocha::ParameterMatchers
-  
-  def test_should_match_hash_including_specified_entries
-    matcher = has_entries(:key_1 => 'value_1', :key_2 => 'value_2')
-    assert matcher.matches?([{ :key_1 => 'value_1', :key_2 => 'value_2', :key_3 => 'value_3' }])
-  end
-  
-  def test_should_not_match_hash_not_including_specified_entries
-    matcher = has_entries(:key_1 => 'value_2', :key_2 => 'value_2', :key_3 => 'value_3')
-    assert !matcher.matches?([{ :key_1 => 'value_1', :key_2 => 'value_2' }])
-  end
-  
-  def test_should_describe_matcher
-    matcher = has_entries(:key_1 => 'value_1', :key_2 => 'value_2')
-    description = matcher.mocha_inspect
-    matches = /has_entries\((.*)\)/.match(description)
-    assert_not_nil matches[0]
-    entries = eval(matches[1], binding, __FILE__, __LINE__)
-    assert_equal 'value_1', entries[:key_1]
-    assert_equal 'value_2', entries[:key_2]
-  end
-  
-  def test_should_match_hash_including_specified_entries_with_nested_key_matchers
-    matcher = has_entries(equals(:key_1) => 'value_1', equals(:key_2) => 'value_2')
-    assert matcher.matches?([{ :key_1 => 'value_1', :key_2 => 'value_2', :key_3 => 'value_3' }])
-  end
-  
-  def test_should_not_match_hash_not_including_specified_entries_with_nested_key_matchers
-    matcher = has_entries(equals(:key_1) => 'value_2', equals(:key_2) => 'value_2', equals(:key_3) => 'value_3')
-    assert !matcher.matches?([{ :key_1 => 'value_1', :key_2 => 'value_2' }])
-  end
-  
-  def test_should_match_hash_including_specified_entries_with_nested_value_matchers
-    matcher = has_entries(:key_1 => equals('value_1'), :key_2 => equals('value_2'))
-    assert matcher.matches?([{ :key_1 => 'value_1', :key_2 => 'value_2', :key_3 => 'value_3' }])
-  end
-  
-  def test_should_not_match_hash_not_including_specified_entries_with_nested_value_matchers
-    matcher = has_entries(:key_1 => equals('value_2'), :key_2 => equals('value_2'), :key_3 => equals('value_3'))
-    assert !matcher.matches?([{ :key_1 => 'value_1', :key_2 => 'value_2' }])
-  end
-  
-end

data/test/unit/parameter_matchers/has_entry_test.rb

@@ -1,96 +0,0 @@
-require File.expand_path('../../../test_helper', __FILE__)
-
-require 'mocha/parameter_matchers/has_entry'
-require 'mocha/parameter_matchers/object'
-require 'mocha/parameter_matchers/equals'
-require 'mocha/inspect'
-
-class HasEntryTest < Test::Unit::TestCase
-  
-  include Mocha::ParameterMatchers
-  
-  def test_should_match_hash_including_specified_key_value_pair
-    matcher = has_entry(:key_1, 'value_1')
-    assert matcher.matches?([{ :key_1 => 'value_1', :key_2 => 'value_2' }])
-  end
-  
-  def test_should_not_match_hash_not_including_specified_key_value_pair
-    matcher = has_entry(:key_1, 'value_2')
-    assert !matcher.matches?([{ :key_1 => 'value_1', :key_2 => 'value_2' }])
-  end
-  
-  def test_should_match_hash_including_specified_entry
-    matcher = has_entry(:key_1 => 'value_1')
-    assert matcher.matches?([{ :key_1 => 'value_1', :key_2 => 'value_2' }])
-  end
-  
-  def test_should_not_match_hash_not_including_specified_entry
-    matcher = has_entry(:key_1 => 'value_2')
-    assert !matcher.matches?([{ :key_1 => 'value_1', :key_2 => 'value_2' }])
-  end
-  
-  def test_should_describe_matcher_with_key_value_pair
-    matcher = has_entry(:key_1, 'value_1')
-    assert_equal "has_entry(:key_1 => 'value_1')", matcher.mocha_inspect
-  end
-  
-  def test_should_describe_matcher_with_entry
-    matcher = has_entry(:key_1 => 'value_1')
-    assert_equal "has_entry(:key_1 => 'value_1')", matcher.mocha_inspect
-  end
-  
-  def test_should_match_hash_including_specified_entry_with_nested_key_matcher
-    matcher = has_entry(equals(:key_1) => 'value_1')
-    assert matcher.matches?([{ :key_1 => 'value_1', :key_2 => 'value_2' }])
-  end
-  
-  def test_should_match_hash_including_specified_entry_with_nested_value_matcher
-    matcher = has_entry(:key_1 => equals('value_1'))
-    assert matcher.matches?([{ :key_1 => 'value_1', :key_2 => 'value_2' }])
-  end
-  
-  def test_should_not_match_hash_not_including_specified_entry_with_nested_key_matcher
-    matcher = has_entry(equals(:key_1) => 'value_2')
-    assert !matcher.matches?([{ :key_1 => 'value_1', :key_2 => 'value_2' }])
-  end
-  
-  def test_should_not_match_hash_not_including_specified_entry_with_nested_value_matcher
-    matcher = has_entry(:key_1 => equals('value_2'))
-    assert !matcher.matches?([{ :key_1 => 'value_1', :key_2 => 'value_2' }])
-  end
-  
-  def test_should_not_match_object_that_doesnt_respond_to_keys
-    matcher = has_entry(:key_1 => equals('value_2'))
-    object = Class.new do
-      def [](key)
-        'value_2'
-      end
-    end.new
-    assert !matcher.matches?([object])
-  end
-  
-  def test_should_not_match_object_that_doesnt_respond_to_square_bracket
-    matcher = has_entry(:key_1 => equals('value_2'))
-    object = Class.new do
-      def keys
-        [:key_1]
-      end
-    end.new
-    assert !matcher.matches?([object])
-  end
-
-  def test_should_raise_argument_error_if_no_entries_are_supplied
-    e = assert_raises(ArgumentError) do
-      has_entry({})
-    end
-    assert_equal "Argument has no entries.", e.message
-  end
-
-  def test_should_raise_argument_error_if_multiple_entries_are_supplied
-    e = assert_raises(ArgumentError) do
-      has_entry(:key_1 => 'value_1', :key_2 => 'value_2')
-    end
-    assert_equal "Argument has multiple entries. Use Mocha::ParameterMatchers#has_entries instead.", e.message
-  end
-
-end

data/test/unit/parameter_matchers/has_key_test.rb

@@ -1,55 +0,0 @@
-require File.expand_path('../../../test_helper', __FILE__)
-
-require 'mocha/parameter_matchers/has_key'
-require 'mocha/parameter_matchers/object'
-require 'mocha/inspect'
-
-class HasKeyTest < Test::Unit::TestCase
-  
-  include Mocha::ParameterMatchers
-  
-  def test_should_match_hash_including_specified_key
-    matcher = has_key(:key_1)
-    assert matcher.matches?([{ :key_1 => 1, :key_2 => 2 }])
-  end
-  
-  def test_should_not_match_hash_not_including_specified_key
-    matcher = has_key(:key_1)
-    assert !matcher.matches?([{ :key_2 => 2 }])
-  end
-  
-  def test_should_describe_matcher
-    matcher = has_key(:key)
-    assert_equal 'has_key(:key)', matcher.mocha_inspect
-  end
-  
-  def test_should_match_hash_including_specified_key_with_nested_key_matcher
-    matcher = has_key(equals(:key_1))
-    assert matcher.matches?([{ :key_1 => 1, :key_2 => 2 }])
-  end
-  
-  def test_should_not_match_hash_not_including_specified_key_with_nested_key_matcher
-    matcher = has_key(equals(:key_1))
-    assert !matcher.matches?([{ :key_2 => 2 }])
-  end
-  
-  def test_should_not_raise_error_on_empty_arguments
-    matcher = has_key(:key)
-    assert_nothing_raised { matcher.matches?([]) }
-  end
-  
-  def test_should_not_match_on_empty_arguments
-    matcher = has_key(:key)
-    assert !matcher.matches?([])
-  end
-  
-  def test_should_not_raise_error_on_argument_that_does_not_respond_to_keys
-    matcher = has_key(:key)
-    assert_nothing_raised { matcher.matches?([:key]) }
-  end
-  
-  def test_should_not_match_on_argument_that_does_not_respond_to_keys
-    matcher = has_key(:key)
-    assert !matcher.matches?([:key])
-  end
-end

data/test/unit/parameter_matchers/has_value_test.rb

@@ -1,57 +0,0 @@
-require File.expand_path('../../../test_helper', __FILE__)
-
-require 'mocha/parameter_matchers/has_value'
-require 'mocha/parameter_matchers/object'
-require 'mocha/parameter_matchers/equals'
-require 'mocha/inspect'
-
-class HasValueTest < Test::Unit::TestCase
-  
-  include Mocha::ParameterMatchers
-  
-  def test_should_match_hash_including_specified_value
-    matcher = has_value('value_1')
-    assert matcher.matches?([{ :key_1 => 'value_1', :key_2 => 'value_2' }])
-  end
-  
-  def test_should_not_match_hash_not_including_specified_value
-    matcher = has_value('value_1')
-    assert !matcher.matches?([{ :key_2 => 'value_2' }])
-  end
-  
-  def test_should_describe_matcher
-    matcher = has_value('value_1')
-    assert_equal "has_value('value_1')", matcher.mocha_inspect
-  end
-  
-  def test_should_match_hash_including_specified_value_with_nested_value_matcher
-    matcher = has_value(equals('value_1'))
-    assert matcher.matches?([{ :key_1 => 'value_1', :key_2 => 'value_2' }])
-  end
-  
-  def test_should_not_match_hash_not_including_specified_value_with_nested_value_matcher
-    matcher = has_value(equals('value_1'))
-    assert !matcher.matches?([{ :key_2 => 'value_2' }])
-  end
-  
-  def test_should_not_raise_error_on_empty_arguments
-    matcher = has_value('value_1')
-    assert_nothing_raised { matcher.matches?([]) }
-  end
-  
-  def test_should_not_match_empty_arguments
-    matcher = has_value('value_1')
-    assert !matcher.matches?([])
-  end
-  
-  def test_should_not_raise_error_on_argument_that_does_not_respond_to_values
-    matcher = has_value('value_1')
-    assert_nothing_raised { matcher.matches?(['value_1']) }
-  end
-  
-  def test_should_not_match_on_argument_that_does_not_respond_to_values
-    matcher = has_value('value_1')
-    assert !matcher.matches?(['value_1'])
-  end
-  
-end

data/test/unit/parameter_matchers/includes_test.rb

@@ -1,44 +0,0 @@
-require File.expand_path('../../../test_helper', __FILE__)
-
-require 'mocha/parameter_matchers/includes'
-require 'mocha/inspect'
-
-class IncludesTest < Test::Unit::TestCase
-
-  include Mocha::ParameterMatchers
-
-  def test_should_match_object_including_value
-    matcher = includes(:x)
-    assert matcher.matches?([[:x, :y, :z]])
-  end
-
-  def test_should_not_match_object_that_does_not_include_value
-    matcher = includes(:not_included)
-    assert !matcher.matches?([[:x, :y, :z]])
-  end
-
-  def test_should_describe_matcher
-    matcher = includes(:x)
-    assert_equal "includes(:x)", matcher.mocha_inspect
-  end
-  
-  def test_should_not_raise_error_on_emtpy_arguments
-    matcher = includes(:x)
-    assert_nothing_raised { matcher.matches?([]) }
-  end
-  
-  def test_should_not_match_on_empty_arguments
-    matcher = includes(:x)
-    assert !matcher.matches?([])
-  end
-  
-  def test_should_not_raise_error_on_argument_that_does_not_respond_to_include
-    matcher = includes(:x)
-    assert_nothing_raised { matcher.matches?([:x]) }
-  end
-  
-  def test_should_not_match_on_argument_that_does_not_respond_to_include
-    matcher = includes(:x)
-    assert !matcher.matches?([:x])
-  end
-end

data/test/unit/parameter_matchers/instance_of_test.rb

@@ -1,25 +0,0 @@
-require File.expand_path('../../../test_helper', __FILE__)
-
-require 'mocha/parameter_matchers/instance_of'
-require 'mocha/inspect'
-
-class InstanceOfTest < Test::Unit::TestCase
-
-  include Mocha::ParameterMatchers
-
-  def test_should_match_object_that_is_an_instance_of_specified_class
-    matcher = instance_of(String)
-    assert matcher.matches?(['string'])
-  end
-
-  def test_should_not_match_object_that_is_not_an_instance_of_specified_class
-    matcher = instance_of(String)
-    assert !matcher.matches?([99])
-  end
-
-  def test_should_describe_matcher
-    matcher = instance_of(String)
-    assert_equal "instance_of(String)", matcher.mocha_inspect
-  end
-
-end

data/test/unit/parameter_matchers/is_a_test.rb

@@ -1,25 +0,0 @@
-require File.expand_path('../../../test_helper', __FILE__)
-
-require 'mocha/parameter_matchers/is_a'
-require 'mocha/inspect'
-
-class IsATest < Test::Unit::TestCase
-
-  include Mocha::ParameterMatchers
-
-  def test_should_match_object_that_is_a_specified_class
-    matcher = is_a(Integer)
-    assert matcher.matches?([99])
-  end
-
-  def test_should_not_match_object_that_is_not_a_specified_class
-    matcher = is_a(Integer)
-    assert !matcher.matches?(['string'])
-  end
-
-  def test_should_describe_matcher
-    matcher = is_a(Integer)
-    assert_equal "is_a(Integer)", matcher.mocha_inspect
-  end
-
-end

data/test/unit/parameter_matchers/kind_of_test.rb

@@ -1,25 +0,0 @@
-require File.expand_path('../../../test_helper', __FILE__)
-
-require 'mocha/parameter_matchers/kind_of'
-require 'mocha/inspect'
-
-class KindOfTest < Test::Unit::TestCase
-
-  include Mocha::ParameterMatchers
-
-  def test_should_match_object_that_is_a_kind_of_specified_class
-    matcher = kind_of(Integer)
-    assert matcher.matches?([99])
-  end
-
-  def test_should_not_match_object_that_is_not_a_kind_of_specified_class
-    matcher = kind_of(Integer)
-    assert !matcher.matches?(['string'])
-  end
-
-  def test_should_describe_matcher
-    matcher = kind_of(Integer)
-    assert_equal "kind_of(Integer)", matcher.mocha_inspect
-  end
-
-end

data/test/unit/parameter_matchers/not_test.rb

@@ -1,26 +0,0 @@
-require File.expand_path('../../../test_helper', __FILE__)
-
-require 'mocha/parameter_matchers/not'
-require 'mocha/inspect'
-require 'stub_matcher'
-
-class NotTest < Test::Unit::TestCase
-  
-  include Mocha::ParameterMatchers
-  
-  def test_should_match_if_matcher_does_not_match
-    matcher = Not(Stub::Matcher.new(false))
-    assert matcher.matches?(['any_old_value'])
-  end
-  
-  def test_should_not_match_if_matcher_does_match
-    matcher = Not(Stub::Matcher.new(true))
-    assert !matcher.matches?(['any_old_value'])
-  end
-  
-  def test_should_describe_matcher
-    matcher = Not(Stub::Matcher.new(true))
-    assert_equal 'Not(matcher(true))', matcher.mocha_inspect
-  end
-  
-end

data/test/unit/parameter_matchers/regexp_matches_test.rb

@@ -1,46 +0,0 @@
-require File.expand_path('../../../test_helper', __FILE__)
-
-require 'mocha/parameter_matchers/regexp_matches'
-require 'mocha/inspect'
-
-class RegexpMatchesTest < Test::Unit::TestCase
-  
-  include Mocha::ParameterMatchers
-  
-  def test_should_match_parameter_matching_regular_expression
-    matcher = regexp_matches(/oo/)
-    assert matcher.matches?(['foo'])
-  end
-  
-  def test_should_not_match_parameter_not_matching_regular_expression
-    matcher = regexp_matches(/oo/)
-    assert !matcher.matches?(['bar'])
-  end
-  
-  def test_should_describe_matcher
-    matcher = regexp_matches(/oo/)
-    assert_equal "regexp_matches(/oo/)", matcher.mocha_inspect
-  end
-  
-  def test_should_not_raise_error_on_empty_arguments
-    matcher = regexp_matches(/oo/)
-    assert_nothing_raised { matcher.matches?([]) }
-  end
-  
-  def test_should_not_match_on_empty_arguments
-    matcher = regexp_matches(/oo/)
-    assert !matcher.matches?([])
-  end
-  
-  def test_should_not_raise_error_on_argument_that_does_not_respond_to_equals_tilde
-    object_not_responding_to_equals_tilde = Class.new { undef =~ }.new
-    matcher = regexp_matches(/oo/)
-    assert_nothing_raised { matcher.matches?([object_not_responding_to_equals_tilde]) }
-  end
-  
-  def test_should_not_match_on_argument_that_does_not_respond_to_equals_tilde
-    object_not_responding_to_equals_tilde = Class.new { undef =~ }.new
-    matcher = regexp_matches(/oo/)
-    assert !matcher.matches?([object_not_responding_to_equals_tilde])
-  end
-end

data/test/unit/parameter_matchers/responds_with_test.rb

@@ -1,25 +0,0 @@
-require File.expand_path('../../../test_helper', __FILE__)
-
-require 'mocha/parameter_matchers/responds_with'
-require 'mocha/inspect'
-
-class RespondsWithTest < Test::Unit::TestCase
-  
-  include Mocha::ParameterMatchers
-  
-  def test_should_match_parameter_responding_with_expected_value
-    matcher = responds_with(:upcase, 'FOO')
-    assert matcher.matches?(['foo'])
-  end
-  
-  def test_should_not_match_parameter_responding_with_unexpected_value
-    matcher = responds_with(:upcase, 'FOO')
-    assert !matcher.matches?(['bar'])
-  end
-  
-  def test_should_describe_matcher
-    matcher = responds_with(:foo, :bar)
-    assert_equal 'responds_with(:foo, :bar)', matcher.mocha_inspect
-  end
-  
-end

data/test/unit/parameter_matchers/stub_matcher.rb

@@ -1,27 +0,0 @@
-module Stub
-  
-  class Matcher
-
-    attr_accessor :value
-
-    def initialize(matches)
-      @matches = matches
-    end
-
-    def matches?(available_parameters)
-      value = available_parameters.shift
-      @value = value
-      @matches
-    end
-
-    def mocha_inspect
-      "matcher(#{@matches})"
-    end
-    
-    def to_matcher
-      self
-    end
-
-  end
-  
-end

data/test/unit/parameter_matchers/yaml_equivalent_test.rb

@@ -1,25 +0,0 @@
-require File.expand_path('../../../test_helper', __FILE__)
-
-require 'mocha/parameter_matchers/yaml_equivalent'
-require 'mocha/inspect'
-
-class YamlEquivalentTest < Test::Unit::TestCase
-  
-  include Mocha::ParameterMatchers
-  
-  def test_should_match_parameter_matching_yaml_representation_of_object
-    matcher = yaml_equivalent([1, 2, 3])
-    assert matcher.matches?(["--- \n- 1\n- 2\n- 3\n"])
-  end
-  
-  def test_should_not_match_parameter_matching_yaml_representation_of_object
-    matcher = yaml_equivalent([1, 2, 3])
-    assert !matcher.matches?(["--- \n- 4\n- 5\n"])
-  end
-  
-  def test_should_describe_matcher
-    matcher = yaml_equivalent([1, 2, 3])
-    assert_equal "yaml_equivalent([1, 2, 3])", matcher.mocha_inspect
-  end
-  
-end

data/test/unit/parameters_matcher_test.rb

@@ -1,121 +0,0 @@
-require File.expand_path('../../test_helper', __FILE__)
-require 'mocha/parameters_matcher'
-
-class ParametersMatcherTest < Test::Unit::TestCase
-  
-  include Mocha
-
-  def test_should_match_any_actual_parameters_if_no_expected_parameters_specified
-    parameters_matcher = ParametersMatcher.new
-    assert parameters_matcher.match?([1, 2, 3])
-  end
-
-  def test_should_match_if_actual_parameters_are_same_as_expected_parameters
-    parameters_matcher = ParametersMatcher.new([4, 5, 6])
-    assert parameters_matcher.match?([4, 5, 6])
-  end
-  
-  def test_should_not_match_if_actual_parameters_are_different_from_expected_parameters
-    parameters_matcher = ParametersMatcher.new([4, 5, 6])
-    assert !parameters_matcher.match?([1, 2, 3])
-  end
-  
-  def test_should_not_match_if_there_are_less_actual_parameters_than_expected_parameters
-    parameters_matcher = ParametersMatcher.new([4, 5, 6])
-    assert !parameters_matcher.match?([4, 5])
-  end
-  
-  def test_should_not_match_if_there_are_more_actual_parameters_than_expected_parameters
-    parameters_matcher = ParametersMatcher.new([4, 5])
-    assert !parameters_matcher.match?([4, 5, 6])
-  end
-  
-  def test_should_not_match_if_not_all_required_parameters_are_supplied
-    optionals = ParameterMatchers::Optionally.new(6, 7)
-    parameters_matcher = ParametersMatcher.new([4, 5, optionals])
-    assert !parameters_matcher.match?([4])
-  end
-  
-  def test_should_match_if_all_required_parameters_match_and_no_optional_parameters_are_supplied
-    optionals = ParameterMatchers::Optionally.new(6, 7)
-    parameters_matcher = ParametersMatcher.new([4, 5, optionals])
-    assert parameters_matcher.match?([4, 5])
-  end
-  
-  def test_should_match_if_all_required_and_optional_parameters_match_and_some_optional_parameters_are_supplied
-    optionals = ParameterMatchers::Optionally.new(6, 7)
-    parameters_matcher = ParametersMatcher.new([4, 5, optionals])
-    assert parameters_matcher.match?([4, 5, 6])
-  end
-  
-  def test_should_match_if_all_required_and_optional_parameters_match_and_all_optional_parameters_are_supplied
-    optionals = ParameterMatchers::Optionally.new(6, 7)
-    parameters_matcher = ParametersMatcher.new([4, 5, optionals])
-    assert parameters_matcher.match?([4, 5, 6, 7])
-  end
-  
-  def test_should_not_match_if_all_required_and_optional_parameters_match_but_too_many_optional_parameters_are_supplied
-    optionals = ParameterMatchers::Optionally.new(6, 7)
-    parameters_matcher = ParametersMatcher.new([4, 5, optionals])
-    assert !parameters_matcher.match?([4, 5, 6, 7, 8])
-  end
-  
-  def test_should_not_match_if_all_required_parameters_match_but_some_optional_parameters_do_not_match
-    optionals = ParameterMatchers::Optionally.new(6, 7)
-    parameters_matcher = ParametersMatcher.new([4, 5, optionals])
-    assert !parameters_matcher.match?([4, 5, 6, 0])
-  end
-
-  def test_should_not_match_if_some_required_parameters_do_not_match_although_all_optional_parameters_do_match
-    optionals = ParameterMatchers::Optionally.new(6, 7)
-    parameters_matcher = ParametersMatcher.new([4, 5, optionals])
-    assert !parameters_matcher.match?([4, 0, 6])
-  end
-
-  def test_should_not_match_if_all_required_parameters_match_but_no_optional_parameters_match
-    optionals = ParameterMatchers::Optionally.new(6, 7)
-    parameters_matcher = ParametersMatcher.new([4, 5, optionals])
-    assert !parameters_matcher.match?([4, 5, 0, 0])
-  end
-
-  def test_should_match_if_actual_parameters_satisfy_matching_block
-    parameters_matcher = ParametersMatcher.new { |x, y| x + y == 3 }
-    assert parameters_matcher.match?([1, 2])
-  end
-
-  def test_should_not_match_if_actual_parameters_do_not_satisfy_matching_block
-    parameters_matcher = ParametersMatcher.new { |x, y| x + y == 3 }
-    assert !parameters_matcher.match?([2, 3])
-  end
-  
-  def test_should_remove_outer_array_braces
-    params = [1, 2, [3, 4]]
-    parameters_matcher = ParametersMatcher.new(params)
-    assert_equal '(1, 2, [3, 4])', parameters_matcher.mocha_inspect
-  end
-  
-  def test_should_display_numeric_arguments_as_is
-    params = [1, 2, 3]
-    parameters_matcher = ParametersMatcher.new(params)
-    assert_equal '(1, 2, 3)', parameters_matcher.mocha_inspect
-  end
-  
-  def test_should_remove_curly_braces_if_hash_is_only_argument
-    params = [{:a => 1, :z => 2}]
-    parameters_matcher = ParametersMatcher.new(params)
-    assert_nil parameters_matcher.mocha_inspect.index('{')
-    assert_nil parameters_matcher.mocha_inspect.index('}')
-  end
-  
-  def test_should_not_remove_curly_braces_if_hash_is_not_the_only_argument
-    params = [1, {:a => 1}]
-    parameters_matcher = ParametersMatcher.new(params)
-    assert_equal '(1, {:a => 1})', parameters_matcher.mocha_inspect
-  end
-  
-  def test_should_indicate_that_matcher_will_match_any_actual_parameters
-    parameters_matcher = ParametersMatcher.new
-    assert_equal '(any_parameters)', parameters_matcher.mocha_inspect
-  end
-
-end