miniunit 1.0.0 → 1.1.0

data/.autotest

@@ -0,0 +1,5 @@
+# -*- ruby -*-
+
+Autotest.add_hook(:initialize) do |at|
+  at.libs.sub!(/lib:/, '')
+end

data/History.txt

@@ -1,3 +1,14 @@
+== 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 major enhancement

data/Manifest.txt

@@ -1,6 +1,9 @@
+.autotest
 History.txt
 Manifest.txt
 README.txt
 Rakefile
 lib/test/unit.rb
 lib/test/unit/testcase.rb
+test/test_test_case.rb
+test/test_test_unit.rb

data/README.txt

@@ -4,13 +4,15 @@ miniunit by Ryan Davis
 == DESCRIPTION:
 
 miniunit is a completely minimial drop-in replacement for ruby's
-test/unit. This is meant for language implementors to have a minimal
-set of methods to bootstrap a working unit test suite.
+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.
 
 == FEATURES/PROBLEMS:
 
-* Assertions are not yet complete, but enough for what we've ported
-  from rubicon/rubytest.
+* Fully test/unit compatible assertions.
+* Incredibly small and fast runner, but no bells and whistles.
+* Incompatible at the runner level.
 
 == REQUIREMENTS:
 
@@ -24,7 +26,7 @@ set of methods to bootstrap a working unit test suite.
 
 (The MIT License)
 
-Copyright (c) 2006 Ryan Davis, Seattle.rb
+Copyright (c) 2006-2007 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

@@ -1,5 +1,7 @@
 # -*- ruby -*-
 
+$TESTING_MINIUNIT = true
+
 require 'rubygems'
 require 'hoe'
 require './lib/test/unit.rb'
@@ -12,4 +14,22 @@ Hoe.new('miniunit', Test::Unit::VERSION) do |p|
   p.changes = p.paragraphs_of('History.txt', 0..1).join("\n\n")
 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'
+  end
+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"
+  end
+end
+
 # vim: syntax=Ruby

data/lib/test/unit.rb

@@ -2,101 +2,303 @@
 # Totally minimal (hopefully) drop-in replacement for test/unit
 #
 
-# TODO: document minimal core methods needed for this to work
+# Minimal methods needed to run full miniunit + assert:
+#
+# Array: each, grep, join, size
+# Class: new, inherited
+# Enumerable: find
+# Exception: backtrace, message
+# Fixnum: +
+# Hash: keys
+# Kernel: at_exit
+# Module: ===, public_instance_methods
+# Object: __send__, class, inspect
+# String: sub, %
+# Regexp: =~
+
+# Only needed for specific assertions:
+#
+# Array.last
+# Enumerable.include?
+# Float: abs
+# Object: ==, inspect, equal?, kind_of?, nil?, respond_to?
+# Numeric: to_f, <, -
+
+$TESTING_MINIUNIT ||= false
 
-at_exit { Test::Unit.autotest }
+at_exit { exit MiniTest::Unit.autotest } unless $TESTING_MINIUNIT
 
-module Test
+MINIUNIT_FILE_SEPARATORS = %r{[\\/:]}
+MINIUNIT_PREFIX = __FILE__.split(MINIUNIT_FILE_SEPARATORS)[0..-3]
+MINIUNIT_RB_FILE = /\.rb\Z/
+
+def filter_backtrace(backtrace, prefix=nil)
+  return ["No backtrace"] unless(backtrace)
+  return backtrace if $TESTING_MINIUNIT
+  split_p = if(prefix)
+              prefix.split(MINIUNIT_FILE_SEPARATORS)
+            else
+              MINIUNIT_PREFIX
+            end
+  match = proc do |e|
+    split_e = e.split(MINIUNIT_FILE_SEPARATORS)[0, split_p.size]
+    next false unless(split_e[0..-2] == split_p[0..-2])
+    split_e[-1].sub(MINIUNIT_RB_FILE, '') == split_p[-1]
+  end
+  return backtrace unless(backtrace.detect(&match))
+  found_prefix = false
+  new_backtrace = backtrace.reverse.reject do |e|
+    if(match[e])
+      found_prefix = true
+      true
+    elsif(found_prefix)
+      false
+    else
+      true
+    end
+  end.reverse
+  new_backtrace = (new_backtrace.empty? ? backtrace : new_backtrace)
+  new_backtrace = new_backtrace.reject(&match)
+  new_backtrace.empty? ? backtrace : new_backtrace
+end
+
+module MiniTest
   class Assertion < Exception; end
 
   class Unit
-    VERSION = "1.0.0"
+    VERSION = "1.1.0"
+
+    attr_reader :report
+
+    @@out = $stdout
+
+    def self.output= stream
+      @@out = stream
+    end
 
     def self.autotest
-      ObjectSpace.each_object(Class) do |klass|
-        next unless klass < Test::Unit::TestCase
+      self.new.autotest
+    end
+
+    def self.tests_from(klass)
+      klass.public_instance_methods(true).grep(/^test/).sort
+    end
+
+    def self.location_of_failure(e)
+      e.backtrace.find { |s|
+        s !~ /in .(assert|flunk)/
+      }.sub(/:in .*$/, '')
+    end
+
+    def puke(klass, meth, e)
+      if MiniTest::Assertion === e then
+        @results[:failures] += 1
+        loc = self.class.location_of_failure(e)
+        @report << "Failure:\n#{meth}(#{klass}) [#{loc}]:\n#{e.message}\n"
+        'F'
+      else
+        @results[:errors] += 1
+        bt = filter_backtrace(e.backtrace).join("\n    ")
+        @report << "Error:\n#{meth}(#{klass}):\n#{e.class}: #{e.message}\n    #{bt}\n"
+        'E'
+      end
+    end
+
+    def initialize
+      @report = []
+      @results = {:errors => 0, :failures => 0}
+    end
+
+    def autotest
+      @@out.puts "Loaded suite #{$0.sub(/\.rb$/, '')}\nStarted"
+
+      timestamp_before_test_run = Time.now
+      test_count, assertion_count = run_test_suites
+
+      @@out.puts
+      @@out.puts "Finished in #{'%.6f' % (Time.now - timestamp_before_test_run)} seconds."
+
+      @report.each_with_index do |msg, i|
+        @@out.puts "\n%3d) %s" % [i + 1, msg]
+      end
+
+      @@out.puts
+      @@out.puts "%d tests, %d assertions, %d failures, %d errors" % [test_count, assertion_count, failures, errors]
+
+      return failures + errors
+    end
+
+    def run_test_suites
+      test_count, assertion_count = 0, 0
+      TestCase.test_suites.each do |klass|
         inst = klass.new
-        klass.public_instance_methods(true).each do |meth|
-          next unless meth.index("test") == 0
+        inst._assertions = 0
+        tests = self.class.tests_from(klass)
+        tests.each do |meth|
+          result = '.'
           begin
             inst.setup
-            inst.send meth.intern
-            inst.teardown
+            inst.__send__ meth
           rescue Exception => e
-            # TODO: make output compatible with unit_diff
-            print "\n", (Test::Assertion === e ? "Failure: " : "Error: ")
-            puts "#{klass}.#{meth}: #{e}"
-            puts e.backtrace
+            result = puke(klass, meth, e)
+          ensure
+            begin
+              inst.teardown
+            rescue Exception => e
+              result = puke(klass, meth, e)
+            end
           end
+          @@out.print result
         end
+        test_count += tests.size
+        assertion_count += inst._assertions
       end
+      [test_count, assertion_count]
+    end
+
+    def failures
+      @results[:failures]
+    end
+
+    def errors
+      @results[:errors]
     end
 
     class TestCase
+      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
+
+      attr_accessor :_assertions
       def setup; end
       def teardown; end
 
-      def assert(test, msg="failed assertion (no message given)")
-        raise Test::Assertion, msg unless test
+      def _increment_assertions
+        @_assertions ||= 0
+        @_assertions += 1
+      end
+
+      def assert test, msg = "failed assertion (no message given)"
+        _increment_assertions
+        raise MiniTest::Assertion, msg unless test
+      end
+
+      def assert_block msg = "assert_block failed."
+        assert yield, msg
+      end
+
+      def assert_equal exp, act, msg = ""
+        msg += '.' unless msg.empty?
+        assert exp == act, "#{msg}\n<#{exp.inspect}> expected but was\n<#{act.inspect}>.".strip
       end
 
-      def assert_equal(exp, act, msg=nil)
-        assert exp == act, msg || "Expected #{act.inspect} to be equal to #{exp.inspect}"
+      def assert_in_delta exp, act, delta, msg = "Expected #{exp} to be within #{delta} of #{act}"
+        assert delta.to_f > (exp.to_f - act.to_f).abs, msg
       end
 
-      def assert_in_delta(exp, act, delta, msg=nil)
-        assert((exp.to_f - act.to_f).abs <= delta.to_f, msg || "Expected #{exp} to be within #{delta} of #{act}")
+      def assert_instance_of cls, obj, msg = "Expected #{obj.inspect} to be an instance of #{cls}"
+        assert cls === obj, msg
       end
 
-      def assert_instance_of(cls, obj, msg=nil)
-        assert cls === obj, msg || "Expected #{obj} to be a #{cls}"
+      def assert_kind_of cls, obj, msg = "Expected #{obj.inspect} to be a kind of #{cls}"
+        assert obj.kind_of?(cls), msg
       end
 
-      def assert_kind_of(cls, obj, msg=nil)
-        assert obj.kind_of?(cls), msg || "Expected #{obj.inspect} to be a kind of #{cls}"
+      def assert_match exp, act, msg = "Expected #{act.inspect} to match #{exp.inspect}"
+        assert act =~ exp, msg
       end
 
-      def assert_match(exp, act, msg=nil)
-        assert act =~ exp, msg || "Expected #{act.inspect} to match #{exp.inspect}"
+      def assert_nil obj, msg = "Expected #{obj.inspect} to be nil"
+        assert obj.nil?, msg
       end
 
-      def assert_nil(obj, msg=nil)
-        assert obj.nil?, msg || "Expected #{obj.inspect} to be nil"
+      def assert_no_match exp, act, msg = "Expected #{act.inspect} to not match #{exp.inspect}"
+        assert act !~ exp, msg
       end
 
-      def assert_not_equal(exp, act, msg=nil)
-        assert exp != act, msg || "Expected #{act.inspect} to not be equal to #{exp.inspect}"
+      def assert_not_equal exp, act, msg = "Expected #{act.inspect} to not be equal to #{exp.inspect}"
+        assert exp != act, msg
        end
 
-      def assert_not_nil(obj, msg=nil)
-        assert ! obj.nil?, msg || "Expected #{obj.inspect} to not be nil"
+      def assert_not_nil obj, msg = "Expected #{obj.inspect} to not be nil"
+        assert ! obj.nil?, msg
+      end
+
+      def assert_not_same exp, act, msg = "Expected #{act.inspect} to not be the same as #{exp.inspect}"
+        assert ! exp.equal?(act), msg
+      end
+
+      def assert_nothing_raised
+        _increment_assertions
+        yield
+      rescue => e
+        raise MiniTest::Assertion, exception_details(e, "Exception raised:")
+      end
+
+      alias :assert_nothing_thrown :assert_nothing_raised
+
+      def assert_operator o1, op, o2, msg = "<#{o1.inspect}> expected to be\n#{op.inspect}\n<#{o2.inspect}>."
+        assert o1.__send__(op, o2), msg
       end
 
-      def assert_not_same(exp, act, msg=nil)
-        assert ! exp.equal?(act), msg || "Expected #{act.inspect} to not be the same as #{exp.inspect}"
+      def exception_details e, msg
+        "#{msg}\nClass: <#{e.class}>\nMessage: <#{e.message.inspect}>\n---Backtrace---\n#{filter_backtrace(e.backtrace).join("\n")}\n---------------"
       end
 
-      def assert_raises(exp, msg=nil)
+      def assert_raises *exp
+        msg = String === exp.last ? exp.pop : nil
+        exp = exp.first if exp.size == 1
         begin
           yield
-          assert false, "Expected #{exp} to be raised"
+          raise MiniTest::Assertion, "<#{exp.inspect}> exception expected but none was thrown."
         rescue Exception => e
-          assert exp === e, msg || "Expected #{exp} to be raised, but got #{e.class}"
+          assert((Array === exp ? exp.include?(e) : exp === e),
+                 exception_details(e,
+                                   "<#{exp.inspect}> exception expected but was"))
+
           return e
         end
       end
       alias :assert_raise :assert_raises
 
-      def assert_same(exp, act, msg=nil)
-        assert exp.equal?(act), msg || "Expected #{act.inspect} to be the same as #{exp.inspect}"
+      def assert_respond_to obj, meth, msg = "Expected #{obj.inspect} of type #{obj.class} to respond_to? #{meth.inspect}"
+        assert obj.respond_to?(meth), msg
       end
 
-      def assert_operator(o1, op, o2, msg="")
-        assert o1.__send__(op, o2), msg || "Expected #{o1}.#{op}(#{o2}) to be true"
+      def assert_same exp, act, msg = "Expected #{act.inspect} to be the same as #{exp.inspect}."
+        assert exp.equal?(act), msg
       end
 
-      def assert_nothing_raised; yield; end
+      def assert_send send, msg = nil
+        recv, meth, *args = send
+        assert(recv.__send__(meth, *args),
+               msg || "<#{recv.inspect}> expected to respond to\n<#{meth.inspect}> with a true value.")
+      end
 
+      def assert_throws sym, msg = "<#{sym.inspect}> should have been thrown."
+        caught = true
+        catch(sym) do
+          yield rescue nil
+          caught = false
+        end
+        assert caught, msg
+      end
+
+      def flunk msg = "Flunked"
+        assert false, msg
+      end
     end # class TestCase
   end # class Unit
-end # module Test
+end # module MiniTest
+
+Test = MiniTest unless defined? Test

data/lib/test/unit/testcase.rb

@@ -1,2 +1,7 @@
 # don't define anything, this is just so we don't get the real one
 
+$TEST_UNIT_TESTCASE_DEPRECATION ||= false
+
+warn "require 'test/unit/testcase' has been deprecated" unless $TEST_UNIT_TESTCASE_DEPRECATION
+
+$TEST_UNIT_TESTCASE_DEPRECATION = true

data/test/test_test_case.rb

@@ -0,0 +1,321 @@
+#!/usr/local/bin/ruby -w
+
+$TESTING_TEST_UNIT = true
+
+require 'test/unit'
+
+# TODO: add message versions
+class TestTestCase < MiniTest::Unit::TestCase
+  def setup
+    util_test_suites.clear
+    @tc = MiniTest::Unit::TestCase.new
+    @zomg = "zomg ponies!"
+    @assertion_count = 1
+  end
+
+  def teardown
+    assert_equal @assertion_count, @tc._assertions if @tc._assertions
+    Object.send :remove_const, :ATestCase if defined? ATestCase
+  end
+
+  def test_class_inherited
+    util_test_case
+    assert util_test_suites[ATestCase]
+  end
+
+  def test_class_test_suites
+    util_test_case
+    assert_equal 1, MiniTest::Unit::TestCase.test_suites.size
+    assert_equal [ATestCase], MiniTest::Unit::TestCase.test_suites
+  end
+
+  def test_assert
+    @tc.assert true
+    @tc.assert true, "message"
+    @assertion_count = 2
+  end
+
+  def test_assert_triggered
+    util_assert_triggered "failed assertion (no message given)" do
+      @tc.assert false
+    end
+  end
+
+  def test_assert_triggered_message
+    util_assert_triggered @zomg do
+      @tc.assert false, @zomg
+    end
+  end
+
+  def test_assert_block
+    @tc.assert_block do
+      true
+    end
+  end
+
+  def test_assert_block_triggered
+    util_assert_triggered 'assert_block failed.' do
+      @tc.assert_block do
+        false
+      end
+    end
+  end
+
+  def test_assert_equal
+    @tc.assert_equal 1, 1
+  end
+
+  def test_assert_equal_triggered
+    util_assert_triggered "<1> expected but was\n<2>." do
+      @tc.assert_equal 1, 2
+    end
+  end
+
+  def test_assert_in_delta
+    @tc.assert_in_delta 0.0, 1.0 / 1000, 0.1
+  end
+
+  def test_assert_in_delta_triggered
+    util_assert_triggered 'Expected 0.0 to be within 1.0e-06 of 0.001' do
+      @tc.assert_in_delta 0.0, 1.0 / 1000, 0.000001
+    end
+  end
+
+  def test_assert_instance_of
+    @tc.assert_instance_of String, "blah"
+  end
+
+  def test_assert_instance_of_triggered
+    util_assert_triggered 'Expected "blah" to be an instance of Array' do
+      @tc.assert_instance_of Array, "blah"
+    end
+  end
+
+  def test_assert_kind_of
+    @tc.assert_kind_of String, "blah"
+  end
+
+  def test_assert_kind_of_triggered
+    util_assert_triggered 'Expected "blah" to be a kind of Array' do
+      @tc.assert_kind_of Array, "blah"
+    end
+  end
+
+  def test_assert_match
+    @tc.assert_match "blah blah blah", /\w+/
+  end
+
+  def test_assert_match_triggered
+    util_assert_triggered 'Expected /\d+/ to match "blah blah blah"' do
+      @tc.assert_match "blah blah blah", /\d+/
+    end
+  end
+
+  def test_assert_nil
+    @tc.assert_nil nil
+  end
+
+  def test_assert_nil_triggered
+    util_assert_triggered 'Expected 42 to be nil' do
+      @tc.assert_nil 42
+    end
+  end
+
+  def test_assert_no_match
+    @tc.assert_no_match "blah blah blah", /\d+/
+  end
+
+  def test_assert_no_match_triggered
+    util_assert_triggered 'Expected /\w+/ to not match "blah blah blah"' do
+      @tc.assert_no_match "blah blah blah", /\w+/
+    end
+  end
+
+  def test_assert_not_equal
+    @tc.assert_not_equal "blah", "yay"
+  end
+
+  def test_assert_not_equal_triggered
+    util_assert_triggered 'Expected "blah" to not be equal to "blah"' do
+      @tc.assert_not_equal "blah", "blah"
+    end
+  end
+
+  def test_assert_not_nil
+    @tc.assert_not_nil 42
+  end
+
+  def test_assert_not_nil_triggered
+    util_assert_triggered 'Expected nil to not be nil' do
+      @tc.assert_not_nil nil
+    end
+  end
+
+  def test_assert_not_same
+    @tc.assert_not_same 1, 2
+  end
+
+  # TODO: "with id <id>" crap from assertions.rb
+  def test_assert_not_same_triggered
+    util_assert_triggered 'Expected 1 to not be the same as 1' do
+      @tc.assert_not_same 1, 1
+    end
+  end
+
+  def test_assert_nothing_raised
+    @tc.assert_nothing_raised do
+      # do nothing
+    end
+  end
+
+  def test_assert_nothing_raised_triggered
+    expected = 'Exception raised:
+Class: <RuntimeError>
+Message: <"oops!">
+---Backtrace---'
+
+    util_assert_triggered expected do
+      @tc.assert_nothing_raised do
+        raise "oops!"
+      end
+    end
+  end
+
+  def test_assert_operator
+    @tc.assert_operator 2, :>, 1
+  end
+
+  def test_assert_operator_triggered
+    util_assert_triggered "<2> expected to be\n:<\n<1>." do
+      @tc.assert_operator 2, :<, 1
+    end
+  end
+
+  def test_assert_raises
+    @tc.assert_raises RuntimeError do
+      raise "blah"
+    end
+  end
+
+  def test_assert_raises_triggered_none
+    e = @tc.assert_raises MiniTest::Assertion do
+      # do nothing
+    end
+
+    expected = "<MiniTest::Assertion> exception expected but none was thrown."
+
+    assert_equal expected, e.message
+    # @assertion_count = 2
+  end
+
+  def test_assert_raises_triggered_wrong
+    e = assert_raises(MiniTest::Assertion) do
+      @tc.assert_raises RuntimeError do
+        raise SyntaxError, "icky"
+      end
+    end
+
+    expected = "<RuntimeError> exception expected but was
+Class: <SyntaxError>
+Message: <\"icky\">
+---Backtrace---"
+
+    assert_equal expected, e.message.sub(/(---Backtrace---).*/m, '\1')
+  end
+
+  def test_assert_respond_to
+    @tc.assert_respond_to "blah", :empty?
+  end
+
+  def test_assert_respond_to_triggered
+    util_assert_triggered 'Expected "blah" of type String to respond_to? :rawr!' do
+      @tc.assert_respond_to "blah", :rawr!
+    end
+  end
+
+  def test_assert_same
+    o = "blah"
+    @tc.assert_same 1, 1
+    @tc.assert_same :blah, :blah
+    @tc.assert_same o, o
+    @assertion_count = 3
+  end
+
+  def test_assert_same_triggered
+    util_assert_triggered 'Expected 2 to be the same as 1.' do
+      @tc.assert_same 1, 2
+    end
+
+    util_assert_triggered 'Expected "blah" to be the same as "blah".' do
+      s1 = "blah"
+      s2 = "blah"
+      @tc.assert_same s1, s2
+    end
+
+    @assertion_count = 2
+  end
+
+  def test_assert_send
+    o = [ 42 ]
+    @tc.assert_send([o, :clear])
+    assert_equal [], o
+  end
+
+  def test_assert_send_triggered
+    util_assert_triggered '<"blah"> expected to respond to
+<:empty?> with a true value.' do
+      o = "blah"
+      @tc.assert_send([o, :empty?])
+    end
+  end
+
+  def test_assert_throws
+    @tc.assert_throws(:blah) do
+      throw :blah
+    end
+  end
+
+  def test_assert_throws_triggered
+    util_assert_triggered '<:blah> should have been thrown.' do
+      @tc.assert_throws(:blah) do
+        # do nothing
+      end
+    end
+  end
+
+  def test_assert_throws_triggered_different
+    util_assert_triggered '<:blah> should have been thrown.' do
+      @tc.assert_throws(:blah) do
+        throw :not_blah
+      end
+    end
+  end
+
+  def test_flunk
+    util_assert_triggered 'Flunked' do
+      @tc.flunk
+    end
+  end
+
+  def test_flunk_message
+    util_assert_triggered @zomg do
+      @tc.flunk @zomg
+    end
+  end
+
+  def util_assert_triggered expected
+    e = assert_raises(MiniTest::Assertion) do
+      yield
+    end
+
+    assert_equal expected, e.message.sub(/(---Backtrace---).*/m, '\1')
+  end
+
+  def util_test_suites
+    MiniTest::Unit::TestCase.__send__(:class_variable_get, :@@test_suites)
+  end
+
+  def util_test_case
+    Object.const_set(:ATestCase, Class.new(MiniTest::Unit::TestCase))
+  end
+end

data/test/test_test_unit.rb

@@ -0,0 +1,75 @@
+#!/usr/local/bin/ruby -w
+
+require 'stringio'
+
+$TESTING_MINIUNIT = true
+
+require 'test/unit'
+
+class TestTestUnit < MiniTest::Unit::TestCase
+
+  def setup
+    MiniTest::Unit::TestCase.reset
+    @tu = MiniTest::Unit.new
+    MiniTest::Unit.output = StringIO.new("")
+    assert_equal [0, 0], @tu.run_test_suites
+  end
+
+  def teardown
+    MiniTest::Unit.output = $stdout
+  end
+
+  def test_class_puke_with_assertion_failed
+    exception = MiniTest::Assertion.new "Oh no!"
+    exception.set_backtrace ["unhappy"]
+    assert_equal 'F', @tu.puke('SomeClass', 'method_name', exception)
+    assert_equal 1, @tu.failures
+    assert_match(/^Failure.*Oh no!/m, @tu.report.first)
+  end
+
+  def test_class_puke_with_failure_and_flunk_in_backtrace
+    exception = begin
+                  MiniTest::Unit::TestCase.new.flunk
+                rescue MiniTest::Assertion => failure
+                  failure
+                end
+    assert_equal 'F', @tu.puke('SomeClass', 'method_name', exception)
+    assert !@tu.report.any?{|line| line =~ /in .flunk/}
+  end
+
+  def test_class_puke_with_non_failure_exception
+    exception = Exception.new("Oh no again!")
+    assert_equal 'E', @tu.puke('SomeClass', 'method_name', exception)
+    assert_equal 1, @tu.errors
+    assert_match(/^Exception.*Oh no again!/m, @tu.report.first)
+  end
+
+  def test_class_run_test_suites
+    create_a_test_case_named("ATestCase")
+    assert_equal [1, 1], @tu.run_test_suites
+  end
+
+  def test_class_autotest_failing
+    create_a_test_case_named("FailingTest", :failing => true)
+    @tu.autotest
+    assert_equal(1, @tu.report.size)
+    assert_match(/test_failure/, @tu.report.first)
+  end
+
+  def test_class_autotest_passing
+    create_a_test_case_named("PassingTest")
+    @tu.autotest
+    assert_equal([], @tu.report)
+  end
+
+  def create_a_test_case_named(name, options = {})
+    eval <<-CODE
+      class #{name} < MiniTest::Unit::TestCase
+        def test_something
+          assert true
+        end
+        #{if options[:failing]; "def test_failure; assert false; end"; end}
+      end
+    CODE
+  end
+end

metadata

@@ -1,17 +1,17 @@
 --- !ruby/object:Gem::Specification 
-rubygems_version: 0.9.0
+rubygems_version: 0.9.4
 specification_version: 1
 name: miniunit
 version: !ruby/object:Gem::Version 
-  version: 1.0.0
-date: 2006-10-30 00:00:00 -08:00
+  version: 1.1.0
+date: 2007-11-08 00:00:00 -08:00
 summary: miniunit is a completely minimial drop-in replacement for ruby's test/unit.
 require_paths: 
 - lib
 email: ryand-ruby@zenspider.com
 homepage: "    http://rubyforge.org/projects/bfts"
 rubyforge_project: bfts
-description: miniunit is a completely minimial drop-in replacement for ruby's test/unit. This is meant for language implementors to have a minimal set of methods to bootstrap a working unit test suite.
+description: miniunit 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.
 autorequire: 
 default_executable: 
 bindir: bin
@@ -29,18 +29,25 @@ post_install_message:
 authors: 
 - Ryan Davis
 files: 
+- .autotest
 - History.txt
 - Manifest.txt
 - README.txt
 - Rakefile
 - lib/test/unit.rb
 - lib/test/unit/testcase.rb
-test_files: []
-
-rdoc_options: []
-
-extra_rdoc_files: []
-
+- test/test_test_case.rb
+- test/test_test_unit.rb
+test_files: 
+- test/test_test_case.rb
+- test/test_test_unit.rb
+rdoc_options: 
+- --main
+- README.txt
+extra_rdoc_files: 
+- History.txt
+- Manifest.txt
+- README.txt
 executables: []
 
 extensions: []
@@ -55,5 +62,5 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        version: 1.1.2
+        version: 1.3.0
     version: