minitest 5.27.0 → 6.0.3

data/test/minitest/test_bisect.rb

@@ -0,0 +1,249 @@
+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]
+
+    exp = "minitest -Ilib:test a.rb b.rb c.rb --seed 42"
+    act = bisect.build_files_cmd(files, rb, mt, cmd:"minitest")
+
+    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 setup
+    @orig_i = $LOAD_PATH.dup
+    @orig_w = $VERBOSE
+    @orig_d = $DEBUG
+  end
+
+  def teardown
+    $LOAD_PATH.replace @orig_i
+    $VERBOSE = @orig_w
+    $DEBUG   = @orig_d
+  end
+
+  def test_sanity
+    args = %w[1 -Iblah 2 -d 3 -w 4 5 6 lib/hoe] # lib to not have any test files
+
+    mtbpe = Minitest::Bisect::PathExpander
+    expander = mtbpe.new args
+
+    files = expander.process.to_a # to_a forces process -> files
+
+    assert_empty files
+    assert_empty $LOAD_PATH - @orig_i
+    assert_equal %w[-Iblah -d -w], expander.rb_flags
+    assert_equal %w[1 2 3 4 5 6], args
+    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[-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

@@ -165,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
@@ -283,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 = /.*?test_minitest_\w+.rb:\d+: warning: DEPRECATED: Use assert_nil if expecting nil. This will fail in Minitest 6./
-      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
 
@@ -525,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
 
@@ -536,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
@@ -717,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
@@ -962,25 +960,9 @@ 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
+  def test_assert_same__does_not_allow_lhs_nil
+    assert_triggered(/Use assert_nil if expecting nil/) do
+      @tc.assert_same nil, nil
     end
   end
 
@@ -1141,7 +1123,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
@@ -1342,10 +1324,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
 
@@ -1353,6 +1339,8 @@ 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
@@ -1389,10 +1377,14 @@ class TestMinitestAssertions < Minitest::Test
   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
@@ -1568,10 +1560,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

data/test/minitest/test_minitest_benchmark.rb

@@ -25,6 +25,20 @@ class TestMinitestBenchmark < Minitest::Test
     assert_equal ["bench_blah"], c.runnable_methods
   end
 
+  def test_cls_run
+    c = Class.new Minitest::Benchmark do
+      def bench_dummy
+        assert true
+      end
+    end
+
+    reporter = Minitest::StatisticsReporter.new(StringIO.new(+""))
+
+    c.run c, "bench_dummy", reporter
+
+    assert_equal 1, reporter.count
+  end
+
   def test_cls_bench_range
     assert_equal [1, 10, 100, 1_000, 10_000], Minitest::Benchmark.bench_range
   end