miniunit 1.1.0 → 1.2.0

data/.autotest

@@ -1,5 +1,13 @@
 # -*- ruby -*-
 
-Autotest.add_hook(:initialize) do |at|
-  at.libs.sub!(/lib:/, '')
+Autotest.add_hook :initialize do |at|
+  at.extra_class_map["MiniSpec"]             = "test/test_mini_spec.rb"
+  at.extra_class_map["TestMiniTestTestCase"] = "test/test_mini_test.rb"
+
+  at.add_exception 'coverage.info'
+  at.add_exception 'coverage'
 end
+
+require 'autotest/rcov'
+Autotest::RCov.command = 'rcov_info'
+

data/History.txt

@@ -1,16 +1,71 @@
-== 1.1.0 / 2007-11-08
+=== 1.2.0 / 2008-06-09
+
+* 2 major enhancements:
+
+  * Added Mini::Spec.
+  * Added Mini::Mock. Thanks Steven Baker!!
+
+* 23 minor enhancements:
+
+  * Added bin/use_miniunit to make it easy to test out miniunit.
+  * Added -n filtering, thanks to Phil Hagelberg!
+  * Added args argument to #run, takes ARGV from at_exit.
+  * Added test name output if $DEBUG.
+  * Added a refute (was deny) for every assert.
+  * Added capture_io and a bunch of nice assertions from zentest.
+  * Added deprecation mechanism for assert_no/not methods to test/unit/assertions.
+  * Added pp output when available.
+  * Added tests for all assertions. Pretty much maxed out coverage.
+  * Added tests to verify consistency and good naming.
+  * Aliased and deprecated all ugly assertions.
+  * Cleaned out test/unit. Moved autorun there.
+  * Code cleanup to make extensions easier. Thanks Chad!
+  * Got spec args reversed in all but a couple assertions. Much more readable.
+  * Improved error messages across the board. Adds your message to the default.
+  * Moved into Mini namespace, renamed to Mini::Test and Mini::Spec.
+  * Pulled the assertions into their own module...
+  * Removed as much code as I could while still maintaining full functionality.
+    * Moved filter_backtrace into MiniTest.
+    * Removed MiniTest::Unit::run. Unnecessary.
+    * Removed location_of_failure. Unnecessary.
+    * Rewrote test/unit's filter_backtrace. Flog from 37.0 to 18.1
+  * Removed assert_send. Google says it is never used.
+  * Renamed MiniTest::Unit.autotest to #run.
+  * Renamed deny to refute.
+  * Rewrote some ugly/confusing default assertion messages.
+  * assert_in_delta now defaults to 0.001 precision. Makes specs prettier.
+
+* 9 bug fixes:
+
+  * Fixed assert_raises to raise outside of the inner-begin/rescue.
+  * Fixed for ruby 1.9 and rubinius.
+  * No longer exits 0 if exception in code PRE-test run causes early exit.
+  * Removed implementors method list from mini/test.rb - too stale.
+  * assert_nothing_raised takes a class as an arg. wtf? STUPID
+  * ".EF" output is now unbuffered.
+  * Bunch of changes to get working with rails... UGH.
+    * Added stupid hacks to deal with rails not requiring their dependencies.
+    * Now bitch loudly if someone defines one of my classes instead of requiring.
+  * Fixed infect method to work better on 1.9.
+  * Fixed all shadowed variable warnings in 1.9.
+
+=== 1.1.0 / 2007-11-08
 
 * 4 major enhancements:
+
   * Finished writing all missing assertions.
   * Output matches original test/unit.
   * Documented every method needed by language implementor.
   * Fully switched over to self-testing setup.
+
 * 2 minor enhancements:
+
   * Added deny (assert ! test), our favorite extension to test/unit.
   * Added .autotest and fairly complete unit tests. (thanks Chad for help here)
 
-== 1.0.0 / 2006-10-30
+=== 1.0.0 / 2006-10-30
 
 * 1 major enhancement
+
   * Birthday!
 

data/Manifest.txt

@@ -3,7 +3,14 @@ History.txt
 Manifest.txt
 README.txt
 Rakefile
+bin/use_miniunit
+lib/mini/mock.rb
+lib/mini/spec.rb
+lib/mini/test.rb
 lib/test/unit.rb
+lib/test/unit/assertions.rb
+lib/test/unit/error.rb
 lib/test/unit/testcase.rb
-test/test_test_case.rb
-test/test_test_unit.rb
+test/test_mini_mock.rb
+test/test_mini_spec.rb
+test/test_mini_test.rb

data/README.txt

@@ -1,16 +1,25 @@
-miniunit by Ryan Davis
-    http://rubyforge.org/projects/bfts
+= mini/{test,spec,mock}
+
+* http://rubyforge.org/projects/bfts
 
 == DESCRIPTION:
 
-miniunit is a completely minimial drop-in replacement for ruby's
+mini/test is a completely minimial drop-in replacement for ruby's
 test/unit. This is meant to be clean and easy to use both as a regular
 test writer and for language implementors that need a minimal set of
 methods to bootstrap a working unit test suite.
 
+mini/spec is a functionally complete spec engine.
+
+mini/mock, by Steven Baker, is a beautifully tiny mock object framework.
+
 == FEATURES/PROBLEMS:
 
+* Contains mini/test - a simple and clean test system (301 lines!).
+* Contains mini/spec - a simple and clean spec system (52 lines!).
+* Contains mini/mock - a simple and clean mock system (35 lines!).
 * Fully test/unit compatible assertions.
+* Allows test/unit to be required, firing up an autorunner.
 * Incredibly small and fast runner, but no bells and whistles.
 * Incompatible at the runner level.
 
@@ -20,13 +29,13 @@ methods to bootstrap a working unit test suite.
 
 == INSTALL:
 
-+ sudo gem install miniunit or sudo rake install
++ sudo gem install miniunit
 
 == LICENSE:
 
 (The MIT License)
 
-Copyright (c) 2006-2007 Ryan Davis, Seattle.rb
+Copyright (c) Ryan Davis, Seattle.rb
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/Rakefile

@@ -4,32 +4,62 @@ $TESTING_MINIUNIT = true
 
 require 'rubygems'
 require 'hoe'
-require './lib/test/unit.rb'
-
-Hoe.new('miniunit', Test::Unit::VERSION) do |p|
-  p.rubyforge_name = 'bfts'
-  p.description = p.paragraphs_of('README.txt', 2).join("\n\n")
-  p.summary = p.description.split(/\. /)[0] + "."
-  p.url = p.paragraphs_of('README.txt', 0).first.split(/\n/)[1..-1]
-  p.changes = p.paragraphs_of('History.txt', 0..1).join("\n\n")
+require './lib/mini/test.rb'
+
+Hoe.new('miniunit', Mini::Test::VERSION) do |miniunit|
+  miniunit.rubyforge_name = "bfts"
+
+  miniunit.developer('Ryan Davis', 'ryand-ruby@zenspider.com')
 end
 
-task :sort do
-  begin
-    sh 'for f in lib/**/*.rb; do echo $f; grep "^ *def " $f | grep -v sort=skip > x; sort x > y; echo $f; echo; diff x y; done'
-    sh 'for f in test/test_*.rb; do echo $f; grep "^ *def.test_" $f > x; sort x > y; echo $f; echo; diff x y; done'
-  ensure
-    sh 'rm x y'
+begin
+  require 'rcov/rcovtask'
+  Rcov::RcovTask.new do |t|
+    t.verbose = true
+    t.rcov_opts << "--include-file lib/test"
+    t.rcov_opts << "--no-color"
   end
+
+  task :rcov_info do
+    pattern = ENV['PATTERN'] || "test/test_*.rb"
+    ruby "-Ilib -S rcov --text-report --include-file lib/test --save coverage.info #{pattern}"
+  end
+
+  task :rcov_overlay do
+    rcov, eol = Marshal.load(File.read("coverage.info")).last[ENV["FILE"]], 1
+    puts rcov[:lines].zip(rcov[:coverage]).map { |line, coverage|
+      bol, eol = eol, eol + line.length
+      [bol, eol, "#ffcccc"] unless coverage
+    }.compact.inspect
+  end
+rescue LoadError
+  # skip
+end
+
+def loc dir
+  system "find #{dir} -name \\*.rb | xargs wc -l | tail -1"
 end
 
-task :woot do
-  begin
-    system "ruby blah.rb > x; ruby -Ilib blah.rb > y"
-    system "diff -u x y > z"
-#   ensure
-#     rm_f "x", "y", "z"
+desc "stupid line count"
+task :dickwag do
+  puts
+  puts "miniunit"
+  puts
+  print " lib  loc"; loc "lib"
+  print " test loc"; loc "test"
+  print " totl loc"; loc "lib test"
+  print " flog = "; system "flog -s lib"
+
+  puts
+  puts "test/unit"
+  puts
+  Dir.chdir File.expand_path("~/Work/svn/ruby/ruby_1_8") do
+    print " lib  loc"; loc "lib/test"
+    print " test loc"; loc "test/testunit"
+    print " totl loc"; loc "lib/test test/testunit"
+    print " flog = "; system "flog -s lib/test"
   end
+  puts
 end
 
 # vim: syntax=Ruby

data/bin/use_miniunit

@@ -0,0 +1,23 @@
+#!/usr/bin/env ruby
+
+require 'rbconfig'
+
+use_miniunit = ARGV.shift
+sitelib = Config::CONFIG["sitelibdir"]
+projdir = File.dirname(File.dirname(File.expand_path(__FILE__)))
+minidir = File.join(projdir, "lib")
+
+case use_miniunit
+when /^y/ then
+  File.symlink File.join(minidir, "mini"), File.join(sitelib, "mini")
+  File.symlink File.join(minidir, "test"), File.join(sitelib, "test")
+  puts "Added links to #{sitelib}"
+when /^n/ then
+  File.unlink File.join(sitelib, "mini")
+  File.unlink File.join(sitelib, "test")
+  puts "Removed links from #{sitelib}"
+else
+  pgm = File.basename __FILE__
+  puts "usage: #{pgm} (yes|no)"
+  exit 1
+end

data/lib/mini/mock.rb

@@ -0,0 +1,31 @@
+class MockExpectationError < StandardError; end
+
+require 'mini/test'
+
+class Mini::Mock
+  def initialize
+    @expected_calls = {}
+    @actual_calls = Hash.new {|h,k| h[k] = [] }
+  end
+
+  def expect(name, retval, args=[])
+    n, r, a = name, retval, args # for the closure below
+    @expected_calls[name] = { :retval => retval, :args => args }
+    self.class.__send__(:define_method, name) { |*a|
+      raise ArgumentError unless @expected_calls[n][:args].size == a.size
+      @actual_calls[n] << { :retval => r, :args => a }
+      retval
+    }
+    self
+  end
+
+  def verify
+    @expected_calls.each_key do |name|
+      expected = @expected_calls[name]
+      msg = "expected #{name}, #{expected.inspect}"
+      raise MockExpectationError, msg unless
+        @actual_calls.has_key? name and @actual_calls[name].include?(expected)
+    end
+    true
+  end
+end

data/lib/mini/spec.rb

@@ -0,0 +1,81 @@
+#!/usr/bin/ruby -w
+
+require 'mini/test'
+
+class Module
+  def infect_with_assertions pos_prefix, neg_prefix, skip_re, map = {}
+    Mini::Assertions.public_instance_methods(false).each do |meth|
+      meth = meth.to_s
+
+      new_name = case meth
+                 when /^assert/ then
+                   meth.sub(/^assert/, pos_prefix.to_s)
+                 when /^refute/ then
+                   meth.sub(/^refute/, neg_prefix.to_s)
+                 end
+      next unless new_name
+      next if new_name =~ skip_re
+
+      regexp, replacement = map.find { |re, _| new_name =~ re }
+      new_name.sub! regexp, replacement if replacement
+
+      # warn "%-22p -> %p %p" % [meth, new_name, regexp]
+      self.class_eval <<-EOM
+        def #{new_name} *args, &block
+          return Mini::Spec.current.#{meth}(*args, &self)     if Proc === self
+          return Mini::Spec.current.#{meth}(args.first, self) if args.size == 1
+          return Mini::Spec.current.#{meth}(self, *args)
+        end
+      EOM
+    end
+  end
+end
+
+Object.infect_with_assertions(:must, :wont,
+                              /^(must|wont)$|wont_(throw)|must_(block|not?_|nothing)/,
+                              /(must_throw)s/                 => '\1',
+                              /(?!not)_same/                  => '_be_same_as',
+                              /_in_/                          => '_be_within_',
+                              /_operator/                     => '_be',
+                              /_includes/                     => '_include',
+                              /(must|wont)_(.*_of|nil|empty)/ => '\1_be_\2',
+                              /must_raises/                   => 'must_raise')
+
+class Object
+  alias :must_be_close_to :must_be_within_delta
+  alias :wont_be_close_to :wont_be_within_delta
+end
+
+module Kernel
+  def describe desc, &block
+    cls = Class.new(Mini::Spec)
+    Object.const_set desc.to_s.split(/\W+/).map { |s| s.capitalize }.join, cls
+
+    cls.class_eval(&block)
+  end
+end
+
+class Mini::Spec < Mini::Test::TestCase
+  def self.current
+    @@current_spec
+  end
+
+  def initialize name
+    super
+    @@current_spec = self
+  end
+
+  def self.before(type = :each, &block)
+    raise "unsupported before type: #{type}" unless type == :each
+    define_method :setup, &block
+  end
+
+  def self.after(type = :each, &block)
+    raise "unsupported after type: #{type}" unless type == :each
+    define_method :teardown, &block
+  end
+
+  def self.it desc, &block
+    define_method "test_#{desc.gsub(/\W+/, '_').downcase}", &block
+  end
+end

data/lib/mini/test.rb

@@ -0,0 +1,423 @@
+##
+#
+# Totally minimal drop-in replacement for test-unit
+#
+# TODO: refute -> debunk, prove/rebut, show/deny... lots of possibilities
+
+module Mini
+  class Assertion < Exception; end
+
+  file = if __FILE__ =~ /^[^\.]/ then # OMG ruby 1.9 is so lame (rubinius too)
+           require 'pathname'
+           pwd = Pathname.new(Dir.pwd)
+           pn = Pathname.new(File.expand_path(__FILE__))
+           pn = File.join(".", pn.relative_path_from(pwd)) unless pn.relative?
+           pn.to_s
+         else
+           __FILE__
+         end
+
+  MINI_DIR = File.dirname(File.dirname(file))
+
+  def self.filter_backtrace bt
+    return ["No backtrace"] unless bt
+
+    new_bt = []
+    bt.each do |line|
+      break if line.index(MINI_DIR) == 0
+      new_bt << line
+    end
+
+    new_bt = bt.reject { |line| line.index(MINI_DIR) == 0 } if
+      new_bt.empty?
+    new_bt = bt.dup if new_bt.empty?
+
+    new_bt
+  end
+
+  module Assertions
+    begin
+      require 'pp'
+      def mu_pp(obj)
+        PP.pp(obj, '').chomp
+      end
+    rescue LoadError
+      def mu_pp(obj)
+        obj.inspect
+      end
+    end
+
+    def _assertions= n
+      @_assertions = n
+    end
+
+    def _assertions
+      @_assertions ||= 0
+    end
+
+    def assert test, msg = nil
+      msg ||= "Failed assertion, no message given."
+      self._assertions += 1
+      raise Mini::Assertion, msg unless test
+      true
+    end
+
+    def assert_block msg = nil
+      msg = message msg, "Expected block to return true value"
+      assert yield, msg
+    end
+
+    def assert_empty obj, msg = nil
+      msg = message msg, "Expected #{obj.inspect} to be empty"
+      assert_respond_to obj, :empty?
+      assert obj.empty?, msg
+    end
+
+    def assert_equal exp, act, msg = nil
+      msg = message msg, "Expected #{mu_pp(exp)}, not #{mu_pp(act)}"
+      assert(exp == act, msg)
+    end
+
+    def assert_in_delta exp, act, delta = 0.001, msg = nil
+      n = (exp - act).abs
+      msg = message msg, "Expected #{exp} - #{act} (#{n}) to be < #{delta}"
+      assert delta > n, msg
+    end
+
+    def assert_in_epsilon a, b, epsilon = 0.001, msg = nil
+      assert_in_delta a, b, [a, b].min * epsilon, msg
+    end
+
+    def assert_includes collection, obj, msg = nil
+      msg = message msg, "Expected #{mu_pp(collection)} to include #{mu_pp(obj)}"
+      assert_respond_to collection, :include?
+      assert collection.include?(obj), msg
+    end
+
+    def assert_instance_of cls, obj, msg = nil
+      msg = message msg, "Expected #{mu_pp(obj)} to be an instance of #{cls}"
+      flip = (Module === obj) && ! (Module === cls) # HACK for specs
+      obj, cls = cls, obj if flip
+      assert cls === obj, msg
+    end
+
+    def assert_kind_of cls, obj, msg = nil # TODO: merge with instance_of
+      msg = message msg, "Expected #{mu_pp(obj)} to be a kind of #{cls}"
+      flip = (Module === obj) && ! (Module === cls) # HACK for specs
+      obj, cls = cls, obj if flip
+      assert obj.kind_of?(cls), msg
+    end
+
+    def assert_match exp, act, msg = nil
+      msg = message msg, "Expected #{mu_pp(act)} to match #{mu_pp(exp)}"
+      assert act =~ exp, msg
+    end
+
+    def assert_nil obj, msg = nil
+      msg = message msg, "Expected #{mu_pp(obj)} to be nil"
+      assert obj.nil?, msg
+    end
+
+    def assert_operator o1, op, o2, msg = nil
+      msg = message msg, "Expected #{mu_pp(o1)} to be #{op} #{mu_pp(o2)}"
+      assert o1.__send__(op, o2), msg
+    end
+
+    def assert_raises *exp
+      msg = String === exp.last ? exp.pop : nil
+      should_raise = false
+      begin
+        yield
+        should_raise = true
+      rescue Exception => e
+        assert_includes exp, e.class
+        exception_details(e, "<#{mu_pp(exp)}> exception expected, not")
+        return e
+      end
+
+      exp = exp.first if exp.size == 1
+      flunk "#{mu_pp(exp)} expected but nothing was raised." if should_raise
+    end
+
+    def assert_respond_to obj, meth, msg = nil
+      msg = message msg, "Expected #{mu_pp(obj)} to respond to #{meth}"
+      flip = (Symbol === obj) && ! (Symbol === meth) # HACK for specs
+      obj, meth = meth, obj if flip
+      assert obj.respond_to?(meth), msg
+    end
+
+    def assert_same exp, act, msg = nil
+      msg = message msg, "Expected #{mu_pp(act)} to be the same as #{mu_pp(exp)}"
+      assert exp.equal?(act), msg
+    end
+
+    def assert_throws sym, msg = nil
+      default = "Expected #{mu_pp(sym)} to have been thrown"
+      caught = true
+      catch(sym) do
+        begin
+          yield
+        rescue ArgumentError => e     # 1.9 exception
+          default += ", not #{e.message.split(/ /).last}"
+        rescue NameError => e         # 1.8 exception
+          default += ", not #{e.name.inspect}"
+        end
+        caught = false
+      end
+
+      assert caught, message(msg, default)
+    end
+
+    def capture_io
+      require 'stringio'
+
+      orig_stdout, orig_stderr         = $stdout.dup, $stderr.dup
+      captured_stdout, captured_stderr = StringIO.new, StringIO.new
+      $stdout, $stderr                 = captured_stdout, captured_stderr
+
+      yield
+
+      return captured_stdout.string, captured_stderr.string
+    ensure
+      $stdout = orig_stdout
+      $stderr = orig_stderr
+    end
+
+    def exception_details e, msg
+      "#{msg}\nClass: <#{e.class}>\nMessage: <#{e.message.inspect}>\n---Backtrace---\n#{Mini::filter_backtrace(e.backtrace).join("\n")}\n---------------"
+    end
+
+    def fail msg = nil
+      msg ||= "Epic Fail!"
+      assert false, msg
+    end
+
+    alias :flunk :fail
+
+    def message msg, default
+      if msg then
+        msg += '.' unless msg.empty?
+        msg += "\n#{default}."
+        msg.strip
+      else
+        "#{default}."
+      end
+    end
+
+    # used for counting assertions
+    def pass msg = nil
+      assert true
+    end
+
+    def refute test, msg = nil
+      msg ||= "Failed refutation, no message given"
+      not assert(! test, msg)
+    end
+
+    def refute_empty obj, msg = nil
+      msg = message msg, "Expected #{obj.inspect} to not be empty"
+      assert_respond_to obj, :empty?
+      refute obj.empty?, msg
+    end
+
+    def refute_equal exp, act, msg = nil
+      msg = message msg, "Expected #{mu_pp(act)} to not be equal to #{mu_pp(exp)}"
+      refute exp == act, msg
+    end
+
+    def refute_in_delta exp, act, delta = 0.001, msg = nil
+      n = (exp - act).abs
+      msg = message msg, "Expected #{exp} - #{act} (#{n}) to not be < #{delta}"
+      refute delta > n, msg
+    end
+
+    def refute_in_epsilon a, b, epsilon = 0.001, msg = nil
+      refute_in_delta a, b, a * epsilon, msg
+    end
+
+    def refute_includes collection, obj, msg = nil
+      msg = message msg, "Expected #{mu_pp(collection)} to not include #{mu_pp(obj)}"
+      assert_respond_to collection, :include?
+      refute collection.include?(obj), msg
+    end
+
+    def refute_instance_of cls, obj, msg = nil
+      msg = message msg, "Expected #{mu_pp(obj)} to not be an instance of #{cls}"
+      flip = (Module === obj) && ! (Module === cls) # HACK for specs
+      obj, cls = cls, obj if flip
+      refute cls === obj, msg
+    end
+
+    def refute_kind_of cls, obj, msg = nil # TODO: merge with instance_of
+      msg = message msg, "Expected #{mu_pp(obj)} to not be a kind of #{cls}"
+      flip = (Module === obj) && ! (Module === cls) # HACK for specs
+      obj, cls = cls, obj if flip
+      refute obj.kind_of?(cls), msg
+    end
+
+    def refute_match exp, act, msg = nil
+      msg = message msg, "Expected #{mu_pp(act)} to not match #{mu_pp(exp)}"
+      refute act =~ exp, msg
+    end
+
+    def refute_nil obj, msg = nil
+      msg = message msg, "Expected #{mu_pp(obj)} to not be nil"
+      refute obj.nil?, msg
+    end
+
+    def refute_operator o1, op, o2, msg = nil
+      msg = message msg, "Expected #{mu_pp(o1)} to not be #{op} #{mu_pp(o2)}"
+      refute o1.__send__(op, o2), msg
+    end
+
+    def refute_respond_to obj, meth, msg = nil
+      msg = message msg, "Expected #{mu_pp(obj)} to not respond to #{meth}"
+      flip = (Symbol === obj) && ! (Symbol === meth) # HACK for specs
+      obj, meth = meth, obj if flip
+      refute obj.respond_to?(meth), msg
+    end
+
+    def refute_same exp, act, msg = nil
+      msg = message msg, "Expected #{mu_pp(act)} to not be the same as #{mu_pp(exp)}"
+      refute exp.equal?(act), msg
+    end
+  end
+
+  class Test
+    VERSION = "1.2.0"
+
+    attr_reader :report, :failures, :errors
+
+    @@installed_at_exit ||= false
+    @@out = $stdout
+
+    def self.autorun
+      at_exit {
+        exit_code = Mini::Test.new.run(ARGV)
+        exit exit_code if exit_code
+      } unless @@installed_at_exit
+      @@installed_at_exit = true
+    end
+
+    def self.output= stream
+      @@out = stream
+    end
+
+    def puke klass, meth, e
+      if Mini::Assertion === e then
+        @failures += 1
+
+        loc = e.backtrace.find { |s| s !~ /in .(assert|flunk|pass|fail|raise)/ }
+        loc.sub!(/:in .*$/, '')
+
+        @report << "Failure:\n#{meth}(#{klass}) [#{loc}]:\n#{e.message}\n"
+        'F'
+      else
+        @errors += 1
+        bt = Mini::filter_backtrace(e.backtrace).join("\n    ")
+        e = "Error:\n#{meth}(#{klass}):\n#{e.class}: #{e.message}\n    #{bt}\n"
+        @report << e
+        'E'
+      end
+    end
+
+    def initialize
+      @report = []
+      @errors = @failures = 0
+    end
+
+    ##
+    # Top level driver, controls all output and filtering.
+
+    def run args
+      filter = if args.first =~ /^(-n|--name)$/ then
+                 args.shift
+                 arg = args.shift
+                 arg =~ /\/(.*)\// ? Regexp.new($1) : arg
+               else
+                 /./ # anything - ^test_ already filtered by #tests
+               end
+
+      @@out.puts "Loaded suite #{$0.sub(/\.rb$/, '')}\nStarted"
+
+      start = Time.now
+      run_test_suites filter
+
+      @@out.puts
+      @@out.puts "Finished in #{'%.6f' % (Time.now - start)} seconds."
+
+      @report.each_with_index do |msg, i|
+        @@out.puts "\n%3d) %s" % [i + 1, msg]
+      end
+
+      @@out.puts
+
+      format = "%d tests, %d assertions, %d failures, %d errors"
+      @@out.puts format % [@test_count, @assertion_count, failures, errors]
+
+      return failures + errors if @test_count > 0 # or return nil...
+    end
+
+    def run_test_suites filter = /^test/
+      @test_count, @assertion_count = 0, 0
+      old_sync, @@out.sync = @@out.sync, true if @@out.respond_to? :sync=
+      TestCase.test_suites.each do |suite|
+        suite.test_methods.grep(filter).each do |test|
+          inst = suite.new test
+          inst._assertions = 0
+          @@out.puts "\n#{test}: " if $DEBUG
+          result = '.'
+          begin
+            inst.setup
+            inst.__send__ test
+          rescue Exception => e
+            result = puke(suite, test, e)
+          ensure
+            begin
+              inst.teardown
+            rescue Exception => e
+              result = puke(suite, test, e)
+            end
+          end
+          @@out.print result
+          @@out.puts if $DEBUG
+          @test_count += 1
+          @assertion_count += inst._assertions
+        end
+      end
+      @@out.sync = old_sync if @@out.respond_to? :sync=
+      [@test_count, @assertion_count]
+    end
+
+    class TestCase
+      attr_reader :name
+
+      def initialize name
+        @name = name
+      end
+
+      def self.reset
+        @@test_suites = {}
+      end
+
+      reset
+
+      def self.inherited klass
+        @@test_suites[klass] = true
+      end
+
+      def self.test_suites
+        @@test_suites.keys.sort_by { |ts| ts.name }
+      end
+
+      def self.test_methods
+        public_instance_methods(true).grep(/^test/).sort.map { |m| m.to_s }
+      end
+
+      def setup; end
+      def teardown; end
+
+      include Mini::Assertions
+    end # class TestCase
+  end # class Test
+end # module Mini