mocha 1.8.0 → 1.13.0

data/test/unit/parameter_matchers/all_of_test.rb

@@ -1,24 +0,0 @@
-require File.expand_path('../../../test_helper', __FILE__)
-
-require 'mocha/parameter_matchers/all_of'
-require 'mocha/inspect'
-require 'stub_matcher'
-
-class AllOfTest < Mocha::TestCase
-  include Mocha::ParameterMatchers
-
-  def test_should_match_if_all_matchers_match
-    matcher = all_of(Stub::Matcher.new(true), Stub::Matcher.new(true), Stub::Matcher.new(true))
-    assert matcher.matches?(['any_old_value'])
-  end
-
-  def test_should_not_match_if_any_matcher_does_not_match
-    matcher = all_of(Stub::Matcher.new(true), Stub::Matcher.new(false), Stub::Matcher.new(true))
-    assert !matcher.matches?(['any_old_value'])
-  end
-
-  def test_should_describe_matcher
-    matcher = all_of(Stub::Matcher.new(true), Stub::Matcher.new(false), Stub::Matcher.new(true))
-    assert_equal 'all_of(matcher(true), matcher(false), matcher(true))', matcher.mocha_inspect
-  end
-end

data/test/unit/parameter_matchers/any_of_test.rb

@@ -1,24 +0,0 @@
-require File.expand_path('../../../test_helper', __FILE__)
-
-require 'mocha/parameter_matchers/any_of'
-require 'mocha/inspect'
-require 'stub_matcher'
-
-class AnyOfTest < Mocha::TestCase
-  include Mocha::ParameterMatchers
-
-  def test_should_match_if_any_matchers_match
-    matcher = any_of(Stub::Matcher.new(false), Stub::Matcher.new(true), Stub::Matcher.new(false))
-    assert matcher.matches?(['any_old_value'])
-  end
-
-  def test_should_not_match_if_no_matchers_match
-    matcher = any_of(Stub::Matcher.new(false), Stub::Matcher.new(false), Stub::Matcher.new(false))
-    assert !matcher.matches?(['any_old_value'])
-  end
-
-  def test_should_describe_matcher
-    matcher = any_of(Stub::Matcher.new(false), Stub::Matcher.new(true), Stub::Matcher.new(false))
-    assert_equal 'any_of(matcher(false), matcher(true), matcher(false))', matcher.mocha_inspect
-  end
-end

data/test/unit/parameter_matchers/anything_test.rb

@@ -1,19 +0,0 @@
-require File.expand_path('../../../test_helper', __FILE__)
-
-require 'mocha/parameter_matchers/anything'
-require 'mocha/inspect'
-
-class AnythingTest < Mocha::TestCase
-  include Mocha::ParameterMatchers
-
-  def test_should_match_anything
-    matcher = anything
-    assert matcher.matches?([:something])
-    assert matcher.matches?([{ 'x' => 'y' }])
-  end
-
-  def test_should_describe_matcher
-    matcher = anything
-    assert_equal 'anything', matcher.mocha_inspect
-  end
-end

data/test/unit/parameter_matchers/equals_test.rb

@@ -1,23 +0,0 @@
-require File.expand_path('../../../test_helper', __FILE__)
-
-require 'mocha/parameter_matchers/equals'
-require 'mocha/inspect'
-
-class EqualsTest < Mocha::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/equivalent_uri_test.rb

@@ -1,50 +0,0 @@
-require File.expand_path('../../../test_helper', __FILE__)
-require 'deprecation_disabler'
-require 'mocha/parameter_matchers/equivalent_uri'
-
-class EquivalentUriMatchesTest < Mocha::TestCase
-  include Mocha::ParameterMatchers
-  include DeprecationDisabler
-
-  def test_should_match_identical_uri
-    matcher = equivalent_uri('http://example.com/foo?a=1&b=2')
-    assert matcher.matches?(['http://example.com/foo?a=1&b=2'])
-  end
-
-  def test_should_support_legacy_matcher_method
-    disable_deprecations do
-      matcher = has_equivalent_query_string('http://example.com/foo?a=1&b=2')
-      assert matcher.matches?(['http://example.com/foo?a=1&b=2'])
-    end
-  end
-
-  def test_should_match_uri_with_rearranged_query_string
-    matcher = equivalent_uri('http://example.com/foo?b=2&a=1')
-    assert matcher.matches?(['http://example.com/foo?a=1&b=2'])
-  end
-
-  def test_should_not_match_uri_with_different_query_string
-    matcher = equivalent_uri('http://example.com/foo?a=1')
-    assert !matcher.matches?(['http://example.com/foo?a=1&b=2'])
-  end
-
-  def test_should_not_match_uri_when_no_query_string_expected
-    matcher = equivalent_uri('http://example.com/foo')
-    assert !matcher.matches?(['http://example.com/foo?a=1&b=2'])
-  end
-
-  def test_should_not_match_uri_with_different_domain
-    matcher = equivalent_uri('http://a.example.com/foo?a=1&b=2')
-    assert !matcher.matches?(['http://b.example.com/foo?a=1&b=2'])
-  end
-
-  def test_should_match_uri_without_scheme_and_domain
-    matcher = equivalent_uri('/foo?a=1&b=2')
-    assert matcher.matches?(['/foo?a=1&b=2'])
-  end
-
-  def test_should_match_uri_with_query_string_containing_blank_value
-    matcher = equivalent_uri('http://example.com/foo?a=&b=2')
-    assert matcher.matches?(['http://example.com/foo?a=&b=2'])
-  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 < Mocha::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]
-    # rubocop:disable Security/Eval
-    entries = eval(matches[1], binding, __FILE__, __LINE__)
-    # rubocop:enable Security/Eval
-    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,128 +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 < Mocha::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_single_argument_is_not_a_hash
-    e = assert_raises(ArgumentError) do
-      has_entry([])
-    end
-    assert_equal 'Argument is not a Hash.', e.message
-  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
-
-  def test_should_raise_argument_error_if_more_than_two_arguments_are_supplied
-    e = assert_raises(ArgumentError) do
-      has_entry(1, 2, 3)
-    end
-    assert_equal 'Too many arguments; use either a single argument (must be a Hash) or two arguments (a key and a value).', e.message
-  end
-
-  def test_should_match_array_as_key
-    matcher = has_entry([:key_1, :key_2] => 'value_1')
-    assert matcher.matches?([{ [:key_1, :key_2] => 'value_1', :key_3 => 'value_2' }])
-  end
-
-  def test_should_match_array_as_value
-    matcher = has_entry(:key_1 => %w[value_1 value_2])
-    assert matcher.matches?([{ :key_1 => %w[value_1 value_2] }])
-  end
-
-  def test_should_match_hash_as_value_and_key
-    matcher = has_entry({ :key_1 => 'value_1', :key_2 => 'value_2' } => { :key_3 => 'value_3', :key_4 => 'value_4' })
-    assert matcher.matches?([{ { :key_1 => 'value_1', :key_2 => 'value_2' } => { :key_3 => 'value_3', :key_4 => 'value_4' }, :key_5 => 'value_5' }])
-  end
-
-  def test_should_match_matcher_as_value_and_key
-    matcher = has_entry(has_entry(:key_1 => 'value_1') => has_entry(:key_3 => 'value_3'))
-    assert matcher.matches?([{ { :key_1 => 'value_1', :key_2 => 'value_2' } => { :key_3 => 'value_3', :key_4 => 'value_4' }, :key_5 => 'value_5' }])
-  end
-end

data/test/unit/parameter_matchers/has_key_test.rb

@@ -1,54 +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 < Mocha::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,55 +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 < Mocha::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,106 +0,0 @@
-require File.expand_path('../../../test_helper', __FILE__)
-
-require 'mocha/parameter_matchers/includes'
-require 'mocha/parameter_matchers/object'
-require 'mocha/parameter_matchers/has_key'
-require 'mocha/parameter_matchers/regexp_matches'
-require 'mocha/inspect'
-
-class IncludesTest < Mocha::TestCase
-  include Mocha::ParameterMatchers
-
-  def test_should_match_object_including_value
-    matcher = includes(:x)
-    assert matcher.matches?([[:x, :y, :z]])
-  end
-
-  def test_should_match_object_including_array_value
-    matcher = includes([:x])
-    assert matcher.matches?([[[:x], [:y], [:z]]])
-  end
-
-  def test_should_match_object_including_all_values
-    matcher = includes(:x, :y, :z)
-    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_not_match_object_that_does_not_include_any_one_value
-    matcher = includes(:x, :y, :z, :not_included)
-    assert !matcher.matches?([[:x, :y, :z]])
-  end
-
-  def test_should_describe_matcher_with_one_item
-    matcher = includes(:x)
-    assert_equal 'includes(:x)', matcher.mocha_inspect
-  end
-
-  def test_should_describe_matcher_with_multiple_items
-    matcher = includes(:x, :y, :z)
-    assert_equal 'includes(:x, :y, :z)', 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
-
-  def test_should_match_object_including_value_which_matches_nested_matcher
-    matcher = includes(has_key(:key))
-    assert matcher.matches?([[:non_matching_element, { :key => 'value' }]])
-  end
-
-  def test_should_not_match_object_which_doesnt_include_value_that_matches_nested_matcher
-    matcher = includes(has_key(:key))
-    assert !matcher.matches?([[:non_matching_element, { :other_key => 'other-value' }]])
-  end
-
-  def test_should_match_string_argument_containing_substring
-    matcher = includes('bar')
-    assert matcher.matches?(['foobarbaz'])
-  end
-
-  def test_should_not_match_string_argument_without_substring
-    matcher = includes('bar')
-    assert !matcher.matches?(['foobaz'])
-  end
-
-  def test_should_match_hash_argument_containing_given_key
-    matcher = includes(:key)
-    assert matcher.matches?([{ :thing => 1, :key => 2 }])
-  end
-
-  def test_should_not_match_hash_argument_missing_given_key
-    matcher = includes(:key)
-    assert !matcher.matches?([{ :thing => 1, :other => :key }])
-  end
-
-  def test_should_match_hash_when_nested_matcher_matches_key
-    matcher = includes(regexp_matches(/ar/))
-    assert matcher.matches?([{ 'foo' => 1, 'bar' => 2 }])
-  end
-
-  def test_should_not_match_hash_when_nested_matcher_doesn_not_match_key
-    matcher = includes(regexp_matches(/az/))
-    assert !matcher.matches?([{ 'foo' => 1, 'bar' => 2 }])
-  end
-end

data/test/unit/parameter_matchers/instance_of_test.rb

@@ -1,23 +0,0 @@
-require File.expand_path('../../../test_helper', __FILE__)
-
-require 'mocha/parameter_matchers/instance_of'
-require 'mocha/inspect'
-
-class InstanceOfTest < Mocha::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,23 +0,0 @@
-require File.expand_path('../../../test_helper', __FILE__)
-
-require 'mocha/parameter_matchers/is_a'
-require 'mocha/inspect'
-
-class IsATest < Mocha::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,23 +0,0 @@
-require File.expand_path('../../../test_helper', __FILE__)
-
-require 'mocha/parameter_matchers/kind_of'
-require 'mocha/inspect'
-
-class KindOfTest < Mocha::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,24 +0,0 @@
-require File.expand_path('../../../test_helper', __FILE__)
-
-require 'mocha/parameter_matchers/not'
-require 'mocha/inspect'
-require 'stub_matcher'
-
-class NotTest < Mocha::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