ceedling 0.13.0 → 0.15.0

data/vendor/cmock/vendor/hardmock/test/unit/method_cleanout_test.rb

@@ -1,36 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + "/../test_helper")
-require 'hardmock/method_cleanout'
-
-class MethodCleanoutTest < Test::Unit::TestCase
-  class Victim
-    OriginalMethods = instance_methods
-    include Hardmock::MethodCleanout
-  end
-  
-  def setup
-    @victim = Victim.new
-  end
-
-  def test_should_remove_most_methods_from_a_class
-    expect_removed = Victim::OriginalMethods.reject { |m| 
-      Hardmock::MethodCleanout::SACRED_METHODS.include?(m)
-    }
-    expect_removed.each do |m|
-      assert !@victim.respond_to?(m), "should not have method #{m}"
-    end
-  end
-
-  def test_should_leave_the_sacred_methods_defined
-    Hardmock::MethodCleanout::SACRED_METHODS.each do |m|
-      next if m =~ /^hm_/
-      assert @victim.respond_to?(m), "Sacred method '#{m}' was removed unexpectedly"
-    end
-  end
-
-  def test_should_include_certain_important_methods_in_the_sacred_methods_list
-    %w|__id__ __send__ equal? object_id send nil? class kind_of? respond_to? inspect method to_s instance_variables instance_eval|.each do |m|
-      assert Hardmock::MethodCleanout::SACRED_METHODS.include?(m), "important method #{m} is not included in SACRED_METHODS"
-    end
-  end
-
-end

data/vendor/cmock/vendor/hardmock/test/unit/mock_control_test.rb

@@ -1,175 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + "/../test_helper")
-require 'hardmock/utils'
-require 'hardmock/errors'
-require 'hardmock/mock_control'
-
-class MockControlTest < Test::Unit::TestCase
-  include Hardmock
-
-  def setup
-    @unmock = OpenStruct.new( :_name => 'fakemock' )
-
-    @control = MockControl.new
-    assert @control.happy?, "Control should start out happy"
-  end
-
-  def teardown
-  end
-
-  #
-  # HELPERS
-  #
-
-  class MyExp  
-    attr_reader :mock, :mname, :args, :block
-    def apply_method_call(mock, mname, args, block)
-      @mock = mock
-      @mname = mname
-      @args = args
-      @block = block
-    end
-  end
-
-  class BoomExp < MyExp
-    def apply_method_call(mock, mname, args, block)
-      super
-      raise "BOOM"
-    end
-  end
-
-  #
-  # TESTS
-  #
-
-  def test_add_exepectation_and_apply_method_call
-    e1 = MyExp.new
-
-    @control.add_expectation e1
-    assert !@control.happy?
-
-    @control.apply_method_call @unmock, 'some_func', [ 'the', :args ], nil
-    assert @control.happy?
-    
-    assert_same @unmock, e1.mock, "Wrong mock"
-    assert_equal 'some_func', e1.mname, "Wrong method"
-    assert_equal [ 'the', :args ], e1.args, "Wrong args"
-
-    @control.verify
-  end
-
-  def test_add_exepectation_and_apply_method_call_with_block
-    e1 = MyExp.new
-
-    @control.add_expectation e1
-    assert !@control.happy?
-
-    runtime_block = Proc.new { "hello" }
-    @control.apply_method_call @unmock, 'some_func', [ 'the', :args ], runtime_block
-    assert @control.happy?
-    
-    assert_same @unmock, e1.mock, "Wrong mock"
-    assert_equal 'some_func', e1.mname, "Wrong method"
-    assert_equal [ 'the', :args ], e1.args, "Wrong args"
-    assert_equal "hello", e1.block.call, "Wrong block in expectation"
-
-    @control.verify
-  end
-
-  def test_add_expectation_then_verify
-    e1 = MyExp.new
-
-    @control.add_expectation e1
-    assert !@control.happy?, "Shoudn't be happy"
-    err = assert_raise VerifyError do
-      @control.verify
-    end
-    assert_match(/unmet expectations/i, err.message) 
-
-    @control.apply_method_call @unmock, 'some_func', [ 'the', :args ], nil
-    assert @control.happy?
-    
-    assert_same @unmock, e1.mock, "Wrong mock"
-    assert_equal 'some_func', e1.mname, "Wrong method"
-    assert_equal [ 'the', :args ], e1.args, "Wrong args"
-
-    @control.verify
-  end
-
-  def test_expectation_explosion
-    be1 = BoomExp.new
-
-    @control.add_expectation be1
-
-    err = assert_raise RuntimeError do
-      @control.apply_method_call @unmock, 'a func', [:arg], nil
-    end
-    assert_match(/BOOM/i, err.message) 
-
-    assert_same @unmock, be1.mock
-    assert_equal 'a func', be1.mname
-    assert_equal [:arg], be1.args
-  end
-
-  def test_disappointment_on_bad_verify
-    @control.add_expectation MyExp.new
-    assert !@control.happy?, "Shouldn't be happy"
-    assert !@control.disappointed?, "too early to be disappointed"
-
-    # See verify fails
-    err = assert_raise VerifyError do
-      @control.verify
-    end
-    assert_match(/unmet expectations/i, err.message) 
-
-    assert !@control.happy?, "Still have unmet expectation"
-    assert @control.disappointed?, "We should be disappointed following that failure"
-
-    @control.apply_method_call @unmock, 'something', [], nil
-    assert @control.happy?, "Should be happy"
-    assert @control.disappointed?, "We should be skeptical"
-
-    @control.verify
-
-    assert !@control.disappointed?, "Should be non-disappointed"
-  end
-
-  def test_disappointment_from_surprise_calls
-    assert @control.happy?, "Should be happy"
-    assert !@control.disappointed?, "too early to be disappointed"
-
-    # See verify fails
-    err = assert_raise ExpectationError do
-      @control.apply_method_call @unmock, "something", [], nil
-    end
-    assert_match(/surprise/i, err.message) 
-
-    assert @control.happy?, "Happiness is an empty list of expectations"
-    assert @control.disappointed?, "We should be disappointed following that failure"
-
-    @control.verify
-    assert !@control.disappointed?, "Disappointment should be gone"
-  end
-
-  def test_disappointment_from_bad_calls
-    be1 = BoomExp.new
-    assert !@control.disappointed?, "Shouldn't be disappointed"
-    @control.add_expectation be1
-    assert !@control.disappointed?, "Shouldn't be disappointed"
-
-    err = assert_raise RuntimeError do
-      @control.apply_method_call @unmock, 'a func', [:arg], nil
-    end
-    assert_match(/BOOM/i, err.message) 
-    assert @control.disappointed?, "Should be disappointed"
-
-    assert_same @unmock, be1.mock
-    assert_equal 'a func', be1.mname
-    assert_equal [:arg], be1.args
-
-    assert @control.happy?, "Happiness is an empty list of expectations"
-    @control.verify
-    assert !@control.disappointed?, "Disappointment should be gone"
-  end
-
-
-end

data/vendor/cmock/vendor/hardmock/test/unit/mock_test.rb

@@ -1,279 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + "/../test_helper")
-require 'hardmock/method_cleanout'
-require 'hardmock/mock'
-require 'hardmock/mock_control'
-require 'hardmock/expectation_builder'
-require 'hardmock/expector'
-require 'hardmock/trapper'
-
-class MockTest < Test::Unit::TestCase
-  include Hardmock
-
-  def test_build_with_control
-    mc1 = MockControl.new
-    mock = Mock.new('hi', mc1)
-    assert_equal 'hi', mock._name, "Wrong name"
-    assert_same mc1, mock._control, "Wrong contol"
-  end
-
-  def test_basics
-    mock = Mock.new('a name')
-    assert_equal 'a name', mock._name, "Wrong name for mock"
-    assert_not_nil mock._control, "Nil control in mock"
-  end
-
-  def test_expects
-    mock = Mock.new('order')
-    control = mock._control
-    assert control.happy?, "Mock should start out satisfied"
-
-    mock.expects.absorb_something(:location, 'garbage')
-    assert !control.happy?, "mock control should be unhappy"
-
-    # Do the call
-    mock.absorb_something(:location, 'garbage')
-    assert control.happy?, "mock control should be happy again"
-
-    # Verify
-    assert_nothing_raised Exception do
-      mock._verify
-    end 
-  end
-
-  def test_expects_using_arguments_for_method_and_arguments
-    mock = Mock.new('order')
-    mock.expects(:absorb_something, :location, 'garbage')
-    mock.absorb_something(:location, 'garbage')
-    mock._verify
-  end
-
-  def test_expects_using_arguments_for_method_and_arguments_with_block
-    mock = Mock.new('order')
-    mock.expects(:absorb_something, :location, 'garbage') { |a,b,block|
-      assert_equal :location, a, "Wrong 'a' argument"
-      assert_equal 'garbage', b, "Wrong 'b' argument"
-      assert_equal 'innards', block.call, "Wrong block"
-    }
-    mock.absorb_something(:location, 'garbage') do "innards" end
-    mock._verify
-  end
-
-  def test_expects_using_string_method_name
-    mock = Mock.new('order')
-    mock.expects('absorb_something', :location, 'garbage')
-    mock.absorb_something(:location, 'garbage')
-    mock._verify
-  end
-
-
-  def test_expects_assignment
-    mock = Mock.new('order')
-    mock.expects.account_number = 1234
-
-    mock.account_number = 1234
-
-    mock._verify
-  end
-
-  def test_expects_assigment_using_arguments_for_method_and_arguments
-    mock = Mock.new('order')
-    mock.expects(:account_number=, 1234)
-    mock.account_number = 1234
-    mock._verify
-  end
-
-  def test_expects_assigment_using_string_method_name
-    mock = Mock.new('order')
-    mock.expects('account_number=', 1234)
-    mock.account_number = 1234
-    mock._verify
-  end
-
-  def test_expects_assignment_and_return_is_overruled_by_ruby_syntax
-    # Prove that we can set up a return but that it doesn't mean much,
-    # because ruby's parser will 'do the right thing' as regards semantic
-    # values for assignment.  (That is, the rvalue of the assignment)
-    mock = Mock.new('order')
-    mock.expects(:account_number=, 1234).returns "gold"
-    got = mock.account_number = 1234
-    mock._verify
-    assert_equal 1234, got, "Expected rvalue"
-  end
-
-  def test_expects_assignment_and_raise
-    mock = Mock.new('order')
-    mock.expects(:account_number=, 1234).raises StandardError.new("kaboom")
-    err = assert_raise StandardError do
-      mock.account_number = 1234
-    end
-    assert_match(/kaboom/i, err.message) 
-    mock._verify
-  end
-
-
-  def test_expects_multiple
-    mock = Mock.new('order')
-    control = mock._control
-
-    assert control.happy?
-
-    mock.expects.one_thing :hi, { :goose => 'neck' }
-    mock.expects.another 5,6,7
-    assert !control.happy?
-
-    mock.one_thing :hi, { :goose => 'neck' }
-    assert !control.happy?
-
-    mock.another 5,6,7
-    assert control.happy?
-  end
-
-  def test_surprise_call
-    mock = Mock.new('order')
-    err = assert_raise ExpectationError do
-      mock.uh_oh
-    end
-    assert_match(/surprise/i, err.message) 
-    assert_match(/uh_oh/i, err.message) 
-    
-    err = assert_raise ExpectationError do
-      mock.whoa :horse  
-    end
-    assert_match(/surprise/i, err.message) 
-    assert_match(/order\.whoa\(:horse\)/i, err.message) 
-  end
-
-  def test_wrong_call
-    mock = Mock.new('order')
-    mock.expects.pig 'arse'
-    err = assert_raise ExpectationError do
-      mock.whoa :horse  
-    end
-    assert_match(/wrong method/i, err.message) 
-    assert_match(/order\.whoa\(:horse\)/i, err.message) 
-    assert_match(/order\.pig\("arse"\)/i, err.message) 
-  end
-
-  def test_wrong_arguments
-    mock = Mock.new('order')
-    mock.expects.go_fast(:a, 1, 'three')
-
-    err = assert_raise ExpectationError do
-      mock.go_fast :a, 1, 'not right'  
-    end
-    assert_match(/wrong argument/i, err.message) 
-    assert_match(/order\.go_fast\(:a, 1, "three"\)/i, err.message) 
-    assert_match(/order\.go_fast\(:a, 1, "not right"\)/i, err.message) 
-  end
-
-  def test_expects_and_return
-    mock = Mock.new('order')
-    mock.expects.delivery_date.returns Date.today
-    assert_equal Date.today, mock.delivery_date
-    mock._verify
-  end
-
-  def test_expects_and_return_with_arguments
-    mock = Mock.new('order')
-    mock.expects.delivery_date(:arf,14).returns(Date.today)
-    assert_equal Date.today, mock.delivery_date(:arf,14)
-    mock._verify
-  end
-
-  def test_expects_and_raise
-    mock = Mock.new('order')
-    mock.expects.delivery_date.raises StandardError.new("bloof")
-
-    err = assert_raise StandardError do
-      mock.delivery_date
-    end
-    assert_match(/bloof/i, err.message) 
-
-    mock._verify
-    
-    # Try convenience argument String 
-    mock.expects.pow.raises "hell"
-    err = assert_raise RuntimeError do
-      mock.pow
-    end
-    assert_match(/hell/i, err.message) 
-
-    mock._verify
-
-    # Try convenience argument nothing
-    mock.expects.pow.raises 
-    err = assert_raise RuntimeError do
-      mock.pow
-    end
-    assert_match(/an error/i, err.message) 
-
-    mock._verify
-  end
-
-  def test_expects_a_runtime_block
-    mock = Mock.new('order')
-    got_val = nil
-
-    mock.expects.when(:something) { |e,block|
-      got_val = block.call
-    }
-
-    mock.when :something do "hi there" end
-
-    assert_equal "hi there", got_val, "Expectation block not invoked"
-    mock._verify
-  end
-
-  def test_trap_block
-    mock = Mock.new('order')
-    exp = mock.trap.observe
-
-    # use it
-    mock.observe { "burp" }
-
-    assert_equal "burp", exp.block_value.call
-  end
-
-  def test_trap_arguments_and_block
-    mock = Mock.new('order')
-    exp = mock.trap.subscribe(:data_changed)
-
-    # use it
-    mock.subscribe(:data_changed) { "burp" }
-    assert_equal "burp", exp.block_value.call
-    mock._verify
-  end
-
-  def test_trap_arguments_and_block_wrong_num_args
-    mock = Mock.new('order')
-    exp = mock.trap.subscribe(:data_changed)
-
-    assert_raise ExpectationError do
-      mock.subscribe(:data_changed,1) { "burp" }
-    end
-    mock._verify
-  end
-
-  def test_trap_arguments_and_block_wrong_args
-    mock = Mock.new('order')
-    exp = mock.trap.subscribe(:data_changed)
-
-    assert_raise ExpectationError do
-      mock.subscribe("no good") { "burp" }
-    end
-
-    mock._verify
-  end
-
-  def test_trap_is_not_leniant_about_arguments
-    mock = Mock.new('order')
-    exp = mock.trap.subscribe
-
-    assert_raise ExpectationError do
-      mock.subscribe("no good") { "burp" }
-    end
-
-    mock._verify
-  end
-
-end