RubyGems - minilab - Versions diffs - 1.0.0-mswin32 - Mend

minilab 1.0.0-mswin32

Files changed (128) hide show

data/.document +2 -0
data/CHANGES +2 -0
data/LICENSE +19 -0
data/README +107 -0
data/Rakefile +145 -0
data/config/environment.rb +15 -0
data/config/objects.yml +22 -0
data/lib/analog_io.rb +30 -0
data/lib/digital_auxport_io.rb +49 -0
data/lib/digital_configuration.rb +66 -0
data/lib/digital_port_io.rb +68 -0
data/lib/extension/extconf.rb +4 -0
data/lib/extension/minilab_hardware.c +235 -0
data/lib/extension/minilab_hardware.so +0 -0
data/lib/library_translator.rb +48 -0
data/lib/minilab.rb +149 -0
data/lib/minilab_context.rb +39 -0
data/lib/result_verifier.rb +14 -0
data/test/integration/analog_input_output_test.rb +43 -0
data/test/integration/connect_to_hardware_test.rb +13 -0
data/test/integration/digital_input_output_test.rb +114 -0
data/test/integration/integration_test.rb +53 -0
data/test/integration/require_minilab_test.rb +9 -0
data/test/system/analog_input.test +3 -0
data/test/system/analog_output.test +37 -0
data/test/system/digital_port_input.test +5 -0
data/test/system/digital_port_output.test +39 -0
data/test/system/digital_port_read_byte.test +26 -0
data/test/system/digital_screw_terminals_input.test +2 -0
data/test/system/digital_screw_terminals_output.test +11 -0
data/test/system/minilab_driver.rb +85 -0
data/test/test_helper.rb +11 -0
data/test/unit/analog_io_test.rb +87 -0
data/test/unit/digital_auxport_io_test.rb +114 -0
data/test/unit/digital_configuration_test.rb +136 -0
data/test/unit/digital_port_io_test.rb +117 -0
data/test/unit/library_translator_test.rb +100 -0
data/test/unit/minilab_context_test.rb +82 -0
data/test/unit/minilab_hardware_test.rb +83 -0
data/test/unit/minilab_test.rb +131 -0
data/test/unit/result_verifier_test.rb +33 -0
data/vendor/behaviors/lib/behaviors.rb +50 -0
data/vendor/behaviors/tasks/behaviors_tasks.rake +140 -0
data/vendor/behaviors/test/behaviors_tasks_test.rb +71 -0
data/vendor/behaviors/test/behaviors_test.rb +50 -0
data/vendor/behaviors/test/tasks_test/Rakefile +16 -0
data/vendor/behaviors/test/tasks_test/doc/behaviors.html +55 -0
data/vendor/behaviors/test/tasks_test/lib/user.rb +2 -0
data/vendor/behaviors/test/tasks_test/test/user_test.rb +17 -0
data/vendor/constructor/Rakefile +44 -0
data/vendor/constructor/config/environment.rb +12 -0
data/vendor/constructor/lib/constructor.rb +132 -0
data/vendor/constructor/test/constructor_test.rb +366 -0
data/vendor/constructor/test/helper.rb +3 -0
data/vendor/diy/README +26 -0
data/vendor/diy/Rakefile +18 -0
data/vendor/diy/lib/constructor.rb +114 -0
data/vendor/diy/lib/diy.rb +329 -0
data/vendor/diy/proto/context.rb +117 -0
data/vendor/diy/proto/context.yml +20 -0
data/vendor/diy/test/diy_test.rb +370 -0
data/vendor/diy/test/files/broken_construction.yml +7 -0
data/vendor/diy/test/files/cat/cat.rb +4 -0
data/vendor/diy/test/files/cat/extra_conflict.yml +5 -0
data/vendor/diy/test/files/cat/heritage.rb +2 -0
data/vendor/diy/test/files/cat/needs_input.yml +3 -0
data/vendor/diy/test/files/cat/the_cat_lineage.rb +1 -0
data/vendor/diy/test/files/dog/dog_model.rb +4 -0
data/vendor/diy/test/files/dog/dog_presenter.rb +4 -0
data/vendor/diy/test/files/dog/dog_view.rb +2 -0
data/vendor/diy/test/files/dog/file_resolver.rb +2 -0
data/vendor/diy/test/files/dog/other_thing.rb +2 -0
data/vendor/diy/test/files/dog/simple.yml +11 -0
data/vendor/diy/test/files/donkey/foo.rb +8 -0
data/vendor/diy/test/files/donkey/foo/bar/qux.rb +7 -0
data/vendor/diy/test/files/fud/objects.yml +13 -0
data/vendor/diy/test/files/fud/toy.rb +15 -0
data/vendor/diy/test/files/gnu/objects.yml +14 -0
data/vendor/diy/test/files/gnu/thinger.rb +8 -0
data/vendor/diy/test/files/goat/base.rb +8 -0
data/vendor/diy/test/files/goat/can.rb +6 -0
data/vendor/diy/test/files/goat/goat.rb +6 -0
data/vendor/diy/test/files/goat/objects.yml +12 -0
data/vendor/diy/test/files/goat/paper.rb +6 -0
data/vendor/diy/test/files/goat/plane.rb +8 -0
data/vendor/diy/test/files/goat/shirt.rb +6 -0
data/vendor/diy/test/files/goat/wings.rb +8 -0
data/vendor/diy/test/files/horse/holder_thing.rb +4 -0
data/vendor/diy/test/files/horse/objects.yml +7 -0
data/vendor/diy/test/files/yak/core_model.rb +4 -0
data/vendor/diy/test/files/yak/core_presenter.rb +4 -0
data/vendor/diy/test/files/yak/core_view.rb +1 -0
data/vendor/diy/test/files/yak/data_source.rb +1 -0
data/vendor/diy/test/files/yak/fringe_model.rb +4 -0
data/vendor/diy/test/files/yak/fringe_presenter.rb +4 -0
data/vendor/diy/test/files/yak/fringe_view.rb +1 -0
data/vendor/diy/test/files/yak/my_objects.yml +21 -0
data/vendor/diy/test/test_helper.rb +40 -0
data/vendor/hardmock/CHANGES +8 -0
data/vendor/hardmock/LICENSE +7 -0
data/vendor/hardmock/README +48 -0
data/vendor/hardmock/Rakefile +100 -0
data/vendor/hardmock/TODO +7 -0
data/vendor/hardmock/config/environment.rb +12 -0
data/vendor/hardmock/homepage/demo.rb +21 -0
data/vendor/hardmock/homepage/hardmock_sample.png +0 -0
data/vendor/hardmock/homepage/index.html +65 -0
data/vendor/hardmock/init.rb +3 -0
data/vendor/hardmock/lib/hardmock.rb +634 -0
data/vendor/hardmock/lib/method_cleanout.rb +14 -0
data/vendor/hardmock/rcov.rake +18 -0
data/vendor/hardmock/test/functional/assert_error_test.rb +52 -0
data/vendor/hardmock/test/functional/auto_verify_test.rb +192 -0
data/vendor/hardmock/test/functional/direct_mock_usage_test.rb +396 -0
data/vendor/hardmock/test/functional/hardmock_test.rb +380 -0
data/vendor/hardmock/test/test_helper.rb +23 -0
data/vendor/hardmock/test/unit/expectation_builder_test.rb +18 -0
data/vendor/hardmock/test/unit/expector_test.rb +56 -0
data/vendor/hardmock/test/unit/method_cleanout_test.rb +35 -0
data/vendor/hardmock/test/unit/mock_control_test.rb +172 -0
data/vendor/hardmock/test/unit/mock_test.rb +273 -0
data/vendor/hardmock/test/unit/simple_expectation_test.rb +345 -0
data/vendor/hardmock/test/unit/trapper_test.rb +60 -0
data/vendor/hardmock/test/unit/verify_error_test.rb +34 -0
data/vendor/systir/systir.rb +403 -0
data/vendor/systir/test/unit/ui/xml/testrunner.rb +192 -0
data/vendor/systir/test/unit/ui/xml/xmltestrunner.xslt +109 -0
metadata +235 -0

data/vendor/hardmock/homepage/hardmock_sample.png ADDED

Binary file

data/vendor/hardmock/homepage/index.html ADDED

@@ -0,0 +1,65 @@
+<html>
+	<head>
+		<title>Hardmock</title>
+		<style>
+			html
+			{
+				text-align: center;
+			}
+			body
+			{
+				margin: 10px auto;
+				width: 750px;
+				text-align: left;
+				font-family: "Lucida Grande", verdana, arial, helvetica, sans-serif;
+				font-size: 14px;
+			}
+			.title
+			{
+				background-color: #99FFB3;
+				border: 1px solid;
+				border-color: #ccc;
+				text-align: center;
+				padding: 10px;
+			}
+			.big
+			{
+				font-size: 170%;
+				font-weight: bold;
+			}
+			pre
+			{
+				border: 1px solid #ddd;
+				padding: 5px;
+			}
+			img
+			{
+				border: none;
+			}
+		</style>
+	</head>
+	<body>
+		<div id="content">
+      <div class="title"><span class="big">Hardmock =></span> Strict, ordered mock objects.</div>
+			<h3>Install</h3>
+			<p>
+				<pre>$ script/plugin install svn://rubyforge.org/var/svn/hardmock/tags/hardmock</pre>
+			</p>
+			<p>(Also available on <a href="http://rubyforge.org/frs/?group_id=2742">Rubyforge</a> as Gem, Tgz and Zip)</p>
+			<h3>Use</h3>
+			<p align="center">
+				<a class="codelink" href="/doc/">
+					<img src="hardmock_sample.png"/>
+				</a>
+			</p>
+		</div>
+	</body>
+</html>

data/vendor/hardmock/init.rb ADDED

@@ -0,0 +1,3 @@
+if RAILS_ENV == 'test'
+  require 'hardmock'
+end

data/vendor/hardmock/lib/hardmock.rb ADDED

@@ -0,0 +1,634 @@
+require 'method_cleanout'
+module Hardmock
+  # Setup auto mock verification on teardown, being careful not to interfere
+  # with inherited, pre-mixed or post-added user teardowns.
+  def self.included(base) #:nodoc:#
+    base.class_eval do
+      # Core of our actual teardown behavior
+      def hardmock_teardown
+        verify_mocks
+      end
+      # disable until later:
+      def self.method_added(symbol) #:nodoc:
+      end
+      if method_defined?(:teardown) then
+        # Wrap existing teardown
+        alias_method :old_teardown, :teardown
+        define_method(:new_teardown) do
+          begin
+            hardmock_teardown
+          ensure
+            old_teardown
+          end
+        end
+      else
+        # We don't need to account for previous teardown
+        define_method(:new_teardown) do
+          hardmock_teardown
+        end
+      end
+      alias_method :teardown, :new_teardown
+      def self.method_added(method) #:nodoc:
+        case method
+        when :teardown
+          unless method_defined?(:user_teardown)
+            alias_method :user_teardown, :teardown
+            define_method(:teardown) do
+              begin
+                new_teardown
+              ensure
+                user_teardown
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+  # Create one or more new Mock instances in your test suite.
+  # Once created, the Mocks are accessible as instance variables in your test.
+  # Newly built Mocks are added to the full set of Mocks for this test, which will
+  # be verified when you call verify_mocks.
+  #
+  #   create_mocks :donkey, :cat # Your test now has @donkey and @cat
+  #   create_mock  :dog          # Test now has @donkey, @cat and @dog
+  #
+  # The first call returned a hash { :donkey => @donkey, :cat => @cat }
+  # and the second call returned { :dog => @dog }
+  #
+  # For more info on how to use your mocks, see Mock and SimpleExpectation
+  #
+  def create_mocks(*mock_names)
+    @main_mock_control ||= MockControl.new
+    mocks = {}
+    mock_names.each do |mock_name|
+      mock_name = mock_name.to_s
+      mock_object = Mock.new(mock_name, @main_mock_control)
+      mocks[mock_name.to_sym] = mock_object
+      self.instance_variable_set "@#{mock_name}", mock_object
+    end
+    @all_mocks ||= {}
+    @all_mocks.merge! mocks
+    return mocks.clone
+  end
+  alias :create_mock :create_mocks
+  # Ensures that all expectations have been met.  If not, VerifyException is
+  # raised.
+  #
+  # <b>You normally won't need to call this yourself.</b> Within Test::Unit::TestCase, this will be done automatically at teardown time.
+  #
+  # * +force+ -- if +false+, and a VerifyError or ExpectationError has already occurred, this method will not raise.  This is to help you suppress repeated errors when if you're calling #verify_mocks in the teardown method of your test suite.  BE WARNED - only use this if you're sure you aren't obscuring useful information.  Eg, if your code handles exceptions internally, and an ExpectationError gets gobbled up by your +rescue+ block, the cause of failure for your test may be hidden from you.  For this reason, #verify_mocks defaults to force=true as of Hardmock 1.0.1
+  def verify_mocks(force=true)
+    return unless @main_mock_control
+    return if @main_mock_control.disappointed? and !force
+    @main_mock_control.verify
+  end
+  module Utils #:nodoc:
+    def fmt_call(mock,mname,args)
+      arg_string = args.map { |a| a.inspect }.join(', ')
+      call_text = "#{mock._name}.#{mname}(#{arg_string})"
+    end
+  end
+  # Mock is used to set expectations in your test.  Most of the time you'll use
+  # <tt>#expects</tt> to create expectations.
+  #
+  # Aside from the scant few control methods (like +expects+, +trap+ and +_verify+)
+  # all calls made on a Mock instance will be immediately applied to the internal
+  # expectation mechanism.
+  #
+  # * If the method call was expected and all the parameters match properly, execution continues
+  # * If the expectation was configured with an expectation block, the block is invoked
+  # * If the expectation was set up to raise an error, the error is raised now
+  # * If the expectation was set up to return a value, it is returned
+  # * If the method call was _not_ expected, or the parameter values are wrong, an ExpectationError is raised.
+  class Mock
+    include MethodCleanout
+    # Create a new Mock instance with a name and a MockControl to support it.
+    # If not given, a MockControl is made implicitly for this Mock alone; this means
+    # expectations for this mock are not tied to other expectations in your test.
+    #
+    # It's not recommended to use a Mock directly; see Hardmock and
+    # Hardmock#create_mocks for the more wholistic approach.
+    def initialize(name, mock_control=nil)
+      @name = name
+      @control = mock_control || MockControl.new
+      @expectation_builder = ExpectationBuilder.new
+    end
+    # Begin declaring an expectation for this Mock.
+    #
+    # == Simple Examples
+    # Expect the +customer+ to be queried for +account+, and return <tt>"The
+    # Account"</tt>:
+    #   @customer.expects.account.returns "The Account"
+    #
+    # Expect the +withdraw+ method to be called, and raise an exception when it
+    # is (see SimpleExpectation#raises for more info):
+    #   @cash_machine.expects.withdraw(20,:dollars).raises("not enough money")
+    #
+    # Expect +customer+ to have its +user_name+ set
+    #   @customer.expects.user_name = 'Big Boss'
+    #
+    # Expect +customer+ to have its +user_name+ set, and raise a RuntimeException when
+    # that happens:
+    #   @customer.expects('user_name=', "Big Boss").raises "lost connection"
+    #
+    # Expect +evaluate+ to be passed a block, and when that happens, pass a value
+    # to the block (see SimpleExpectation#yields for more info):
+    #   @cruncher.expects.evaluate.yields("some data").returns("some results")
+    #
+    #
+    # == Expectation Blocks
+    # To do special handling of expected method calls when they occur, you
+    # may pass a block to your expectation, like:
+    #   @page_scraper.expects.handle_content do |address,request,status|
+    #     assert_not_nil address, "Can't abide nil addresses"
+    #     assert_equal "http-get", request.method, "Can only handle GET"
+    #     assert status > 200 and status < 300, status, "Failed status"
+    #     "Simulated results #{request.content.downcase}"
+    #   end
+    # In this example, when <tt>page_scraper.handle_content</tt> is called, its
+    # three arguments are passed to the <i>expectation block</i> and evaluated
+    # using the above assertions.  The last value in the block will be used
+    # as the return value for +handle_content+
+    #
+    # You may specify arguments to the expected method call, just like any normal
+    # expectation, and those arguments will be pre-validated before being passed
+    # to the expectation block.  This is useful when you know all of the
+    # expected values but still need to do something programmatic.
+    #
+    # If the method being invoked on the mock accepts a block, that block will be
+    # passed to your expectation block as the last (or only) argument.  Eg, the
+    # convenience method +yields+ can be replaced with the more explicit:
+    #   @cruncher.expects.evaluate do |block|
+    #     block.call "some data"
+    #     "some results"
+    #   end
+    #
+    # The result value of the expectation block becomes the return value for the
+    # expected method call. This can be overidden by using the +returns+ method:
+    #   @cruncher.expects.evaluate do |block|
+    #     block.call "some data"
+    #     "some results"
+    #   end.returns("the actual value")
+    #
+    # <b>Additionally</b>, the resulting value of the expectation block is stored
+    # in the +block_value+ field on the expectation.  If you've saved a reference
+    # to your expectation, you may retrieve the block value once the expectation
+    # has been met.
+    #
+    #   evaluation_event = @cruncher.expects.evaluate do |block|
+    #     block.call "some data"
+    #     "some results"
+    #   end.returns("the actual value")
+    #
+    #   result = @cruncher.evaluate do |input|
+    #     puts input  # => 'some data'
+    #   end
+    #   # result is 'the actual value'
+    #
+    #   evaluation_event.block_value # => 'some results'
+    #
+    def expects(*args, &block)
+      expector = Expector.new(self,@control,@expectation_builder)
+      # If there are no args, we return the Expector
+      return expector if args.empty?
+      # If there ARE args, we set up the expectation right here and return it
+      expector.send(args.shift.to_sym, *args, &block)
+    end
+    alias_method :expect, :expects
+#    def expect(*args, &block) #:nodoc:
+#      raise DeprecationError.new("Please use 'expects' instead of 'expect'.  Sorry about the inconvenience.")
+#    end
+    # Special-case convenience: #trap sets up an expectation for a method
+    # that will take a block.  That block, when sent to the expected method, will
+    # be trapped and stored in the expectation's +block_value+ field.
+    # The SimpleExpectation#trigger method may then be used to invoke that block.
+    #
+    # Like +expects+, the +trap+ mechanism can be followed by +raises+ or +returns+.
+    #
+    # _Unlike_ +expects+, you may not use an expectation block with +trap+.  If
+    # the expected method takes arguments in addition to the block, they must
+    # be specified in the arguments to the +trap+ call itself.
+    #
+    # == Example
+    #
+    #   create_mocks :address_book, :editor_form
+    #
+    #   # Expect a subscription on the :person_added event for @address_book:
+    #   person_event = @address_book.trap.subscribe(:person_added)
+    #
+    #   # The runtime code would look like:
+    #   @address_book.subscribe :person_added do |person_name|
+    #     @editor_form.name = person_name
+    #   end
+    #
+    #   # At this point, the expectation for 'subscribe' is met and the
+    #   # block has been captured.  But we're not done:
+    #   @editor_form.expects.name = "David"
+    #
+    #   # Now invoke the block we trapped earlier:
+    #    person_event.trigger "David"
+    #
+    #   verify_mocks
+    def trap(*args)
+      Trapper.new(self,@control,ExpectationBuilder.new)
+    end
+    def method_missing(mname,*args) #:nodoc:
+      block = nil
+      block = Proc.new if block_given?
+      @control.apply_method_call(self,mname,args,block)
+    end
+    def _control #:nodoc:
+      @control
+    end
+    def _name #:nodoc:
+      @name
+    end
+    # Verify that all expectations are fulfilled.  NOTE: this method triggers
+    # validation on the _control_ for this mock, so all Mocks that share the
+    # MockControl with this instance will be included in the verification.
+    #
+    # <b>Only use this method if you are managing your own Mocks and their controls.</b>
+    #
+    # Normal usage of Hardmock doesn't require you to call this; let
+    # Hardmock#verify_mocks do it for you.
+    def _verify
+      @control.verify
+    end
+  end
+  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
+  class Trapper #: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)
+      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
+  class ExpectationBuilder #:nodoc:
+    def build_expectation(options)
+      SimpleExpectation.new(options)
+    end
+  end
+  class SimpleExpectation
+    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
+    # 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("Can't pass #{item.inspect} to block with arity #{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:
+      fmt_call(@options[:mock],@options[:method],@options[:arguments])
+    end
+    private
+    def anger(msg, mock,mname,args)
+      ExpectationError.new("#{msg}: expected call <#{to_s}> but was <#{fmt_call(mock,mname,args)}>")
+    end
+  end
+  class MockControl #:nodoc:
+    include Utils
+    attr_accessor :name
+    def initialize
+      @expectations = []
+      @disappointed = false
+    end
+    def happy?
+      @expectations.empty?
+    end
+    def disappointed?
+      @disappointed
+    end
+    def add_expectation(expectation)
+      @expectations << expectation
+    end
+    def apply_method_call(mock,mname,args,block)
+      # Are we even expecting any sort of call?
+      if happy?
+        @disappointed = true
+        raise ExpectationError.new("Surprise call to #{fmt_call(mock,mname,args)}")
+      end
+      begin
+        @expectations.shift.apply_method_call(mock,mname,args,block)
+      rescue Exception => ouch
+        @disappointed = true
+        raise ouch
+      end
+    end
+    def verify
+      @disappointed = !happy?
+      raise VerifyError.new("Unmet expectations", @expectations) unless happy?
+    end
+  end
+  # Raised when:
+  # * Unexpected method is called on a mock object
+  # * Bad arguments passed to an expected call
+  class ExpectationError < StandardError; end
+  # Raised for methods that should no longer be called.  Hopefully, the exception message contains helpful alternatives.
+  class DeprecationError < StandardError; end
+  # Raised when it is discovered that an expected method call was never made.
+  class VerifyError < StandardError
+    def initialize(msg,unmet_expectations)
+      super("#{msg}:" + unmet_expectations.map { |ex| "\n * #{ex.to_s}" }.join)
+    end
+  end
+  # 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
+# Insert Hardmock functionality into the TestCase base class
+require 'test/unit/testcase'
+unless Test::Unit::TestCase.instance_methods.include?('hardmock_teardown')
+  class Test::Unit::TestCase
+    include Hardmock
+  end
+end