Imported minitest 1.6.0 r5717.

git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@27076 b2dd03c8-39d4-4d8f-98ff-823fe69b080e

ChangeLog

@@ -1,3 +1,8 @@
+Sun Mar 28 10:35:45 2010  Ryan Davis  <ryand-ruby@zenspider.com>
+
+	* lib/minitest/*.rb: Imported minitest 1.6.0 r5717.
+	* test/minitest/*.rb: ditto.
+
 Sun Mar 28 10:12:28 2010  Tanaka Akira  <akr@fsij.org>
 
 	* time.c (rb_time_magnify): fix for LP64.

lib/minitest/mock.rb

@@ -16,6 +16,7 @@ module MiniTest
     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__ :remove_method, name if respond_to? name
       self.class.__send__(:define_method, name) { |*x|
         raise ArgumentError unless @expected_calls[n][:args].size == x.size
         @actual_calls[n] << { :retval => r, :args => x }

lib/minitest/spec.rb

@@ -64,6 +64,14 @@ class Object
 end
 
 module Kernel
+  ##
+  # Describe a series of expectations for a given target +desc+.
+  #
+  # TODO: find good tutorial url.
+  #
+  # Defines a test class subclassing from either
+  # MiniTest::Unit::TestCase or from the surrounding describe's class.
+
   def describe desc, &block
     stack = MiniTest::Spec.describe_stack
     name  = desc.to_s.split(/\W+/).map { |s| s.capitalize }.join + "Spec"
@@ -80,28 +88,36 @@ module Kernel
   private :describe
 end
 
+class Module
+  def classes type = Object # :nodoc:
+    constants.map { |n| const_get n }.find_all { |c|
+      c.class == Class and type > c
+    } - [self]
+  end
+end
+
 class MiniTest::Spec < MiniTest::Unit::TestCase
   @@describe_stack = [MiniTest::Spec]
-  def self.describe_stack
+  def self.describe_stack # :nodoc:
     @@describe_stack
   end
 
-  def self.current
+  def self.current # :nodoc:
     @@current_spec
   end
 
-  def initialize name
+  def initialize name # :nodoc:
     super
     @@current_spec = self
   end
 
-  def self.nuke_test_methods!
+  def self.nuke_test_methods! # :nodoc:
     self.public_instance_methods.grep(/^test_/).each do |name|
       self.send :undef_method, name
     end
   end
 
-  def self.define_inheritable_method name, &block
+  def self.define_inheritable_method name, &block # :nodoc:
     super_method = self.superclass.instance_method name
 
     define_method name do
@@ -110,25 +126,167 @@ class MiniTest::Spec < MiniTest::Unit::TestCase
     end
   end
 
-  def self.before(type = :each, &block)
+  ##
-    if type == :all
+  # Define a 'before' action. Inherits the way normal methods should.
-      warn "change before :all to before :each"
+  #
-      type = :each
+  # NOTE: +type+ is ignored and is only there to make porting easier.
-    end
+  #
+  # Equivalent to MiniTest::Unit::TestCase#setup.
+
+  def self.before type = :each, &block
     raise "unsupported before type: #{type}" unless type == :each
     define_inheritable_method :setup, &block
   end
 
-  def self.after(type = :each, &block)
+  ##
-    if type == :all # REFACTOR
+  # Define an 'after' action. Inherits the way normal methods should.
-      warn "change before :all to before :each"
+  #
-      type = :each
+  # NOTE: +type+ is ignored and is only there to make porting easier.
-    end
+  #
+  # Equivalent to MiniTest::Unit::TestCase#teardown.
+
+  def self.after type = :each, &block
     raise "unsupported after type: #{type}" unless type == :each
     define_inheritable_method :teardown, &block
   end
 
+  ##
+  # Define an expectation with name +desc+. Name gets morphed to a
+  # proper test method name. For some freakish reason, people who
+  # write specs don't like class inheritence, so this goes way out of
+  # its way to make sure that expectations aren't inherited.
+  #
+  # Hint: If you _do_ want inheritence, use minitest/unit. You can mix
+  # and match between assertions and expectations as much as you want.
+
   def self.it desc, &block
-    define_method "test_#{desc.gsub(/\W+/, '_').downcase}", &block
+    block ||= proc { skip "(no tests defined)" }
+
+    @specs ||= 0
+    @specs += 1
+
+    name = "test_%04d_%s" % [ @specs, desc.gsub(/\W+/, '_').downcase ]
+
+    define_method name, &block
+
+    classes(MiniTest::Spec).each do |mod|
+      mod.send :undef_method, name if mod.respond_to? name
+    end
   end
+
+  ##
+  # :method: must_be
+  # See MiniTest::Assertions#assert
+
+  ##
+  # :method: must_be_close_to
+  # See MiniTest::Assertions#assert_in_delta
+
+  ##
+  # :method: must_be_empty
+  # See MiniTest::Assertions#assert_empty
+
+  ##
+  # :method: must_be_instance_of
+  # See MiniTest::Assertions#assert_instance_of
+
+  ##
+  # :method: must_be_kind_of
+  # See MiniTest::Assertions#assert_kind_of
+
+  ##
+  # :method: must_be_nil
+  # See MiniTest::Assertions#assert_nil
+
+  ##
+  # :method: must_be_same_as
+  # See MiniTest::Assertions#assert_same
+
+  ##
+  # :method: must_be_within_delta
+  # See MiniTest::Assertions#assert_in_delta
+
+  ##
+  # :method: must_be_within_epsilon
+  # See MiniTest::Assertions#assert_in_epsilon
+
+  ##
+  # :method: must_equal
+  # See MiniTest::Assertions#assert_equal
+
+  ##
+  # :method: must_include
+  # See MiniTest::Assertions#assert_includes
+
+  ##
+  # :method: must_match
+  # See MiniTest::Assertions#assert_match
+
+  ##
+  # :method: must_raise
+  # See MiniTest::Assertions#assert_raises
+
+  ##
+  # :method: must_respond_to
+  # See MiniTest::Assertions#assert_respond_to
+
+  ##
+  # :method: must_send
+  # See MiniTest::Assertions#assert_send
+
+  ##
+  # :method: must_throw
+  # See MiniTest::Assertions#assert_throw
+
+  ##
+  # :method: wont_be
+  # See MiniTest::Assertions#refute
+
+  ##
+  # :method: wont_be_close_to
+  # See MiniTest::Assertions#refute_in_delta
+
+  ##
+  # :method: wont_be_empty
+  # See MiniTest::Assertions#refute_empty
+
+  ##
+  # :method: wont_be_instance_of
+  # See MiniTest::Assertions#refute_instance_of
+
+  ##
+  # :method: wont_be_kind_of
+  # See MiniTest::Assertions#refute_kind_of
+
+  ##
+  # :method: wont_be_nil
+  # See MiniTest::Assertions#refute_nil
+
+  ##
+  # :method: wont_be_same_as
+  # See MiniTest::Assertions#refute_same
+
+  ##
+  # :method: wont_be_within_delta
+  # See MiniTest::Assertions#refute_in_delta
+
+  ##
+  # :method: wont_be_within_epsilon
+  # See MiniTest::Assertions#refute_in_epsilon
+
+  ##
+  # :method: wont_equal
+  # See MiniTest::Assertions#refute_equal
+
+  ##
+  # :method: wont_include
+  # See MiniTest::Assertions#refute_includes
+
+  ##
+  # :method: wont_match
+  # See MiniTest::Assertions#refute_match
+
+  ##
+  # :method: wont_respond_to
+  # See MiniTest::Assertions#refute_respond_to
 end

lib/minitest/unit.rb

@@ -4,14 +4,21 @@
 # File a patch instead and assign it to Ryan Davis
 ############################################################
 
+require 'optparse'
+
 ##
-#
+# Minimal (mostly drop-in) replacement for test-unit.
-# Totally minimal drop-in replacement for test-unit
-#
-# TODO: refute -> debunk, prove/rebut, show/deny... lots of possibilities
 
 module MiniTest
+
+  ##
+  # Assertion base class
+
   class Assertion < Exception; end
+
+  ##
+  # Assertion raised when skipping a test
+
   class Skip < Assertion; end
 
   file = if RUBY_VERSION =~ /^1\.9/ then  # bt's expanded, but __FILE__ isn't :(
@@ -27,9 +34,9 @@ module MiniTest
          end
 
   # './lib' in project dir, or '/usr/local/blahblah' if installed
-  MINI_DIR = File.dirname(File.dirname(file))
+  MINI_DIR = File.dirname(File.dirname(file)) # :nodoc:
 
-  def self.filter_backtrace bt
+  def self.filter_backtrace bt # :nodoc:
     return ["No backtrace"] unless bt
 
     new_bt = []
@@ -43,21 +50,33 @@ module MiniTest
     new_bt
   end
 
+  ##
+  # MiniTest Assertions.  All assertion methods accept a +msg+ which is
+  # printed if the assertion fails.
+
   module Assertions
-    def mu_pp(obj)
+
+    ##
+    # mu_pp gives a human-readable version of +obj+.  By default #inspect is
+    # called.  You can override this to use #pretty_print if you want.
+
+    def mu_pp obj
       s = obj.inspect
       s = s.force_encoding(Encoding.default_external) if defined? Encoding
       s
     end
 
-    def _assertions= n
+    def _assertions= n # :nodoc:
       @_assertions = n
     end
 
-    def _assertions
+    def _assertions # :nodoc:
       @_assertions ||= 0
     end
 
+    ##
+    # Fails unless +test+ is a true value.
+
     def assert test, msg = nil
       msg ||= "Failed assertion, no message given."
       self._assertions += 1
@@ -68,32 +87,56 @@ module MiniTest
       true
     end
 
+    ##
+    # Fails unless the block returns a true value.
+
     def assert_block msg = nil
       msg = message(msg) { "Expected block to return true value" }
       assert yield, msg
     end
 
+    ##
+    # Fails unless +obj+ is empty.
+
     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
 
+    ##
+    # Fails unless <tt>exp == act</tt>.
+    #
+    # For floats use assert_in_delta
+
     def assert_equal exp, act, msg = nil
       msg = message(msg) { "Expected #{mu_pp(exp)}, not #{mu_pp(act)}" }
       assert(exp == act, msg)
     end
 
+    ##
+    # For comparing Floats.  Fails unless +exp+ and +act+ are within +delta+
+    # of each other.
+    #
+    #   assert_in_delta Math::PI, (22.0 / 7.0), 0.01
+
     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
 
+    ##
+    # For comparing Floats.  Fails unless +exp+ and +act+ have a relative
+    # error less than +epsilon+.
+
     def assert_in_epsilon a, b, epsilon = 0.001, msg = nil
       assert_in_delta a, b, [a, b].min * epsilon, msg
     end
 
+    ##
+    # Fails unless +collection+ includes +obj+.
+
     def assert_includes collection, obj, msg = nil
       msg = message(msg) {
         "Expected #{mu_pp(collection)} to include #{mu_pp(obj)}"
@@ -102,6 +145,9 @@ module MiniTest
       assert collection.include?(obj), msg
     end
 
+    ##
+    # Fails unless +obj+ is an instace of +cls+.
+
     def assert_instance_of cls, obj, msg = nil
       msg = message(msg) {
         "Expected #{mu_pp(obj)} to be an instance of #{cls}, not #{obj.class}"
@@ -110,6 +156,9 @@ module MiniTest
       assert obj.instance_of?(cls), msg
     end
 
+    ##
+    # Fails unless +obj+ is a kind of +cls+.
+
     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}, not #{obj.class}" }
@@ -117,23 +166,37 @@ module MiniTest
       assert obj.kind_of?(cls), msg
     end
 
+    ##
+    # Fails unless +exp+ is <tt>=~</tt> +act+.
+
     def assert_match exp, act, msg = nil
       msg = message(msg) { "Expected #{mu_pp(exp)} to match #{mu_pp(act)}" }
       assert_respond_to act, :"=~"
-      exp = /#{Regexp.escape(exp)}/ if String === exp && String === act
+      exp = /#{Regexp.escape exp}/ if String === exp && String === act
       assert exp =~ act, msg
     end
 
+    ##
+    # Fails unless +obj+ is nil
+
     def assert_nil obj, msg = nil
       msg = message(msg) { "Expected #{mu_pp(obj)} to be nil" }
       assert obj.nil?, msg
     end
 
+    ##
+    # For testing equality operators and so-forth.
+    #
+    #   assert_operator 5, :<=, 4
+
     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
 
+    ##
+    # Fails unless the block raises one of +exp+
+
     def assert_raises *exp
       msg = String === exp.last ? exp.pop : nil
       msg = msg.to_s + "\n" if msg
@@ -155,6 +218,9 @@ module MiniTest
         should_raise
     end
 
+    ##
+    # Fails unless +obj+ responds to +meth+.
+
     def assert_respond_to obj, meth, msg = nil
       msg = message(msg) {
           "Expected #{mu_pp(obj)} (#{obj.class}) to respond to ##{meth}"
@@ -162,14 +228,22 @@ module MiniTest
       assert obj.respond_to?(meth), msg
     end
 
+    ##
+    # Fails unless +exp+ and +act+ are #equal?
+
     def assert_same exp, act, msg = nil
       msg = message(msg) {
         data = [mu_pp(act), act.object_id, mu_pp(exp), exp.object_id]
-        "Expected %s (0x%x) to be the same as %s (0x%x)" % data
+        "Expected %s (oid=%d) to be the same as %s (oid=%d)" % data
       }
       assert exp.equal?(act), msg
     end
 
+    ##
+    # +send_ary+ is a receiver, message and arguments.
+    #
+    # Fails unless the call returns a true value
+
     def assert_send send_ary, m = nil
       recv, msg, *args = send_ary
       m = message(m) {
@@ -177,6 +251,9 @@ module MiniTest
       assert recv.__send__(msg, *args), m
     end
 
+    ##
+    # Fails unless the block throws +sym+
+
     def assert_throws sym, msg = nil
       default = "Expected #{mu_pp(sym)} to have been thrown"
       caught = true
@@ -194,6 +271,15 @@ module MiniTest
       assert caught, message(msg) { default }
     end
 
+    ##
+    # Captures $stdout and $stderr into strings:
+    #
+    #   out, err = capture_io do
+    #     warn "You did a bad thing"
+    #   end
+    #
+    #   assert_match %r%bad%, err
+
     def capture_io
       require 'stringio'
 
@@ -209,15 +295,24 @@ module MiniTest
       $stderr = orig_stderr
     end
 
+    ##
+    # Returns details for exception +e+
+
     def exception_details e, msg
       "#{msg}\nClass: <#{e.class}>\nMessage: <#{e.message.inspect}>\n---Backtrace---\n#{MiniTest::filter_backtrace(e.backtrace).join("\n")}\n---------------"
     end
 
+    ##
+    # Fails with +msg+
+
     def flunk msg = nil
       msg ||= "Epic Fail!"
       assert false, msg
     end
 
+    ##
+    # Returns a proc that will output +msg+ along with the default message.
+
     def message msg = nil, &default
       proc {
         if msg then
@@ -231,22 +326,35 @@ module MiniTest
       }
     end
 
+    ##
     # used for counting assertions
+
     def pass msg = nil
       assert true
     end
 
+    ##
+    # Fails if +test+ is a true value
+
     def refute test, msg = nil
       msg ||= "Failed refutation, no message given"
       not assert(! test, msg)
     end
 
+    ##
+    # Fails if +obj+ is empty.
+
     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
 
+    ##
+    # Fails if <tt>exp == act</tt>.
+    #
+    # For floats use refute_in_delta.
+
     def refute_equal exp, act, msg = nil
       msg = message(msg) {
         "Expected #{mu_pp(act)} to not be equal to #{mu_pp(exp)}"
@@ -254,6 +362,11 @@ module MiniTest
       refute exp == act, msg
     end
 
+    ##
+    # For comparing Floats.  Fails if +exp+ is within +delta+ of +act+
+    #
+    #   refute_in_delta Math::PI, (22.0 / 7.0)
+
     def refute_in_delta exp, act, delta = 0.001, msg = nil
       n = (exp - act).abs
       msg = message(msg) {
@@ -262,10 +375,17 @@ module MiniTest
       refute delta > n, msg
     end
 
+    ##
+    # For comparing Floats.  Fails if +exp+ and +act+ have a relative error
+    # less than +epsilon+.
+
     def refute_in_epsilon a, b, epsilon = 0.001, msg = nil
       refute_in_delta a, b, a * epsilon, msg
     end
 
+    ##
+    # Fails if +collection+ includes +obj+
+
     def refute_includes collection, obj, msg = nil
       msg = message(msg) {
         "Expected #{mu_pp(collection)} to not include #{mu_pp(obj)}"
@@ -274,6 +394,9 @@ module MiniTest
       refute collection.include?(obj), msg
     end
 
+    ##
+    # Fails if +obj+ is an instance of +cls+
+
     def refute_instance_of cls, obj, msg = nil
       msg = message(msg) {
         "Expected #{mu_pp(obj)} to not be an instance of #{cls}"
@@ -281,23 +404,38 @@ module MiniTest
       refute obj.instance_of?(cls), msg
     end
 
+    ##
+    # Fails if +obj+ is a kind of +cls+
+
     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}" }
       refute obj.kind_of?(cls), msg
     end
 
+    ##
+    # Fails if +exp+ <tt>=~</tt> +act+
+
     def refute_match exp, act, msg = nil
       msg = message(msg) { "Expected #{mu_pp(exp)} to not match #{mu_pp(act)}" }
       assert_respond_to act, :"=~"
-      exp = /#{Regexp.escape(exp)}/ if String === exp && String === act
+      exp = (/#{Regexp.escape exp}/) if String === exp and String === act
       refute exp =~ act, msg
     end
 
+    ##
+    # Fails if +obj+ is nil.
+
     def refute_nil obj, msg = nil
       msg = message(msg) { "Expected #{mu_pp(obj)} to not be nil" }
       refute obj.nil?, msg
     end
 
+    ##
+    # Fails if +o1+ is not +op+ +o2+ nil. eg:
+    #
+    #   refute_operator 1, :>, 2 #=> pass
+    #   refute_operator 1, :<, 2 #=> fail
+
     def refute_operator o1, op, o2, msg = nil
       msg = message(msg) {
         "Expected #{mu_pp(o1)} to not be #{op} #{mu_pp(o2)}"
@@ -305,19 +443,30 @@ module MiniTest
       refute o1.__send__(op, o2), msg
     end
 
+    ##
+    # Fails if +obj+ responds to the message +meth+.
+
     def refute_respond_to obj, meth, msg = nil
       msg = message(msg) { "Expected #{mu_pp(obj)} to not respond to #{meth}" }
 
       refute obj.respond_to?(meth), msg
     end
 
+    ##
+    # Fails if +exp+ is the same (by object identity) as +act+.
+
     def refute_same exp, act, msg = nil
       msg = message(msg) {
-        "Expected #{mu_pp(act)} to not be the same as #{mu_pp(exp)}"
+        data = [mu_pp(act), act.object_id, mu_pp(exp), exp.object_id]
+        "Expected %s (oid=%d) to not be the same as %s (oid=%d)" % data
       }
       refute exp.equal?(act), msg
     end
 
+    ##
+    # Skips the current test. Gets listed at the end of the run but
+    # doesn't cause a failure exit code.
+
     def skip msg = nil, bt = caller
       msg ||= "Skipped, no message given"
       raise MiniTest::Skip, msg, bt
@@ -325,15 +474,18 @@ module MiniTest
   end
 
   class Unit
-    VERSION = "1.5.0"
+    VERSION = "1.6.0" # :nodoc:
 
-    attr_accessor :report, :failures, :errors, :skips
+    attr_accessor :report, :failures, :errors, :skips # :nodoc:
-    attr_accessor :test_count, :assertion_count
+    attr_accessor :test_count, :assertion_count       # :nodoc:
-    attr_accessor :start_time
+    attr_accessor :start_time                         # :nodoc:
 
     @@installed_at_exit ||= false
     @@out = $stdout
 
+    ##
+    # Registers MiniTest::Unit to run tests at process exit
+
     def self.autorun
       at_exit {
         next if $! # don't run if there was an exception
@@ -343,11 +495,15 @@ module MiniTest
       @@installed_at_exit = true
     end
 
+    ##
+    # Sets MiniTest::Unit to write output to +stream+.  $stdout is the default
+    # output
+
     def self.output= stream
       @@out = stream
     end
 
-    def location e
+    def location e # :nodoc:
       last_before_assertion = ""
       e.backtrace.reverse_each do |s|
         break if s =~ /in .(assert|refute|flunk|pass|fail|raise|must|wont)/
@@ -356,6 +512,10 @@ module MiniTest
       last_before_assertion.sub(/:in .*$/, '')
     end
 
+    ##
+    # Writes status for failed test +meth+ in +klass+ which finished with
+    # exception +e+
+
     def puke klass, meth, e
       e = case e
           when MiniTest::Skip then
@@ -373,25 +533,60 @@ module MiniTest
       e[0, 1]
     end
 
-    def initialize
+    def initialize # :nodoc:
       @report = []
       @errors = @failures = @skips = 0
       @verbose = false
     end
 
+    def process_args args = []
+      options = {}
+
+      OptionParser.new do |opts|
+        opts.banner  = 'minitest options:'
+        opts.version = MiniTest::Unit::VERSION
+
+        opts.on '-h', '--help', 'Display this help.' do
+          puts opts
+          exit
+        end
+
+        opts.on '-s', '--seed SEED', Integer, "Sets random seed" do |m|
+          options[:seed] = m.to_i
+        end
+
+        opts.on '-v', '--verbose', "Verbose. Show progress processing files." do
+          options[:verbose] = true
+        end
+
+        opts.on '-n', '--name PATTERN', "Filter test names on pattern." do |a|
+          options[:filter] = a
+        end
+
+        opts.parse args
+      end
+
+      options
+    end
+
     ##
     # Top level driver, controls all output and filtering.
 
     def run args = []
-      @verbose = args.delete('-v')
+      options = process_args args
 
-      filter = if args.first =~ /^(-n|--name)$/ then
+      @verbose = options[:verbose]
-                 args.shift
+
-                 arg = args.shift
+      filter = options[:filter] || '/./'
-                 arg =~ /\/(.*)\// ? Regexp.new($1) : arg
+      filter = Regexp.new $1 if filter and filter =~ /\/(.*)\//
-               else
+
-                 /./ # anything - ^test_ already filtered by #tests
+      seed = options[:seed]
-               end
+      unless seed then
+        srand
+        seed = srand % 0xFFFF
+      end
+
+      srand seed
 
       @@out.puts "Loaded suite #{$0.sub(/\.rb$/, '')}\nStarted"
 
@@ -409,16 +604,30 @@ module MiniTest
 
       status
 
+      @@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...
     rescue Interrupt
       abort 'Interrupted'
     end
 
+    ##
+    # Writes status to +io+
+
     def status io = @@out
       format = "%d tests, %d assertions, %d failures, %d errors, %d skips"
       io.puts format % [test_count, assertion_count, failures, errors, skips]
     end
 
+    ##
+    # Runs test suites matching +filter+
+
     def run_test_suites filter = /./
       @test_count, @assertion_count = 0, 0
       old_sync, @@out.sync = @@out.sync, true if @@out.respond_to? :sync=
@@ -442,13 +651,20 @@ module MiniTest
       [@test_count, @assertion_count]
     end
 
+    ##
+    # Subclass TestCase to create your own tests.  Typically you'll want a
+    # TestCase subclass per implementation class.
+
     class TestCase
-      attr_reader :__name__
+      attr_reader :__name__ # :nodoc:
 
-      PASSTHROUGH_EXCEPTIONS = [NoMemoryError, SignalException, Interrupt,
+      PASSTHROUGH_EXCEPTIONS = [NoMemoryError, SignalException,
-        SystemExit]
+                                Interrupt, SystemExit] # :nodoc:
 
-      SUPPORTS_INFO_SIGNAL = Signal.list['INFO']
+      SUPPORTS_INFO_SIGNAL = Signal.list['INFO'] # :nodoc:
+
+      ##
+      # Runs the tests reporting the status to +runner+
 
       def run runner
         trap 'INFO' do
@@ -481,61 +697,79 @@ module MiniTest
         result
       end
 
-      def initialize name
+      def initialize name # :nodoc:
         @__name__ = name
         @passed = nil
       end
 
-      def self.reset
+      def self.reset # :nodoc:
         @@test_suites = {}
       end
 
       reset
 
-      def self.inherited klass
+      def self.inherited klass # :nodoc:
         @@test_suites[klass] = true
       end
 
+      ##
+      # Defines test order and is subclassable. Defaults to :random
+      # but can be overridden to return :alpha if your tests are order
+      # dependent (read: weak).
+
       def self.test_order
         :random
       end
 
-      def self.test_suites
+      def self.test_suites # :nodoc:
         @@test_suites.keys.sort_by { |ts| ts.name }
       end
 
-      def self.test_methods
+      def self.test_methods # :nodoc:
-        methods = public_instance_methods(true).grep(/^test/).map { |m|
+        methods = public_instance_methods(true).grep(/^test/).map { |m| m.to_s }
-          m.to_s
-        }.sort
 
-        if self.test_order == :random then
+        case self.test_order
+        when :random then
           max = methods.size
-          methods = methods.sort_by { rand(max) }
+          methods.sort.sort_by { rand(max) }
+        when :alpha, :sorted then
+          methods.sort
+        else
+          raise "Unknown test_order: #{self.test_order.inspect}"
         end
-
-        methods
       end
 
-      def setup; end
+      ##
-      def teardown; end
+      # Returns true if the test passed.
 
       def passed?
         @passed
       end
 
+      ##
+      # Runs before every test. Use this to refactor test initialization.
+
+      def setup; end
+
+      ##
+      # Runs after every test. Use this to refactor test cleanup.
+
+      def teardown; end
+
       include MiniTest::Assertions
     end # class TestCase
   end # class Unit
 end # module MiniTest
 
 if $DEBUG then
-  # this helps me ferret out porting issues
+  module Test                # :nodoc:
-  module Test; end
+    module Unit              # :nodoc:
-  module Test::Unit; end
+      class TestCase         # :nodoc:
-  class Test::Unit::TestCase
+        def self.inherited x # :nodoc:
-    def self.inherited x
+          # this helps me ferret out porting issues
-      raise "You're running minitest and test/unit in the same process: #{x}"
+          raise "Using minitest and test/unit in the same process: #{x}"
+        end
+      end
     end
   end
 end

test/minitest/test_mini_spec.rb

@@ -17,6 +17,9 @@ describe MiniTest::Spec do
     self._assertions.must_equal @assertion_count
   end
 
+  # TODO: figure out how the hell to write a test for this
+  # it "will skip if there is no block"
+
   it "needs to have all methods named well" do
     @assertion_count = 2
 

test/minitest/test_mini_test.rb

@@ -207,7 +207,7 @@ class TestMiniTest < MiniTest::Unit::TestCase
 
     Object.const_set(:ATestCase, tc)
 
-    @tu.run
+    @tu.run %w[-s 42]
 
     expected = "Loaded suite blah
 Started
@@ -219,6 +219,8 @@ 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
 "
     util_assert_report expected
   end
@@ -236,7 +238,7 @@ Failed assertion, no message given.
 
     Object.const_set(:ATestCase, tc)
 
-    @tu.run
+    @tu.run %w[-s 42]
 
     expected = "Loaded suite blah
 Started
@@ -249,6 +251,8 @@ RuntimeError: unhandled exception
     FILE:LINE:in `test_error'
 
 2 tests, 1 assertions, 0 failures, 1 errors, 0 skips
+
+Test run options: --seed 42
 "
     util_assert_report expected
   end
@@ -266,7 +270,7 @@ RuntimeError: unhandled exception
 
     Object.const_set(:ATestCase, tc)
 
-    @tu.run
+    @tu.run %w[-s 42]
 
     expected = "Loaded suite blah
 Started
@@ -279,6 +283,8 @@ RuntimeError: unhandled exception
     FILE:LINE:in `teardown'
 
 1 tests, 1 assertions, 0 failures, 1 errors, 0 skips
+
+Test run options: --seed 42
 "
     util_assert_report expected
   end
@@ -296,7 +302,7 @@ RuntimeError: unhandled exception
 
     Object.const_set(:ATestCase, tc)
 
-    @tu.run
+    @tu.run %w[-s 42]
 
     expected = "Loaded suite blah
 Started
@@ -308,6 +314,8 @@ 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
@@ -319,6 +327,8 @@ Started
 Finished in 0.00
 
 1 tests, 1 assertions, 0 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')
@@ -340,9 +350,18 @@ Finished in 0.00
 
     Object.const_set(:ATestCase, tc)
 
-    @tu.run(%w(-n /something/))
+    @tu.run %w[-n /something/ -s 42]
 
-    util_assert_report
+    expected = "Loaded suite blah
+Started
+.
+Finished in 0.00
+
+1 tests, 1 assertions, 0 failures, 0 errors, 0 skips
+
+Test run options: --seed 42 --name \"/something/\"
+"
+    util_assert_report expected
   end
 
   def test_run_passing
@@ -354,7 +373,7 @@ Finished in 0.00
 
     Object.const_set(:ATestCase, tc)
 
-    @tu.run
+    @tu.run %w[-s 42]
 
     util_assert_report
   end
@@ -703,14 +722,14 @@ FILE:LINE:in `test_assert_raises_triggered_subclass'
   def test_assert_same_triggered
     @assertion_count = 2
 
-    util_assert_triggered 'Expected 2 (0xXXX) to be the same as 1 (0xXXX).' do
+    util_assert_triggered 'Expected 2 (oid=N) to be the same as 1 (oid=N).' 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
+    util_assert_triggered 'Expected "blah" (oid=N) to be the same as "blah" (oid=N).' do
       @tc.assert_same s1, s2
     end
   end
@@ -786,16 +805,11 @@ FILE:LINE:in `test_assert_raises_triggered_subclass'
   def test_test_methods_sorted
     @assertion_count = 0
 
-    sample_test_case = Class.new(MiniTest::Unit::TestCase)
+    sample_test_case = Class.new(MiniTest::Unit::TestCase) do
-
+      def self.test_order; :sorted end
-    class << sample_test_case
+      def test_test3; assert "does not matter" end
-      def test_order; :sorted end
+      def test_test2; assert "does not matter" end
-    end
+      def test_test1; assert "does not matter" 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)
@@ -805,27 +819,15 @@ FILE:LINE:in `test_assert_raises_triggered_subclass'
   def test_test_methods_random
     @assertion_count = 0
 
-    sample_test_case = Class.new(MiniTest::Unit::TestCase)
+    sample_test_case = Class.new(MiniTest::Unit::TestCase) do
-
+      def test_test1; assert "does not matter" end
-    class << sample_test_case
+      def test_test2; assert "does not matter" end
-      def test_order; :random end
+      def test_test3; assert "does not matter" 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)
+    expected = %w(test_test2 test_test1 test_test3)
-    max = expected.size
+    assert_equal expected, sample_test_case.test_methods
-    expected = expected.sort_by { rand(max) }
-
-    srand 42
-    result = sample_test_case.test_methods
-
-    assert_equal expected, result
   end
 
   def test_refute
@@ -991,9 +993,8 @@ FILE:LINE:in `test_assert_raises_triggered_subclass'
     @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
+    util_assert_triggered 'Expected 1 (oid=N) to not be the same as 1 (oid=N).' do
       @tc.refute_same 1, 1
     end
   end
@@ -1012,7 +1013,7 @@ FILE:LINE:in `test_assert_raises_triggered_subclass'
     end
 
     msg = e.message.sub(/(---Backtrace---).*/m, '\1')
-    msg.gsub!(/\(0x[0-9a-f]+\)/, '(0xXXX)')
+    msg.gsub!(/\(oid=[-0-9]+\)/, '(oid=N)')
 
     assert_equal expected, msg
   end