minitest 1.6.0 → 1.7.0

data/History.txt

@@ -1,3 +1,13 @@
+=== 1.7.0 / 2010-07-15
+
+* 5 minor enhancements:
+
+  * Added assert_output (mapped to must_output).
+  * Added assert_silent (mapped to must_be_silent).
+  * Added examples to readme (Mike Dalessio)
+  * Added options output at the top of the run, for fatal run debugging (tenderlove)
+  * Spec's describe method returns created class
+
 === 1.6.0 / 2010-03-27
 
 * 10 minor enhancements:

data/README.txt

@@ -26,6 +26,97 @@ mini/mock, by Steven Baker, is a beautifully tiny mock object framework.
 
 See design_rationale.rb to see how specs and tests work in minitest.
 
+== SYNOPSIS:
+
+Given that you'd like to test the following class:
+
+    class Meme
+      def i_can_has_cheezburger?
+        "OHAI!"
+      end
+
+      def does_it_blend?
+        "YES!"
+      end
+    end
+
+
+=== Unit tests
+
+    require 'minitest/unit'
+    MiniTest::Unit.autorun
+
+    class TestMeme < MiniTest::Unit::TestCase
+      def setup
+        @meme = Meme.new
+      end
+
+      def test_that_kitty_can_eat
+        assert_equal "OHAI!", @meme.i_can_has_cheezburger?
+      end
+
+      def test_that_it_doesnt_not_blend
+        refute_match /^no/i, @meme.does_it_blend?
+      end
+    end
+
+=== Specs
+
+    require 'minitest/spec'
+    MiniTest::Unit.autorun
+
+    describe Meme do
+      before do
+        @meme = Meme.new
+      end
+
+      describe "when asked about cheeseburgers" do
+        it "should respond positively" do
+          @meme.i_can_has_cheezburger?.must_equal "OHAI!"
+        end
+      end
+
+      describe "when asked about blending possibilities" do
+        it "won't say no" do
+          @meme.does_it_blend?.wont_match /^no/i
+        end
+      end
+    end
+
+=== Mocks
+
+    class MemeAsker
+      def initialize(meme)
+        @meme = meme
+      end
+
+      def ask(question)
+        method = question.tr(" ","_") + "?"
+        @meme.send(method)
+      end
+    end
+
+    require 'minitest/spec'
+    require 'minitest/mock'
+    MiniTest::Unit.autorun
+
+    describe MemeAsker do
+      before do
+        @meme = MiniTest::Mock.new
+        @meme_asker = MemeAsker.new @meme
+      end
+
+      describe "#ask" do
+        describe "when passed an unpunctuated question" do
+          it "should invoke the appropriate predicate method on the meme" do
+            @meme.expect :does_it_blend?, :return_value
+            @meme_asker.ask "does it blend"
+            @meme.verify
+          end
+        end
+      end
+    end
+
 == REQUIREMENTS:
 
 + Ruby 1.8, maybe even 1.6 or lower. No magic is involved.

data/Rakefile

@@ -11,6 +11,7 @@ Hoe.spec 'minitest' do
   developer 'Ryan Davis', 'ryand-ruby@zenspider.com'
 
   self.rubyforge_name = "bfts"
+  self.testlib = :minitest
 end
 
 def loc dir

data/lib/minitest/spec.rb

@@ -49,7 +49,7 @@ Object.infect_with_assertions(:must, :wont,
                               /_in_/                          => '_be_within_',
                               /_operator/                     => '_be',
                               /_includes/                     => '_include',
-                              /(must|wont)_(.*_of|nil|empty)/ => '\1_be_\2',
+                       /(must|wont)_(.*_of|nil|silent|empty)/ => '\1_be_\2',
                               /must_raises/                   => 'must_raise')
 
 class Object
@@ -78,6 +78,7 @@ module Kernel
     stack.push cls
     cls.class_eval(&block)
     stack.pop
+    cls
   end
   private :describe
 end
@@ -196,6 +197,10 @@ class MiniTest::Spec < MiniTest::Unit::TestCase
   # :method: must_be_same_as
   # See MiniTest::Assertions#assert_same
 
+  ##
+  # :method: must_be_silent
+  # See MiniTest::Assertions#assert_silent
+
   ##
   # :method: must_be_within_delta
   # See MiniTest::Assertions#assert_in_delta
@@ -216,6 +221,10 @@ class MiniTest::Spec < MiniTest::Unit::TestCase
   # :method: must_match
   # See MiniTest::Assertions#assert_match
 
+  ##
+  # :method: must_output
+  # See MiniTest::Assertions#assert_output
+
   ##
   # :method: must_raise
   # See MiniTest::Assertions#assert_raises
@@ -264,6 +273,10 @@ class MiniTest::Spec < MiniTest::Unit::TestCase
   # :method: wont_be_within_delta
   # See MiniTest::Assertions#refute_in_delta
 
+  ##
+  # :method: wont_be_within_delta
+  # See MiniTest::Assertions#refute_in_delta
+
   ##
   # :method: wont_be_within_epsilon
   # See MiniTest::Assertions#refute_in_epsilon

data/lib/minitest/unit.rb

@@ -188,6 +188,24 @@ module MiniTest
       assert o1.__send__(op, o2), msg
     end
 
+    ##
+    # Fails if stdout or stderr do not output the expected results.
+    # Pass in nil if you don't care about that streams output. Pass in
+    # "" if you require it to be silent.
+    #
+    # See also: #assert_silent
+
+    def assert_output stdout = nil, stderr = nil
+      out, err = capture_io do
+        yield
+      end
+
+      x = assert_equal stdout, out, "In stdout" if stdout
+      y = assert_equal stderr, err, "In stderr" if stderr
+
+      (!stdout || x) && (!stderr || y)
+    end
+
     ##
     # Fails unless the block raises one of +exp+
 
@@ -245,6 +263,17 @@ module MiniTest
       assert recv.__send__(msg, *args), m
     end
 
+    ##
+    # Fails if the block outputs anything to stderr or stdout.
+    #
+    # See also: #assert_output
+
+    def assert_silent
+      assert_output "", "" do
+        yield
+      end
+    end
+
     ##
     # Fails unless the block throws +sym+
 
@@ -468,7 +497,7 @@ module MiniTest
   end
 
   class Unit
-    VERSION = "1.6.0" # :nodoc:
+    VERSION = "1.7.0" # :nodoc:
 
     attr_accessor :report, :failures, :errors, :skips # :nodoc:
     attr_accessor :test_count, :assertion_count       # :nodoc:
@@ -582,6 +611,12 @@ module MiniTest
 
       srand seed
 
+      help = ["--seed", seed]
+      help.push "--verbose" if @verbose
+      help.push("--name", options[:filter].inspect) if options[:filter]
+
+      @@out.puts "Test run options: #{help.join(" ")}"
+      @@out.puts
       @@out.puts "Loaded suite #{$0.sub(/\.rb$/, '')}\nStarted"
 
       start = Time.now
@@ -600,10 +635,6 @@ module MiniTest
 
       @@out.puts
 
-      help = ["--seed", seed]
-      help.push "--verbose" if @verbose
-      help.push("--name", options[:filter].inspect) if options[:filter]
-
       @@out.puts "Test run options: #{help.join(" ")}"
 
       return failures + errors if @test_count > 0 # or return nil...

data/test/test_mini_spec.rb

@@ -29,18 +29,22 @@ describe MiniTest::Spec do
                         must_be_kind_of
                         must_be_nil
                         must_be_same_as
+                        must_be_silent
                         must_be_within_delta
                         must_be_within_epsilon
                         must_equal
                         must_include
                         must_match
+                        must_output
                         must_raise
                         must_respond_to
                         must_send
                         must_throw)
 
+    bad = %w[not raise throw send output be_silent]
+
     expected_wonts = expected_musts.map { |m| m.sub(/^must/, 'wont') }
-    expected_wonts.reject! { |m| m =~ /wont_(not|raise|throw|send)/ }
+    expected_wonts.reject! { |m| m =~ /wont_#{Regexp.union bad}/ }
 
     musts.must_equal expected_musts
     wonts.must_equal expected_wonts
@@ -152,6 +156,32 @@ describe MiniTest::Spec do
     proc { 1.wont_be_same_as 1 }.must_raise MiniTest::Assertion
   end
 
+  it "needs to verify output in stdout" do
+    proc { print "blah" }.must_output("blah").must_equal true
+
+    proc {
+      proc { print "xxx" }.must_output("blah")
+    }.must_raise MiniTest::Assertion
+  end
+
+  it "needs to verify output in stderr" do
+    proc { $stderr.print "blah" }.must_output(nil, "blah").must_equal true
+
+    proc {
+      proc { $stderr.print "xxx" }.must_output(nil, "blah")
+    }.must_raise MiniTest::Assertion
+  end
+
+  it "needs to ensure silence" do
+    @assertion_count = 5
+
+    proc {  }.must_be_silent.must_equal true
+
+    proc {
+      proc { print "xxx" }.must_be_silent
+    }.must_raise MiniTest::Assertion
+  end
+
   it "needs to be sensible about must_include order" do
     @assertion_count = 6
     [1, 2, 3].must_include(2).must_equal true
@@ -164,3 +194,26 @@ describe MiniTest::Spec do
     proc { [1, 2, 3].wont_include 2 }.must_raise MiniTest::Assertion
   end
 end
+
+class TestMeta < MiniTest::Unit::TestCase
+  def test_structure
+    x = y = nil
+    x = describe "top-level thingy" do
+      before {}
+      after  {}
+
+      it "top-level-it" do end
+
+      y = describe "inner thingy" do
+        before {}
+        it "inner-it" do end
+      end
+    end
+
+    top_methods = %w(setup teardown test_0001_top_level_it)
+    inner_methods = %w(setup test_0001_inner_it)
+
+    assert_equal top_methods, x.instance_methods(false).sort.map { |o| o.to_s }
+    assert_equal inner_methods, y.instance_methods(false).sort.map{|o| o.to_s }
+  end
+end

data/test/test_mini_test.rb

@@ -8,20 +8,6 @@ module M; end
 class E < StandardError; include M; end
 
 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
-
   pwd = Pathname.new(File.expand_path(Dir.pwd))
   basedir = Pathname.new(File.expand_path(MiniTest::MINI_DIR)) + 'mini'
   basedir = basedir.relative_path_from(pwd).to_s
@@ -34,54 +20,37 @@ class TestMiniTest < MiniTest::Unit::TestCase
                "#{MINITEST_BASE_DIR}/test.rb:139:in `run'",
                "#{MINITEST_BASE_DIR}/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'",
-           "#{MINITEST_BASE_DIR}/test.rb:165:in `__send__'"] +
-          BT_MIDDLE +
-          ["#{MINITEST_BASE_DIR}/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
+  def assert_report expected = nil
+    expected ||= "Test run options: --seed 42
 
-    fu = MiniTest::filter_backtrace(bt)
+Loaded suite blah
+Started
+.
+Finished in 0.00
 
-    assert_equal ex, fu
-  end
+1 tests, 1 assertions, 0 failures, 0 errors, 0 skips
 
-  def util_expand_bt bt
-    if RUBY_VERSION =~ /^1\.9/ then
-      bt.map { |f| (f =~ /^\./) ? File.expand_path(f) : f }
-    else
-      bt
-    end
+Test run options: --seed 42
+"
+    output = @output.string.sub(/Finished in .*/, "Finished in 0.00")
+    output.sub!(/Loaded suite .*/, 'Loaded suite blah')
+    output.sub!(/^(\s+)(?:#{Regexp.union(__FILE__, File.expand_path(__FILE__))}):\d+:/o, '\1FILE:LINE:')
+    output.sub!(/\[(?:#{Regexp.union(__FILE__, File.expand_path(__FILE__))}):\d+\]/o, '[FILE:LINE]')
+    assert_equal(expected, output)
   end
 
-  def test_filter_backtrace_all_unit
-    bt = (["#{MINITEST_BASE_DIR}/test.rb:165:in `__send__'"] +
-          BT_MIDDLE +
-          ["#{MINITEST_BASE_DIR}/test.rb:29"])
-    ex = bt.clone
-    fu = MiniTest::filter_backtrace(bt)
-    assert_equal ex, fu
+  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 test_filter_backtrace_unit_starts
-    bt = (["#{MINITEST_BASE_DIR}/test.rb:165:in `__send__'"] +
-          BT_MIDDLE +
-          ["#{MINITEST_BASE_DIR}/mini/test.rb:29",
-           "-e:1"])
-
-    bt = util_expand_bt bt
-
-    ex = ["-e:1"]
-    fu = MiniTest::filter_backtrace(bt)
-    assert_equal ex, fu
+  def teardown
+    MiniTest::Unit.output = $stdout
+    Object.send :remove_const, :ATestCase if defined? ATestCase
   end
 
   def test_class_puke_with_assertion_failed
@@ -93,16 +62,6 @@ class TestMiniTest < MiniTest::Unit::TestCase
     assert_match("method_name(SomeClass) [unhappy]", @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_assertion_failed_and_long_backtrace
     bt = (["test/test_some_class.rb:615:in `method_name'",
            "#{MINITEST_BASE_DIR}/unit.rb:140:in `assert_raises'",
@@ -146,6 +105,16 @@ class TestMiniTest < MiniTest::Unit::TestCase
     assert_match("test_method_name(TestSomeClass) [#{ex_location}]", @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_flunk_and_user_defined_assertions
     bt = (["lib/test/my/util.rb:16:in `flunk'",
            "#{MINITEST_BASE_DIR}/unit.rb:140:in `assert_raises'",
@@ -188,35 +157,46 @@ class TestMiniTest < MiniTest::Unit::TestCase
     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_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'",
+           "#{MINITEST_BASE_DIR}/test.rb:165:in `__send__'"] +
+          BT_MIDDLE +
+          ["#{MINITEST_BASE_DIR}/test.rb:29",
+           "test/test_autotest.rb:422"])
+    bt = util_expand_bt bt
 
-      def test_failure
-        assert false
-      end
-    end
+    ex = ["lib/autotest.rb:571:in `add_exception'",
+          "test/test_autotest.rb:62:in `test_add_exception'"]
+    ex = util_expand_bt ex
 
-    Object.const_set(:ATestCase, tc)
+    fu = MiniTest::filter_backtrace(bt)
 
-    @tu.run %w[-s 42]
+    assert_equal ex, fu
+  end
 
-    expected = "Loaded suite blah
-Started
-F.
-Finished in 0.00
+  def test_filter_backtrace_all_unit
+    bt = (["#{MINITEST_BASE_DIR}/test.rb:165:in `__send__'"] +
+          BT_MIDDLE +
+          ["#{MINITEST_BASE_DIR}/test.rb:29"])
+    ex = bt.clone
+    fu = MiniTest::filter_backtrace(bt)
+    assert_equal ex, fu
+  end
 
-  1) Failure:
-test_failure(ATestCase) [FILE:LINE]:
-Failed assertion, no message given.
+  def test_filter_backtrace_unit_starts
+    bt = (["#{MINITEST_BASE_DIR}/test.rb:165:in `__send__'"] +
+          BT_MIDDLE +
+          ["#{MINITEST_BASE_DIR}/mini/test.rb:29",
+           "-e:1"])
 
-2 tests, 2 assertions, 1 failures, 0 errors, 0 skips
+    bt = util_expand_bt bt
 
-Test run options: --seed 42
-"
-    util_assert_report expected
+    ex = ["-e:1"]
+    fu = MiniTest::filter_backtrace(bt)
+    assert_equal ex, fu
   end
 
   def test_run_error
@@ -234,7 +214,9 @@ Test run options: --seed 42
 
     @tu.run %w[-s 42]
 
-    expected = "Loaded suite blah
+    expected = "Test run options: --seed 42
+
+Loaded suite blah
 Started
 E.
 Finished in 0.00
@@ -248,7 +230,7 @@ RuntimeError: unhandled exception
 
 Test run options: --seed 42
 "
-    util_assert_report expected
+    assert_report expected
   end
 
   def test_run_error_teardown
@@ -266,7 +248,9 @@ Test run options: --seed 42
 
     @tu.run %w[-s 42]
 
-    expected = "Loaded suite blah
+    expected = "Test run options: --seed 42
+
+Loaded suite blah
 Started
 E
 Finished in 0.00
@@ -280,17 +264,17 @@ RuntimeError: unhandled exception
 
 Test run options: --seed 42
 "
-    util_assert_report expected
+    assert_report expected
   end
 
-  def test_run_skip
+  def test_run_failing # TODO: add error test
     tc = Class.new(MiniTest::Unit::TestCase) do
       def test_something
         assert true
       end
 
-      def test_skip
-        skip "not yet"
+      def test_failure
+        assert false
       end
     end
 
@@ -298,37 +282,22 @@ Test run options: --seed 42
 
     @tu.run %w[-s 42]
 
-    expected = "Loaded suite blah
-Started
-S.
-Finished in 0.00
+    expected = "Test run options: --seed 42
 
-  1) Skipped:
-test_skip(ATestCase) [FILE:LINE]:
-not yet
-
-2 tests, 1 assertions, 0 failures, 0 errors, 1 skips
-
-Test run options: --seed 42
-"
-    util_assert_report expected
-  end
-
-  def util_assert_report expected = nil
-    expected ||= "Loaded suite blah
+Loaded suite blah
 Started
-.
+F.
 Finished in 0.00
 
-1 tests, 1 assertions, 0 failures, 0 errors, 0 skips
+  1) Failure:
+test_failure(ATestCase) [FILE:LINE]:
+Failed assertion, no message given.
+
+2 tests, 2 assertions, 1 failures, 0 errors, 0 skips
 
 Test run options: --seed 42
 "
-    output = @output.string.sub(/Finished in .*/, "Finished in 0.00")
-    output.sub!(/Loaded suite .*/, 'Loaded suite blah')
-    output.sub!(/^(\s+)(?:#{Regexp.union(__FILE__, File.expand_path(__FILE__))}):\d+:/o, '\1FILE:LINE:')
-    output.sub!(/\[(?:#{Regexp.union(__FILE__, File.expand_path(__FILE__))}):\d+\]/o, '[FILE:LINE]')
-    assert_equal(expected, output)
+    assert_report expected
   end
 
   def test_run_failing_filtered
@@ -346,7 +315,9 @@ Test run options: --seed 42
 
     @tu.run %w[-n /something/ -s 42]
 
-    expected = "Loaded suite blah
+    expected = "Test run options: --seed 42 --name \"/something/\"
+
+Loaded suite blah
 Started
 .
 Finished in 0.00
@@ -355,7 +326,7 @@ Finished in 0.00
 
 Test run options: --seed 42 --name \"/something/\"
 "
-    util_assert_report expected
+    assert_report expected
   end
 
   def test_run_passing
@@ -369,7 +340,48 @@ Test run options: --seed 42 --name \"/something/\"
 
     @tu.run %w[-s 42]
 
-    util_assert_report
+    assert_report
+  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 %w[-s 42]
+
+    expected = "Test run options: --seed 42
+
+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
+
+Test run options: --seed 42
+"
+    assert_report expected
+  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
 end
 
@@ -388,39 +400,6 @@ class TestMiniTestTestCase < MiniTest::Unit::TestCase
     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
 
@@ -597,6 +576,60 @@ class TestMiniTestTestCase < MiniTest::Unit::TestCase
     end
   end
 
+  def test_assert_output_both
+    @assertion_count = 2
+
+    @tc.assert_output "yay", "blah" do
+      print "yay"
+      $stderr.print "blah"
+    end
+  end
+
+  def test_assert_output_err
+    @tc.assert_output nil, "blah" do
+      $stderr.print "blah"
+    end
+  end
+
+  def test_assert_output_neither
+    @assertion_count = 0
+
+    @tc.assert_output do
+      # do nothing
+    end
+  end
+
+  def test_assert_output_out
+    @tc.assert_output "blah" do
+      print "blah"
+    end
+  end
+
+  def test_assert_output_triggered_both
+    util_assert_triggered "In stdout.\nExpected \"yay\", not \"boo\"." do
+      @tc.assert_output "yay", "blah" do
+        print "boo"
+        $stderr.print "blah blah"
+      end
+    end
+  end
+
+  def test_assert_output_triggered_err
+    util_assert_triggered "In stderr.\nExpected \"blah\", not \"blah blah\"." do
+      @tc.assert_output nil, "blah" do
+        $stderr.print "blah blah"
+      end
+    end
+  end
+
+  def test_assert_output_triggered_out
+    util_assert_triggered "In stdout.\nExpected \"blah\", not \"blah blah\"." do
+      @tc.assert_output "blah" do
+        print "blah blah"
+      end
+    end
+  end
+
   def test_assert_raises
     @tc.assert_raises RuntimeError do
       raise "blah"
@@ -738,6 +771,32 @@ FILE:LINE:in `test_assert_raises_triggered_subclass'
     end
   end
 
+  def test_assert_silent
+    @assertion_count = 2
+
+    @tc.assert_silent do
+      # do nothing
+    end
+  end
+
+  def test_assert_silent_triggered_err
+    @assertion_count = 2
+
+    util_assert_triggered "In stderr.\nExpected \"\", not \"blah blah\"." do
+      @tc.assert_silent do
+        $stderr.print "blah blah"
+      end
+    end
+  end
+
+  def test_assert_silent_triggered_out
+    util_assert_triggered "In stdout.\nExpected \"\", not \"blah blah\"." do
+      @tc.assert_silent do
+        print "blah blah"
+      end
+    end
+  end
+
   def test_assert_throws
     @tc.assert_throws(:blah) do
       throw :blah
@@ -772,6 +831,41 @@ FILE:LINE:in `test_assert_raises_triggered_subclass'
     assert_equal "bye!\n", err
   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_raised
+                 assert_nothing_thrown assert_output assert_raise
+                 assert_raises assert_send assert_silent assert_throws)
+
+    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_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_flunk
     util_assert_triggered 'Epic Fail!' do
       @tc.flunk
@@ -796,34 +890,6 @@ FILE:LINE:in `test_assert_raises_triggered_subclass'
     @tc.pass
   end
 
-  def test_test_methods_sorted
-    @assertion_count = 0
-
-    sample_test_case = Class.new(MiniTest::Unit::TestCase) do
-      def self.test_order; :sorted end
-      def test_test3; assert "does not matter" end
-      def test_test2; assert "does not matter" end
-      def test_test1; 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) do
-      def test_test1; assert "does not matter" end
-      def test_test2; assert "does not matter" end
-      def test_test3; assert "does not matter" end
-    end
-
-    srand 42
-    expected = %w(test_test2 test_test1 test_test3)
-    assert_equal expected, sample_test_case.test_methods
-  end
-
   def test_refute
     @assertion_count = 2
 
@@ -922,18 +988,6 @@ FILE:LINE:in `test_assert_raises_triggered_subclass'
     @tc.refute_match Object.new, 5 # default #=~ returns false
   end
 
-  def test_assert_object_triggered
-    @assertion_count = 2
-
-    pattern = Object.new
-    def pattern.=~(other) false end
-    def pattern.inspect; "<<Object>>" end
-
-    util_assert_triggered 'Expected <<Object>> to match 5.' do
-      @tc.assert_match pattern, 5
-    end
-  end
-
   def test_refute_match_object_triggered
     @assertion_count = 2
 
@@ -1001,6 +1055,34 @@ FILE:LINE:in `test_assert_raises_triggered_subclass'
     end
   end
 
+  def test_test_methods_random
+    @assertion_count = 0
+
+    sample_test_case = Class.new(MiniTest::Unit::TestCase) do
+      def test_test1; assert "does not matter" end
+      def test_test2; assert "does not matter" end
+      def test_test3; assert "does not matter" end
+    end
+
+    srand 42
+    expected = %w(test_test2 test_test1 test_test3)
+    assert_equal expected, sample_test_case.test_methods
+  end
+
+  def test_test_methods_sorted
+    @assertion_count = 0
+
+    sample_test_case = Class.new(MiniTest::Unit::TestCase) do
+      def self.test_order; :sorted end
+      def test_test3; assert "does not matter" end
+      def test_test2; assert "does not matter" end
+      def test_test1; assert "does not matter" end
+    end
+
+    expected = %w(test_test1 test_test2 test_test3)
+    assert_equal expected, sample_test_case.test_methods
+  end
+
   def util_assert_triggered expected, klass = MiniTest::Assertion
     e = assert_raises(klass) do
       yield

metadata

@@ -1,12 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: minitest
 version: !ruby/object:Gem::Version 
+  hash: 11
   prerelease: false
   segments: 
   - 1
-  - 6
+  - 7
   - 0
-  version: 1.6.0
+  version: 1.7.0
 platform: ruby
 authors: 
 - Ryan Davis
@@ -35,49 +36,55 @@ cert_chain:
   FBHgymkyj/AOSqKRIpXPhjC6
   -----END CERTIFICATE-----
 
-date: 2010-03-27 00:00:00 -07:00
+date: 2010-07-15 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: rubyforge
   prerelease: false
   requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
+        hash: 7
         segments: 
         - 2
         - 0
-        - 3
-        version: 2.0.3
+        - 4
+        version: 2.0.4
   type: :development
   version_requirements: *id001
 - !ruby/object:Gem::Dependency 
   name: minitest
   prerelease: false
   requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
+        hash: 15
         segments: 
         - 1
-        - 5
+        - 6
         - 0
-        version: 1.5.0
+        version: 1.6.0
   type: :development
   version_requirements: *id002
 - !ruby/object:Gem::Dependency 
   name: hoe
   prerelease: false
   requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
+        hash: 21
         segments: 
         - 2
         - 6
-        - 0
-        version: 2.6.0
+        - 1
+        version: 2.6.1
   type: :development
   version_requirements: *id003
 description: |-
@@ -126,23 +133,27 @@ rdoc_options:
 require_paths: 
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      hash: 3
       segments: 
       - 0
       version: "0"
 required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      hash: 3
       segments: 
       - 0
       version: "0"
 requirements: []
 
 rubyforge_project: bfts
-rubygems_version: 1.3.6
+rubygems_version: 1.3.7
 signing_key: 
 specification_version: 3
 summary: minitest/unit is a small and fast replacement for ruby's huge and slow test/unit