minitest 5.15.0 → 5.16.0

data/test/minitest/test_minitest_mock.rb

@@ -51,7 +51,7 @@ class TestMinitestMock < Minitest::Test
       @mock.sum
     end
 
-    assert_equal "mocked method :sum expects 2 arguments, got 0", e.message
+    assert_equal "mocked method :sum expects 2 arguments, got []", e.message
   end
 
   def test_return_mock_does_not_raise
@@ -210,7 +210,7 @@ class TestMinitestMock < Minitest::Test
       mock.a
     end
 
-    assert_equal "No more expects available for :a: []", e.message
+    assert_equal "No more expects available for :a: [] {}", e.message
   end
 
   def test_same_method_expects_are_verified_when_all_called
@@ -252,6 +252,21 @@ class TestMinitestMock < Minitest::Test
     assert_equal exp, e.message
   end
 
+  def test_handles_kwargs_in_error_message
+    mock = Minitest::Mock.new
+
+    mock.expect :foo, nil, [], kw: true
+    mock.expect :foo, nil, [], kw: false
+
+    mock.foo kw: true
+
+    e = assert_raises(MockExpectationError) { mock.verify }
+
+    exp = "expected foo(:kw=>false) => nil, got [foo(:kw=>true) => nil]"
+
+    assert_equal exp, e.message
+  end
+
   def test_verify_passes_when_mock_block_returns_true
     mock = Minitest::Mock.new
     mock.expect :foo, nil do
@@ -270,11 +285,133 @@ class TestMinitestMock < Minitest::Test
       a1 == arg1 && a2 == arg2 && a3 == arg3
     end
 
-    mock.foo arg1, arg2, arg3
+    assert_silent do
+      if RUBY_VERSION > "3" then
+        mock.foo arg1, arg2, arg3
+      else
+        mock.foo arg1, arg2, **arg3 # oddity just for ruby 2.7
+      end
+    end
 
     assert_mock mock
   end
 
+  def test_mock_block_is_passed_keyword_args__block
+    arg1, arg2, arg3 = :bar, [1, 2, 3], { :a => "a" }
+    mock = Minitest::Mock.new
+    mock.expect :foo, nil do |k1:, k2:, k3:|
+      k1 == arg1 && k2 == arg2 && k3 == arg3
+    end
+
+    mock.foo(k1: arg1, k2: arg2, k3: arg3)
+
+    assert_mock mock
+  end
+
+  def test_mock_block_is_passed_keyword_args__block_bad_missing
+    arg1, arg2, arg3 = :bar, [1, 2, 3], { :a => "a" }
+    mock = Minitest::Mock.new
+    mock.expect :foo, nil do |k1:, k2:, k3:|
+      k1 == arg1 && k2 == arg2 && k3 == arg3
+    end
+
+    e = assert_raises ArgumentError do
+      mock.foo(k1: arg1, k2: arg2)
+    end
+
+    # basically testing ruby ... need ? for ruby < 2.7 :(
+    assert_match(/missing keyword: :?k3/, e.message)
+  end
+
+  def test_mock_block_is_passed_keyword_args__block_bad_extra
+    arg1, arg2, arg3 = :bar, [1, 2, 3], { :a => "a" }
+    mock = Minitest::Mock.new
+    mock.expect :foo, nil do |k1:, k2:|
+      k1 == arg1 && k2 == arg2 && k3 == arg3
+    end
+
+    e = assert_raises ArgumentError do
+      mock.foo(k1: arg1, k2: arg2, k3: arg3)
+    end
+
+    # basically testing ruby ... need ? for ruby < 2.7 :(
+    assert_match(/unknown keyword: :?k3/, e.message)
+  end
+
+  def test_mock_block_is_passed_keyword_args__block_bad_value
+    arg1, arg2, arg3 = :bar, [1, 2, 3], { :a => "a" }
+    mock = Minitest::Mock.new
+    mock.expect :foo, nil do |k1:, k2:, k3:|
+      k1 == arg1 && k2 == arg2 && k3 == arg3
+    end
+
+    e = assert_raises MockExpectationError do
+      mock.foo(k1: arg1, k2: arg2, k3: :BAD!)
+    end
+
+    exp = "mocked method :foo failed block w/ [] {:k1=>:bar, :k2=>[1, 2, 3], :k3=>:BAD!}"
+    assert_equal exp, e.message
+  end
+
+  def test_mock_block_is_passed_keyword_args__args
+    arg1, arg2, arg3 = :bar, [1, 2, 3], { :a => "a" }
+    mock = Minitest::Mock.new
+    mock.expect :foo, nil, k1: arg1, k2: arg2, k3: arg3
+
+    mock.foo(k1: arg1, k2: arg2, k3: arg3)
+
+    assert_mock mock
+  end
+
+  def test_mock_block_is_passed_keyword_args__args_bad_missing
+    arg1, arg2, arg3 = :bar, [1, 2, 3], { :a => "a" }
+    mock = Minitest::Mock.new
+    mock.expect :foo, nil, k1: arg1, k2: arg2, k3: arg3
+
+    e = assert_raises ArgumentError do
+      mock.foo(k1: arg1, k2: arg2)
+    end
+
+    assert_equal "mocked method :foo expects 3 keyword arguments, got %p" % {k1: arg1, k2: arg2}, e.message
+  end
+
+  def test_mock_block_is_passed_keyword_args__args_bad_extra
+    arg1, arg2, arg3 = :bar, [1, 2, 3], { :a => "a" }
+    mock = Minitest::Mock.new
+    mock.expect :foo, nil, k1: arg1, k2: arg2
+
+    e = assert_raises ArgumentError do
+      mock.foo(k1: arg1, k2: arg2, k3: arg3)
+    end
+
+    assert_equal "mocked method :foo expects 2 keyword arguments, got %p" % {k1: arg1, k2: arg2, k3: arg3}, e.message
+  end
+
+  def test_mock_block_is_passed_keyword_args__args_bad_key
+    arg1, arg2, arg3 = :bar, [1, 2, 3], { :a => "a" }
+    mock = Minitest::Mock.new
+    mock.expect :foo, nil, k1: arg1, k2: arg2, k3: arg3
+
+    e = assert_raises MockExpectationError do
+      mock.foo(k1: arg1, k2: arg2, BAD: arg3)
+    end
+
+    assert_includes e.message, "unexpected keywords [:k1, :k2, :k3]"
+    assert_includes e.message, "vs [:k1, :k2, :BAD]"
+  end
+
+  def test_mock_block_is_passed_keyword_args__args_bad_val
+    arg1, arg2, arg3 = :bar, [1, 2, 3], { :a => "a" }
+    mock = Minitest::Mock.new
+    mock.expect :foo, nil, k1: arg1, k2: arg2, k3: arg3
+
+    e = assert_raises MockExpectationError do
+      mock.foo(k1: arg1, k2: :BAD!, k3: arg3)
+    end
+
+    assert_match(/unexpected keyword arguments.* vs .*:k2=>:BAD!/, e.message)
+  end
+
   def test_mock_block_is_passed_function_block
     mock = Minitest::Mock.new
     block = proc { "bar" }
@@ -286,6 +423,13 @@ class TestMinitestMock < Minitest::Test
     assert_mock mock
   end
 
+  def test_mock_forward_keyword_arguments
+    mock = Minitest::Mock.new
+    mock.expect(:foo, nil) { |bar:| bar == 'bar' }
+    mock.foo(bar: 'bar')
+    assert_mock mock
+  end
+
   def test_verify_fails_when_mock_block_returns_false
     mock = Minitest::Mock.new
     mock.expect :foo, nil do
@@ -293,7 +437,7 @@ class TestMinitestMock < Minitest::Test
     end
 
     e = assert_raises(MockExpectationError) { mock.foo }
-    exp = "mocked method :foo failed block w/ []"
+    exp = "mocked method :foo failed block w/ [] {}"
 
     assert_equal exp, e.message
   end
@@ -519,6 +663,19 @@ class TestMinitestStub < Minitest::Test
     @tc.assert_equal true, rs
   end
 
+  def test_mock_with_yield_kwargs
+    mock = Minitest::Mock.new
+    rs = nil
+
+    File.stub :open, true, mock, kw:42 do
+      File.open "foo.txt", "r" do |f, kw:|
+        rs = kw
+      end
+    end
+
+    @tc.assert_equal 42, rs
+  end
+
   alias test_stub_value__old test_stub_value # TODO: remove/rename
 
   ## Permutation Sets:

data/test/minitest/test_minitest_reporter.rb

@@ -30,6 +30,7 @@ class TestMinitestReporter < MetaMetaMetaTestCase
   end
 
   def setup
+    super
     self.io = StringIO.new("")
     self.r  = new_composite_reporter
   end

data/test/minitest/test_minitest_spec.rb

@@ -505,7 +505,7 @@ describe Minitest::Spec do
   it "needs to verify regexp matches" do
     @assertion_count += 3 # must_match is 2 assertions
 
-    assert_success _("blah").must_match(/\w+/)
+    assert_kind_of MatchData, _("blah").must_match(/\w+/)
 
     assert_triggered "Expected /\\d+/ to match \"blah\"." do
       _("blah").must_match(/\d+/)
@@ -744,6 +744,10 @@ describe Minitest::Spec, :subject do
 end
 
 class TestMetaStatic < Minitest::Test
+  def assert_method_count expected, klass
+    assert_equal expected, klass.public_instance_methods.grep(/^test_/).count
+  end
+
   def test_children
     Minitest::Spec.children.clear # prevents parallel run
 
@@ -777,8 +781,8 @@ class TestMetaStatic < Minitest::Test
       end
     end
 
-    assert_equal 1, outer.public_instance_methods.grep(/^test_/).count
-    assert_equal 1, inner.public_instance_methods.grep(/^test_/).count
+    assert_method_count 1, outer
+    assert_method_count 1, inner
   end
 
   def test_it_wont_add_test_methods_to_children
@@ -792,14 +796,18 @@ class TestMetaStatic < Minitest::Test
       end
     end
 
-    assert_equal 1, outer.public_instance_methods.grep(/^test_/).count
-    assert_equal 0, inner.public_instance_methods.grep(/^test_/).count
+    assert_method_count 1, outer
+    assert_method_count 0, inner
   end
 end
 
 class TestMeta < MetaMetaMetaTestCase
   # do not call parallelize_me! here because specs use register_spec_type globally
 
+  def assert_defined_methods expected, klass
+    assert_equal expected, klass.instance_methods(false).sort.map(&:to_s)
+  end
+
   def util_structure
     y = z = nil
     before_list = []
@@ -872,7 +880,7 @@ class TestMeta < MetaMetaMetaTestCase
       end
     end
 
-    test_name = spec_class.instance_methods.sort.grep(/test/).first
+    test_name = spec_class.instance_methods.sort.grep(/test_/).first
 
     spec = spec_class.new test_name
 
@@ -921,9 +929,9 @@ class TestMeta < MetaMetaMetaTestCase
     inner_methods2 = inner_methods1 +
       %w[test_0002_anonymous test_0003_anonymous]
 
-    assert_equal top_methods,    x.instance_methods(false).sort.map(&:to_s)
-    assert_equal inner_methods1, y.instance_methods(false).sort.map(&:to_s)
-    assert_equal inner_methods2, z.instance_methods(false).sort.map(&:to_s)
+    assert_defined_methods top_methods, x
+    assert_defined_methods inner_methods1, y
+    assert_defined_methods inner_methods2, z
   end
 
   def test_structure_postfix_it
@@ -940,8 +948,8 @@ class TestMeta < MetaMetaMetaTestCase
       it "inner-it" do end
     end
 
-    assert_equal %w[test_0001_inner-it], y.instance_methods(false).map(&:to_s)
-    assert_equal %w[test_0001_inner-it], z.instance_methods(false).map(&:to_s)
+    assert_defined_methods %w[test_0001_inner-it], y
+    assert_defined_methods %w[test_0001_inner-it], z
   end
 
   def test_setup_teardown_behavior
@@ -972,9 +980,9 @@ class TestMeta < MetaMetaMetaTestCase
                    ].sort
 
     assert_equal test_methods, [x1, x2]
-    assert_equal test_methods, x.instance_methods.grep(/^test/).map(&:to_s).sort
-    assert_equal [], y.instance_methods.grep(/^test/)
-    assert_equal [], z.instance_methods.grep(/^test/)
+    assert_defined_methods test_methods, x
+    assert_defined_methods [], y
+    assert_defined_methods [], z
   end
 
   def test_structure_subclasses

data/test/minitest/test_minitest_test.rb

@@ -48,9 +48,11 @@ class TestMinitestUnit < MetaMetaMetaTestCase
           "test/test_autotest.rb:62:in `test_add_exception'"]
     ex = util_expand_bt ex
 
-    fu = Minitest.filter_backtrace(bt)
+    Minitest::Test.io_lock.synchronize do # try not to trounce in parallel
+      fu = Minitest.filter_backtrace(bt)
 
-    assert_equal ex, fu
+      assert_equal ex, fu
+    end
   end
 
   def test_filter_backtrace_all_unit
@@ -71,8 +73,10 @@ class TestMinitestUnit < MetaMetaMetaTestCase
     bt = util_expand_bt bt
 
     ex = ["-e:1"]
-    fu = Minitest.filter_backtrace bt
-    assert_equal ex, fu
+    Minitest::Test.io_lock.synchronize do # try not to trounce in parallel
+      fu = Minitest.filter_backtrace bt
+      assert_equal ex, fu
+    end
   end
 
   def test_filter_backtrace__empty
@@ -95,24 +99,26 @@ class TestMinitestUnit < MetaMetaMetaTestCase
     end
 
     expected = clean <<-EOM
-      EF
+      FE
 
       Finished in 0.00
 
-        1) Error:
-      FakeNamedTestXX#test_this_is_non_ascii_failure_message:
-      RuntimeError: ЁЁЁ
-          FILE:LINE:in `test_this_is_non_ascii_failure_message'
-
-        2) Failure:
+        1) Failure:
       FakeNamedTestXX#test_this_is_not_ascii_assertion [FILE:LINE]:
       Expected: \"ЁЁЁ\"
         Actual: \"ёёё\"
 
+        2) Error:
+      FakeNamedTestXX#test_this_is_non_ascii_failure_message:
+      RuntimeError: ЁЁЁ
+          FILE:LINE:in `test_this_is_non_ascii_failure_message'
+
       2 runs, 1 assertions, 1 failures, 1 errors, 0 skips
     EOM
 
-    assert_report expected
+    Minitest::Test.io_lock.synchronize do # try not to trounce in parallel
+      assert_report expected
+    end
   end
 
   def test_passed_eh_teardown_good
@@ -158,11 +164,7 @@ class TestMinitestUnit < MetaMetaMetaTestCase
   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
+    bt.map { |f| (f =~ /^\./) ? File.expand_path(f) : f }
   end
 end
 
@@ -254,7 +256,7 @@ class TestMinitestRunner < MetaMetaMetaTestCase
     end
 
     expected = clean <<-EOM
-      E.
+      .E
 
       Finished in 0.00
 
@@ -301,7 +303,7 @@ class TestMinitestRunner < MetaMetaMetaTestCase
     setup_basic_tu
 
     expected = clean <<-EOM
-      F.
+      .F
 
       Finished in 0.00
 
@@ -328,6 +330,10 @@ class TestMinitestRunner < MetaMetaMetaTestCase
     end
   end
 
+  def test_seed # this is set for THIS run, so I'm not testing it's actual value
+    assert_instance_of Integer, Minitest.seed
+  end
+
   def test_run_failing_filtered
     setup_basic_tu
 
@@ -485,7 +491,7 @@ class TestMinitestRunner < MetaMetaMetaTestCase
     end
 
     expected = clean <<-EOM
-      S.
+      .S
 
       Finished in 0.00
 
@@ -512,8 +518,8 @@ class TestMinitestRunner < MetaMetaMetaTestCase
     end
 
     expected = clean <<-EOM
-      FakeNamedTestXX#test_skip = 0.00 s = S
       FakeNamedTestXX#test_something = 0.00 s = .
+      FakeNamedTestXX#test_skip = 0.00 s = S
 
       Finished in 0.00
 
@@ -527,6 +533,33 @@ class TestMinitestRunner < MetaMetaMetaTestCase
     assert_report expected, %w[--seed 42 --verbose]
   end
 
+  def test_run_skip_show_skips
+    @tu =
+    Class.new FakeNamedTest do
+      def test_something
+        assert true
+      end
+
+      def test_skip
+        skip "not yet"
+      end
+    end
+
+    expected = clean <<-EOM
+      .S
+
+      Finished in 0.00
+
+        1) Skipped:
+      FakeNamedTestXX#test_skip [FILE:LINE]:
+      not yet
+
+      2 runs, 1 assertions, 0 failures, 0 errors, 1 skips
+    EOM
+
+    assert_report expected, %w[--seed 42 --show-skips]
+  end
+
   def test_run_with_other_runner
     @tu =
     Class.new FakeNamedTest do
@@ -627,6 +660,8 @@ class TestMinitestRunner < MetaMetaMetaTestCase
       2 runs, 2 assertions, 0 failures, 0 errors, 0 skips
     EOM
 
+    skip if Minitest.parallel_executor.size < 2 # locks up test runner if 1 CPU
+
     assert_report(expected) do |reporter|
       reporter.extend(Module.new {
         define_method("record") do |result|
@@ -805,13 +840,51 @@ class TestMinitestRunnable < Minitest::Test
   end
 
   def test_spec_marshal_with_exception
-    klass = describe("whatever") { it("passes") { raise Class.new(StandardError)} }
+    klass = describe("whatever") {
+      it("raises, badly") {
+        raise Class.new(StandardError), "this is bad!"
+      }
+    }
+
     rm = klass.runnable_methods.first
 
     # Run the test
     @tc = klass.new(rm).run
 
     assert_kind_of Minitest::Result, @tc
+    assert_instance_of Minitest::UnexpectedError, @tc.failure
+
+    msg = @tc.failure.error.message
+    assert_includes msg, "Neutered Exception #<Class:"
+    assert_includes msg, "this is bad!"
+
+    # Pass it over the wire
+    over_the_wire = Marshal.load Marshal.dump @tc
+
+    assert_equal @tc.time,       over_the_wire.time
+    assert_equal @tc.name,       over_the_wire.name
+    assert_equal @tc.assertions, over_the_wire.assertions
+    assert_equal @tc.failures,   over_the_wire.failures
+    assert_equal @tc.klass,      over_the_wire.klass
+  end
+
+  def test_spec_marshal_with_exception_nameerror
+    klass = describe("whatever") {
+      it("raises nameerror") {
+        NOPE::does_not_exist
+      }
+    }
+
+    rm = klass.runnable_methods.first
+
+    # Run the test
+    @tc = klass.new(rm).run
+
+    assert_kind_of Minitest::Result, @tc
+    assert_instance_of Minitest::UnexpectedError, @tc.failure
+
+    msg = @tc.failure.error.message
+    assert_includes msg, "uninitialized constant TestMinitestRunnable::NOPE"
 
     # Pass it over the wire
     over_the_wire = Marshal.load Marshal.dump @tc
@@ -885,7 +958,7 @@ class TestMinitestUnitTestCase < Minitest::Test
     random_tests_3 = sample_test_case 1_000
 
     assert_equal random_tests_1, random_tests_2
-    refute_equal random_tests_1, random_tests_3
+    assert_equal random_tests_1, random_tests_3
   end
 
   def test_runnable_methods_sorted

data/test/minitest/test_minitest_test_task.rb

@@ -0,0 +1,46 @@
+require "minitest/autorun"
+require "hoe"
+
+require "minitest/test_task"
+
+Hoe.load_plugins # make sure Hoe::Test is loaded
+
+class TestHoeTest < Minitest::Test
+  PATH = "test/minitest/test_minitest_test_task.rb"
+
+  mt_path = %w[lib test .].join File::PATH_SEPARATOR
+
+  MT_EXPECTED = %W[-I#{mt_path} -w
+                   -e '%srequire "#{PATH}"'
+                   --].join(" ") + " "
+
+  def test_make_test_cmd_for_minitest
+    skip "Using TESTOPTS... skipping" if ENV["TESTOPTS"]
+
+    require "minitest/test_task"
+
+    framework = %(require "minitest/autorun"; )
+
+    @tester = Minitest::TestTask.create :test do |t|
+      t.test_globs = [PATH]
+    end
+
+    assert_equal MT_EXPECTED % [framework].join("; "), @tester.make_test_cmd
+  end
+
+  def test_make_test_cmd_for_minitest_prelude
+    skip "Using TESTOPTS... skipping" if ENV["TESTOPTS"]
+
+    require "minitest/test_task"
+
+    prelude = %(require "other/file")
+    framework = %(require "minitest/autorun"; )
+
+    @tester = Minitest::TestTask.create :test do |t|
+      t.test_prelude = prelude
+      t.test_globs = [PATH]
+    end
+
+    assert_equal MT_EXPECTED % [prelude, framework].join("; "), @tester.make_test_cmd
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: minitest
 version: !ruby/object:Gem::Version
-  version: 5.15.0
+  version: 5.16.0
 platform: ruby
 authors:
 - Ryan Davis
@@ -10,9 +10,9 @@ bindir: bin
 cert_chain:
 - |
   -----BEGIN CERTIFICATE-----
-  MIIDPjCCAiagAwIBAgIBBTANBgkqhkiG9w0BAQsFADBFMRMwEQYDVQQDDApyeWFu
+  MIIDPjCCAiagAwIBAgIBBjANBgkqhkiG9w0BAQsFADBFMRMwEQYDVQQDDApyeWFu
   ZC1ydWJ5MRkwFwYKCZImiZPyLGQBGRYJemVuc3BpZGVyMRMwEQYKCZImiZPyLGQB
-  GRYDY29tMB4XDTIwMTIyMjIwMzgzMFoXDTIxMTIyMjIwMzgzMFowRTETMBEGA1UE
+  GRYDY29tMB4XDTIxMTIyMzIzMTkwNFoXDTIyMTIyMzIzMTkwNFowRTETMBEGA1UE
   AwwKcnlhbmQtcnVieTEZMBcGCgmSJomT8ixkARkWCXplbnNwaWRlcjETMBEGCgmS
   JomT8ixkARkWA2NvbTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBALda
   b9DCgK+627gPJkB6XfjZ1itoOQvpqH1EXScSaba9/S2VF22VYQbXU1xQXL/WzCkx
@@ -22,14 +22,14 @@ cert_chain:
   qhtV7HJxNKuPj/JFH0D2cswvzznE/a5FOYO68g+YCuFi5L8wZuuM8zzdwjrWHqSV
   gBEfoTEGr7Zii72cx+sCAwEAAaM5MDcwCQYDVR0TBAIwADALBgNVHQ8EBAMCBLAw
   HQYDVR0OBBYEFEfFe9md/r/tj/Wmwpy+MI8d9k/hMA0GCSqGSIb3DQEBCwUAA4IB
-  AQAE3XRm1YZcCVjAJy5yMZvTOFrS7B2SYErc+0QwmKYbHztTTDY2m5Bii+jhpuxh
-  H+ETcU1z8TUKLpsBUP4kUpIRowkVN1p/jKapV8T3Rbwq+VuYFe+GMKsf8wGZSecG
-  oMQ8DzzauZfbvhe2kDg7G9BBPU0wLQlY25rDcCy9bLnD7R0UK3ONqpwvsI5I7x5X
-  ZIMXR0a9/DG+55mawwdGzCQobDKiSNLK89KK7OcNTALKU0DfgdTkktdgKchzKHqZ
-  d/AHw/kcnU6iuMUoJEcGiJd4gVCTn1l3cDcIvxakGslCA88Jubw0Sqatan0TnC9g
-  KToW560QIey7SPfHWduzFJnV
+  AQCKB5jfsuSnKb+t/Wrh3UpdkmX7TrEsjVmERC0pPqzQ5GQJgmEXDD7oMgaKXaAq
+  x2m+KSZDrqk7c8uho5OX6YMqg4KdxehfSLqqTZGoeV78qwf/jpPQZKTf+W9gUSJh
+  zsWpo4K50MP+QtdSbKXZwjAafpQ8hK0MnnZ/aeCsW9ov5vdXpYbf3dpg6ADXRGE7
+  lQY2y1tJ5/chqu6h7dQmnm2ABUqx9O+JcN9hbCYoA5i/EeubUEtFIh2w3SpO6YfB
+  JFmxn4h9YO/pVdB962BdBNNDia0kgIjI3ENnkLq0dKpYU3+F3KhEuTksLO0L6X/V
+  YsuyUzsMz6GQA4khyaMgKNSD
   -----END CERTIFICATE-----
-date: 2021-12-15 00:00:00.000000000 Z
+date: 2022-06-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rdoc
@@ -57,14 +57,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.22'
+        version: '3.23'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.22'
+        version: '3.23'
 description: |-
   minitest provides a complete suite of testing facilities supporting
   TDD, BDD, mocking, and benchmarking.
@@ -147,6 +147,7 @@ files:
 - lib/minitest/pride_plugin.rb
 - lib/minitest/spec.rb
 - lib/minitest/test.rb
+- lib/minitest/test_task.rb
 - lib/minitest/unit.rb
 - test/minitest/metametameta.rb
 - test/minitest/test_minitest_assertions.rb
@@ -155,6 +156,7 @@ files:
 - test/minitest/test_minitest_reporter.rb
 - test/minitest/test_minitest_spec.rb
 - test/minitest/test_minitest_test.rb
+- test/minitest/test_minitest_test_task.rb
 homepage: https://github.com/seattlerb/minitest
 licenses:
 - MIT
@@ -171,7 +173,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '2.2'
+      version: '2.6'
   - - "<"
     - !ruby/object:Gem::Version
       version: '4.0'
@@ -181,7 +183,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.16
+rubygems_version: 3.3.12
 signing_key:
 specification_version: 4
 summary: minitest provides a complete suite of testing facilities supporting TDD,