minitest 1.5.0 → 1.6.0

data/.autotest

@@ -3,6 +3,8 @@
 require 'autotest/restart'
 
 Autotest.add_hook :initialize do |at|
+  at.testlib = 'minitest/unit'
+
   at.extra_class_map["MiniSpec"]             = "test/test_mini_spec.rb"
   at.extra_class_map["TestMiniTestTestCase"] = "test/test_mini_test.rb"
 

data/History.txt

@@ -1,3 +1,23 @@
+=== 1.6.0 / 2010-03-27
+
+* 10 minor enhancements:
+
+  * Added --seed argument so you can reproduce a random order for debugging.
+  * Added documentation for assertions
+  * Added more rdoc and tons of :nodoc:
+  * Added output to give you all the options you need to reproduce that run.
+  * Added proper argument parsing to minitest.
+  * Added unique serial # to spec names so order can be preserved (needs tests). (phrogz)
+  * Empty 'it' fails with default msg. (phrogz)
+  * Remove previous method on expect to remove 1.9 warnings
+  * Spec#it is now order-proof wrt subclasses/nested describes.
+  * assert_same error message now reports in decimal, eg: oid=123. (mattkent)
+
+* 2 bug fixes:
+
+  * Fixed message on refute_same to be consistent with assert_same.
+  * Fixed method randomization to be stable for testing.
+
 === 1.5.0 / 2010-01-06
 
 * 4 minor enhancements:

data/lib/minitest/mock.rb

@@ -10,6 +10,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 }

data/lib/minitest/spec.rb

@@ -58,6 +58,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"
@@ -74,28 +82,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
@@ -104,25 +120,167 @@ class MiniTest::Spec < MiniTest::Unit::TestCase
     end
   end
 
-  def self.before(type = :each, &block)
-    if type == :all
-      warn "change before :all to before :each"
-      type = :each
-    end
+  ##
+  # Define a 'before' action. Inherits the way normal methods should.
+  #
+  # NOTE: +type+ is ignored and is only there to make porting easier.
+  #
+  # 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
-      warn "change before :all to before :each"
-      type = :each
-    end
+  ##
+  # Define an 'after' action. Inherits the way normal methods should.
+  #
+  # NOTE: +type+ is ignored and is only there to make porting easier.
+  #
+  # 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

data/lib/minitest/unit.rb

@@ -1,11 +1,18 @@
+require 'optparse'
+
 ##
-#
-# Totally minimal drop-in replacement for test-unit
-#
-# TODO: refute -> debunk, prove/rebut, show/deny... lots of possibilities
+# Minimal (mostly drop-in) replacement for test-unit.
 
 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 :(
@@ -21,9 +28,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 = []
@@ -37,21 +44,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
@@ -62,32 +81,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)}"
@@ -96,6 +139,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}"
@@ -104,6 +150,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}" }
@@ -111,23 +160,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
@@ -149,6 +212,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}"
@@ -156,14 +222,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) {
@@ -171,6 +245,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
@@ -188,6 +265,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'
 
@@ -203,15 +289,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
@@ -225,22 +320,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)}"
@@ -248,6 +356,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) {
@@ -256,10 +369,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)}"
@@ -268,6 +388,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}"
@@ -275,23 +398,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)}"
@@ -299,19 +437,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
@@ -319,15 +468,18 @@ module MiniTest
   end
 
   class Unit
-    VERSION = "1.5.0"
+    VERSION = "1.6.0" # :nodoc:
 
-    attr_accessor :report, :failures, :errors, :skips
-    attr_accessor :test_count, :assertion_count
-    attr_accessor :start_time
+    attr_accessor :report, :failures, :errors, :skips # :nodoc:
+    attr_accessor :test_count, :assertion_count       # :nodoc:
+    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
@@ -337,11 +489,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)/
@@ -350,6 +506,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
@@ -367,25 +527,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
+
+      @verbose = options[:verbose]
+
+      filter = options[:filter] || '/./'
+      filter = Regexp.new $1 if filter and filter =~ /\/(.*)\//
+
+      seed = options[:seed]
+      unless seed then
+        srand
+        seed = srand % 0xFFFF
+      end
 
-      filter = if args.first =~ /^(-n|--name)$/ then
-                 args.shift
-                 arg = args.shift
-                 arg =~ /\/(.*)\// ? Regexp.new($1) : arg
-               else
-                 /./ # anything - ^test_ already filtered by #tests
-               end
+      srand seed
 
       @@out.puts "Loaded suite #{$0.sub(/\.rb$/, '')}\nStarted"
 
@@ -403,16 +598,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=
@@ -436,13 +645,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,
-        SystemExit]
+      PASSTHROUGH_EXCEPTIONS = [NoMemoryError, SignalException,
+                                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
@@ -475,61 +691,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
-        methods = public_instance_methods(true).grep(/^test/).map { |m|
-          m.to_s
-        }.sort
+      def self.test_methods # :nodoc:
+        methods = public_instance_methods(true).grep(/^test/).map { |m| m.to_s }
 
-        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; end
-  module Test::Unit; end
-  class Test::Unit::TestCase
-    def self.inherited x
-      raise "You're running minitest and test/unit in the same process: #{x}"
+  module Test                # :nodoc:
+    module Unit              # :nodoc:
+      class TestCase         # :nodoc:
+        def self.inherited x # :nodoc:
+          # this helps me ferret out porting issues
+          raise "Using minitest and test/unit in the same process: #{x}"
+        end
+      end
     end
   end
 end

data/test/test_mini_spec.rb

@@ -11,6 +11,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
 

data/test/test_mini_test.rb

@@ -201,7 +201,7 @@ class TestMiniTest < MiniTest::Unit::TestCase
 
     Object.const_set(:ATestCase, tc)
 
-    @tu.run
+    @tu.run %w[-s 42]
 
     expected = "Loaded suite blah
 Started
@@ -213,6 +213,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
@@ -230,7 +232,7 @@ Failed assertion, no message given.
 
     Object.const_set(:ATestCase, tc)
 
-    @tu.run
+    @tu.run %w[-s 42]
 
     expected = "Loaded suite blah
 Started
@@ -243,6 +245,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
@@ -260,7 +264,7 @@ RuntimeError: unhandled exception
 
     Object.const_set(:ATestCase, tc)
 
-    @tu.run
+    @tu.run %w[-s 42]
 
     expected = "Loaded suite blah
 Started
@@ -273,6 +277,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
@@ -290,7 +296,7 @@ RuntimeError: unhandled exception
 
     Object.const_set(:ATestCase, tc)
 
-    @tu.run
+    @tu.run %w[-s 42]
 
     expected = "Loaded suite blah
 Started
@@ -302,6 +308,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
@@ -313,6 +321,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')
@@ -334,9 +344,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
@@ -348,7 +367,7 @@ Finished in 0.00
 
     Object.const_set(:ATestCase, tc)
 
-    @tu.run
+    @tu.run %w[-s 42]
 
     util_assert_report
   end
@@ -697,14 +716,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
@@ -780,16 +799,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)
-
-    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
+    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)
@@ -799,27 +813,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)
-
-    class << sample_test_case
-      def test_order; :random end
+    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
 
-    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
+    expected = %w(test_test2 test_test1 test_test3)
+    assert_equal expected, sample_test_case.test_methods
   end
 
   def test_refute
@@ -985,9 +987,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
@@ -1006,7 +1007,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

metadata

@@ -1,7 +1,12 @@
 --- !ruby/object:Gem::Specification 
 name: minitest
 version: !ruby/object:Gem::Version 
-  version: 1.5.0
+  prerelease: false
+  segments: 
+  - 1
+  - 6
+  - 0
+  version: 1.6.0
 platform: ruby
 authors: 
 - Ryan Davis
@@ -30,49 +35,51 @@ cert_chain:
   FBHgymkyj/AOSqKRIpXPhjC6
   -----END CERTIFICATE-----
 
-date: 2010-01-06 00:00:00 -08:00
+date: 2010-03-27 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: rubyforge
-  type: :development
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Requirement 
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
+        segments: 
+        - 2
+        - 0
+        - 3
         version: 2.0.3
-    version: 
-- !ruby/object:Gem::Dependency 
-  name: gemcutter
   type: :development
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Requirement 
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        version: 0.2.1
-    version: 
+  version_requirements: *id001
 - !ruby/object:Gem::Dependency 
   name: minitest
-  type: :development
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Requirement 
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        version: 1.4.2
-    version: 
+        segments: 
+        - 1
+        - 5
+        - 0
+        version: 1.5.0
+  type: :development
+  version_requirements: *id002
 - !ruby/object:Gem::Dependency 
   name: hoe
-  type: :development
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Requirement 
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        version: 2.5.0
-    version: 
+        segments: 
+        - 2
+        - 6
+        - 0
+        version: 2.6.0
+  type: :development
+  version_requirements: *id003
 description: |-
   minitest/unit is a small and fast replacement for ruby's huge and slow
   test/unit. This is meant to be clean and easy to use both as a regular
@@ -122,18 +129,20 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      segments: 
+      - 0
       version: "0"
-  version: 
 required_rubygems_version: !ruby/object:Gem::Requirement 
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      segments: 
+      - 0
       version: "0"
-  version: 
 requirements: []
 
 rubyforge_project: bfts
-rubygems_version: 1.3.5
+rubygems_version: 1.3.6
 signing_key: 
 specification_version: 3
 summary: minitest/unit is a small and fast replacement for ruby's huge and slow test/unit