ceedling 0.13.0 → 0.15.0

data/vendor/cmock/vendor/hardmock/lib/hardmock/trapper.rb

@@ -1,31 +0,0 @@
-require 'test/unit/assertions'
-require 'hardmock/errors'
-
-module Hardmock
-  class Trapper #:nodoc:
-    include Hardmock::MethodCleanout
-
-    def initialize(mock,mock_control,expectation_builder)
-      @mock = mock
-      @mock_control = mock_control
-      @expectation_builder = expectation_builder
-    end
-
-    def method_missing(mname, *args)
-      if block_given?
-        raise ExpectationError.new("Don't pass blocks when using 'trap' (setting exepectations for '#{mname}')")
-      end
-      
-      the_block = lambda { |target_block| target_block }
-      expectation = @expectation_builder.build_expectation(
-        :mock => @mock, 
-        :method => mname, 
-        :arguments => args, 
-        :suppress_arguments_to_block => true,
-        :block => the_block)
-
-      @mock_control.add_expectation expectation
-      expectation
-    end
-  end
-end

data/vendor/cmock/vendor/hardmock/lib/hardmock/utils.rb

@@ -1,9 +0,0 @@
-
-module Hardmock
-  module Utils #:nodoc:
-    def format_method_call_string(mock,mname,args)
-      arg_string = args.map { |a| a.inspect }.join(', ')
-      call_text = "#{mock._name}.#{mname}(#{arg_string})"
-    end
-  end
-end

data/vendor/cmock/vendor/hardmock/lib/test_unit_before_after.rb

@@ -1,169 +0,0 @@
-require 'test/unit'
-require 'test/unit/testcase'
-require 'test/unit/assertions'
-
-module Test #:nodoc:#
-  module Unit #:nodoc:#
-    
-    # == TestCase Modifications
-    #
-    # Monkey-patch to provide a formal mechanism for appending actions to be executed after teardown.
-    # Use after_teardown to define one or more actions to be executed after teardown for ALL tests.
-    #
-    # COMING SOON?
-    # * (maybe?) Hooks for before_teardown, after_setup, on_error
-    # * (maybe?) Options for positional control, eg, after_teardown :before_other_actions
-    # * (maybe?) Provide tagging/filtering so action execution can be controlled specifically?
-    #
-    # == Usage
-    #
-    # Invoke TestCase.after_teardown with optional parameter, which will be invoked with a reference
-    # to the test instance that has just been torn down.
-    #
-    # Example:
-    # 
-    #   Test::Unit::TestCase.after_teardown do |test|
-    #     test.verify_mocks
-    #   end
-    #   
-    # == Justification
-    #
-    # There are a number of tools and libraries that play fast-n-loose with setup and teardown by 
-    # wrapping them, and by overriding method_added as a means of upholding special setup/teardown 
-    # behavior, usually by re-wrapping newly defined user-level setup/teardown methods.
-    # mocha and active_record/fixtures (and previously, hardmock) will fight for this
-    # territory with often unpredictable results.
-    #
-    # We wouldn't have to battle if Test::Unit provided a formal pre- and post- hook mechanism.
-    #
-    class TestCase
-
-      class << self
-        
-        # Define an action to be run after teardown. Subsequent calls result in 
-        # multiple actions.  The block will be given a reference to the test
-        # being executed.
-        #
-        # Example:
-        # 
-        #   Test::Unit::TestCase.after_teardown do |test|
-        #     test.verify_mocks
-        #   end
-        def after_teardown(&block)
-          post_teardown_actions << block
-        end
-
-        # Used internally. Access the list of post teardown actions for to be
-        # used by all tests.
-        def post_teardown_actions
-          @@post_teardown_actions ||= []
-        end
-
-        # Define an action to be run before setup. Subsequent calls result in 
-        # multiple actions, EACH BEING PREPENDED TO THE PREVIOUS.  
-        # The block will be given a reference to the test being executed.
-        #
-        # Example:
-        # 
-        #   Test::Unit::TestCase.before_setup do |test|
-        #     test.prepare_hardmock_control
-        #   end
-        def before_setup(&block)
-          pre_setup_actions.unshift block
-        end
-
-        # Used internally. Access the list of post teardown actions for to be
-        # used by all tests.
-        def pre_setup_actions
-          @@pre_setup_actions ||= []
-        end
-      end
-
-      # OVERRIDE: This is a reimplementation of the default "run", updated to
-      # execute actions after teardown.
-      def run(result)
-        yield(STARTED, name)
-        @_result = result
-        begin
-          execute_pre_setup_actions(self)
-          setup
-          __send__(@method_name)
-        rescue Test::Unit::AssertionFailedError => e
-          add_failure(e.message, auxiliary_backtrace_filter(e.backtrace))
-        rescue Exception
-          raise if should_passthru_exception($!) # See implementation; this is for pre-1.8.6 compat
-          add_error($!)
-        ensure
-          begin
-            teardown
-          rescue Test::Unit::AssertionFailedError => e
-            add_failure(e.message, auxiliary_backtrace_filter(e.backtrace))
-          rescue Exception
-            raise if should_passthru_exception($!) # See implementation; this is for pre-1.8.6 compat
-            add_error($!)
-          ensure
-            execute_post_teardown_actions(self)
-          end
-        end
-        result.add_run
-        yield(FINISHED, name)
-      end
-
-      private
-
-      # Run through the after_teardown actions, treating failures and errors
-      # in the same way that "run" does: they are reported, and the remaining
-      # actions are executed.
-      def execute_post_teardown_actions(test_instance)
-        self.class.post_teardown_actions.each do |action|
-          begin
-            action.call test_instance
-          rescue Test::Unit::AssertionFailedError => e
-            add_failure(e.message, auxiliary_backtrace_filter(e.backtrace))
-          rescue Exception
-            raise if should_passthru_exception($!)
-            add_error($!)
-          end
-        end
-      end
-      
-      # Run through the before_setup actions.
-      # Failures or errors cause execution to stop.
-      def execute_pre_setup_actions(test_instance)
-        self.class.pre_setup_actions.each do |action|
-#          begin
-            action.call test_instance
-#          rescue Test::Unit::AssertionFailedError => e
-#            add_failure(e.message, auxiliary_backtrace_filter(e.backtrace))
-#          rescue Exception
-#            raise if should_passthru_exception($!)
-#            add_error($!)
-#          end
-        end
-      end
-
-      # Make sure that this extension doesn't show up in failure backtraces
-      def auxiliary_backtrace_filter(trace)
-        trace.reject { |x| x =~ /test_unit_before_after/ }
-      end
-
-      # Is the given error of the type that we allow to fly out (rather than catching it)?
-      def should_passthru_exception(ex)
-        return passthrough_exception_types.include?($!.class)
-      end
-
-      # Provide a list of exception types that are to be allowed to explode out.
-      # Pre-ruby-1.8.6 doesn't use this functionality, so the PASSTHROUGH_EXCEPTIONS
-      # constant won't be defined.  This methods defends against that and returns
-      # an empty list instead.
-      def passthrough_exception_types
-        begin 
-          return PASSTHROUGH_EXCEPTIONS
-        rescue NameError
-          # older versions of test/unit do not have PASSTHROUGH_EXCEPTIONS constant
-          return []
-        end
-      end
-    end
-  end
-end

data/vendor/cmock/vendor/hardmock/rake_tasks/rdoc.rake

@@ -1,19 +0,0 @@
-require 'rake/rdoctask'
-require File.expand_path(File.dirname(__FILE__) + "/rdoc_options.rb")
-
-namespace :doc do
-
-  desc "Generate RDoc documentation"
-  Rake::RDocTask.new { |rdoc|
-    rdoc.rdoc_dir = 'doc'
-    rdoc.title    = "Hardmock: Strict expectation-based mock object library " 
-    add_rdoc_options(rdoc.options)
-    rdoc.rdoc_files.include('lib/**/*.rb', 'README','CHANGES','LICENSE')
-  }
-
-  task :show => [ 'doc:rerdoc' ] do
-    sh "open doc/index.html"
-  end
-
-end
-

data/vendor/cmock/vendor/hardmock/rake_tasks/rdoc_options.rb

@@ -1,4 +0,0 @@
-
-def add_rdoc_options(options)
-  options << '--line-numbers' << '--inline-source' << '--main' << 'README' << '--title' << 'Hardmock'
-end

data/vendor/cmock/vendor/hardmock/rake_tasks/test.rake

@@ -1,22 +0,0 @@
-require 'rake/testtask'
-
-namespace :test do
-
-  desc "Run unit tests"
-  Rake::TestTask.new("units") { |t|
-    t.libs << "test"
-    t.pattern = 'test/unit/*_test.rb'
-    t.verbose = true
-  }
-
-  desc "Run functional tests"
-  Rake::TestTask.new("functional") { |t|
-    t.libs << "test"
-    t.pattern = 'test/functional/*_test.rb'
-    t.verbose = true
-  }
-
-  desc "Run all the tests"
-  task :all => [ 'test:units', 'test:functional' ]
-
-end

data/vendor/cmock/vendor/hardmock/test/functional/assert_error_test.rb

@@ -1,52 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + "/../test_helper")
-require 'assert_error'
-
-class AssertErrorTest < Test::Unit::TestCase
-
-  it "specfies an error type and message that should be raised" do
-    assert_error RuntimeError, "Too funky" do
-      raise RuntimeError.new("Too funky")
-    end
-  end
-
-  it "flunks if the error message is wrong" do
-    err = assert_raise Test::Unit::AssertionFailedError do
-      assert_error RuntimeError, "not good" do
-        raise RuntimeError.new("Too funky")
-      end
-    end
-    assert_match(/not good/i, err.message) 
-    assert_match(/too funky/i, err.message) 
-  end
-
-  it "flunks if the error type is wrong" do
-    err = assert_raise Test::Unit::AssertionFailedError do
-      assert_error StandardError, "Too funky" do
-        raise RuntimeError.new("Too funky")
-      end
-    end
-    assert_match(/StandardError/i, err.message) 
-    assert_match(/RuntimeError/i, err.message) 
-  end
-
-  it "can match error message text using a series of Regexps" do 
-    assert_error StandardError, /too/i, /funky/i do
-      raise StandardError.new("Too funky")
-    end
-  end
-
-  it "flunks if the error message doesn't match all the Regexps" do
-    err = assert_raise Test::Unit::AssertionFailedError do
-      assert_error StandardError, /way/i, /too/i, /funky/i do
-        raise StandardError.new("Too funky")
-      end
-    end
-    assert_match(/way/i, err.message) 
-  end
-
-  it "can operate without any message specification" do
-    assert_error StandardError do 
-      raise StandardError.new("ooof")
-    end
-  end
-end

data/vendor/cmock/vendor/hardmock/test/functional/auto_verify_test.rb

@@ -1,178 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + "/../test_helper")
-require 'fileutils'
-
-class AutoVerifyTest < Test::Unit::TestCase
-
-  def setup
-    @expect_unmet_expectations = true
-  end
-
-  def teardown
-    remove_temp_test_file
-  end
-
-  #
-  # TESTS
-  #
-
-  it "auto-verifies all mocks in teardown" do
-    write_and_execute_test 
-  end
-
-  it "auto-verifies even if user defines own teardown" do
-    @teardown_code =<<-EOM 
-      def teardown
-        # just in the way
-      end
-    EOM
-    write_and_execute_test 
-  end
-
-  should "not obscure normal failures when verification fails" do
-    @test_code =<<-EOM
-        def test_setup_doomed_expectation
-          create_mock :automobile
-          @automobile.expects.start
-          flunk "natural failure"
-        end
-    EOM
-    @expect_failures = 1
-    write_and_execute_test
-  end
-
-  should "not skip user-defined teardown when verification fails" do
-    @teardown_code =<<-EOM 
-      def teardown
-        puts "User teardown"
-      end
-    EOM
-    write_and_execute_test 
-    assert_output_contains(/User teardown/)
-  end
-
-  it "is quiet when verification is ok" do
-    @test_code =<<-EOM
-        def test_ok
-          create_mock :automobile
-          @automobile.expects.start
-          @automobile.start
-        end
-    EOM
-    @teardown_code =<<-EOM 
-      def teardown
-        puts "User teardown"
-      end
-    EOM
-    @expect_unmet_expectations = false
-    @expect_failures = 0
-    @expect_errors = 0
-    write_and_execute_test
-    assert_output_contains(/User teardown/)
-  end
-
-  should "auto-verify even if user teardown explodes" do
-    @teardown_code =<<-EOM 
-      def teardown
-        raise "self destruct"
-      end
-    EOM
-    @expect_errors = 2
-    write_and_execute_test
-    assert_output_contains(/self destruct/)
-  end
-
-  it "plays nice with inherited teardown methods" do
-    @full_code ||=<<-EOTEST
-      require File.expand_path(File.dirname(__FILE__) + "/../test_helper")
-      require 'hardmock'
-      class Test::Unit::TestCase 
-        def teardown
-          puts "Test helper teardown"
-        end
-      end
-      class DummyTest < Test::Unit::TestCase
-        def test_prepare_to_die
-          create_mock :automobile
-          @automobile.expects.start
-        end
-      end 
-    EOTEST
-    write_and_execute_test
-    assert_output_contains(/Test helper teardown/)
-  end
-
-  #
-  # HELPERS
-  #
-
-  def temp_test_file
-    File.expand_path(File.dirname(__FILE__) + "/tear_down_verification_test.rb")
-  end
-
-  def run_test(tbody)
-    File.open(temp_test_file,"w") { |f| f.print(tbody) }
-    @test_output = `ruby #{temp_test_file} 2>&1`
-  end
-
-  def formatted_test_output
-    if @test_output
-      @test_output.split(/\n/).map { |line| "> #{line}" }.join("\n")
-    else
-      "(NO TEST OUTPUT!)"
-    end
-  end
-
-  def remove_temp_test_file
-    FileUtils::rm_f temp_test_file
-  end
-
-  def assert_results(h)
-    if @test_output !~ /#{h[:tests]} tests, [0-9]+ assertions, #{h[:failures]} failures, #{h[:errors]} errors/
-      flunk "Test results didn't match #{h.inspect}:\n#{formatted_test_output}"
-    end
-  end
-
-  def assert_output_contains(*patterns)
-    patterns.each do |pattern|
-      if @test_output !~ pattern
-        flunk "Test output didn't match #{pattern.inspect}:\n#{formatted_test_output}"
-      end
-    end
-  end
-  
-  def assert_output_doesnt_contain(*patterns)
-    patterns.each do |pattern|
-      assert @test_output !~ pattern, "Output shouldn't match #{pattern.inspect} but it does."
-    end
-  end
-
-  def write_and_execute_test
-    @test_code ||=<<-EOM
-        def test_setup_doomed_expectation
-          create_mock :automobile
-          @automobile.expects.start
-        end
-    EOM
-    @full_code ||=<<-EOTEST
-      require File.expand_path(File.dirname(__FILE__) + "/../test_helper")
-      require 'hardmock'
-      class DummyTest < Test::Unit::TestCase
-        #{@teardown_code}
-        #{@test_code}
-      end 
-    EOTEST
-    run_test @full_code
-
-    if @expect_unmet_expectations 
-      assert_output_contains(/unmet expectations/i, /automobile/, /start/)
-    else
-      assert_output_doesnt_contain(/unmet expectations/i, /automobile/, /start/)
-    end
-
-    @expect_tests ||= 1
-    @expect_failures ||= 0
-    @expect_errors ||= 1
-    assert_results :tests => @expect_tests, :failures => @expect_failures, :errors => @expect_errors
-  end
-  
-end