minilab 1.0.0-mswin32

data/vendor/hardmock/test/unit/simple_expectation_test.rb

@@ -0,0 +1,345 @@
+require File.expand_path(File.dirname(__FILE__) + "/../test_helper")
+require 'hardmock'
+
+class SimpleExpectationTest < Test::Unit::TestCase
+
+  def setup
+    @mock = TheMock.new
+  end
+  #
+  # HELPERS
+  #
+   
+  class TheMock
+    def _name; 'the_mock'; end
+  end
+  class OtherMock
+    def _name; 'other_mock'; end
+  end
+
+  #
+  # TESTS
+  #
+
+  def test_to_s
+    ex = SimpleExpectation.new( :mock => @mock, :method => 'a_func', :arguments => [1, "two", :three, { :four => 4 }] )  
+    assert_equal %|the_mock.a_func(1, "two", :three, {:four=>4})|, ex.to_s
+  end
+   
+  def test_apply_method_call
+    se = SimpleExpectation.new(:mock => @mock, :method => 'some_func',
+      :arguments => [1,'two',:three] )
+
+    # Try it good:
+    assert_nothing_raised ExpectationError do
+      se.apply_method_call( @mock, 'some_func', [1,'two',:three], nil )
+    end 
+
+    # Bad func name:
+    err = assert_raise ExpectationError do
+      se.apply_method_call( @mock, 'wrong_func', [1,'two',:three], nil )
+    end
+    assert_match(/wrong method/i, err.message) 
+    assert_match(/wrong_func/i, err.message) 
+    assert_match(/[1, "two", :three]/i, err.message) 
+    assert_match(/some_func/i, err.message) 
+    assert_match(/the_mock/i, err.message) 
+
+    # Wrong mock
+    err = assert_raise ExpectationError do
+      se.apply_method_call( OtherMock.new, 'some_func', [1,'two',:three], nil )
+    end
+    assert_match(/[1, "two", :three]/i, err.message) 
+    assert_match(/some_func/i, err.message) 
+    assert_match(/the_mock/i, err.message) 
+    assert_match(/other_mock/i, err.message) 
+    
+    # Wrong args
+    err = assert_raise ExpectationError do
+      se.apply_method_call( @mock, 'some_func', [1,'two',:four], nil)
+    end
+    assert_match(/[1, "two", :three]/i, err.message) 
+    assert_match(/[1, "two", :four]/i, err.message) 
+    assert_match(/wrong arguments/i, err.message) 
+    assert_match(/some_func/i, err.message) 
+  end
+
+  def test_apply_method_call_should_call_proc_when_given
+    # now with a proc
+    thinger = nil
+    the_proc = Proc.new { thinger = :shaq }
+    se = SimpleExpectation.new(:mock => @mock, :method => 'some_func',
+      :block => the_proc)
+
+    # Try it good:
+    assert_nil thinger
+    assert_nothing_raised ExpectationError do
+      se.apply_method_call(@mock, 'some_func', [], nil)
+    end 
+    assert_equal :shaq, thinger, 'wheres shaq??'
+  end
+
+  def test_apply_method_call_passes_runtime_block_as_last_argument_to_expectation_block
+
+    passed_block = nil
+    exp_block_called = false
+    exp_block = Proc.new { |blk| 
+      exp_block_called = true
+      passed_block = blk 
+    }
+
+    se = SimpleExpectation.new(:mock => @mock, :method => 'some_func', :block => exp_block,
+      :arguments => [])
+
+    set_flag = false
+    runtime_block = Proc.new { set_flag = true }
+
+    assert_nil passed_block, "Passed block should be nil"
+    assert !set_flag, "set_flag should be off"
+
+    # Go
+    se.apply_method_call( @mock, 'some_func', [], runtime_block)
+
+    # Examine the passed block
+    assert exp_block_called, "Expectation block not called"
+    assert_not_nil passed_block, "Should have been passed a block"
+    assert !set_flag, "set_flag should still be off"
+    passed_block.call
+    assert set_flag, "set_flag should be on"
+  end
+
+  def test_apply_method_call_fails_when_theres_no_expectation_block_to_handle_the_runtime_block
+    se = SimpleExpectation.new(:mock => @mock, :method => 'some_func', :arguments => [])
+    runtime_block = Proc.new { set_flag = true }
+    err = assert_raise ExpectationError do
+      se.apply_method_call( @mock, 'some_func', [], runtime_block)
+    end
+    assert_match(/unexpected block/i, err.message) 
+    assert_match(/the_mock.some_func()/i, err.message) 
+  end
+
+  def test_returns
+    se = SimpleExpectation.new(:mock => @mock, :method => 'some_func',
+      :arguments => [1,'two',:three])
+
+    se.returns "A value"
+
+    assert_equal "A value", se.apply_method_call(@mock, 'some_func', [1,'two',:three], nil)
+  end
+
+  def test_apply_method_call_captures_block_value
+    the_proc = lambda { "in the block" }
+    se = SimpleExpectation.new(:mock => @mock, :method => 'do_it', :arguments => [], :block => the_proc)
+
+    assert_nil se.block_value, "Block value starts out nil"
+    
+    se.apply_method_call(@mock, 'do_it', [], nil)
+
+    assert_equal "in the block", se.block_value, "Block value not captured"
+  end
+
+  def test_trigger
+    # convenience method for block_value.call
+    target = false
+    inner_proc = lambda { target = true }
+    the_proc = lambda { inner_proc }
+    se = SimpleExpectation.new(:mock => @mock, :method => 'do_it', :arguments => [], :block => the_proc)
+
+    assert_nil se.block_value, "Block value starts out nil"
+    se.apply_method_call(@mock, 'do_it', [], nil)
+    assert_not_nil se.block_value, "Block value not set"
+
+    assert !target, "Target should still be false"
+    se.trigger
+    assert target, "Target not true!"
+  end
+
+  def test_trigger_with_arguments
+    # convenience method for block_value.call
+    target = nil
+    inner_proc = lambda { |one,two| target = [one,two] }
+    the_proc = lambda { inner_proc }
+    se = SimpleExpectation.new(:mock => @mock, :method => 'do_it', :arguments => [], :block => the_proc)
+
+    assert_nil se.block_value, "Block value starts out nil"
+    se.apply_method_call(@mock, 'do_it', [], nil)
+    assert_not_nil se.block_value, "Block value not set"
+
+    assert_nil target, "target should still be nil"
+    se.trigger 'cat','dog'
+    assert_equal ['cat','dog'], target
+  end
+
+  def test_trigger_nil_block_value
+    se = SimpleExpectation.new(:mock => @mock, :method => 'do_it', :arguments => [])
+
+    assert_nil se.block_value, "Block value starts out nil"
+    se.apply_method_call(@mock, 'do_it', [], nil)
+    assert_nil se.block_value, "Block value should still be nil"
+
+    err = assert_raise ExpectationError do
+      se.trigger
+    end
+    assert_match(/do_it/i, err.message) 
+    assert_match(/block value/i, err.message) 
+  end
+
+  def test_trigger_non_proc_block_value
+    the_block = lambda { "woops" }
+    se = SimpleExpectation.new(:mock => @mock, :method => 'do_it', :arguments => [], :block => the_block)
+
+    se.apply_method_call(@mock, 'do_it', [], nil)
+    assert_equal "woops", se.block_value
+
+    err = assert_raise ExpectationError do
+      se.trigger
+    end
+    assert_match(/do_it/i, err.message) 
+    assert_match(/trigger/i, err.message) 
+    assert_match(/woops/i, err.message) 
+  end
+
+
+
+  def test_proc_used_for_return
+    the_proc = lambda { "in the block" }
+    se = SimpleExpectation.new(:mock => @mock, :method => 'do_it', :arguments => [], :block => the_proc)
+
+    assert_equal "in the block", se.apply_method_call(@mock, 'do_it', [], nil)
+    assert_equal "in the block", se.block_value, "Captured block value affected wrongly"
+  end
+
+  def test_explicit_return_overrides_proc_return
+    the_proc = lambda { "in the block" }
+    se = SimpleExpectation.new(:mock => @mock, :method => 'do_it', :arguments => [], :block => the_proc)
+    se.returns "the override"
+    assert_equal "the override", se.apply_method_call(@mock, 'do_it', [], nil)
+    assert_equal "in the block", se.block_value, "Captured block value affected wrongly"
+  end
+
+  def test_yields
+    se = SimpleExpectation.new(:mock => @mock, :method => 'each_bean', :arguments => [:side_slot] )
+    se.yields :bean1, :bean2
+
+    things = []
+    a_block = lambda { |thinger| things << thinger } 
+
+    se.apply_method_call(@mock,'each_bean',[:side_slot],a_block)
+    assert_equal [:bean1,:bean2], things, "Wrong things"
+  end
+
+  def test_yields_block_takes_no_arguments
+    se = SimpleExpectation.new(:mock => @mock, :method => 'each_bean', :arguments => [:side_slot] )
+    se.yields
+
+    things = []
+    a_block = lambda { things << 'OOF' }
+    se.apply_method_call(@mock,'each_bean',[:side_slot],a_block)
+    assert_equal ['OOF'], things
+  end
+
+  def test_yields_params_to_block_takes_no_arguments
+    se = SimpleExpectation.new(:mock => @mock, :method => 'each_bean', :arguments => [:side_slot] )
+    se.yields :wont_fit
+
+    things = []
+    a_block = lambda { things << 'WUP' }
+
+    err = assert_raise ExpectationError do
+      se.apply_method_call(@mock,'each_bean',[:side_slot],a_block)
+    end
+    assert_match(/wont_fit/i, err.message) 
+    assert_match(/arity -1/i, err.message) 
+    assert_equal [], things, "Wrong things"
+  end
+
+  def test_yields_with_returns
+    se = SimpleExpectation.new(:mock => @mock, :method => 'each_bean', :arguments => [:side_slot] ,
+      :returns => 'the results')
+    
+    exp = se.yields :bean1, :bean2
+    assert_same se, exp, "'yields' needs to return a reference to the expectation"
+    things = []
+    a_block = lambda { |thinger| things << thinger } 
+    returned = se.apply_method_call(@mock,'each_bean',[:side_slot],a_block)
+    assert_equal [:bean1,:bean2], things, "Wrong things"
+    assert_equal 'the results', returned, "Wrong return value"
+  end
+
+  def test_yields_with_raises
+    se = SimpleExpectation.new(:mock => @mock, :method => 'each_bean', :arguments => [:side_slot],
+      :raises => RuntimeError.new("kerboom"))
+    
+    exp = se.yields :bean1, :bean2
+    assert_same se, exp, "'yields' needs to return a reference to the expectation"
+    things = []
+    a_block = lambda { |thinger| things << thinger } 
+    err = assert_raise RuntimeError do
+      se.apply_method_call(@mock,'each_bean',[:side_slot],a_block)
+    end
+    assert_match(/kerboom/i, err.message) 
+    assert_equal [:bean1,:bean2], things, "Wrong things"
+  end
+
+  def test_yields_and_inner_block_explodes
+    se = SimpleExpectation.new(:mock => @mock, :method => 'each_bean', :arguments => [:side_slot])
+    
+    exp = se.yields :bean1, :bean2
+    assert_same se, exp, "'yields' needs to return a reference to the expectation"
+    things = []
+    a_block = lambda { |thinger| 
+      things << thinger 
+      raise "nasty"
+    } 
+    err = assert_raise RuntimeError do
+      se.apply_method_call(@mock,'each_bean',[:side_slot],a_block)
+    end
+    assert_match(/nasty/i, err.message) 
+    assert_equal [:bean1], things, "Wrong things"
+  end
+
+  def test_yields_with_several_arrays
+    se = SimpleExpectation.new(:mock => @mock, :method => 'each_bean', :arguments => [:side_slot] )
+    se.yields ['a','b'], ['c','d']
+
+    things = []
+    a_block = lambda { |thinger| things << thinger } 
+
+    se.apply_method_call(@mock,'each_bean',[:side_slot],a_block)
+    assert_equal [ ['a','b'], ['c','d'] ], things, "Wrong things"
+  end
+
+  def test_yields_tuples
+    se = SimpleExpectation.new(:mock => @mock, :method => 'each_bean', :arguments => [:side_slot] )
+    se.yields ['a','b','c'], ['d','e','f']
+
+    things = []
+    a_block = lambda { |left,mid,right| 
+      things << { :left => left, :mid => mid, :right => right }
+    } 
+
+    se.apply_method_call(@mock,'each_bean',[:side_slot],a_block)
+    assert_equal [ 
+      {:left => 'a', :mid => 'b', :right => 'c' }, 
+      {:left => 'd', :mid => 'e', :right => 'f' },
+      ], things, "Wrong things"
+  end
+
+  def test_yields_tuples_size_mismatch
+    se = SimpleExpectation.new(:mock => @mock, :method => 'each_bean', :arguments => [:side_slot] )
+    se.yields ['a','b','c'], ['d','e','f']
+
+    things = []
+    a_block = lambda { |left,mid| 
+      things << { :left => left, :mid => mid }
+    } 
+
+    err = assert_raise ExpectationError do
+      se.apply_method_call(@mock,'each_bean',[:side_slot],a_block)
+    end
+    assert_match(/arity/i, err.message) 
+    assert_match(/the_mock.each_bean/i, err.message) 
+    assert_match(/"a", "b", "c"/i, err.message) 
+    assert_equal [], things, "Wrong things"
+  end
+end

data/vendor/hardmock/test/unit/trapper_test.rb

@@ -0,0 +1,60 @@
+require File.expand_path(File.dirname(__FILE__) + "/../test_helper")
+require 'hardmock'
+
+class TrapperTest < Test::Unit::TestCase
+
+  def setup
+    @mock = Object.new
+    @mock_control = MyControl.new
+    @builder = ExpBuilder.new
+    @trapper = Trapper.new(@mock, @mock_control, @builder)
+  end
+
+  #
+  # HELPERS
+  #
+   
+  class MyControl
+    attr_reader :added
+    def add_expectation(expectation)
+      @added ||= []
+      @added << expectation
+    end
+  end
+
+  class ExpBuilder
+    attr_reader :options
+    def build_expectation(options)
+      @options = options
+      "dummy expectation"
+    end
+  end
+
+  #
+  # TESTS
+  #
+
+  def test_method_missing
+
+    output = @trapper.change(:less)
+
+    assert_same @mock, @builder.options[:mock]
+    assert_equal :change, @builder.options[:method]
+    assert_equal [:less], @builder.options[:arguments]
+    assert_not_nil @builder.options[:block]
+    assert @builder.options[:suppress_arguments_to_block], ":suppress_arguments_to_block should be set"
+    assert_equal [ "dummy expectation" ], @mock_control.added,
+      "Wrong expectation added to control"
+
+    assert_equal "dummy expectation", output, "Expectation should have been returned"
+
+    # Examine the block.  It should take one argument and simply return
+    # that argument.  because of the 'suppress arguments to block' 
+    # setting, the argument can only end up being a block, in practice.
+    trapper_block = @builder.options[:block]
+    assert_equal "the argument", trapper_block.call("the argument"),
+      "The block should merely return the passed argument"
+  end
+
+
+end

data/vendor/hardmock/test/unit/verify_error_test.rb

@@ -0,0 +1,34 @@
+require File.expand_path(File.dirname(__FILE__) + "/../test_helper")
+require 'hardmock'
+
+class VerifyErrorTest < Test::Unit::TestCase
+
+  #
+  # TESTS
+  #
+
+  def test_formatted_list_of_unmet_expectations
+    mock1 = Mock.new('mock1')
+    mock2 = Mock.new('mock2')
+    exp1 = SimpleExpectation.new( :mock => mock1, :method => 'send_parts', :arguments => [1,2,:a] )
+    exp2 = SimpleExpectation.new( :mock => mock2, :method => 'grind_it', :arguments => [] )
+
+    exp_list = [ exp1, exp2 ]
+
+    err = VerifyError.new("This is the error", exp_list)
+    assert_equal "This is the error:\n * #{exp1.to_s}\n * #{exp2.to_s}", err.message
+  end
+
+  def test_empty_list_of_expectations
+    # this is not a normal case; not spending a lot of time to make this better
+    exp_list = []
+    err = VerifyError.new("This is the error:\n", exp_list)
+  end
+
+  def test_nil_expectation_list
+    # this is not a normal case; not spending a lot of time to make this better
+    exp_list = []
+    err = VerifyError.new("This is the error:\n", exp_list)
+  end
+
+end

data/vendor/systir/systir.rb

@@ -0,0 +1,403 @@
+#!/usr/bin/ruby
+
+# = DESCRIPTION
+#
+# Systir stands for "SYStem Testing In Ruby".  It's a framework for
+# automating system-level tests using domain-specific language, and contains
+# some tools and hints on how to construct and utilize your own domain language.
+#
+# The breakdown of using Systir for test automation is:
+# 1. Tester defines test steps using project- and technology-specific language.
+#    * Tests are written in files like +authentication+.+test+ and 
+#      +order_placement+.+test+
+# 2. The Toolsmith implements a driver to support the syntax of that language
+#    * In a project-specific module, the Toolsmith writes an extension of the 
+#      Systir::LanguageDriver class to support the macros used in *.test
+# 3. The Tester's "scripts" are gathered up by Systir, executed, and a report 
+#    is generated.
+#    * Toolsmith writes a short script which uses Systest::Launcher to compose 
+#      *.test files into a suite for execution.
+#
+# = TECHNICAL NOTE
+# Under the hood, Systir is an extension of Test::Unit.  The output from 
+# executing the test suite should therefor be familiar to a Ruby coder.  
+# Additionally, it might be educational to the Toolsmith to understand that 
+# LanguageDriver is a derivative of Test::Unit::TestCase, and that all *.test 
+# files become test methods inside the TestCase which is then composed as a 
+# Test::Unit::TestSuite
+# 
+
+require 'test/unit'
+require 'test/unit/ui/console/testrunner'
+require 'test/unit/ui/xml/testrunner'
+require 'find'
+require 'stringio'
+require 'ostruct'
+
+# This disables the auto-run-at-exit feature inside test/unit.rb:
+Test::Unit.run = true 
+
+module Test
+  module Unit
+    class TestResult
+      attr_reader :failures, :errors, :assertion_count
+			attr_accessor :output
+    end
+  end
+end
+
+#
+# Systir contains classes and modules to support writing and launching
+# high-level test scripts.
+#
+module Systir
+
+  VERSION = '0.5'
+
+  #
+  # Systir::LanguageDriver is a special derivative of TestCase designed to
+  # contain user code written to support more macro-fied testing scripts.
+  #
+  class LanguageDriver < Test::Unit::TestCase
+		attr_accessor :params
+
+    # == Description
+    # Installs a back-reference from this Driver instance into the specified Helper
+    # and returns a reference to that Helper.  Typically thismethod is called
+    # on the same line you return the helper from once it's built.
+    #
+    # == Params
+    # +helper+ :: The Helper instance you're handing control over to
+    #
+    # == Return
+    # The same +helper+ reference that was sent in as a parameter.
+    # 
+    # == Details
+    #
+    # Since Helpers are usually built as support for domain-level syntax,
+    # they usually require a direct reference to macro functions built into
+    # the driver.  Additionally, the Helper may need to make assertions
+    # defined in the driver, or test/unit itself, and only the Driver may
+    # count assertions; the Helper must use a special internal implementation
+    # of 'add_assertion' in order to increment the test's assertion count.
+    #
+    # Some aliases have been added to aid readability
+    #
+    def associate_helper(helper)
+      unless helper.respond_to? :driver=
+        raise "helper doesn't support 'driver=' method"
+      end
+      helper.driver = self
+      return helper
+    end
+    alias_method :return_helper, :associate_helper
+    alias_method :hand_off_to, :associate_helper
+
+    # (INTERNAL USE) 
+    # Sneaky trick to expose the private mix-in method +add_assertion+ from
+    # Test::Unit::Assertions.  Helpers derivatives that make assertions are
+    # able to have them counted because of this method.  
+    # (See associate_helper.)
+    def collect_assertion
+      add_assertion
+    end
+  end
+
+  # = Description 
+  #  Imports test scripts into the given driver class
+  # and produces a TestSuite ready for execution
+  class Builder
+    def initialize(driver_class)
+			raise 'driver class must be a Systir::LanguageDriver' unless driver_class < Systir::LanguageDriver
+      @driver_class = driver_class
+      remove_test_methods
+    end
+
+    # Read contents from_file, wrap text in 'def', 
+    # add the resulting code as a new method on the target driver class
+    def import_test(test)
+      # Transform the test script into a test method inside
+      # the driver class:
+      text = File.readlines(test.path)
+      text = "def test_#{test.fullname}\n#{text}\nend\n";
+
+      # Dynamically define the method:
+      @driver_class.class_eval(text, File.basename(test.path), 0)
+			test_case = @driver_class.new("test_#{test.fullname}")
+			test_case.params = test.params
+			test_case
+    end
+
+    def suite_for_directory(dir)
+			list = TestList.new
+      Find.find(dir) do |path|
+        if File.basename(path) =~ /\.test$/
+          list.add :test => path 
+        end
+        if File.directory? path
+          next
+        end
+      end
+      suite_for_test_list list
+    end
+
+    def suite_for_file(filename,params=nil)
+			list = TestList.new
+			list.add :test => filename, :params => params
+			suite_for_test_list list
+    end
+
+    def suite_for_list(file_list)
+			list = TestList.new
+			file_list.each do |path|
+				list.add :test => path
+			end
+			suite_for_test_list list
+    end
+
+		def suite_for_test_list(test_list)
+			suite = Test::Unit::TestSuite.new(@driver_class.name)
+			test_list.tests.each do |test|
+				suite << import_test(test)
+			end
+			suite
+		end
+
+    def remove_test_methods
+      methods = @driver_class.public_instance_methods.select { |m| 
+        m =~ /^test_/ 
+      }
+      methods.each do |method|
+        @driver_class.send(:undef_method,method)
+      end
+    end
+  end
+
+	class TestList #:nodoc:
+		attr_reader :tests
+
+		def initialize
+			@tests = []
+		end
+
+		def add(args)
+			test = OpenStruct.new
+			test.path = args[:test]
+			test.params = args[:params]
+			test.name = File.basename(test.path).sub(/\.test$/, '')
+			test.fullname = test.name + (args[:name_suffix] ? "_#{args[:name_suffix]}" : '')
+			@tests << test
+		end
+	end
+	
+  # = Description
+  # Launcher is the utility for launching Systir test scripts.
+  #
+  class Launcher
+		#
+		# Creates a new Launcher, the following arguments may be specified in a hash
+		# 
+		# :stdout - true or false, whether to send test reporting output to stdout (default true)
+		# :format - :console or :xml, format of test reporting output (default :xml)
+		#
+		# note: output is available via the TestResult returned from the following methods:
+		# * find_and_run_all_tests
+		# * run_test
+		# * run_test_list
+		# * run_suite
+		#
+    def initialize(args={})
+			@stdout = args[:stdout].nil? ? true : args[:stdout]
+      @format = args[:format].nil? ? :console : args[:format]
+    end
+
+    # 
+    # Find and run all the system test scripts in the given directory.
+    # Tests are identified by the .test file extension.
+    #
+    def find_and_run_all_tests(driver_class, dir='.')
+      raise 'dir cannot be nil' if dir.nil?
+      raise 'dir does not exist' unless File.directory?(dir)
+      b = Builder.new(driver_class)
+      execute b.suite_for_directory(dir)
+    end
+
+    #
+    # Run a specific test, optionally providing parameters to be available 
+		# within the driver instance.
+		#
+		#   Systir::Launcher.new.run_test(MyDriver, './tests/foo.test')
+		#
+		#   Systir::Launcher.new.run_test(MyDriver, './tests/foo.test', :opt1 => 'thinger', :another => 'bar')
+		# 
+		# given parameters are available via the <tt>params</tt> method on the 
+		# driver instance which returns the hash passed to run_test.
+		#
+		# returns TestResult
+    #
+    def run_test(driver_class, filename, params=nil)
+      raise 'filename cannot be nil' if filename.nil?
+      raise 'filename does not exist' unless File.exists?(filename)
+      b = Builder.new(driver_class)
+      execute b.suite_for_file(filename,params)
+    end
+
+    #
+    # Run a specific list of tests
+    #
+		# returns TestResult
+    #
+    def run_test_list(driver_class, file_list)
+      raise 'file_list cannot be nil' if file_list.nil?
+      raise 'file_list cannot be empty' if file_list.empty?
+      b = Builder.new(driver_class)
+      execute b.suite_for_list(file_list)
+    end
+
+		#
+		# Run a suite of tests defined by a given block.
+		#
+		#   launcher.run_suite(MyDriver) do |suite|
+		#     suite.add :test => './tests/run_me_twice.test'
+		#     suite.add :test => './tests/run_me_twice.test', :name_suffix => 'other_one'
+		#     suite.add :test => './tests/specific_parameters.test', :params => {:one => 'mine', :two => 'also mine'}
+		#   end
+		#
+		# :test - path to the systir test file
+		# :name_suffix - (optional) string appended to the end of the test name in 
+		#                this suite run.this option is useful when running multiple 
+		#                tests from the same file.
+		# :params - (optional) hash of parameters to be set on the driver instance
+		#           for the execution of this test
+		#
+		# returns TestResult
+    #
+		def run_suite(driver_class)
+			b = Builder.new(driver_class)
+			suite = TestList.new
+			yield suite
+			execute b.suite_for_test_list(suite)
+		end
+
+    #
+    # Use console test runner to execute the given suite
+    #
+    def execute(suite)
+      buffer = StringIO.new
+			ios = []
+			ios << STDOUT if @stdout
+			ios << buffer
+      io = MethodMulticaster.new(ios)
+			level = Test::Unit::UI::NORMAL
+
+      runner = case @format
+        when :console
+          Test::Unit::UI::Console::TestRunner
+        when :xml
+          Test::Unit::UI::XML::TestRunner
+        else
+          raise "don't know anything about runner: [#{@runner}]"
+      end
+
+			result = runner.new(suite, level, io).start
+      buffer.rewind
+      result.output = buffer.read
+      result
+    end
+  end
+
+  class MethodMulticaster #:nodoc:
+    def initialize(targets)
+      @targets = targets
+    end
+
+    def method_missing(method,*args)
+      @targets.each do |target|
+        target.send(method,*args)
+      end
+    end
+  end
+
+
+  # = DESCRIPTION 
+  # Systir::Helper is a module intended for mixing-in to classes defined 
+  # to assist a project-specific Systir::LanguageDriver.
+  # 
+  #
+  module Helper
+    include Test::Unit::Assertions
+
+    #
+    # Construct a new Helper with a back reference to the language driver.
+    # NOTE: the +driver+ argument is optional if you utilize <code>driver=</code>
+    # or Systir::LanguageDriver.associate_helper
+    # 
+    def initialize(driver=nil)
+      @_driver = driver
+    end
+
+    #
+    # Returns a reference to our owning LanguageDriver instance.
+    #
+    def driver
+      unless @_driver
+        raise "Implementation error: helper has no back reference to the language driver!" 
+      end
+      return @_driver
+    end
+
+    #
+    # Sets the owning reference to a LanguageDriver.
+    # This method is used by Systir::LanguageDriver#associate_helper.
+    #
+    def driver=(dr)
+      @_driver = dr
+    end
+
+    # == Description
+    # Installs a back-reference from this Driver instance into the specified Helper
+    # and returns a reference to that Helper.  Typically thismethod is called
+    # on the same line you return the helper from once it's built.
+    #
+    # == Params
+    # +helper+ :: The Helper instance you're handing control over to
+    #
+    # == Return
+    # The same +helper+ reference that was sent in as a parameter.
+    # 
+    # == Details
+    #
+    # Since Helpers are usually built as support for domain-level syntax,
+    # they usually require a direct reference to macro functions built into
+    # the driver.  Additionally, the Helper may need to make assertions
+    # defined in the driver, or test/unit itself, and only the Driver may
+    # count assertions; the Helper must use a special internal implementation
+    # of 'add_assertion' in order to increment the test's assertion count.
+    #
+    # Some aliases have been added to aid readability
+    #
+    def associate_helper(helper)
+      unless helper.respond_to? :driver=
+        raise "helper doesn't support 'driver=' method"
+      end
+      helper.driver = self.driver
+      return helper
+    end
+    alias_method :return_helper, :associate_helper
+    alias_method :hand_off_to, :associate_helper
+
+    # 
+    # Redirects assertion counting into our owning LanguageDriver.
+    # Assertions module will automatically attempt to store the count
+    # within a Helper otherwise, leading to incorrect results.
+    #
+    private
+    def add_assertion
+      unless driver.respond_to? :collect_assertion
+        raise "Implementation error: driver needs a 'collect_assertion' method"
+      end
+      driver.collect_assertion
+    end
+  end
+end
+