redcar 0.3.2dev → 0.3.3

data/lib/openssl/mocha/test/unit/class_method_test.rb

@@ -0,0 +1,196 @@
+require File.join(File.dirname(__FILE__), "..", "test_helper")
+require 'method_definer'
+require 'mocha/mock'
+
+require 'mocha/class_method'
+
+class ClassMethodTest < Test::Unit::TestCase
+  
+  include Mocha
+
+  def test_should_provide_hidden_version_of_method_name_starting_with_prefix
+    method = ClassMethod.new(nil, :original_method_name)
+    assert_match(/^__stubba__/, method.hidden_method)
+  end
+  
+  def test_should_provide_hidden_version_of_method_name_ending_with_suffix
+    method = ClassMethod.new(nil, :original_method_name)
+    assert_match(/__stubba__$/, method.hidden_method)
+  end
+  
+  def test_should_provide_hidden_version_of_method_name_including_original_method_name
+    method = ClassMethod.new(nil, :original_method_name)
+    assert_match(/original_method_name/, method.hidden_method)
+  end
+  
+  def test_should_provide_hidden_version_of_method_name_substituting_question_mark
+    method = ClassMethod.new(nil, :question_mark?)
+    assert_no_match(/\?/, method.hidden_method)
+    assert_match(/question_mark_substituted_character_63/, method.hidden_method)
+  end
+  
+  def test_should_provide_hidden_version_of_method_name_substituting_exclamation_mark
+    method = ClassMethod.new(nil, :exclamation_mark!)
+    assert_no_match(/!/, method.hidden_method)
+    assert_match(/exclamation_mark_substituted_character_33/, method.hidden_method)
+  end
+
+  def test_should_provide_hidden_version_of_method_name_substituting_equals_sign
+    method = ClassMethod.new(nil, :equals_sign=)
+    assert_no_match(/\=/, method.hidden_method)
+    assert_match(/equals_sign_substituted_character_61/, method.hidden_method)
+  end
+
+  def test_should_provide_hidden_version_of_method_name_substituting_brackets
+    method = ClassMethod.new(nil, :[])
+    assert_no_match(/\[\]/, method.hidden_method)
+    assert_match(/substituted_character_91__substituted_character_93/, method.hidden_method)
+  end
+  
+  def test_should_provide_hidden_version_of_method_name_substituting_plus_sign
+    method = ClassMethod.new(nil, :+)
+    assert_no_match(/\+/, method.hidden_method)
+    assert_match(/substituted_character_43/, method.hidden_method)
+  end
+  
+  def test_should_hide_original_method
+    klass = Class.new { def self.method_x; end }
+    method = ClassMethod.new(klass, :method_x)
+    hidden_method_x = method.hidden_method
+    
+    method.hide_original_method
+
+    assert klass.respond_to?(hidden_method_x)
+  end
+  
+  def test_should_respond_to_original_method_name_after_original_method_has_been_hidden
+    klass = Class.new { def self.original_method_name; end }
+    method = ClassMethod.new(klass, :original_method_name)
+    hidden_method_x = method.hidden_method
+    
+    method.hide_original_method
+
+    assert klass.respond_to?(:original_method_name)
+  end
+  
+  def test_should_not_hide_original_method_if_method_not_defined
+    klass = Class.new
+    method = ClassMethod.new(klass, :method_x)
+    hidden_method_x = method.hidden_method
+    
+    method.hide_original_method
+
+    assert_equal false, klass.respond_to?(hidden_method_x)
+  end
+  
+  def test_should_define_a_new_method_which_should_call_mocha_method_missing
+    klass = Class.new { def self.method_x; end }
+    mocha = Mocha::Mock.new
+    klass.define_instance_method(:mocha) { mocha }
+    mocha.expects(:method_x).with(:param1, :param2).returns(:result)
+    method = ClassMethod.new(klass, :method_x)
+    
+    method.define_new_method
+    result = klass.method_x(:param1, :param2)
+    
+    assert_equal :result, result
+    mocha.verify
+  end
+  
+  def test_should_remove_new_method
+    klass = Class.new { def self.method_x; end }
+    method = ClassMethod.new(klass, :method_x)
+    
+    method.remove_new_method
+    
+    assert_equal false, klass.respond_to?(:method_x)
+  end
+
+  def test_should_restore_original_method
+    klass = Class.new { def self.method_x; end }
+    method = ClassMethod.new(klass, :method_x)
+    hidden_method_x = method.hidden_method.to_sym
+    klass.define_instance_method(hidden_method_x) { :original_result }
+
+    method.restore_original_method
+    
+    assert_equal :original_result, klass.method_x 
+    assert_equal false, klass.respond_to?(hidden_method_x)
+  end
+
+  def test_should_not_restore_original_method_if_hidden_method_is_not_defined
+    klass = Class.new { def self.method_x; :new_result; end }
+    method = ClassMethod.new(klass, :method_x)
+
+    method.restore_original_method
+    
+    assert_equal :new_result, klass.method_x
+  end
+
+  def test_should_call_hide_original_method
+    klass = Class.new { def self.method_x; end }
+    method = ClassMethod.new(klass, :method_x)
+    method.define_instance_accessor(:hide_called)
+    method.replace_instance_method(:hide_original_method) { self.hide_called = true }
+    
+    method.stub
+    
+    assert method.hide_called
+  end
+
+  def test_should_call_define_new_method
+    klass = Class.new { def self.method_x; end }
+    method = ClassMethod.new(klass, :method_x)
+    method.define_instance_accessor(:define_called)
+    method.replace_instance_method(:define_new_method) { self.define_called = true }
+    
+    method.stub
+    
+    assert method.define_called
+  end
+  
+  def test_should_call_remove_new_method
+    klass = Class.new { def self.method_x; end }
+    klass.define_instance_method(:reset_mocha) { }
+    method = ClassMethod.new(klass, :method_x)
+    method.define_instance_accessor(:remove_called)
+    method.replace_instance_method(:remove_new_method) { self.remove_called = true }
+    
+    method.unstub
+    
+    assert method.remove_called
+  end
+
+  def test_should_call_restore_original_method
+    klass = Class.new { def self.method_x; end }
+    klass.define_instance_method(:reset_mocha) { }
+    method = ClassMethod.new(klass, :method_x)
+    method.define_instance_accessor(:restore_called)
+    method.replace_instance_method(:restore_original_method) { self.restore_called = true }
+    
+    method.unstub
+    
+    assert method.restore_called
+  end
+
+  def test_should_call_reset_mocha
+    klass = Class.new { def self.method_x; end }
+    klass.define_instance_accessor(:reset_called)
+    klass.define_instance_method(:reset_mocha) { self.reset_called = true }
+    method = ClassMethod.new(klass, :method_x)
+    method.replace_instance_method(:restore_original_method) { }
+    
+    method.unstub
+    
+    assert klass.reset_called
+  end
+  
+  def test_should_return_mock_for_stubbee
+    mocha = Object.new
+    stubbee = Object.new
+    stubbee.define_instance_accessor(:mocha) { mocha }
+    method = ClassMethod.new(stubbee, :method_name)
+    assert_equal stubbee.mocha, method.mock
+  end
+
+end

data/lib/openssl/mocha/test/unit/date_time_inspect_test.rb

@@ -0,0 +1,21 @@
+require File.join(File.dirname(__FILE__), "..", "test_helper")
+require 'mocha/inspect'
+
+class TimeDateInspectTest < Test::Unit::TestCase
+  
+  def test_should_use_include_date_in_seconds
+    time = Time.now
+    assert_equal "#{time.inspect} (#{time.to_f} secs)", time.mocha_inspect
+  end
+  
+  def test_should_use_to_s_for_date
+    date = Date.new(2006, 1, 1)
+    assert_equal date.to_s, date.mocha_inspect
+  end
+  
+  def test_should_use_to_s_for_datetime
+    datetime = DateTime.new(2006, 1, 1)
+    assert_equal datetime.to_s, datetime.mocha_inspect
+  end
+  
+end

data/lib/openssl/mocha/test/unit/expectation_list_test.rb

@@ -0,0 +1,69 @@
+require File.join(File.dirname(__FILE__), "..", "test_helper")
+require 'mocha/expectation_list'
+require 'mocha/expectation'
+require 'set'
+require 'method_definer'
+
+class ExpectationListTest < Test::Unit::TestCase
+  
+  include Mocha
+  
+  def test_should_find_matching_expectation
+    expectation_list = ExpectationList.new
+    expectation1 = Expectation.new(nil, :my_method).with(:argument1, :argument2)
+    expectation2 = Expectation.new(nil, :my_method).with(:argument3, :argument4)
+    expectation_list.add(expectation1)
+    expectation_list.add(expectation2)
+    assert_same expectation2, expectation_list.detect(:my_method, :argument3, :argument4)
+  end
+
+  def test_should_find_most_recent_matching_expectation
+    expectation_list = ExpectationList.new
+    expectation1 = Expectation.new(nil, :my_method).with(:argument1, :argument2)
+    expectation2 = Expectation.new(nil, :my_method).with(:argument1, :argument2)
+    expectation_list.add(expectation1)
+    expectation_list.add(expectation2)
+    assert_same expectation2, expectation_list.detect(:my_method, :argument1, :argument2)
+  end
+
+  def test_should_find_most_recent_matching_expectation_but_give_preference_to_those_allowing_invocations
+    expectation_list = ExpectationList.new
+    expectation1 = Expectation.new(nil, :my_method)
+    expectation2 = Expectation.new(nil, :my_method)
+    expectation1.define_instance_method(:invocations_allowed?) { true }
+    expectation2.define_instance_method(:invocations_allowed?) { false }
+    expectation_list.add(expectation1)
+    expectation_list.add(expectation2)
+    assert_same expectation1, expectation_list.detect(:my_method)
+  end
+
+  def test_should_find_most_recent_matching_expectation_if_no_matching_expectations_allow_invocations
+    expectation_list = ExpectationList.new
+    expectation1 = Expectation.new(nil, :my_method)
+    expectation2 = Expectation.new(nil, :my_method)
+    expectation1.define_instance_method(:invocations_allowed?) { false }
+    expectation2.define_instance_method(:invocations_allowed?) { false }
+    expectation_list.add(expectation1)
+    expectation_list.add(expectation2)
+    assert_same expectation2, expectation_list.detect(:my_method)
+  end
+
+  def test_should_find_expectations_for_the_same_method_no_matter_what_the_arguments
+    expectation_list = ExpectationList.new
+    expectation1 = Expectation.new(nil, :my_method).with(:argument1, :argument2)
+    expectation_list.add(expectation1)
+    expectation2 = Expectation.new(nil, :my_method).with(:argument3, :argument4)
+    expectation_list.add(expectation2)
+    assert_equal [expectation1, expectation2].to_set, expectation_list.similar(:my_method).to_set
+  end
+  
+  def test_should_ignore_expectations_for_different_methods
+    expectation_list = ExpectationList.new
+    expectation1 = Expectation.new(nil, :method1).with(:argument1, :argument2)
+    expectation_list.add(expectation1)
+    expectation2 = Expectation.new(nil, :method2).with(:argument1, :argument2)
+    expectation_list.add(expectation2)
+    assert_equal [expectation2], expectation_list.similar(:method2)
+  end
+  
+end

data/lib/openssl/mocha/test/unit/expectation_raiser_test.rb

@@ -0,0 +1,28 @@
+require File.join(File.dirname(__FILE__), "..", "test_helper")
+
+require 'mocha/exception_raiser'
+
+class ExceptionRaiserTest < Test::Unit::TestCase
+  
+  include Mocha
+  
+  def test_should_raise_exception_with_specified_class_and_default_message
+    exception_class = Class.new(StandardError)
+    raiser = ExceptionRaiser.new(exception_class, nil)
+    exception = assert_raises(exception_class) { raiser.evaluate }
+    assert_equal exception_class.to_s, exception.message
+  end
+
+  def test_should_raise_exception_with_specified_class_and_message
+    exception_class = Class.new(StandardError)
+    raiser = ExceptionRaiser.new(exception_class, 'message')
+    exception = assert_raises(exception_class) { raiser.evaluate }
+    assert_equal 'message', exception.message
+  end
+  
+  def test_should_raise_interrupt_exception_with_default_message_so_it_works_in_ruby_1_8_6
+    raiser = ExceptionRaiser.new(Interrupt, nil)
+    assert_raises(Interrupt) { raiser.evaluate }
+  end
+
+end

data/lib/openssl/mocha/test/unit/expectation_test.rb

@@ -0,0 +1,399 @@
+require File.join(File.dirname(__FILE__), "..", "test_helper")
+require 'method_definer'
+require 'mocha/expectation'
+require 'execution_point'
+require 'deprecation_disabler'
+
+class ExpectationTest < Test::Unit::TestCase
+  
+  include Mocha
+  include DeprecationDisabler
+  
+  def new_expectation
+    Expectation.new(nil, :expected_method)
+  end
+  
+  def test_should_match_calls_to_same_method_with_any_parameters
+    assert new_expectation.match?(:expected_method, 1, 2, 3)
+  end
+  
+  def test_should_match_calls_to_same_method_with_exactly_zero_parameters
+    expectation = new_expectation.with()
+    assert expectation.match?(:expected_method)
+  end
+  
+  def test_should_not_match_calls_to_same_method_with_more_than_zero_parameters
+    expectation = new_expectation.with()
+    assert !expectation.match?(:expected_method, 1, 2, 3)
+  end
+  
+  def test_should_match_calls_to_same_method_with_expected_parameter_values
+    expectation = new_expectation.with(1, 2, 3)
+    assert expectation.match?(:expected_method, 1, 2, 3)
+  end
+  
+  def test_should_match_calls_to_same_method_with_parameters_constrained_as_expected
+    expectation = new_expectation.with() {|x, y, z| x + y == z}
+    assert expectation.match?(:expected_method, 1, 2, 3)
+  end
+  
+  def test_should_not_match_calls_to_different_method_with_parameters_constrained_as_expected
+    expectation = new_expectation.with() {|x, y, z| x + y == z}
+    assert !expectation.match?(:different_method, 1, 2, 3)
+  end
+  
+  def test_should_not_match_calls_to_different_methods_with_no_parameters
+    assert !new_expectation.match?(:unexpected_method)
+  end
+  
+  def test_should_not_match_calls_to_same_method_with_too_few_parameters
+    expectation = new_expectation.with(1, 2, 3)
+    assert !expectation.match?(:unexpected_method, 1, 2)
+  end
+  
+  def test_should_not_match_calls_to_same_method_with_too_many_parameters
+    expectation = new_expectation.with(1, 2)
+    assert !expectation.match?(:unexpected_method, 1, 2, 3)
+  end
+  
+  def test_should_not_match_calls_to_same_method_with_unexpected_parameter_values
+    expectation = new_expectation.with(1, 2, 3)
+    assert !expectation.match?(:unexpected_method, 1, 0, 3)
+  end
+  
+  def test_should_not_match_calls_to_same_method_with_parameters_not_constrained_as_expected
+    expectation = new_expectation.with() {|x, y, z| x + y == z}
+    assert !expectation.match?(:expected_method, 1, 0, 3)
+  end
+  
+  def test_should_allow_invocations_until_expected_invocation_count_is_one_and_actual_invocation_count_would_be_two
+    expectation = new_expectation.times(1)
+    assert expectation.invocations_allowed?
+    expectation.invoke
+    assert !expectation.invocations_allowed?
+  end
+  
+  def test_should_allow_invocations_until_expected_invocation_count_is_two_and_actual_invocation_count_would_be_three
+    expectation = new_expectation.times(2)
+    assert expectation.invocations_allowed?
+    expectation.invoke
+    assert expectation.invocations_allowed?
+    expectation.invoke
+    assert !expectation.invocations_allowed?
+  end
+
+  def test_should_allow_invocations_until_expected_invocation_count_is_a_range_from_two_to_three_and_actual_invocation_count_would_be_four
+    expectation = new_expectation.times(2..3)
+    assert expectation.invocations_allowed?
+    expectation.invoke
+    assert expectation.invocations_allowed?
+    expectation.invoke
+    assert expectation.invocations_allowed?
+    expectation.invoke
+    assert !expectation.invocations_allowed?
+  end
+  
+  def test_should_store_provided_backtrace
+    backtrace = Object.new
+    expectation = Expectation.new(nil, :expected_method, backtrace)
+    assert_equal backtrace, expectation.backtrace
+  end
+  
+  def test_should_default_backtrace_to_caller
+    execution_point = ExecutionPoint.current; expectation = Expectation.new(nil, :expected_method)
+    assert_equal execution_point, ExecutionPoint.new(expectation.backtrace)
+  end
+  
+  def test_should_not_yield
+    yielded = false
+    new_expectation.invoke() { yielded = true }
+    assert_equal false, yielded
+  end
+
+  def test_should_yield_no_parameters
+    expectation = new_expectation().yields()
+    yielded_parameters = nil
+    expectation.invoke() { |*parameters| yielded_parameters = parameters }
+    assert_equal Array.new, yielded_parameters
+  end
+
+  def test_should_yield_with_specified_parameters
+    expectation = new_expectation().yields(1, 2, 3)
+    yielded_parameters = nil
+    expectation.invoke() { |*parameters| yielded_parameters = parameters }
+    assert_equal [1, 2, 3], yielded_parameters
+  end
+
+  def test_should_yield_different_parameters_on_consecutive_invocations
+    expectation = new_expectation().yields(1, 2, 3).yields(4, 5)
+    yielded_parameters = []
+    expectation.invoke() { |*parameters| yielded_parameters << parameters }
+    expectation.invoke() { |*parameters| yielded_parameters << parameters }
+    assert_equal [[1, 2, 3], [4, 5]], yielded_parameters
+  end
+  
+  def test_should_yield_multiple_times_for_single_invocation
+    expectation = new_expectation().multiple_yields([1, 2, 3], [4, 5])
+    yielded_parameters = []
+    expectation.invoke() { |*parameters| yielded_parameters << parameters }
+    assert_equal [[1, 2, 3], [4, 5]], yielded_parameters
+  end
+
+  def test_should_yield_multiple_times_for_first_invocation_and_once_for_second_invocation
+    expectation = new_expectation().multiple_yields([1, 2, 3], [4, 5]).then.yields(6, 7)
+    yielded_parameters = []
+    expectation.invoke() { |*parameters| yielded_parameters << parameters }
+    expectation.invoke() { |*parameters| yielded_parameters << parameters }
+    assert_equal [[1, 2, 3], [4, 5], [6, 7]], yielded_parameters
+  end
+
+  def test_should_return_specified_value
+    expectation = new_expectation.returns(99)
+    assert_equal 99, expectation.invoke
+  end
+  
+  def test_should_return_same_specified_value_multiple_times
+    expectation = new_expectation.returns(99)
+    assert_equal 99, expectation.invoke
+    assert_equal 99, expectation.invoke
+  end
+  
+  def test_should_return_specified_values_on_consecutive_calls
+    expectation = new_expectation.returns(99, 100, 101)
+    assert_equal 99, expectation.invoke
+    assert_equal 100, expectation.invoke
+    assert_equal 101, expectation.invoke
+  end
+  
+  def test_should_return_specified_values_on_consecutive_calls_even_if_values_are_modified
+    values = [99, 100, 101]
+    expectation = new_expectation.returns(*values)
+    values.shift
+    assert_equal 99, expectation.invoke
+    assert_equal 100, expectation.invoke
+    assert_equal 101, expectation.invoke
+  end
+  
+  def test_should_return_nil_by_default
+    assert_nil new_expectation.invoke
+  end
+  
+  def test_should_return_nil_if_no_value_specified
+    expectation = new_expectation.returns()
+    assert_nil expectation.invoke
+  end
+  
+  def test_should_return_evaluated_proc
+    proc = lambda { 99 }
+    expectation = new_expectation.returns(proc)
+    result = nil
+    disable_deprecations { result = expectation.invoke }
+    assert_equal 99, result
+  end
+  
+  def test_should_return_evaluated_proc_without_using_is_a_method
+    proc = lambda { 99 }
+    proc.define_instance_accessor(:called)
+    proc.called = false
+    proc.replace_instance_method(:is_a?) { self.called = true; true}
+    expectation = new_expectation.returns(proc)
+    disable_deprecations { expectation.invoke }
+    assert_equal false, proc.called
+  end
+  
+  def test_should_raise_runtime_exception
+    expectation = new_expectation.raises
+    assert_raise(RuntimeError) { expectation.invoke }
+  end
+  
+  def test_should_raise_custom_exception
+    exception = Class.new(Exception)
+    expectation = new_expectation.raises(exception)
+    assert_raise(exception) { expectation.invoke }
+  end
+  
+  def test_should_raise_same_instance_of_custom_exception
+    exception_klass = Class.new(StandardError)
+    expected_exception = exception_klass.new
+    expectation = new_expectation.raises(expected_exception)
+    actual_exception = assert_raise(exception_klass) { expectation.invoke }
+    assert_same expected_exception, actual_exception
+  end
+  
+  def test_should_use_the_default_exception_message
+    expectation = new_expectation.raises(Exception)
+    exception = assert_raise(Exception) { expectation.invoke }
+    assert_equal Exception.new.message, exception.message
+  end
+  
+  def test_should_raise_custom_exception_with_message
+    exception_msg = "exception message"
+    expectation = new_expectation.raises(Exception, exception_msg)
+    exception = assert_raise(Exception) { expectation.invoke }
+    assert_equal exception_msg, exception.message
+  end
+  
+  def test_should_return_values_then_raise_exception
+    expectation = new_expectation.returns(1, 2).then.raises()
+    assert_equal 1, expectation.invoke
+    assert_equal 2, expectation.invoke
+    assert_raise(RuntimeError) { expectation.invoke }
+  end
+  
+  def test_should_raise_exception_then_return_values
+    expectation = new_expectation.raises().then.returns(1, 2)
+    assert_raise(RuntimeError) { expectation.invoke }
+    assert_equal 1, expectation.invoke
+    assert_equal 2, expectation.invoke
+  end
+  
+  def test_should_not_raise_error_on_verify_if_expected_call_was_made
+    expectation = new_expectation
+    expectation.invoke
+    assert_nothing_raised(ExpectationError) {
+      expectation.verify
+    }
+  end
+  
+  def test_should_raise_error_on_verify_if_call_expected_once_but_invoked_twice
+    expectation = new_expectation.once
+    expectation.invoke
+    expectation.invoke
+    assert_raises(ExpectationError) {
+      expectation.verify
+    }
+  end
+
+  def test_should_raise_error_on_verify_if_call_expected_once_but_not_invoked
+    expectation = new_expectation.once
+    assert_raises(ExpectationError) {
+      expectation.verify
+    }
+  end
+
+  def test_should_not_raise_error_on_verify_if_call_expected_once_and_invoked_once
+    expectation = new_expectation.once
+    expectation.invoke
+    assert_nothing_raised(ExpectationError) {
+      expectation.verify
+    }
+  end
+
+  def test_should_not_raise_error_on_verify_if_expected_call_was_made_at_least_once
+    expectation = new_expectation.at_least_once
+    3.times {expectation.invoke}
+    assert_nothing_raised(ExpectationError) {
+      expectation.verify
+    }
+  end
+  
+  def test_should_raise_error_on_verify_if_expected_call_was_not_made_at_least_once
+    expectation = new_expectation.with(1, 2, 3).at_least_once
+    e = assert_raise(ExpectationError) {
+      expectation.verify
+    }
+    assert_match(/expected calls: at least 1, actual calls: 0/i, e.message)
+  end
+  
+  def test_should_not_raise_error_on_verify_if_expected_call_was_made_expected_number_of_times
+    expectation = new_expectation.times(2)
+    2.times {expectation.invoke}
+    assert_nothing_raised(ExpectationError) {
+      expectation.verify
+    }
+  end
+  
+  def test_should_expect_call_not_to_be_made
+    expectation = new_expectation
+    expectation.define_instance_accessor(:how_many_times)
+    expectation.replace_instance_method(:times) { |how_many_times| self.how_many_times = how_many_times }
+    expectation.never
+    assert_equal 0, expectation.how_many_times
+  end
+  
+  def test_should_raise_error_on_verify_if_expected_call_was_made_too_few_times
+    expectation = new_expectation.times(2)
+    1.times {expectation.invoke}
+    e = assert_raise(ExpectationError) {
+      expectation.verify
+    }
+    assert_match(/expected calls: 2, actual calls: 1/i, e.message)
+  end
+  
+  def test_should_raise_error_on_verify_if_expected_call_was_made_too_many_times
+    expectation = new_expectation.times(2)
+    3.times {expectation.invoke}
+    assert_raise(ExpectationError) {
+      expectation.verify
+    }
+  end
+  
+  def test_should_yield_self_to_block
+    expectation = new_expectation
+    expectation.invoke
+    yielded_expectation = nil
+    expectation.verify { |x| yielded_expectation = x }
+    assert_equal expectation, yielded_expectation
+  end
+  
+  def test_should_yield_to_block_before_raising_exception
+    yielded = false
+    assert_raise(ExpectationError) {
+      new_expectation.verify { |x| yielded = true }
+    }
+    assert yielded
+  end
+  
+  def test_should_store_backtrace_from_point_where_expectation_was_created
+    execution_point = ExecutionPoint.current; expectation = Expectation.new(nil, :expected_method)
+    assert_equal execution_point, ExecutionPoint.new(expectation.backtrace)
+  end
+  
+  def test_should_set_backtrace_on_assertion_failed_error_to_point_where_expectation_was_created
+    execution_point = ExecutionPoint.current; expectation = Expectation.new(nil, :expected_method)
+    error = assert_raise(ExpectationError) {  
+      expectation.verify
+    }
+    assert_equal execution_point, ExecutionPoint.new(error.backtrace)
+  end
+  
+  def test_should_display_expectation_message_in_exception_message
+    options = [:a, :b, {:c => 1, :d => 2}]
+    expectation = new_expectation.with(*options)
+    exception = assert_raise(ExpectationError) {
+      expectation.verify
+    }
+    assert exception.message.include?(expectation.method_signature)
+  end
+  
+  def test_should_combine_method_name_and_pretty_parameters
+    arguments = 1, 2, {'a' => true, :b => false}, [1, 2, 3]
+    expectation = new_expectation.with(*arguments)
+    assert_equal "expected_method(#{PrettyParameters.new(arguments).pretty})", expectation.method_signature
+  end
+  
+  def test_should_not_include_parameters_in_message
+    assert_equal "expected_method", new_expectation.method_signature
+  end
+  
+  def test_should_raise_error_with_message_indicating_which_method_was_expected_to_be_called_on_which_mock_object
+    mock = Class.new { def mocha_inspect; 'mock'; end }.new
+    expectation = Expectation.new(mock, :expected_method)
+    e = assert_raise(ExpectationError) { expectation.verify }
+    assert_match "mock.expected_method", e.message
+  end
+  
+  def test_should_exclude_mocha_locations_from_backtrace
+    mocha_lib = "/username/workspace/mocha_wibble/lib/"
+    backtrace = [ mocha_lib + 'exclude/me/1', mocha_lib + 'exclude/me/2', '/keep/me', mocha_lib + 'exclude/me/3']
+    expectation = Expectation.new(nil, :expected_method, backtrace)
+    expectation.define_instance_method(:mocha_lib_directory) { mocha_lib }
+    assert_equal ['/keep/me'], expectation.filtered_backtrace
+  end
+  
+  def test_should_determine_path_for_mocha_lib_directory
+    expectation = new_expectation()
+    assert_match Regexp.new("/lib/$"), expectation.mocha_lib_directory
+  end
+
+end