minitest 5.26.0 → 6.0.0

data/test/minitest/test_bisect.rb

@@ -0,0 +1,235 @@
+require "minitest/autorun"
+require "minitest/bisect"
+
+module TestMinitest; end
+
+class TestMinitest::TestBisect < Minitest::Test
+  attr_accessor :bisect
+
+  def setup
+    self.bisect = Minitest::Bisect.new
+    bisect.reset
+  end
+
+  def test_class_run
+    skip "Need to write test_class_run"
+  end
+
+  def test_bisect_files
+    skip "Need to write test_bisect_files"
+  end
+
+  def test_bisect_methods
+    skip "Need to write test_bisect_methods"
+  end
+
+  def test_build_files_cmd
+    files = %w[a.rb b.rb c.rb]
+    rb    = %w[-Ilib:test]
+    mt    = %w[--seed 42]
+
+    ruby = Minitest::Bisect::RUBY
+    body = "require \"./a.rb\" ; require \"./b.rb\" ; require \"./c.rb\""
+
+    exp = "#{ruby} -Ilib:test -e '#{body}' -- --seed 42"
+    act = bisect.build_files_cmd(files, rb, mt)
+
+    assert_equal exp, act
+  end
+
+  def test_build_methods_cmd
+    cmd = "cmd"
+    assert_equal "cmd", bisect.build_methods_cmd(cmd)
+  end
+
+  def test_build_methods_cmd_verify
+    cmd = "cmd"
+    cul = []
+    bad = %w[A#test_1 B#test_2]
+
+    exp = "cmd -n \"/^(?:A#(?:test_1)|B#(?:test_2))$/\""
+
+    assert_equal exp, bisect.build_methods_cmd(cmd, cul, bad)
+  end
+
+  def test_build_methods_cmd_verify_same
+    cmd = "cmd"
+    cul = []
+    bad = %w[C#test_5 C#test_6]
+
+    exp = "cmd -n \"/^(?:C#(?:test_5|test_6))$/\""
+
+    assert_equal exp, bisect.build_methods_cmd(cmd, cul, bad)
+  end
+
+  def test_build_methods_cmd_full
+    cmd = "cmd"
+    cul = %w[A#test_1 A#test_2 B#test_3 B#test_4]
+    bad = %w[C#test_5 C#test_6]
+
+    a = "A#(?:test_1|test_2)"
+    b = "B#(?:test_3|test_4)"
+    c = "C#(?:test_5|test_6)"
+    exp = "cmd -n \"/^(?:#{a}|#{b}|#{c})$/\""
+
+    assert_equal exp, bisect.build_methods_cmd(cmd, cul, bad)
+  end
+
+  def test_build_re
+    bad = %w[A#test_1 B#test_2]
+
+    exp = "/^(?:A#(?:test_1)|B#(?:test_2))$/"
+
+    assert_equal exp, bisect.build_re(bad)
+  end
+
+  def test_build_re_same
+    bad = %w[C#test_5 C#test_6]
+
+    exp = "/^(?:C#(?:test_5|test_6))$/"
+
+    assert_equal exp, bisect.build_re(bad)
+  end
+
+  def test_build_re_class_escaping
+    bad = ["{}#[]"]
+
+    exp = "/^(?:\\{\\}#(?:\\[\\]))$/"
+
+    assert_equal exp, bisect.build_re(bad)
+  end
+
+  def test_build_re_method_escaping
+    bad = ["Some Class#It shouldn't care what the name is"]
+
+    exp = "/^(?:Some Class#(?:It shouldn\\'t care what the name is))$/"
+
+    assert_equal exp, bisect.build_re(bad)
+  end
+
+  def test_map_failures
+    bisect.failures =
+      {
+       "file.rb" => { "Class" => %w[test_method1 test_method2] },
+       "blah.rb" => { "Apple" => %w[test_method3 test_method4] },
+      }
+
+    exp = %w[
+           Apple#test_method3
+           Apple#test_method4
+           Class#test_method1
+           Class#test_method2
+          ]
+
+    assert_equal exp, bisect.map_failures
+  end
+
+  def test_minitest_result
+    bisect.minitest_result "file.rb", "TestClass", "test_method", [], 1, 1
+
+    assert_equal false, bisect.tainted
+    assert_empty bisect.failures
+    assert_equal ["TestClass#test_method"], bisect.culprits
+  end
+
+  def test_minitest_result_skip
+    fail = Minitest::Skip.new("woot")
+
+    bisect.minitest_result "file.rb", "TestClass", "test_method", [fail], 1, 1
+
+    assert_equal false, bisect.tainted
+    assert_empty bisect.failures
+    assert_equal ["TestClass#test_method"], bisect.culprits
+  end
+
+  def test_minitest_result_fail
+    fail = Minitest::Assertion.new "msg"
+
+    bisect.minitest_result "file.rb", "TestClass", "test_method", [fail], 1, 1
+
+    exp = {"file.rb" => {"TestClass" => ["test_method"] }}
+
+    assert_equal true, bisect.tainted
+    assert_equal exp, bisect.failures
+    assert_empty bisect.culprits
+  end
+
+  def test_minitest_result_error
+    fail = Minitest::UnexpectedError.new RuntimeError.new("woot")
+
+    bisect.minitest_result "file.rb", "TestClass", "test_method", [fail], 1, 1
+
+    exp = {"file.rb" => {"TestClass" => ["test_method"] }}
+
+    assert_equal true, bisect.tainted
+    assert_equal exp, bisect.failures
+    assert_empty bisect.culprits
+  end
+
+  def test_minitest_start
+    bisect.failures["file.rb"]["Class"] << "test_bad1"
+
+    bisect.minitest_start
+
+    assert_empty bisect.failures
+  end
+
+  def test_reset
+    bisect.seen_bad = true
+    bisect.tainted  = true
+    bisect.failures["file.rb"]["Class"] << "test_bad1"
+    bisect.culprits << "A#test_1" << "B#test_2"
+
+    bisect.reset
+
+    assert_equal false, bisect.seen_bad
+    assert_equal false, bisect.tainted
+    assert_empty bisect.failures
+    assert_equal %w[A#test_1 B#test_2], bisect.culprits
+  end
+
+  def test_run
+    skip "Need to write test_run"
+  end
+
+  def test_time_it
+    exp = /\Ado stuff: in 0.\d\d sec\n\z/
+
+    assert_output exp, "" do
+      bisect.time_it "do stuff:", "echo you should not see me"
+    end
+  end
+end
+
+class TestMinitest::TestBisect::TestPathExpander < Minitest::Test
+  def test_sanity
+    args = %w[1 -Iblah 2 -d 3 -w 4 5 6]
+
+    mtbpe = Minitest::Bisect::PathExpander
+    expander = mtbpe.new args
+
+    assert_equal %w[-Itest:lib], expander.rb_flags
+    assert_same mtbpe::TEST_GLOB, expander.glob
+  end
+
+  def test_process_flags
+    args = %w[1 -Iblah 2 -d 3 -w 4 5 6]
+
+    expander = Minitest::Bisect::PathExpander.new args
+
+    exp_files = %w[1 2 3 4 5 6]
+    exp_flags = %w[-Itest:lib -Iblah -d -w]
+
+    files = expander.process_flags(args)
+
+    assert_equal files, exp_files
+
+    # process_flags only filters and does not mutate args
+    assert_same args, expander.args
+    refute_equal args, exp_files
+    refute_equal files, args
+
+    # separates rb_flags out for separate handling
+    assert_equal exp_flags, expander.rb_flags
+  end
+end

data/test/minitest/test_find_minimal_combination.rb

@@ -0,0 +1,138 @@
+#!/usr/bin/ruby -w
+
+$: << "." << "lib"
+
+require "minitest/autorun"
+require "minitest/find_minimal_combination"
+
+describe Array, :find_minimal_combination do
+  def check(*bad)
+    lambda { |sample| bad & sample == bad }
+  end
+
+  def record_and_check(tests, *bad)
+    lambda { |test| tests << test.join; bad & test == bad }
+  end
+
+  def parse_trials s
+    s.lines.map { |s| s.chomp.sub(/#.*/, '').delete " " }.reject(&:empty?)
+  end
+
+  def assert_steps input, bad, exp
+    tests = []
+
+    found = input.find_minimal_combination(&record_and_check(tests, *bad))
+
+    assert_equal bad, found, "algorithm is bad"
+
+    assert_equal parse_trials(exp), tests
+  end
+
+  HEX = "0123456789ABCDEF".chars.to_a
+
+  # lvl      collection
+  #
+  #  0 |         A
+  #  1 |     B       C
+  #  2 |   D   E   F   G
+  #  3 |  H I J K L M N O
+  #    |
+  #  4 |  0123456789ABCDEF
+
+  def test_ordering_best_case_1
+    ary = HEX
+    bad = %w[0]
+    exp = <<~EOT
+      #123456789ABCDEF
+      01234567         # HIT! -- level 1 = B, C
+      0123             # HIT! -- level 2 = D, E
+      01               # HIT! -- level 3 = H, I
+      0                # HIT!
+    EOT
+
+    assert_steps ary, bad, exp
+  end
+
+  def test_ordering_best_case_2
+    ary = HEX
+    bad = %w[0 1]
+    exp = <<~EOT
+      01234567         # HIT! -- level 1 = B, C
+      0123             # HIT! -- level 2 = D, E
+      01               # HIT! -- level 3 = H, I
+      0                # miss -- level 4 = 0, 1, n_combos = 1
+       1               # miss
+      01               # HIT! -- level 3 = H,    n_combos = 2
+    EOT
+
+    assert_steps ary, bad, exp
+  end
+
+  def test_ordering
+    ary = HEX
+    bad = %w[1 F]
+    exp = <<~EOT
+      01234567         # miss -- level 1 = B, C
+              89ABCDEF # miss
+      0123    89AB     # miss -- level 2 = DF, DG, EF, EG
+      0123        CDEF # HIT!
+      01          CD   # miss -- level 3 = HN, HO
+      01            EF # HIT!
+      0             E  # miss -- level 4 = 0E, 0F, 1E, 1F
+      0              F # miss
+       1            E  # miss
+       1             F # HIT!
+    EOT
+
+    assert_steps ary, bad, exp
+  end
+
+  def self.test_find_minimal_combination max, *bad
+    define_method "%s_%s_%s" % [__method__, max, bad.join("_")] do
+      a = (1..max).to_a
+
+      assert_equal bad, a.find_minimal_combination(&check(*bad))
+    end
+  end
+
+  def self.test_find_minimal_combination_and_count max, nsteps, *bad
+    define_method "%s_%s_%s_%s" % [__method__, max, nsteps, bad.join("_")] do
+      a = (1..max).to_a
+
+      found, count = a.find_minimal_combination_and_count(&check(*bad))
+
+      assert_equal bad, found
+      assert_equal nsteps, count
+    end
+  end
+
+  test_find_minimal_combination    8, 5
+  test_find_minimal_combination    8, 2, 7
+  test_find_minimal_combination    8, 1, 2, 7
+  test_find_minimal_combination    8, 1, 4, 7
+  test_find_minimal_combination    8, 1, 3, 5, 7
+
+  test_find_minimal_combination    9, 5
+  test_find_minimal_combination    9, 9
+  test_find_minimal_combination    9, 2, 7
+  test_find_minimal_combination    9, 1, 2, 7
+  test_find_minimal_combination    9, 1, 4, 7
+  test_find_minimal_combination    9, 1, 3, 5, 7
+
+  test_find_minimal_combination 1023, 5
+  test_find_minimal_combination 1023, 1005
+  test_find_minimal_combination 1023, 802, 907
+  test_find_minimal_combination 1023, 7, 15, 166, 1001
+  test_find_minimal_combination 1023, 1000, 1001, 1002
+  test_find_minimal_combination 1023, 1001, 1003, 1005, 1007
+  test_find_minimal_combination 1024, 1001, 1003, 1005, 1007
+  test_find_minimal_combination 1024, 1, 1024
+
+  test_find_minimal_combination_and_count 1024, 12, 1, 2
+  test_find_minimal_combination_and_count 1024, 23, 1, 1023
+  test_find_minimal_combination_and_count 1024, 24, 1, 1024
+  test_find_minimal_combination_and_count 1023, 26, 1, 1023
+
+  test_find_minimal_combination_and_count 1024, 93, 1001, 1003, 1005, 1007
+  test_find_minimal_combination_and_count 1023, 93, 1001, 1003, 1005, 1007
+end

data/test/minitest/test_minitest_assertions.rb

@@ -142,8 +142,7 @@ class TestMinitestAssertions < Minitest::Test
     exp[1] = Object.new
     act[1] = Object.new
     act_obj = act[1]
-    # TODO: switch to endless when 2.7 is dropped
-    act_obj.define_singleton_method(:inspect) { "#<Object:0xXXXXXX>" }
+    def act_obj.inspect = "#<Object:0xXXXXXX>"
     msg = <<~EOM.chomp % [act]
            No visible difference in the Hash#inspect output.
            You should look at the implementation of #== on Hash or its members.
@@ -166,14 +165,20 @@ class TestMinitestAssertions < Minitest::Test
     end
   end
 
-  def test_assert_equal_different_message
+  def test_assert_equal_string_message
     assert_triggered "whoops.\nExpected: 1\n  Actual: 2" do
+      @tc.assert_equal 1, 2, "whoops"
+    end
+  end
+
+  def test_assert_equal_different_message
+    assert_triggered "whoops." do
       @tc.assert_equal 1, 2, message { "whoops" }
     end
   end
 
   def test_assert_equal_different_lambda
-    assert_triggered "whoops.\nExpected: 1\n  Actual: 2" do
+    assert_triggered "whoops" do
       @tc.assert_equal 1, 2, lambda { "whoops" }
     end
   end
@@ -284,26 +289,8 @@ class TestMinitestAssertions < Minitest::Test
   end
 
   def test_assert_equal_does_not_allow_lhs_nil
-    if Minitest::VERSION >= "6" then
-      warn "Time to strip the MT5 test"
-
-      @assertion_count += 1
-      assert_triggered(/Use assert_nil if expecting nil/) do
-        @tc.assert_equal nil, nil
-      end
-    else
-      err_re = /Use assert_nil if expecting nil from .*test_minitest_\w+.rb/
-      err_re = "" if $-w.nil?
-
-      assert_deprecation err_re do
-        @tc.assert_equal nil, nil
-      end
-    end
-  end
-
-  def test_assert_equal_does_not_allow_lhs_nil_triggered
-    assert_triggered "Expected: nil\n  Actual: false" do
-      @tc.assert_equal nil, false
+    assert_triggered(/Use assert_nil if expecting nil/) do
+      @tc.assert_equal nil, nil
     end
   end
 
@@ -526,10 +513,14 @@ class TestMinitestAssertions < Minitest::Test
   end
 
   def test_assert_operator
+    @assertion_count += 1
+
     @tc.assert_operator 2, :>, 1
   end
 
   def test_assert_operator_bad_object
+    @assertion_count += 1
+
     bad = Object.new
     def bad.== _; true end
 
@@ -537,6 +528,8 @@ class TestMinitestAssertions < Minitest::Test
   end
 
   def test_assert_operator_triggered
+    @assertion_count += 1
+
     assert_triggered "Expected 2 to be < 1." do
       @tc.assert_operator 2, :<, 1
     end
@@ -718,10 +711,14 @@ class TestMinitestAssertions < Minitest::Test
   end
 
   def test_assert_predicate
+    @assertion_count += 1
+
     @tc.assert_predicate "", :empty?
   end
 
   def test_assert_predicate_triggered
+    @assertion_count += 1
+
     assert_triggered 'Expected "blah" to be empty?.' do
       @tc.assert_predicate "blah", :empty?
     end
@@ -963,28 +960,6 @@ class TestMinitestAssertions < Minitest::Test
     end
   end
 
-  def test_assert_send
-    @assertion_count = 0 if error_on_warn?
-    assert_deprecation(/DEPRECATED: assert_send/) do
-      @tc.assert_send [1, :<, 2]
-    end
-  end
-
-  def test_assert_send_bad
-    if error_on_warn? then
-      @assertion_count = 0
-      assert_deprecation(/DEPRECATED: assert_send/) do
-        @tc.assert_send [1, :>, 2]
-      end
-    else
-      assert_triggered "Expected 1.>(*[2]) to return true." do
-        assert_deprecation(/DEPRECATED: assert_send/) do
-          @tc.assert_send [1, :>, 2]
-        end
-      end
-    end
-  end
-
   def test_assert_silent
     @assertion_count = 2
 
@@ -1074,48 +1049,24 @@ class TestMinitestAssertions < Minitest::Test
   end
 
   def test_assert_pattern
-    if RUBY_VERSION > "3" then
-      @tc.assert_pattern do
-        exp = if RUBY_VERSION.start_with? "3.0"
-                "(eval):1: warning: One-line pattern matching is experimental, and the behavior may change in future versions of Ruby!\n"
-              else
-                ""
-              end
-        assert_output nil, exp do
-          eval "[1,2,3] => [Integer, Integer, Integer]" # eval to escape parser for ruby<3
-        end
-      end
-    else
-      @assertion_count = 0
-
-      assert_raises NotImplementedError do
-        @tc.assert_pattern do
-          # do nothing
-        end
+    @tc.assert_pattern do
+      assert_output nil, "" do
+        [1,2,3] => [Integer, Integer, Integer]
       end
     end
   end
 
   def test_assert_pattern_traps_nomatchingpatternerror
-    skip unless RUBY_VERSION > "3"
-    exp = if RUBY_VERSION.start_with? "3.0" then
-            "[1, 2, 3]" # terrible error message!
-          else
-            /length mismatch/
-          end
+    exp = /length mismatch/
 
     assert_triggered exp do
       @tc.assert_pattern do
-        capture_io do # 3.0 is noisy
-          eval "[1,2,3] => [Integer, Integer]" # eval to escape parser for ruby<3
-        end
+        [1,2,3] => [Integer, Integer]
       end
     end
   end
 
   def test_assert_pattern_raises_other_exceptions
-    skip unless RUBY_VERSION >= "3.0"
-
     @assertion_count = 0
 
     assert_raises RuntimeError do
@@ -1126,8 +1077,6 @@ class TestMinitestAssertions < Minitest::Test
   end
 
   def test_assert_pattern_with_no_block
-    skip unless RUBY_VERSION >= "3.0"
-
     assert_triggered "assert_pattern requires a block to capture errors." do
       @tc.assert_pattern
     end
@@ -1168,7 +1117,7 @@ class TestMinitestAssertions < Minitest::Test
 
     # These don't have corresponding refutes _on purpose_. They're
     # useless and will never be added, so don't bother.
-    ignores = %w[assert_output assert_raises assert_send
+    ignores = %w[assert_output assert_raises
                  assert_silent assert_throws assert_mock]
 
     ignores += %w[assert_allocations] # for minitest-gcstats
@@ -1280,12 +1229,16 @@ class TestMinitestAssertions < Minitest::Test
   end
 
   def test_refute_in_epsilon_triggered
-    assert_triggered "Expected |10000 - 9990| (10) to not be <= 10.0." do
-      @tc.refute_in_epsilon 10_000, 9990
+    assert_triggered "Expected |10000 - 9991| (9) to not be <= 9.991." do
+      @tc.refute_in_epsilon 10_000, 9991
       flunk
     end
   end
 
+  def test_refute_in_epsilon_minimum
+    @tc.refute_in_epsilon 10_000, 9990
+  end
+
   def test_refute_includes
     @assertion_count = 2
 
@@ -1365,10 +1318,14 @@ class TestMinitestAssertions < Minitest::Test
   end
 
   def test_refute_operator
+    @assertion_count += 1
+
     @tc.refute_operator 2, :<, 1
   end
 
   def test_refute_operator_bad_object
+    @assertion_count += 1
+
     bad = Object.new
     def bad.== _; true end
 
@@ -1376,44 +1333,28 @@ class TestMinitestAssertions < Minitest::Test
   end
 
   def test_refute_operator_triggered
+    @assertion_count += 1
+
     assert_triggered "Expected 2 to not be > 1." do
       @tc.refute_operator 2, :>, 1
     end
   end
 
   def test_refute_pattern
-    if RUBY_VERSION >= "3.0"
-      @tc.refute_pattern do
-        capture_io do # 3.0 is noisy
-          eval "[1,2,3] => [Integer, Integer, String]"
-        end
-      end
-    else
-      @assertion_count = 0
-
-      assert_raises NotImplementedError do
-        @tc.refute_pattern do
-          eval "[1,2,3] => [Integer, Integer, String]"
-        end
-      end
+    @tc.refute_pattern do
+      [1,2,3] => [Integer, Integer, String]
     end
   end
 
   def test_refute_pattern_expects_nomatchingpatternerror
-    skip unless RUBY_VERSION > "3"
-
     assert_triggered(/NoMatchingPatternError expected, but nothing was raised./) do
       @tc.refute_pattern do
-        capture_io do # 3.0 is noisy
-          eval "[1,2,3] => [Integer, Integer, Integer]"
-        end
+        [1,2,3] => [Integer, Integer, Integer]
       end
     end
   end
 
   def test_refute_pattern_raises_other_exceptions
-    skip unless RUBY_VERSION >= "3.0"
-
     @assertion_count = 0
 
     assert_raises RuntimeError do
@@ -1424,18 +1365,20 @@ class TestMinitestAssertions < Minitest::Test
   end
 
   def test_refute_pattern_with_no_block
-    skip unless RUBY_VERSION >= "3.0"
-
     assert_triggered "refute_pattern requires a block to capture errors." do
       @tc.refute_pattern
     end
   end
 
   def test_refute_predicate
+    @assertion_count += 1
+
     @tc.refute_predicate "42", :empty?
   end
 
   def test_refute_predicate_triggered
+    @assertion_count += 1
+
     assert_triggered 'Expected "" to not be empty?.' do
       @tc.refute_predicate "", :empty?
     end
@@ -1611,10 +1554,10 @@ class TestMinitestAssertionHelpers < Minitest::Test
     assert_equal "blah1.\nblah2.", message("blah1") { "blah2" }.call
 
     message = proc { "blah1" }
-    assert_equal "blah1.\nblah2.", message(message) { "blah2" }.call
+    assert_equal "blah1", message(message) { "blah2" }.call
 
     message = message { "blah1" }
-    assert_equal "blah1.\nblah2.", message(message) { "blah2" }.call
+    assert_equal "blah1.", message(message) { "blah2" }.call
   end
 
   def test_message_deferred