minitest_tu_shim 1.3.0

data/.autotest

@@ -0,0 +1,47 @@
+# -*- ruby -*-
+
+require 'autotest/restart'
+
+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.libs << ":../../minitest/dev/lib"
+
+  at.add_exception 'coverage.info'
+  at.add_exception 'coverage'
+end
+
+# require 'autotest/rcov'
+# Autotest::RCov.command = 'rcov_info'
+
+
+
+# require 'autotest/restart'
+
+# Autotest.add_hook :initialize do |at|
+#   at.extra_files << "../../ParseTree/dev/test/pt_testcase.rb"
+#   at.libs << ":../../ParseTree/dev/lib:../../ParseTree/dev/test:../../sexp_processor/dev/lib"
+#   at.add_exception 'unit'
+#   at.add_exception 'coverage'
+#   at.add_exception '.diff'
+#   at.add_exception 'coverage.info'
+
+#   at.unit_diff = "unit_diff -u -b"
+
+#   at.add_mapping(/^lib\/.*\.y$/) do |f, _|
+#     at.files_matching %r%^test/.*#{File.basename(f, '.y').gsub '_', '_?'}.rb$%
+#   end
+
+#   at.add_mapping(/pt_testcase.rb/) do |f, _|
+#     at.files_matching(/test_.*rb$/)
+#   end
+
+#   %w(TestEnvironment TestStackState).each do |klass|
+#     at.extra_class_map[klass] = "test/test_ruby_parser_extras.rb"
+#   end
+
+#   %w(TestRubyParser TestParseTree).each do |klass| # HACK
+#     at.extra_class_map[klass] = "test/test_ruby_parser.rb"
+#   end
+# end

data/History.txt

@@ -0,0 +1,5 @@
+=== 1.3.0 / 2008-10-09
+
+* 1 major enhancement:
+
+  * split out of miniunit (now minitest)

data/Manifest.txt

@@ -0,0 +1,12 @@
+.autotest
+History.txt
+Manifest.txt
+README.txt
+Rakefile
+bin/use_minitest
+lib/test/unit.rb
+lib/test/unit/assertions.rb
+lib/test/unit/deprecate.rb
+lib/test/unit/error.rb
+lib/test/unit/testcase.rb
+test/test_mini_test.rb

data/README.txt

@@ -0,0 +1,54 @@
+= minitest_tu_shim
+
+* http://rubyforge.org/projects/bfts
+
+== DESCRIPTION:
+
+minitest_te_shim bridges the gap between the small and fast minitest
+and ruby's huge and slow test/unit.
+
+== FEATURES/PROBLEMS:
+
+* Fully test/unit compatible assertions.
+* Allows test/unit to be required, firing up an autorunner.
+* Incompatible at the runner level. Does not replicate test/unit's internals.
+
+== HOW TO USE:
+
++ sudo gem install minitest_tu_shim
++ sudo use_minitest yes
++ there is no step 3.
+
+== REQUIREMENTS:
+
++ minitest
++ Ruby 1.8, maybe even 1.6 or lower. No magic is involved.
+
+== INSTALL:
+
++ sudo gem install minitest_tu_shim
+
+== LICENSE:
+
+(The MIT License)
+
+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
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,20 @@
+# -*- ruby -*-
+
+$TESTING_MINIUNIT = true
+
+require 'rubygems'
+require 'hoe'
+
+Hoe.add_include_dirs "../../minitest/dev/lib", "lib"
+
+require 'test/unit/testcase'
+
+Hoe.new('minitest_tu_shim', Test::Unit::TestCase::VERSION) do |shim|
+  shim.rubyforge_name = "bfts"
+
+  shim.developer('Ryan Davis', 'ryand-ruby@zenspider.com')
+
+  shim.extra_deps << 'minitest'
+end
+
+# vim: syntax=Ruby

data/bin/use_minitest

@@ -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, "minitest"), File.join(sitelib, "minitest")
+  File.symlink File.join(minidir, "test"), File.join(sitelib, "test")
+  puts "Added links to #{sitelib}"
+when /^n/ then
+  File.unlink File.join(sitelib, "minitest")
+  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/test/unit/assertions.rb

@@ -0,0 +1,53 @@
+require 'minitest/unit'
+require 'test/unit/deprecate'
+
+module Test; end
+module Test::Unit # patch up bastards that that extend improperly.
+  if defined? Assertions then
+    warn "ARGH! someone defined Test::Unit::Assertions rather than requiring"
+    CRAP_ASSERTIONS = Assertions
+    remove_const :Assertions
+
+    # this will break on junit and rubinius... *sigh*
+    ObjectSpace.each_object(Module) do |offender|
+      offender.send :include, ::MiniTest::Assertions if offender < CRAP_ASSERTIONS
+    end rescue nil
+
+    Test::Unit::TestCase.send :include, CRAP_ASSERTIONS
+  end
+
+  Assertions = ::MiniTest::Assertions
+
+  module Assertions
+    def self.included mod
+      mod.send :include, Test::Unit::CRAP_ASSERTIONS
+    end if defined? Test::Unit::CRAP_ASSERTIONS
+  end
+end
+
+module Test::Unit
+  module Assertions # deprecations
+    tu_deprecate :assert_nothing_thrown, :assert_nothing_raised # 2009-06-01
+    tu_deprecate :assert_raise,          :assert_raises         # 2010-06-01
+    tu_deprecate :assert_not_equal,      :refute_equal          # 2009-06-01
+    tu_deprecate :assert_no_match,       :refute_match          # 2009-06-01
+    tu_deprecate :assert_not_nil,        :refute_nil            # 2009-06-01
+    tu_deprecate :assert_not_same,       :refute_same           # 2009-06-01
+
+    def assert_nothing_raised _ = :ignored                      # 2009-06-01
+      self.class.tu_deprecation_warning :assert_nothing_raised
+      self._assertions += 1
+      yield
+    rescue => e
+      raise MiniTest::Assertion, exception_details(e, "Exception raised:")
+    end
+
+    def build_message(user_message, template_message, *args)    # 2009-06-01
+      self.class.tu_deprecation_warning :build_message
+      user_message ||= ''
+      user_message += ' ' unless user_message.empty?
+      msg = template_message.split(/<\?>/).zip(args.map { |o| o.inspect })
+      user_message + msg.join
+    end
+  end
+end

data/lib/test/unit/deprecate.rb

@@ -0,0 +1,24 @@
+class Module # define deprecation api
+  DEPS = Hash.new { |h,k| h[k] = {} }
+
+  def tu_deprecation_warning old, new = nil, kaller = nil
+    kaller ||= caller[1]
+    unless DEPS[old][kaller] then
+      msg = "#{self}##{old} deprecated. "
+      msg += new ? "Use ##{new}" : "No replacement is provided"
+      msg += ". From #{kaller}."
+      warn msg
+    end
+    DEPS[old][kaller] = true
+  end
+
+  def tu_deprecate old, new
+    class_eval <<-EOM
+      def #{old} *args, &block
+        cls, clr = self.class, caller.first
+        self.class.tu_deprecation_warning #{old.inspect}, #{new.inspect}, clr
+        #{new}(*args, &block)
+      end
+    EOM
+  end
+end

data/lib/test/unit/error.rb

@@ -0,0 +1,11 @@
+require 'test/unit/deprecate'
+
+# rails currently needs this file and this one method.
+module Test::Unit
+  class Error
+    def message
+      self.class.tu_deprecation_warning :message # 2009-06-01
+      "you're a loser"
+    end
+  end
+end

data/lib/test/unit/testcase.rb

@@ -0,0 +1,25 @@
+require 'minitest/unit'
+require 'test/unit/deprecate'
+
+module Test; end
+module Test::Unit # was ::Mini::Test, but rails' horrid code forced my hand
+  if defined? TestCase then
+    warn "ARGH! someone defined Test::Unit::TestCase rather than requiring"
+    remove_const :TestCase
+  end
+
+  AssertionFailedError = ::MiniTest::Assertion
+
+  class TestCase < ::MiniTest::Unit::TestCase
+
+    VERSION = '1.3.0'
+
+    tu_deprecate :method_name, :name # 2009-06-01
+
+    def self.test_order              # 2009-06-01
+      :sorted
+    end
+  end
+end
+
+require 'test/unit/assertions' # brings in deprecated methods

data/lib/test/unit.rb

@@ -0,0 +1,4 @@
+require 'minitest/unit'
+require 'test/unit/testcase' # pull in deprecated functionality
+
+MiniTest::Unit.autorun

data/test/test_mini_test.rb

@@ -0,0 +1,851 @@
+require 'stringio'
+require 'minitest/unit'
+
+MiniTest::Unit.autorun
+
+class TestMiniTest < MiniTest::Unit::TestCase
+
+  def setup
+    srand 42
+    MiniTest::Unit::TestCase.reset
+    @tu = MiniTest::Unit.new
+    @output = StringIO.new("")
+    MiniTest::Unit.output = @output
+    assert_equal [0, 0], @tu.run_test_suites
+  end
+
+  def teardown
+    MiniTest::Unit.output = $stdout
+    Object.send :remove_const, :ATestCase if defined? ATestCase
+  end
+
+  BT_MIDDLE = ["./lib/mini/test.rb:165:in `run_test_suites'",
+               "./lib/mini/test.rb:161:in `each'",
+               "./lib/mini/test.rb:161:in `run_test_suites'",
+               "./lib/mini/test.rb:158:in `each'",
+               "./lib/mini/test.rb:158:in `run_test_suites'",
+               "./lib/mini/test.rb:139:in `run'",
+               "./lib/mini/test.rb:106:in `run'"]
+
+#   def test_filter_backtrace
+#     # this is a semi-lame mix of relative paths.
+#     # I cheated by making the autotest parts not have ./
+#     bt = (["lib/autotest.rb:571:in `add_exception'",
+#            "test/test_autotest.rb:62:in `test_add_exception'",
+#            "./lib/mini/test.rb:165:in `__send__'"] +
+#           BT_MIDDLE +
+#           ["./lib/mini/test.rb:29",
+#            "test/test_autotest.rb:422"])
+#     bt = util_expand_bt bt
+
+#     ex = ["lib/autotest.rb:571:in `add_exception'",
+#           "test/test_autotest.rb:62:in `test_add_exception'"]
+#     ex = util_expand_bt ex
+
+#     fu = MiniTest::filter_backtrace(bt)
+
+#     assert_equal ex, fu
+#   end
+
+  def util_expand_bt bt
+    if RUBY_VERSION =~ /^1\.9/ then
+      bt.map { |f| (f =~ /^\./) ? File.expand_path(f) : f }
+    else
+      bt
+    end
+  end
+
+  def test_filter_backtrace_all_unit
+    bt = (["./lib/mini/test.rb:165:in `__send__'"] +
+          BT_MIDDLE +
+          ["./lib/mini/test.rb:29"])
+    ex = bt.clone
+    fu = MiniTest::filter_backtrace(bt)
+    assert_equal ex, fu
+  end
+
+#   def test_filter_backtrace_unit_starts
+#     bt = (["./lib/mini/test.rb:165:in `__send__'"] +
+#           BT_MIDDLE +
+#           ["./lib/mini/test.rb:29",
+#            "-e:1"])
+
+#     bt = util_expand_bt bt
+
+#     ex = ["-e:1"]
+#     fu = MiniTest::filter_backtrace(bt)
+#     assert_equal ex, fu
+#   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('fake tc').flunk
+                rescue MiniTest::Assertion => failure
+                  failure
+                end
+    assert_equal 'F', @tu.puke('SomeClass', 'method_name', exception)
+    refute @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
+    tc = Class.new(MiniTest::Unit::TestCase) do
+      def test_something
+        assert true
+      end
+    end
+
+    Object.const_set(:ATestCase, tc)
+
+    assert_equal [1, 1], @tu.run_test_suites
+  end
+
+  def test_run_failing # TODO: add error test
+    tc = Class.new(MiniTest::Unit::TestCase) do
+      def test_something
+        assert true
+      end
+
+      def test_failure
+        assert false
+      end
+    end
+
+    Object.const_set(:ATestCase, tc)
+
+    @tu.run
+
+    expected = "Loaded suite blah
+Started
+F.
+Finished in 0.00
+
+  1) Failure:
+test_failure(ATestCase) [FILE:LINE]:
+Failed assertion, no message given.
+
+2 tests, 2 assertions, 1 failures, 0 errors, 0 skips
+"
+    util_assert_report expected
+  end
+
+  def test_run_error
+    tc = Class.new(MiniTest::Unit::TestCase) do
+      def test_something
+        assert true
+      end
+
+      def test_error
+        raise "unhandled exception"
+      end
+    end
+
+    Object.const_set(:ATestCase, tc)
+
+    @tu.run
+
+    expected = "Loaded suite blah
+Started
+E.
+Finished in 0.00
+
+  1) Error:
+test_error(ATestCase):
+RuntimeError: unhandled exception
+    FILE:LINE:in `test_error'
+
+2 tests, 1 assertions, 0 failures, 1 errors, 0 skips
+"
+    util_assert_report expected
+  end
+
+  def test_run_error_teardown
+    tc = Class.new(MiniTest::Unit::TestCase) do
+      def test_something
+        assert true
+      end
+
+      def teardown
+        raise "unhandled exception"
+      end
+    end
+
+    Object.const_set(:ATestCase, tc)
+
+    @tu.run
+
+    expected = "Loaded suite blah
+Started
+E
+Finished in 0.00
+
+  1) Error:
+test_something(ATestCase):
+RuntimeError: unhandled exception
+    FILE:LINE:in `teardown'
+
+1 tests, 1 assertions, 0 failures, 1 errors, 0 skips
+"
+    util_assert_report expected
+  end
+
+  def test_run_skip
+    tc = Class.new(MiniTest::Unit::TestCase) do
+      def test_something
+        assert true
+      end
+
+      def test_skip
+        skip "not yet"
+      end
+    end
+
+    Object.const_set(:ATestCase, tc)
+
+    @tu.run
+
+    expected = "Loaded suite blah
+Started
+S.
+Finished in 0.00
+
+  1) Skipped:
+test_skip(ATestCase) [FILE:LINE]:
+not yet
+
+2 tests, 1 assertions, 0 failures, 0 errors, 1 skips
+"
+    util_assert_report expected
+  end
+
+  def util_assert_report expected = nil
+    expected ||= "Loaded suite blah
+Started
+.
+Finished in 0.00
+
+1 tests, 1 assertions, 0 failures, 0 errors, 0 skips
+"
+    output = @output.string.sub(/Finished in .*/, "Finished in 0.00")
+    output.sub!(/Loaded suite .*/, 'Loaded suite blah')
+    output.sub!(/[\w\/\.]+:\d+/, 'FILE:LINE')
+    assert_equal(expected, output)
+  end
+
+  def test_run_failing_filtered
+    tc = Class.new(MiniTest::Unit::TestCase) do
+      def test_something
+        assert true
+      end
+
+      def test_failure
+        assert false
+      end
+    end
+
+    Object.const_set(:ATestCase, tc)
+
+    @tu.run(%w(-n /something/))
+
+    util_assert_report
+  end
+
+  def test_run_passing
+    tc = Class.new(MiniTest::Unit::TestCase) do
+      def test_something
+        assert true
+      end
+    end
+
+    Object.const_set(:ATestCase, tc)
+
+    @tu.run
+
+    util_assert_report
+  end
+end
+
+class TestMiniTestTestCase < MiniTest::Unit::TestCase
+  def setup
+    MiniTest::Unit::TestCase.reset
+
+    @tc = MiniTest::Unit::TestCase.new 'fake tc'
+    @zomg = "zomg ponies!"
+    @assertion_count = 1
+  end
+
+  def teardown
+    assert_equal(@assertion_count, @tc._assertions,
+                 "expected #{@assertion_count} assertions to be fired during the test, not #{@tc._assertions}") if @tc._assertions
+    Object.send :remove_const, :ATestCase if defined? ATestCase
+  end
+
+  def test_class_inherited
+    @assertion_count = 0
+
+    Object.const_set(:ATestCase, Class.new(MiniTest::Unit::TestCase))
+
+    assert_equal [ATestCase], MiniTest::Unit::TestCase.test_suites
+  end
+
+  def test_class_test_suites
+    @assertion_count = 0
+
+    Object.const_set(:ATestCase, Class.new(MiniTest::Unit::TestCase))
+
+    assert_equal 1, MiniTest::Unit::TestCase.test_suites.size
+    assert_equal [ATestCase], MiniTest::Unit::TestCase.test_suites
+  end
+
+  def test_class_asserts_match_refutes
+    @assertion_count = 0
+
+    methods = MiniTest::Assertions.public_instance_methods
+    methods.map! { |m| m.to_s } if Symbol === methods.first
+
+    ignores = %w(assert_block assert_no_match assert_not_equal assert_not_nil
+                 assert_not_same assert_nothing_thrown assert_raise
+                 assert_nothing_raised assert_raises assert_throws assert_send)
+    asserts = methods.grep(/^assert/).sort - ignores
+    refutes = methods.grep(/^refute/).sort - ignores
+
+    assert_empty refutes.map { |n| n.sub(/^refute/, 'assert') } - asserts
+    assert_empty asserts.map { |n| n.sub(/^assert/, 'refute') } - refutes
+  end
+
+  def test_assert
+    @assertion_count = 2
+
+    @tc.assert_equal true, @tc.assert(true), "returns true on success"
+  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 'Expected block to return true value.' do
+      @tc.assert_block do
+        false
+      end
+    end
+  end
+
+  def test_assert_empty
+    @assertion_count = 2
+
+    @tc.assert_empty []
+  end
+
+  def test_assert_empty_triggered
+    @assertion_count = 2
+
+    util_assert_triggered "Expected [1] to be empty." do
+      @tc.assert_empty [1]
+    end
+  end
+
+  def test_assert_equal
+    @tc.assert_equal 1, 1
+  end
+
+  def test_assert_equal_different
+    util_assert_triggered "Expected 1, not 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 - 0.001 (0.001) to be < 1.0e-06.' do
+      @tc.assert_in_delta 0.0, 1.0 / 1000, 0.000001
+    end
+  end
+
+  def test_assert_in_epsilon
+    @assertion_count = 8
+
+    @tc.assert_in_epsilon 10000, 9991
+    @tc.assert_in_epsilon 9991, 10000
+    @tc.assert_in_epsilon 1.0, 1.001
+    @tc.assert_in_epsilon 1.001, 1.0
+
+    @tc.assert_in_epsilon 10000, 9999.1, 0.0001
+    @tc.assert_in_epsilon 9999.1, 10000, 0.0001
+    @tc.assert_in_epsilon 1.0, 1.0001, 0.0001
+    @tc.assert_in_epsilon 1.0001, 1.0, 0.0001
+  end
+
+  def test_assert_in_epsilon_triggered
+    util_assert_triggered 'Expected 10000 - 9990 (10) to be < 9.99.' do
+      @tc.assert_in_epsilon 10000, 9990
+    end
+  end
+
+  def test_assert_includes
+    @assertion_count = 2
+
+    @tc.assert_includes [true], true
+  end
+
+  def test_assert_includes_triggered
+    @assertion_count = 4
+
+    e = @tc.assert_raises MiniTest::Assertion do
+      @tc.assert_includes [true], false
+    end
+
+    expected = "Expected [true] to include false."
+    assert_equal expected, e.message
+  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, not String.' 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, not String.' do
+      @tc.assert_kind_of Array, "blah"
+    end
+  end
+
+  def test_assert_match
+    @assertion_count = 2
+    @tc.assert_match "blah blah blah", /\w+/
+  end
+
+  def test_assert_match_triggered
+    @assertion_count = 2
+    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_operator
+    @tc.assert_operator 2, :>, 1
+  end
+
+  def test_assert_operator_triggered
+    util_assert_triggered "Expected 2 to be < 1." do
+      @tc.assert_operator 2, :<, 1
+    end
+  end
+
+  def test_assert_raises
+    @assertion_count = 2
+
+    @tc.assert_raises RuntimeError do
+      raise "blah"
+    end
+  end
+
+  def test_assert_raises_triggered_different
+    @assertion_count = 2
+
+    e = assert_raises MiniTest::Assertion do
+      @tc.assert_raises RuntimeError do
+        raise SyntaxError, "icky"
+      end
+    end
+
+    expected = "<[RuntimeError]> exception expected, not
+Class: <SyntaxError>
+Message: <\"icky\">
+---Backtrace---
+FILE:LINE:in `test_assert_raises_triggered_different'
+---------------.
+Expected [RuntimeError] to include SyntaxError."
+
+    assert_equal expected, expected.gsub(/[\w\/\.]+:\d+/, 'FILE:LINE')
+  end
+
+  def test_assert_raises_triggered_none
+    e = assert_raises MiniTest::Assertion do
+      @tc.assert_raises MiniTest::Assertion do
+        # do nothing
+      end
+    end
+
+    expected = "MiniTest::Assertion expected but nothing was raised."
+
+    assert_equal expected, e.message
+  end
+
+  def test_assert_respond_to
+    @tc.assert_respond_to "blah", :empty?
+  end
+
+  def test_assert_respond_to_triggered
+    util_assert_triggered 'Expected "blah" (String) to respond to #rawr!.' do
+      @tc.assert_respond_to "blah", :rawr!
+    end
+  end
+
+  def test_assert_same
+    @assertion_count = 3
+
+    o = "blah"
+    @tc.assert_same 1, 1
+    @tc.assert_same :blah, :blah
+    @tc.assert_same o, o
+  end
+
+  def test_assert_same_triggered
+    @assertion_count = 2
+
+    util_assert_triggered 'Expected 2 (0xXXX) to be the same as 1 (0xXXX).' do
+      @tc.assert_same 1, 2
+    end
+
+    s1 = "blah"
+    s2 = "blah"
+
+    util_assert_triggered 'Expected "blah" (0xXXX) to be the same as "blah" (0xXXX).' do
+      @tc.assert_same s1, s2
+    end
+  end
+
+  def test_assert_send
+    @tc.assert_send [1, :<, 2]
+  end
+
+  def test_assert_send_bad
+    util_assert_triggered "Expected 1.>(*[2]) to return true." do
+      @tc.assert_send [1, :>, 2]
+    end
+  end
+
+  def test_assert_throws
+    @tc.assert_throws(:blah) do
+      throw :blah
+    end
+  end
+
+  def test_assert_throws_different
+    util_assert_triggered 'Expected :blah to have been thrown, not :not_blah.' do
+      @tc.assert_throws(:blah) do
+        throw :not_blah
+      end
+    end
+  end
+
+  def test_assert_throws_unthrown
+    util_assert_triggered 'Expected :blah to have been thrown.' do
+      @tc.assert_throws(:blah) do
+        # do nothing
+      end
+    end
+  end
+
+  def test_capture_io
+    @assertion_count = 0
+
+    out, err = capture_io do
+      puts 'hi'
+      warn 'bye!'
+    end
+
+    assert_equal "hi\n", out
+    assert_equal "bye!\n", err
+  end
+
+  def test_flunk
+    util_assert_triggered 'Epic Fail!' do
+      @tc.flunk
+    end
+  end
+
+  def test_flunk_message
+    util_assert_triggered @zomg do
+      @tc.flunk @zomg
+    end
+  end
+
+  def test_message
+    @assertion_count = 0
+
+    assert_equal "blah2.",         @tc.message { "blah2" }.call
+    assert_equal "blah2.",         @tc.message("") { "blah2" }.call
+    assert_equal "blah1.\nblah2.", @tc.message("blah1") { "blah2" }.call
+  end
+
+  def test_pass
+    @tc.pass
+  end
+
+  def test_test_methods_sorted
+    @assertion_count = 0
+
+    sample_test_case = Class.new(MiniTest::Unit::TestCase)
+
+    class << sample_test_case
+      def test_order; :sorted end
+    end
+
+    sample_test_case.instance_eval do
+      define_method :test_test3 do assert "does not matter" end
+      define_method :test_test2 do assert "does not matter" end
+      define_method :test_test1 do assert "does not matter" end
+    end
+
+    expected = %w(test_test1 test_test2 test_test3)
+    assert_equal expected, sample_test_case.test_methods
+  end
+
+  def test_test_methods_random
+    @assertion_count = 0
+
+    sample_test_case = Class.new(MiniTest::Unit::TestCase)
+
+    class << sample_test_case
+      def test_order; :random end
+    end
+
+    sample_test_case.instance_eval do
+      define_method :test_test1 do assert "does not matter" end
+      define_method :test_test2 do assert "does not matter" end
+      define_method :test_test3 do assert "does not matter" end
+    end
+
+    srand 42
+    expected = %w(test_test1 test_test2 test_test3)
+    max = expected.size
+    expected = expected.sort_by { rand(max) }
+
+    srand 42
+    result = sample_test_case.test_methods
+
+    assert_equal expected, result
+  end
+
+  def test_refute
+    @assertion_count = 2
+
+    @tc.assert_equal false, @tc.refute(false), "returns false on success"
+  end
+
+  def test_refute_empty
+    @assertion_count = 2
+
+    @tc.refute_empty [1]
+  end
+
+  def test_refute_empty_triggered
+    @assertion_count = 2
+
+    util_assert_triggered "Expected [] to not be empty." do
+      @tc.refute_empty []
+    end
+  end
+
+  def test_refute_equal
+    @tc.refute_equal "blah", "yay"
+  end
+
+  def test_refute_equal_triggered
+    util_assert_triggered 'Expected "blah" to not be equal to "blah".' do
+      @tc.refute_equal "blah", "blah"
+    end
+  end
+
+  def test_refute_in_delta
+    @tc.refute_in_delta 0.0, 1.0 / 1000, 0.000001
+  end
+
+  def test_refute_in_delta_triggered
+    util_assert_triggered 'Expected 0.0 - 0.001 (0.001) to not be < 0.1.' do
+      @tc.refute_in_delta 0.0, 1.0 / 1000, 0.1
+    end
+  end
+
+  def test_refute_in_epsilon
+    @tc.refute_in_epsilon 10000, 9990
+  end
+
+  def test_refute_in_epsilon_triggered
+    util_assert_triggered 'Expected 10000 - 9991 (9) to not be < 10.0.' do
+      @tc.refute_in_epsilon 10000, 9991
+      fail
+    end
+  end
+
+  def test_refute_includes
+    @assertion_count = 2
+
+    @tc.refute_includes [true], false
+  end
+
+  def test_refute_includes_triggered
+    @assertion_count = 4
+
+    e = @tc.assert_raises MiniTest::Assertion do
+      @tc.refute_includes [true], true
+    end
+
+    expected = "Expected [true] to not include true."
+    assert_equal expected, e.message
+  end
+
+  def test_refute_instance_of
+    @tc.refute_instance_of Array, "blah"
+  end
+
+  def test_refute_instance_of_triggered
+    util_assert_triggered 'Expected "blah" to not be an instance of String.' do
+      @tc.refute_instance_of String, "blah"
+    end
+  end
+
+  def test_refute_kind_of
+    @tc.refute_kind_of Array, "blah"
+  end
+
+  def test_refute_kind_of_triggered
+    util_assert_triggered 'Expected "blah" to not be a kind of String.' do
+      @tc.refute_kind_of String, "blah"
+    end
+  end
+
+  def test_refute_match
+    @tc.refute_match "blah blah blah", /\d+/
+  end
+
+  def test_refute_match_triggered
+    util_assert_triggered 'Expected /\w+/ to not match "blah blah blah".' do
+      @tc.refute_match "blah blah blah", /\w+/
+    end
+  end
+
+  def test_refute_nil
+    @tc.refute_nil 42
+  end
+
+  def test_refute_nil_triggered
+    util_assert_triggered 'Expected nil to not be nil.' do
+      @tc.refute_nil nil
+    end
+  end
+
+  def test_refute_operator
+    @tc.refute_operator 2, :<, 1
+  end
+
+  def test_refute_operator_triggered
+    util_assert_triggered "Expected 2 to not be > 1." do
+      @tc.refute_operator 2, :>, 1
+    end
+  end
+
+  def test_refute_respond_to
+    @tc.refute_respond_to "blah", :rawr!
+  end
+
+  def test_refute_respond_to_triggered
+    util_assert_triggered 'Expected "blah" to not respond to empty?.' do
+      @tc.refute_respond_to "blah", :empty?
+    end
+  end
+
+  def test_refute_same
+    @tc.refute_same 1, 2
+  end
+
+  # TODO: "with id <id>" crap from assertions.rb
+  def test_refute_same_triggered
+    util_assert_triggered 'Expected 1 to not be the same as 1.' do
+      @tc.refute_same 1, 1
+    end
+  end
+
+  def test_skip
+    @assertion_count = 0
+
+    util_assert_triggered "haha!", MiniTest::Skip do
+      @tc.skip "haha!"
+    end
+  end
+
+  def util_assert_triggered expected, klass = MiniTest::Assertion
+    e = assert_raises(klass) do
+      yield
+    end
+
+    msg = e.message.sub(/(---Backtrace---).*/m, '\1')
+    msg.gsub!(/\(0x[0-9a-f]+\)/, '(0xXXX)')
+
+    assert_equal expected, msg
+  end
+
+  if ENV['DEPRECATED'] then
+    require 'test/unit/assertions'
+    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
+  end
+end

metadata

@@ -0,0 +1,87 @@
+--- !ruby/object:Gem::Specification 
+name: minitest_tu_shim
+version: !ruby/object:Gem::Version 
+  version: 1.3.0
+platform: ruby
+authors: 
+- Ryan Davis
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-10-09 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: minitest
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: hoe
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.8.0
+    version: 
+description: minitest_te_shim bridges the gap between the small and fast minitest and ruby's huge and slow test/unit.
+email: 
+- ryand-ruby@zenspider.com
+executables: 
+- use_minitest
+extensions: []
+
+extra_rdoc_files: 
+- History.txt
+- Manifest.txt
+- README.txt
+files: 
+- .autotest
+- History.txt
+- Manifest.txt
+- README.txt
+- Rakefile
+- bin/use_minitest
+- lib/test/unit.rb
+- lib/test/unit/assertions.rb
+- lib/test/unit/deprecate.rb
+- lib/test/unit/error.rb
+- lib/test/unit/testcase.rb
+- test/test_mini_test.rb
+has_rdoc: true
+homepage: http://rubyforge.org/projects/bfts
+post_install_message: 
+rdoc_options: 
+- --main
+- README.txt
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: bfts
+rubygems_version: 1.3.0
+signing_key: 
+specification_version: 2
+summary: minitest_te_shim bridges the gap between the small and fast minitest and ruby's huge and slow test/unit.
+test_files: 
+- test/test_mini_test.rb