ceedling 0.0.1

data/new_project_template/vendor/ceedling/vendor/cmock/vendor/hardmock/CHANGES

@@ -0,0 +1,78 @@
+Hardmock 1.3.7
+
+* BUG FIX: expects! could not setup expectations for more than one concrete method on an object, since the method aliasing and rewriting was only taking place when the background mock instance was first created.  This logic has been updated and now you can do all the things you'd expect.
+
+Hardmock 1.3.6
+
+* BUG FIX: In Rails apps (and others) Hardmock and Fixtures battled viciously over "setup" and "teardown" and "method_added" (and any other clever test enhancement tool, namely Mocha) causing unpredictable results, notably failure to auto-verify mocks after teardown (leading to false positive tests).
+  * The newly-added TestUnitBeforeAfter provides TestCase.before_setup and TestCase.after_teardown -- formal test wrapping hooks -- lets Hardmock provide its preparation and auto-verify behavior without contending for setup/teardown supremacy.  
+
+Hardmock 1.3.5
+
+* Aliased should_receive => expects and and_return => returns for easier transition from rspec mock and flexmock users.
+
+Hardmock 1.3.4
+
+* Prevents accidental stubbing and mocking on NilClasses
+
+Hardmock 1.3.3
+ 
+* stubs! and expects! no longer require that their target methods exist in reality (this used to prevent you from stubbing methods that "exist" by virtue of "method_missing"
+* Tweaked inner metaclass code to avoid collisions with rspec's "metaid" stuff
+* Moved this project's Rake tasks into rake_tasks... otherwise Rails will load them, if Hardmock is installed as a Rails plugin
+* Alias added: 'verify_hardmocks' is now an alias for 'verify_mocks'  (some internal projects were using this modified method name as a means of cooexisting with mocha)
+
+Hardmock 1.3.2
+
+November 2007
+
+* adds 'with' as an alternate syntax for specifying argument expectations.
+
+Hardmock 1.3.1 
+
+October 2007
+
+* Can use stubs! on a mock object 
+* expects! now generates mocked methods that can safely transfer runtime blocks to the mock instance itself 
+* No longer need to call "prepare_hardmock_control" when using stubs in the absence of mocks 
+* Stubs of concrete class or instance methods are restored to original state in teardown
+
+Hardmock 1.3.0 
+
+October 2007
+
+* Adds stubs! and expects! method to all objects and classes to support concrete stubbing/mocking.
+
+Hardmock 1.2.3
+
+Sat Apr 28 01:16:15 EDT 2007
+
+* Re-release of 1.2.2 (which was canceled)... tasks moved to lib/tasks
+
+Hardmock 1.2.2
+
+Sat Apr 28 00:41:30 EDT 2007
+
+* assert_error has been broken out into its own lib file
+* Gem package can now run all tests successfully
+* Internal code refactoring; a number of classes that were defined in hardmock.rb are now in their own files
+
+Hardmock 1.2.1
+
+Sat Apr 28 00:41:30 EDT 2007
+
+* (botched release, see 1.2.2)
+
+Hardmock 1.2.0
+
+* You can now use "expect" in place of "expects" if you must. 
+* "inspect" has been added to the list of methods NOT erased by MethodCleanout.
+
+Hardmock 1.1.0
+
+* "expects" replaces "expect" ("expect" now raises Hardmock::DeprecationError)
+* "verify_mocks" is now implicit in teardown, you needn't call it anymore
+* Mocking methods that Mock would otherwise inherit from Object (eg, to_s) is now possible
+* require 'hardmock' is all that's required to use the library now; no need to include in TestCase
+
+(previously called CMock, translated to Hardmock on 2006-12-10)

data/new_project_template/vendor/ceedling/vendor/cmock/vendor/hardmock/LICENSE

@@ -0,0 +1,7 @@
+Copyright (c) 2006,2007 David Crosby at Atomic Object, LLC
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/new_project_template/vendor/ceedling/vendor/cmock/vendor/hardmock/README

@@ -0,0 +1,70 @@
+== Hardmock
+
+Strict, ordered mock objects using very lightweight syntax in your tests.
+
+== How
+
+The basic procedure for using Hardmock in your tests is:
+
+* require 'hardmock' (this happens automatically when being used as a Rails plugin)
+* Create some mocks
+* Setup some expectations
+* Execute the target code
+* Verification of calls is automatic in =teardown=
+
+The expectations you set when using mocks are <b>strict</b> and <b>ordered</b>.
+Expectations you declare by creating and using mocks are all considered together.
+
+* Hardmock::Mock#expects will show you more examples
+* Hardmock::SimpleExpectation will teach you more about expectation methods
+
+== Example
+
+  create_mocks :garage, :car
+
+  # Set some expectations
+  @garage.expects.open_door
+  @car.expects.start(:choke)
+  @car.expects.drive(:reverse, 5.mph)
+
+  # Execute the code (this code is usually, obviously, in your class under test)
+  @garage.open_door  
+  @car.start :choke
+  @car.drive :reverse, 5.mph
+
+  verify_mocks # OPTIONAL, teardown will do this for you
+
+Expects <tt>@garage.open_door</tt>, <tt>@car.start(:choke)</tt> and <tt>@car.drive(:reverse, 5.mph)</tt> to be called in that order, with those specific arguments.
+* Violations of expectations, such as mis-ordered calls, calls on wrong objects, or incorrect methods result in Hardmock::ExpectationError
+* <tt>verify_mocks</tt> will raise VerifyError if not all expectations have been met.
+
+== Download and Install
+
+* Homepage: http://hardmock.rubyforge.org
+* GEM or TGZ or ZIP: http://rubyforge.org/frs/?group_id=2742
+* Rails plugin: script/plugin install 
+* SVN access: svn co svn://rubyforge.org/var/svn/hardmock/trunk
+* Developer SVN access: svn co svn://developername@rubyforge.org/var/svn/hardmock/trunk
+
+== Setup for Test::Unit
+
+  require 'hardmock'
+  require 'assert_error' # OPTIONAL: this adds the TestUnit extension 'assert_error' 
+
+NOTE: If installed as a Rails plugin, init.rb does this for you... nothing else is needed.
+
+== Setup for RSpec
+
+Get this into your spec helper or environment or Rakefile or wherever you prefer:
+
+  Spec::Runner.configure do |configuration|
+    configuration.include Hardmock
+    configuration.after(:each) {verify_mocks}
+  end
+
+This puts the implicit conveniences into your spec context, like "create_mocks" etc, and also provides for automatic
+"verify_mocks" after each Example is run.
+
+== Author
+* David Crosby crosby at http://atomicobject.com
+* (c) 2006,2007 Atomic Object LLC 

data/new_project_template/vendor/ceedling/vendor/cmock/vendor/hardmock/Rakefile

@@ -0,0 +1,8 @@
+require 'rake'
+require 'rubygems'
+
+HARDMOCK_VERSION = "1.3.7"
+
+Dir["rake_tasks/*.rake"].each { |f| load f }
+
+task :default => [ 'test:all' ]

data/new_project_template/vendor/ceedling/vendor/cmock/vendor/hardmock/config/environment.rb

@@ -0,0 +1,12 @@
+# The path to the root directory of your application.
+APP_ROOT = File.join(File.dirname(__FILE__), '..')
+
+ADDITIONAL_LOAD_PATHS = []
+ADDITIONAL_LOAD_PATHS.concat %w(
+  lib 
+).map { |dir| "#{APP_ROOT}/#{dir}" }.select { |dir| File.directory?(dir) }
+
+# Prepend to $LOAD_PATH
+ADDITIONAL_LOAD_PATHS.reverse.each { |dir| $:.unshift(dir) if File.directory?(dir) }
+
+# Require any additional libraries needed

data/new_project_template/vendor/ceedling/vendor/cmock/vendor/hardmock/lib/assert_error.rb

@@ -0,0 +1,23 @@
+require 'test/unit/assertions'
+
+module Test::Unit #:nodoc:#
+  module Assertions #:nodoc:#
+    # A better 'assert_raise'.  +patterns+ can be one or more Regexps, or a literal String that 
+    # must match the entire error message.
+    def assert_error(err_type,*patterns,&block)
+      assert_not_nil block, "assert_error requires a block"
+      assert((err_type and err_type.kind_of?(Class)), "First argument to assert_error has to be an error type")
+      err = assert_raise(err_type) do
+        block.call
+      end
+      patterns.each do |pattern|
+        case pattern
+        when Regexp
+          assert_match(pattern, err.message) 
+        else
+          assert_equal pattern, err.message
+        end
+      end
+    end
+  end
+end

data/new_project_template/vendor/ceedling/vendor/cmock/vendor/hardmock/lib/extend_test_unit.rb

@@ -0,0 +1,14 @@
+
+require 'test/unit/testcase'
+class Test::Unit::TestCase 
+  include Hardmock
+end
+
+require 'test_unit_before_after'
+Test::Unit::TestCase.before_setup do |test|
+  test.prepare_hardmock_control
+end
+
+Test::Unit::TestCase.after_teardown do |test|
+  test.verify_mocks
+end

data/new_project_template/vendor/ceedling/vendor/cmock/vendor/hardmock/lib/hardmock/errors.rb

@@ -0,0 +1,22 @@
+module Hardmock
+  # Raised when:
+  # * Unexpected method is called on a mock object
+  # * Bad arguments passed to an expected call
+  class ExpectationError < StandardError #:nodoc:#
+  end 
+
+  # Raised for methods that should no longer be called.  Hopefully, the exception message contains helpful alternatives.
+  class DeprecationError < StandardError #:nodoc:#
+  end 
+
+  # Raised when stubbing fails
+  class StubbingError < StandardError #:nodoc:#
+  end
+
+  # Raised when it is discovered that an expected method call was never made.
+  class VerifyError < StandardError #:nodoc:#
+    def initialize(msg,unmet_expectations)
+      super("#{msg}:" + unmet_expectations.map { |ex| "\n * #{ex.to_s}" }.join)
+    end
+  end
+end

data/new_project_template/vendor/ceedling/vendor/cmock/vendor/hardmock/lib/hardmock/expectation.rb

@@ -0,0 +1,229 @@
+require 'hardmock/utils'
+
+module Hardmock
+  class Expectation
+    include Utils
+    attr_reader :block_value
+
+    def initialize(options) #:nodoc:
+      @options = options
+    end
+
+    def apply_method_call(mock,mname,args,block) #:nodoc:
+      unless @options[:mock].equal?(mock)
+        raise anger("Wrong object", mock,mname,args)
+      end
+      unless @options[:method] == mname
+        raise anger("Wrong method",mock,mname,args)
+      end
+
+      # Tester-defined block to invoke at method-call-time:
+      expectation_block = @options[:block]
+
+      expected_args = @options[:arguments]
+      # if we have a block, we can skip the argument check if none were specified
+      unless (expected_args.nil? || expected_args.empty?) && expectation_block && !@options[:suppress_arguments_to_block]
+        unless expected_args == args
+          raise anger("Wrong arguments",mock,mname,args)
+        end
+      end
+
+      relayed_args = args.dup
+      if block
+        if expectation_block.nil?
+          # Can't handle a runtime block without an expectation block
+          raise ExpectationError.new("Unexpected block provided to #{to_s}")
+        else
+          # Runtime blocks are passed as final argument to the expectation block
+          unless @options[:suppress_arguments_to_block]
+            relayed_args << block
+          else
+            # Arguments suppressed; send only the block
+            relayed_args = [block]
+          end
+        end
+      end
+
+      # Run the expectation block:
+      @block_value = expectation_block.call(*relayed_args) if expectation_block
+
+      raise @options[:raises] unless @options[:raises].nil?
+			
+			return_value = @options[:returns]
+			if return_value.nil?
+				return @block_value
+			else
+				return return_value
+			end
+    end
+
+    # Set the return value for an expected method call.
+    # Eg,
+    #   @cash_machine.expects.withdraw(20,:dollars).returns(20.00)
+    def returns(val)
+      @options[:returns] = val
+      self
+    end
+    alias_method :and_return, :returns
+    
+    # Set the arguments for an expected method call.
+    # Eg,
+    #   @cash_machine.expects.deposit.with(20, "dollars").returns(:balance => "20")
+    def with(*args)
+      @options[:arguments] = args
+      self      
+    end
+    
+    # Rig an expected method to raise an exception when the mock is invoked.
+    #
+    # Eg,
+    #   @cash_machine.expects.withdraw(20,:dollars).raises "Insufficient funds"
+    #
+    # The argument can be:
+    # * an Exception -- will be used directly
+    # * a String -- will be used as the message for a RuntimeError
+    # * nothing -- RuntimeError.new("An Error") will be raised
+    def raises(err=nil)
+      case err
+      when Exception
+        @options[:raises] = err
+      when String
+        @options[:raises] = RuntimeError.new(err)
+      else
+        @options[:raises] = RuntimeError.new("An Error")
+      end
+      self
+    end
+
+    # Convenience method: assumes +block_value+ is set, and is set to a Proc
+    # (or anything that responds to 'call')
+    #
+    #   light_event = @traffic_light.trap.subscribe(:light_changes)
+    #
+    #   # This code will meet the expectation:
+    #   @traffic_light.subscribe :light_changes do |color|
+    #     puts color
+    #   end
+    #
+    # The color-handling block is now stored in <tt>light_event.block_value</tt>
+    #
+    # The block can be invoked like this:
+    #
+    #   light_event.trigger :red
+    # 
+    # See Mock#trap and Mock#expects for information on using expectation objects 
+    # after they are set.
+    #
+    def trigger(*block_arguments)
+      unless block_value
+        raise ExpectationError.new("No block value is currently set for expectation #{to_s}")
+      end
+      unless block_value.respond_to?(:call)
+        raise ExpectationError.new("Can't apply trigger to #{block_value} for expectation #{to_s}")
+      end
+      block_value.call *block_arguments
+    end
+
+    # Used when an expected method accepts a block at runtime.  
+    # When the expected method is invoked, the block passed to
+    # that method will be invoked as well.
+    #
+    # NOTE: ExpectationError will be thrown upon running the expected method
+    # if the arguments you set up in +yields+ do not properly match up with
+    # the actual block that ends up getting passed.
+    # 
+    # == Examples
+    # <b>Single invocation</b>: The block passed to +lock_down+ gets invoked
+    # once with no arguments:
+    #
+    #   @safe_zone.expects.lock_down.yields
+    #
+    #   # (works on code that looks like:)
+    #   @safe_zone.lock_down do 
+    #     # ... this block invoked once
+    #   end
+    # 
+    # <b>Multi-parameter blocks:</b> The block passed to +each_item+ gets
+    # invoked twice, with <tt>:item1</tt> the first time, and with
+    # <tt>:item2</tt> the second time:
+    # 
+    #   @fruit_basket.expects.each_with_index.yields [:apple,1], [:orange,2]
+    #
+    #   # (works on code that looks like:)
+    #   @fruit_basket.each_with_index do |fruit,index|
+    #     # ... this block invoked with fruit=:apple, index=1, 
+    #     # ... and then with fruit=:orange, index=2
+    #   end
+    #
+    # <b>Arrays can be passed as arguments too</b>... if the block 
+    # takes a single argument and you want to pass a series of arrays into it,
+    # that will work as well:
+    #
+    #   @list_provider.expects.each_list.yields [1,2,3], [4,5,6]
+    #
+    #   # (works on code that looks like:)
+    #   @list_provider.each_list do |list|
+    #     # ... list is [1,2,3] the first time
+    #     # ... list is [4,5,6] the second time
+    #   end
+    #
+    # <b>Return value</b>: You can set the return value for the method that
+    # accepts the block like so: 
+    #
+    #   @cruncher.expects.do_things.yields(:bean1,:bean2).returns("The Results")
+    #
+    # <b>Raising errors</b>: You can set the raised exception for the method that
+    # accepts the block. NOTE: the error will be raised _after_ the block has
+    # been invoked.
+    #
+    #   # :bean1 and :bean2 will be passed to the block, then an error is raised:
+    #   @cruncher.expects.do_things.yields(:bean1,:bean2).raises("Too crunchy")
+    #
+    def yields(*items)
+      @options[:suppress_arguments_to_block] = true
+      if items.empty?
+        # Yield once
+        @options[:block] = lambda do |block|
+          if block.arity != 0 and block.arity != -1
+            raise ExpectationError.new("The given block was expected to have no parameter count; instead, got #{block.arity} to <#{to_s}>")
+          end
+          block.call
+        end
+      else
+        # Yield one or more specific items
+        @options[:block] = lambda do |block|
+          items.each do |item|
+            if item.kind_of?(Array) 
+              if block.arity == item.size
+                # Unfold the array into the block's arguments:
+                block.call *item
+              elsif block.arity == 1
+                # Just pass the array in
+                block.call item
+              else
+                # Size mismatch
+                raise ExpectationError.new("Can't pass #{item.inspect} to block with arity #{block.arity} to <#{to_s}>")
+              end
+            else
+              if block.arity != 1
+                # Size mismatch
+                raise ExpectationError.new("Can't pass #{item.inspect} to block with arity #{block.arity} to <#{to_s}>")
+              end
+              block.call item
+            end
+          end
+        end
+      end
+      self
+    end
+
+    def to_s # :nodoc:
+      format_method_call_string(@options[:mock],@options[:method],@options[:arguments])
+    end
+
+    private 
+    def anger(msg, mock,mname,args)
+      ExpectationError.new("#{msg}: expected call <#{to_s}> but was <#{format_method_call_string(mock,mname,args)}>")
+    end
+  end
+end

data/new_project_template/vendor/ceedling/vendor/cmock/vendor/hardmock/lib/hardmock/expectation_builder.rb

@@ -0,0 +1,9 @@
+require 'hardmock/expectation'
+
+module Hardmock
+  class ExpectationBuilder #:nodoc:
+    def build_expectation(options)
+      Expectation.new(options)
+    end
+  end
+end

data/new_project_template/vendor/ceedling/vendor/cmock/vendor/hardmock/lib/hardmock/expector.rb

@@ -0,0 +1,26 @@
+require 'hardmock/method_cleanout'
+require 'hardmock/errors'
+
+module Hardmock
+  class Expector #:nodoc:
+    include MethodCleanout
+
+    def initialize(mock,mock_control,expectation_builder)
+      @mock = mock
+      @mock_control = mock_control
+      @expectation_builder = expectation_builder
+    end
+
+    def method_missing(mname, *args, &block)
+      expectation = @expectation_builder.build_expectation(
+        :mock => @mock, 
+        :method => mname, 
+        :arguments => args, 
+        :block => block)
+
+      @mock_control.add_expectation expectation
+      expectation
+    end
+  end
+
+end

data/new_project_template/vendor/ceedling/vendor/cmock/vendor/hardmock/lib/hardmock/method_cleanout.rb

@@ -0,0 +1,33 @@
+
+module Hardmock #:nodoc:
+  module MethodCleanout #:nodoc:
+    SACRED_METHODS = %w{
+      __id__
+      __send__
+      equal?
+      object_id
+      send
+      nil?
+      class
+      kind_of?
+      respond_to?
+      inspect
+      method
+      to_s
+      instance_variables
+      instance_eval
+      ==
+      hm_metaclass
+      hm_meta_eval
+      hm_meta_def
+    }
+
+    def self.included(base) #:nodoc:
+      base.class_eval do
+        instance_methods.each do |m| 
+          undef_method m unless SACRED_METHODS.include?(m.to_s)
+        end
+      end
+    end
+  end
+end