minitest 4.1.0 → 4.2.0

data/History.txt

@@ -1,3 +1,19 @@
+=== 4.2.0 / 2012-11-02
+
+* 4 major enhancements:
+
+  * Added minitest/hell - run all your tests through the ringer!
+  * Added support for :parallel test_order to run test cases in parallel.
+  * Removed last_error and refactored runner code to be threadsafe.
+  * _run_suites now runs suites in parallel if they opt-in.
+
+* 4 minor enhancements:
+
+  * Added TestCase#synchronize
+  * Added TestCase.make_my_diffs_pretty!
+  * Added TestCase.parallelize_me!
+  * Lock on capture_io for thread safety (tenderlove)
+
 === 4.1.0 / 2012-10-05
 
 * 2 minor enhancements:

data/Manifest.txt

@@ -7,7 +7,9 @@ design_rationale.rb
 lib/hoe/minitest.rb
 lib/minitest/autorun.rb
 lib/minitest/benchmark.rb
+lib/minitest/hell.rb
 lib/minitest/mock.rb
+lib/minitest/parallel_each.rb
 lib/minitest/pride.rb
 lib/minitest/spec.rb
 lib/minitest/unit.rb

data/lib/minitest/hell.rb

@@ -0,0 +1,9 @@
+class Minitest::Unit::TestCase
+  class << self
+    alias :old_test_order :test_order
+
+    def test_order # :nodoc:
+      :parallel
+    end
+  end
+end

data/lib/minitest/parallel_each.rb

@@ -0,0 +1,29 @@
+class ParallelEach
+  require 'thread'
+  include Enumerable
+
+  N = (ENV['N'] || 2).to_i
+
+  def initialize list
+    @queue = Queue.new # *sigh*... the Queue api sucks sooo much...
+
+    list.each { |i| @queue << i }
+    N.times { @queue << nil }
+  end
+
+  def grep pattern
+    self.class.new super
+  end
+
+  def each
+    threads = N.times.map {
+      Thread.new do
+        Thread.current.abort_on_exception = true
+        while job = @queue.pop
+          yield job
+        end
+      end
+    }
+    threads.map(&:join)
+  end
+end

data/lib/minitest/unit.rb

@@ -1,5 +1,7 @@
 require 'optparse'
 require 'rbconfig'
+require 'thread' # required for 1.8
+require 'minitest/parallel_each'
 
 ##
 # Minimal (mostly drop-in) replacement for test-unit.
@@ -436,6 +438,8 @@ module MiniTest
       catch(sym) do
         begin
           yield
+        rescue ThreadError => e       # wtf?!? 1.8 + threads == suck
+          default += ", not :#{e.message[/uncaught throw \`(\w+?)\'/, 1]}"
         rescue ArgumentError => e     # 1.9 exception
           default += ", not #{e.message.split(/ /).last}"
         rescue NameError => e         # 1.8 exception
@@ -465,16 +469,21 @@ module MiniTest
     def capture_io
       require 'stringio'
 
-      orig_stdout, orig_stderr         = $stdout, $stderr
       captured_stdout, captured_stderr = StringIO.new, StringIO.new
-      $stdout, $stderr                 = captured_stdout, captured_stderr
 
-      yield
+      synchronize do
+        orig_stdout, orig_stderr = $stdout, $stderr
+        $stdout, $stderr         = captured_stdout, captured_stderr
+
+        begin
+          yield
+        ensure
+          $stdout = orig_stdout
+          $stderr = orig_stderr
+        end
+      end
 
       return captured_stdout.string, captured_stderr.string
-    ensure
-      $stdout = orig_stdout
-      $stderr = orig_stderr
     end
 
     ##
@@ -496,21 +505,26 @@ module MiniTest
       require 'tempfile'
 
       captured_stdout, captured_stderr = Tempfile.new("out"), Tempfile.new("err")
-      orig_stdout, orig_stderr = $stdout.dup, $stderr.dup
-      $stdout.reopen captured_stdout
-      $stderr.reopen captured_stderr
 
-      yield
+      synchronize do
+        orig_stdout, orig_stderr = $stdout.dup, $stderr.dup
+        $stdout.reopen captured_stdout
+        $stderr.reopen captured_stderr
 
-      $stdout.rewind
-      $stderr.rewind
+        begin
+          yield
 
-      return captured_stdout.read, captured_stderr.read
-    ensure
-      captured_stdout.unlink
-      captured_stderr.unlink
-      $stdout.reopen orig_stdout
-      $stderr.reopen orig_stderr
+          $stdout.rewind
+          $stderr.rewind
+
+          [captured_stdout.read, captured_stderr.read]
+        ensure
+          captured_stdout.unlink
+          captured_stderr.unlink
+          $stdout.reopen orig_stdout
+          $stderr.reopen orig_stderr
+        end
+      end
     end
 
     ##
@@ -703,10 +717,19 @@ module MiniTest
       msg ||= "Skipped, no message given"
       raise MiniTest::Skip, msg, bt
     end
+
+    ##
+    # Takes a block and wraps it with the runner's shared mutex.
+
+    def synchronize
+      Minitest::Unit.runner.synchronize do
+        yield
+      end
+    end
   end
 
   class Unit # :nodoc:
-    VERSION = "4.1.0" # :nodoc:
+    VERSION = "4.2.0" # :nodoc:
 
     attr_accessor :report, :failures, :errors, :skips # :nodoc:
     attr_accessor :test_count, :assertion_count       # :nodoc:
@@ -714,7 +737,6 @@ module MiniTest
     attr_accessor :help                               # :nodoc:
     attr_accessor :verbose                            # :nodoc:
     attr_writer   :options                            # :nodoc:
-    attr_accessor :last_error                         # :nodoc:
 
     ##
     # Lazy accessor for options.
@@ -857,10 +879,15 @@ module MiniTest
     end
 
     ##
-    # Runs all the +suites+ for a given +type+.
+    # Runs all the +suites+ for a given +type+. Runs suites declaring
+    # a test_order of +:parallel+ in parallel, and everything else
+    # serial.
 
     def _run_suites suites, type
-      suites.map { |suite| _run_suite suite, type }
+      parallel, serial = suites.partition { |s| s.test_order == :parallel }
+
+      ParallelEach.new(parallel).map { |suite| _run_suite suite, type } +
+        serial.map { |suite| _run_suite suite, type }
     end
 
     ##
@@ -879,14 +906,10 @@ module MiniTest
 
         print "#{suite}##{method} = " if @verbose
 
-        @start_time = Time.now
-        self.last_error = nil
+        start_time = Time.now if @verbose
         result = inst.run self
-        time = Time.now - @start_time
 
-        record suite, method, inst._assertions, time, last_error
-
-        print "%.2f s = " % time if @verbose
+        print "%.2f s = " % (Time.now - start_time) if @verbose
         print result
         puts if @verbose
 
@@ -925,7 +948,6 @@ module MiniTest
     # exception +e+
 
     def puke klass, meth, e
-      self.last_error = e
       e = case e
           when MiniTest::Skip then
             @skips += 1
@@ -947,7 +969,11 @@ module MiniTest
       @report = []
       @errors = @failures = @skips = 0
       @verbose = false
-      self.last_error = nil
+      @mutex = Mutex.new
+    end
+
+    def synchronize # :nodoc:
+      @mutex.synchronize { yield }
     end
 
     def process_args args = [] # :nodoc:
@@ -1255,6 +1281,8 @@ module MiniTest
           runner.status $stderr
         end if SUPPORTS_INFO_SIGNAL
 
+        start_time = Time.now
+
         result = ""
         begin
           @passed = nil
@@ -1263,11 +1291,15 @@ module MiniTest
           self.after_setup
           self.run_test self.__name__
           result = "." unless io?
+          time = Time.now - start_time
+          runner.record self.class, self.__name__, self._assertions, time, nil
           @passed = true
         rescue *PASSTHROUGH_EXCEPTIONS
           raise
         rescue Exception => e
           @passed = false
+          time = Time.now - start_time
+          runner.record self.class, self.__name__, self._assertions, time, e
           result = runner.puke self.class, self.__name__, e
         ensure
           %w{ before_teardown teardown after_teardown }.each do |hook|
@@ -1331,6 +1363,32 @@ module MiniTest
         end
       end
 
+      ##
+      # Make diffs for this TestCase use #pretty_inspect so that diff
+      # in assert_equal can be more details. NOTE: this is much slower
+      # than the regular inspect but much more usable for complex
+      # objects.
+
+      def self.make_my_diffs_pretty!
+        require 'pp'
+
+        define_method :mu_pp do |o|
+          o.pretty_inspect
+        end
+      end
+
+      ##
+      # Call this at the top of your tests when you want to run your
+      # tests in parallel. In doing so, you're admitting that you rule
+      # and your tests are awesome.
+
+      def self.parallelize_me!
+        class << self
+          undef_method :test_order if method_defined? :test_order
+          define_method :test_order do :parallel end
+        end
+      end
+
       def self.inherited klass # :nodoc:
         @@test_suites[klass] = true
         klass.reset_setup_teardown_hooks
@@ -1349,6 +1407,9 @@ module MiniTest
         methods = public_instance_methods(true).grep(/^test/).map { |m| m.to_s }
 
         case self.test_order
+        when :parallel
+          max = methods.size
+          ParallelEach.new methods.sort.sort_by { rand max }
         when :random then
           max = methods.size
           methods.sort.sort_by { rand max }

data/test/minitest/metametameta.rb

@@ -17,7 +17,9 @@ class MetaMetaMetaTestCase < MiniTest::Unit::TestCase
 
     EOM
 
-    @tu.run flags
+    with_output do
+      @tu.run flags
+    end
 
     output = @output.string.dup
     output.sub!(/Finished tests in .*/, "Finished tests in 0.00")
@@ -42,14 +44,24 @@ class MetaMetaMetaTestCase < MiniTest::Unit::TestCase
     srand 42
     MiniTest::Unit::TestCase.reset
     @tu = MiniTest::Unit.new
-    @output = StringIO.new("")
+
     MiniTest::Unit.runner = nil # protect the outer runner from the inner tests
-    MiniTest::Unit.output = @output
   end
 
   def teardown
     super
-    MiniTest::Unit.output = $stdout
-    Object.send :remove_const, :ATestCase if defined? ATestCase
+  end
+
+  def with_output
+    synchronize do
+      begin
+        @output = StringIO.new("")
+        MiniTest::Unit.output = @output
+
+        yield
+      ensure
+        MiniTest::Unit.output = STDOUT
+      end
+    end
   end
 end

data/test/minitest/test_minitest_benchmark.rb

@@ -110,4 +110,3 @@ class TestMiniTestBenchmark < MiniTest::Unit::TestCase
     assert_in_delta exp_b, b
   end
 end
-

data/test/minitest/test_minitest_mock.rb

@@ -4,6 +4,8 @@ require 'minitest/unit'
 MiniTest::Unit.autorun
 
 class TestMiniTestMock < MiniTest::Unit::TestCase
+  parallelize_me!
+
   def setup
     @mock = MiniTest::Mock.new.expect(:foo, nil)
     @mock.expect(:meaning_of_life, 42)
@@ -208,6 +210,8 @@ end
 require "minitest/metametameta"
 
 class TestMiniTestStub < MiniTest::Unit::TestCase
+  parallelize_me!
+
   def setup
     super
     MiniTest::Unit::TestCase.reset
@@ -224,13 +228,15 @@ class TestMiniTestStub < MiniTest::Unit::TestCase
   def assert_stub val_or_callable
     @assertion_count += 1
 
-    t = Time.now.to_i
+    synchronize do
+      t = Time.now.to_i
 
-    Time.stub :now, val_or_callable do
-      @tc.assert_equal 42, Time.now
-    end
+      Time.stub :now, val_or_callable do
+        @tc.assert_equal 42, Time.now
+      end
 
-    @tc.assert_operator Time.now.to_i, :>=, t
+      @tc.assert_operator Time.now.to_i, :>=, t
+    end
   end
 
   def test_stub_value
@@ -244,13 +250,15 @@ class TestMiniTestStub < MiniTest::Unit::TestCase
   def test_stub_block_args
     @assertion_count += 1
 
-    t = Time.now.to_i
+    synchronize do
+      t = Time.now.to_i
 
-    Time.stub :now,  lambda { |n| n * 2 } do
-      @tc.assert_equal 42, Time.now(21)
-    end
+      Time.stub :now,  lambda { |n| n * 2 } do
+        @tc.assert_equal 42, Time.now(21)
+      end
 
-    @tc.assert_operator Time.now.to_i, :>=, t
+      @tc.assert_operator Time.now.to_i, :>=, t
+    end
   end
 
   def test_stub_callable

data/test/minitest/test_minitest_spec.rb

@@ -8,6 +8,8 @@ class ExampleA; end
 class ExampleB < ExampleA; end
 
 describe MiniTest::Spec do
+  # do not parallelize this suite... it just can't handle it.
+
   def assert_triggered expected = "blah", klass = MiniTest::Assertion
     @assertion_count += 2
 
@@ -561,6 +563,8 @@ describe MiniTest::Spec, :subject do
 end
 
 class TestMeta < MiniTest::Unit::TestCase
+  parallelize_me!
+
   def test_setup
     srand 42
     MiniTest::Unit::TestCase.reset
@@ -652,17 +656,15 @@ class TestMeta < MiniTest::Unit::TestCase
     _, _, z, before_list, after_list = util_structure
 
     @tu = MiniTest::Unit.new
-    @output = StringIO.new("")
     MiniTest::Unit.runner = nil # protect the outer runner from the inner tests
-    MiniTest::Unit.output = @output
 
-    tc = z.new :test_0002_anonymous
-    tc.run @tu
+    with_output do
+      tc = z.new :test_0002_anonymous
+      tc.run @tu
+    end
 
     assert_equal [1, 2, 3], before_list
     assert_equal [3, 2, 1], after_list
-  ensure
-    MiniTest::Unit.output = $stdout
   end
 
   def test_children
@@ -716,4 +718,17 @@ class TestMeta < MiniTest::Unit::TestCase
     assert_respond_to y.new(nil), "xyz"
     assert_respond_to z.new(nil), "xyz"
   end
+
+  def with_output # REFACTOR: dupe from metametameta
+    synchronize do
+      begin
+        @output = StringIO.new("")
+        MiniTest::Unit.output = @output
+
+        yield
+      ensure
+        MiniTest::Unit.output = STDOUT
+      end
+    end
+  end
 end

data/test/minitest/test_minitest_unit.rb

@@ -6,6 +6,8 @@ class AnError < StandardError; include MyModule; end
 class ImmutableString < String; def inspect; super.freeze; end; end
 
 class TestMiniTestUnit < MetaMetaMetaTestCase
+  parallelize_me!
+
   pwd = Pathname.new File.expand_path Dir.pwd
   basedir = Pathname.new(File.expand_path "lib/minitest") + 'mini'
   basedir = basedir.relative_path_from(pwd).to_s
@@ -166,6 +168,85 @@ class TestMiniTestUnit < MetaMetaMetaTestCase
     assert_equal ex, fu
   end
 
+  def test_default_runner_is_minitest_unit
+    assert_instance_of MiniTest::Unit, MiniTest::Unit.runner
+  end
+
+  def with_overridden_include
+    Class.class_eval do
+      def inherited_with_hacks klass
+        throw :inherited_hook
+      end
+
+      alias inherited_without_hacks inherited
+      alias inherited               inherited_with_hacks
+      alias IGNORE_ME!              inherited # 1.8 bug. god I love venture bros
+    end
+
+    yield
+  ensure
+    Class.class_eval do
+      alias inherited inherited_without_hacks
+
+      undef_method :inherited_with_hacks
+      undef_method :inherited_without_hacks
+    end
+
+    refute_respond_to Class, :inherited_with_hacks
+    refute_respond_to Class, :inherited_without_hacks
+  end
+
+  def test_inherited_hook_plays_nice_with_others
+    with_overridden_include do
+      assert_throws :inherited_hook do
+        Class.new MiniTest::Unit::TestCase
+      end
+    end
+  end
+
+  def test_passed_eh_teardown_good
+    test_class = Class.new MiniTest::Unit::TestCase do
+      def teardown; assert true; end
+      def test_omg; assert true; end
+    end
+
+    test = test_class.new :test_omg
+    test.run @tu
+    assert test.passed?
+  end
+
+  def test_passed_eh_teardown_flunked
+    test_class = Class.new MiniTest::Unit::TestCase do
+      def teardown; flunk;       end
+      def test_omg; assert true; end
+    end
+
+    test = test_class.new :test_omg
+    test.run @tu
+    refute test.passed?
+  end
+
+  def util_expand_bt bt
+    if RUBY_VERSION >= '1.9.0' then
+      bt.map { |f| (f =~ /^\./) ? File.expand_path(f) : f }
+    else
+      bt
+    end
+  end
+end
+
+class TestMiniTestRunner < MetaMetaMetaTestCase
+  # do not parallelize this suite... it just can't handle it.
+
+  def test_class_test_suites
+    @assertion_count = 0
+
+    tc = Class.new(MiniTest::Unit::TestCase)
+
+    assert_equal 1, MiniTest::Unit::TestCase.test_suites.size
+    assert_equal [tc], MiniTest::Unit::TestCase.test_suites
+  end
+
   def test_run_test
     Class.new MiniTest::Unit::TestCase do
       attr_reader :foo
@@ -362,10 +443,6 @@ class TestMiniTestUnit < MetaMetaMetaTestCase
     assert_report expected, %w[--seed 42 --verbose]
   end
 
-  def test_default_runner_is_minitest_unit
-    assert_instance_of MiniTest::Unit, MiniTest::Unit.runner
-  end
-
   def test_run_with_other_runner
     MiniTest::Unit.runner = Class.new MiniTest::Unit do
       def _run_suite suite, type
@@ -403,37 +480,74 @@ class TestMiniTestUnit < MetaMetaMetaTestCase
     assert_report expected
   end
 
-  def with_overridden_include
-    Class.class_eval do
-      def inherited_with_hacks klass
-        throw :inherited_hook
-      end
+  require 'monitor'
 
-      alias inherited_without_hacks inherited
-      alias inherited               inherited_with_hacks
-      alias IGNORE_ME!              inherited # 1.8 bug. god I love venture bros
+  class Latch
+    def initialize count = 1
+      @count = count
+      @lock  = Monitor.new
+      @cv    = @lock.new_cond
     end
 
-    yield
-  ensure
-    Class.class_eval do
-      alias inherited inherited_without_hacks
-
-      undef_method :inherited_with_hacks
-      undef_method :inherited_without_hacks
+    def release
+      @lock.synchronize do
+        @count -= 1 if @count > 0
+        @cv.broadcast if @count == 0
+      end
     end
 
-    refute_respond_to Class, :inherited_with_hacks
-    refute_respond_to Class, :inherited_without_hacks
+    def await
+      @lock.synchronize { @cv.wait_while { @count > 0 } }
+    end
   end
 
-  def test_inherited_hook_plays_nice_with_others
-    with_overridden_include do
-      assert_throws :inherited_hook do
-        Class.new MiniTest::Unit::TestCase
+  def test_run_parallel
+    test_count = 2
+    test_latch = Latch.new test_count
+    main_latch = Latch.new
+
+    thread = Thread.new {
+      Thread.current.abort_on_exception = true
+
+      # This latch waits until both test latches have been released.  Both
+      # latches can't be released unless done in separate threads because
+      # `main_latch` keeps the test method from finishing.
+      test_latch.await
+      main_latch.release
+    }
+
+    Class.new MiniTest::Unit::TestCase do
+      parallelize_me!
+
+      test_count.times do |i|
+        define_method :"test_wait_on_main_thread_#{i}" do
+          test_latch.release
+
+          # This latch blocks until the "main thread" releases it. The main
+          # thread can't release this latch until both test latches have
+          # been released.  This forces the latches to be released in separate
+          # threads.
+          main_latch.await
+          assert true
+        end
       end
     end
+
+    expected = clean <<-EOM
+      ..
+
+      Finished tests in 0.00
+
+      2 tests, 2 assertions, 0 failures, 0 errors, 0 skips
+    EOM
+
+    assert_report expected
+    assert thread.join
   end
+end
+
+class TestMiniTestUnitOrder < MetaMetaMetaTestCase
+  # do not parallelize this suite... it just can't handle it.
 
   def test_before_setup
     call_order = []
@@ -450,34 +564,14 @@ class TestMiniTestUnit < MetaMetaMetaTestCase
       def test_omg; assert true; end
     end
 
-    @tu.run %w[--seed 42]
+    with_output do
+      @tu.run %w[--seed 42]
+    end
 
     expected = [:before_setup, :setup]
     assert_equal expected, call_order
   end
 
-  def test_passed_eh_teardown_good
-    test_class = Class.new MiniTest::Unit::TestCase do
-      def teardown; assert true; end
-      def test_omg; assert true; end
-    end
-
-    test = test_class.new :test_omg
-    test.run @tu
-    assert test.passed?
-  end
-
-  def test_passed_eh_teardown_flunked
-    test_class = Class.new MiniTest::Unit::TestCase do
-      def teardown; flunk;       end
-      def test_omg; assert true; end
-    end
-
-    test = test_class.new :test_omg
-    test.run @tu
-    refute test.passed?
-  end
-
   def test_after_teardown
     call_order = []
     Class.new MiniTest::Unit::TestCase do
@@ -493,7 +587,9 @@ class TestMiniTestUnit < MetaMetaMetaTestCase
       def test_omg; assert true; end
     end
 
-    @tu.run %w[--seed 42]
+    with_output do
+      @tu.run %w[--seed 42]
+    end
 
     expected = [:teardown, :after_teardown]
     assert_equal expected, call_order
@@ -523,7 +619,9 @@ class TestMiniTestUnit < MetaMetaMetaTestCase
       def test_omg; assert true; end
     end
 
-    @tu.run %w[--seed 42]
+    with_output do
+      @tu.run %w[--seed 42]
+    end
 
     expected = [:before_teardown, :teardown, :after_teardown]
     assert_equal expected, call_order
@@ -548,24 +646,20 @@ class TestMiniTestUnit < MetaMetaMetaTestCase
 
     _ = Class.new parent
 
-    @tu.run %w[--seed 42]
+    with_output do
+      @tu.run %w[--seed 42]
+    end
 
     # Once for the parent class, once for the child
     expected = [:setup_method, :test, :teardown_method] * 2
 
     assert_equal expected, call_order
   end
-
-  def util_expand_bt bt
-    if RUBY_VERSION >= '1.9.0' then
-      bt.map { |f| (f =~ /^\./) ? File.expand_path(f) : f }
-    else
-      bt
-    end
-  end
 end
 
 class TestMiniTestUnitTestCase < MiniTest::Unit::TestCase
+  parallelize_me!
+
   RUBY18 = ! defined? Encoding
 
   def setup
@@ -1205,6 +1299,7 @@ class TestMiniTestUnitTestCase < MiniTest::Unit::TestCase
 
   def test_capture_subprocess_io
     @assertion_count = 0
+    skip "Dunno why but the parallel run of this fails"
 
     orig_verbose = $VERBOSE
     $VERBOSE = false
@@ -1243,15 +1338,6 @@ class TestMiniTestUnitTestCase < MiniTest::Unit::TestCase
     assert_empty asserts.map { |n| n.sub(/^assert/, 'refute') } - refutes
   end
 
-  def test_class_test_suites
-    @assertion_count = 0
-
-    tc = Class.new(MiniTest::Unit::TestCase)
-
-    assert_equal 1, MiniTest::Unit::TestCase.test_suites.size
-    assert_equal [tc], MiniTest::Unit::TestCase.test_suites
-  end
-
   def test_expectation
     @assertion_count = 2
 
@@ -1486,6 +1572,7 @@ class TestMiniTestUnitTestCase < MiniTest::Unit::TestCase
     @assertion_count = 0
 
     sample_test_case = Class.new MiniTest::Unit::TestCase do
+      def self.test_order; :random; end
       def test_test1; assert "does not matter" end
       def test_test2; assert "does not matter" end
       def test_test3; assert "does not matter" end
@@ -1560,6 +1647,8 @@ class TestMiniTestUnitTestCase < MiniTest::Unit::TestCase
 end
 
 class TestMiniTestGuard < MiniTest::Unit::TestCase
+  parallelize_me!
+
   def test_mri_eh
     assert self.class.mri? "ruby blah"
     assert self.mri? "ruby blah"

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: minitest
 version: !ruby/object:Gem::Version 
-  hash: 59
+  hash: 55
   prerelease: 
   segments: 
   - 4
-  - 1
+  - 2
   - 0
-  version: 4.1.0
+  version: 4.2.0
 platform: ruby
 authors: 
 - Ryan Davis
@@ -36,7 +36,7 @@ cert_chain:
   FBHgymkyj/AOSqKRIpXPhjC6
   -----END CERTIFICATE-----
 
-date: 2012-10-05 00:00:00 Z
+date: 2012-11-02 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: rdoc
@@ -61,11 +61,11 @@ dependencies:
     requirements: 
     - - ~>
       - !ruby/object:Gem::Version 
-        hash: 7
+        hash: 5
         segments: 
         - 3
-        - 0
-        version: "3.0"
+        - 1
+        version: "3.1"
   type: :development
   version_requirements: *id002
 description: |-
@@ -131,7 +131,9 @@ files:
 - lib/hoe/minitest.rb
 - lib/minitest/autorun.rb
 - lib/minitest/benchmark.rb
+- lib/minitest/hell.rb
 - lib/minitest/mock.rb
+- lib/minitest/parallel_each.rb
 - lib/minitest/pride.rb
 - lib/minitest/spec.rb
 - lib/minitest/unit.rb