minitest 5.12.2 → 5.14.3

data/lib/minitest/spec.rb

@@ -289,21 +289,28 @@ class Minitest::Spec < Minitest::Test
 
     module InstanceMethods
       ##
-      # Returns a value monad that has all of Expectations methods
-      # available to it.
+      # Takes a value or a block and returns a value monad that has
+      # all of Expectations methods available to it.
       #
-      # Also aliased to #value and #expect for your aesthetic pleasure:
+      #   _(1 + 1).must_equal 2
       #
-      #         _(1 + 1).must_equal 2
-      #     value(1 + 1).must_equal 2
-      #    expect(1 + 1).must_equal 2
+      # And for blocks:
+      #
+      #   _ { 1 + "1" }.must_raise TypeError
       #
       # This method of expectation-based testing is preferable to
       # straight-expectation methods (on Object) because it stores its
       # test context, bypassing our hacky use of thread-local variables.
       #
-      # At some point, the methods on Object will be deprecated and then
-      # removed.
+      # NOTE: At some point, the methods on Object will be deprecated
+      # and then removed.
+      #
+      # It is also aliased to #value and #expect for your aesthetic
+      # pleasure:
+      #
+      #         _(1 + 1).must_equal 2
+      #     value(1 + 1).must_equal 2
+      #    expect(1 + 1).must_equal 2
 
       def _ value = nil, &block
         Minitest::Expectation.new block || value, self

data/test/minitest/metametameta.rb

@@ -6,8 +6,27 @@ class Minitest::Test
   def clean s
     s.gsub(/^ {6}/, "")
   end
+
+  def with_empty_backtrace_filter
+    original = Minitest.backtrace_filter
+
+    obj = Minitest::BacktraceFilter.new
+    def obj.filter _bt
+      []
+    end
+
+    Minitest::Test.io_lock.synchronize do # try not to trounce in parallel
+      begin
+        Minitest.backtrace_filter = obj
+        yield
+      ensure
+        Minitest.backtrace_filter = original
+      end
+    end
+  end
 end
 
+
 class FakeNamedTest < Minitest::Test
   @@count = 0
 
@@ -25,6 +44,14 @@ class AnError < StandardError; include MyModule; end
 class MetaMetaMetaTestCase < Minitest::Test
   attr_accessor :reporter, :output, :tu
 
+  def with_stderr err
+    old = $stderr
+    $stderr = err
+    yield
+  ensure
+    $stderr = old
+  end
+
   def run_tu_with_fresh_reporter flags = %w[--seed 42]
     options = Minitest.process_args flags
 
@@ -34,18 +61,20 @@ class MetaMetaMetaTestCase < Minitest::Test
     reporter << Minitest::SummaryReporter.new(@output, options)
     reporter << Minitest::ProgressReporter.new(@output, options)
 
-    reporter.start
+    with_stderr @output do
+      reporter.start
 
-    yield(reporter) if block_given?
+      yield(reporter) if block_given?
 
-    @tus ||= [@tu]
-    @tus.each do |tu|
-      Minitest::Runnable.runnables.delete tu
+      @tus ||= [@tu]
+      @tus.each do |tu|
+        Minitest::Runnable.runnables.delete tu
 
-      tu.run reporter, options
-    end
+        tu.run reporter, options
+      end
 
-    reporter.report
+      reporter.report
+    end
   end
 
   def first_reporter
@@ -84,6 +113,8 @@ class MetaMetaMetaTestCase < Minitest::Test
       output.gsub!(/^(\s+)[^:]+:\d+:in/, '\1FILE:LINE:in')
     end
 
+    output.gsub!(/( at )[^:]+:\d+/, '\1[FILE:LINE]')
+
     output
   end
 

data/test/minitest/test_minitest_assertions.rb

@@ -77,6 +77,14 @@ class TestMinitestAssertions < Minitest::Test
     self.send assert_msg, expected, msg
   end
 
+  def assert_unexpected expected
+    expected = Regexp.new expected if String === expected
+
+    assert_triggered expected, Minitest::UnexpectedError do
+      yield
+    end
+  end
+
   def clean s
     s.gsub(/^ {6,10}/, "")
   end
@@ -397,7 +405,7 @@ class TestMinitestAssertions < Minitest::Test
   end
 
   def test_assert_in_delta_triggered
-    x = maglev? ? "9.999999xxxe-07" : "1.0e-06"
+    x = "1.0e-06"
     assert_triggered "Expected |0.0 - 0.001| (0.001) to be <= #{x}." do
       @tc.assert_in_delta 0.0, 1.0 / 1000, 0.000001
     end
@@ -428,7 +436,7 @@ class TestMinitestAssertions < Minitest::Test
 
   def test_assert_in_epsilon_triggered_negative_case
     x = (RUBY18 and not maglev?) ? "0.1" : "0.100000xxx"
-    y = maglev? ? "0.100000xxx" : "0.1"
+    y = "0.1"
     assert_triggered "Expected |-1.1 - -1| (#{x}) to be <= #{y}." do
       @tc.assert_in_epsilon(-1.1, -1, 0.1)
     end
@@ -603,12 +611,117 @@ class TestMinitestAssertions < Minitest::Test
     end
   end
 
-  def test_assert_output_without_block
+  def test_assert_output_no_block
     assert_triggered "assert_output requires a block to capture output." do
       @tc.assert_output "blah"
     end
   end
 
+  def test_assert_output_nested_assert_uncaught
+    @assertion_count = 1
+
+    assert_triggered "Epic Fail!" do
+      @tc.assert_output "blah\n" do
+        puts "blah"
+        @tc.flunk
+      end
+    end
+  end
+
+  def test_assert_output_nested_raise
+    @assertion_count = 2
+
+    @tc.assert_output "blah\n" do
+      @tc.assert_raises RuntimeError do
+        puts "blah"
+        raise "boom!"
+      end
+    end
+  end
+
+  def test_assert_output_nested_raise_bad
+    @assertion_count = 0
+
+    assert_unexpected "boom!" do
+      @tc.assert_raises do            # 2) bypassed via UnexpectedError
+        @tc.assert_output "blah\n" do # 1) captures and raises UnexpectedError
+          puts "not_blah"
+          raise "boom!"
+        end
+      end
+    end
+  end
+
+  def test_assert_output_nested_raise_mismatch
+    # this test is redundant, but illustrative
+    @assertion_count = 0
+
+    assert_unexpected "boom!" do
+      @tc.assert_raises RuntimeError do # 2) bypassed via UnexpectedError
+        @tc.assert_output "blah\n" do   # 1) captures and raises UnexpectedError
+          puts "not_blah"
+          raise ArgumentError, "boom!"
+        end
+      end
+    end
+  end
+
+  def test_assert_output_nested_throw_caught
+    @assertion_count = 2
+
+    @tc.assert_output "blah\n" do
+      @tc.assert_throws :boom! do
+        puts "blah"
+        throw :boom!
+      end
+    end
+  end
+
+  def test_assert_output_nested_throw_caught_bad
+    @assertion_count = 1            # want 0; can't prevent throw from escaping :(
+
+    @tc.assert_throws :boom! do     # 2) captured via catch
+      @tc.assert_output "blah\n" do # 1) bypassed via throw
+        puts "not_blah"
+        throw :boom!
+      end
+    end
+  end
+
+  def test_assert_output_nested_throw_mismatch
+    @assertion_count = 0
+
+    assert_unexpected "uncaught throw :boom!" do
+      @tc.assert_throws :not_boom! do # 2) captured via assert_throws+rescue
+        @tc.assert_output "blah\n" do # 1) bypassed via throw
+          puts "not_blah"
+          throw :boom!
+        end
+      end
+    end
+  end
+
+  def test_assert_output_uncaught_raise
+    @assertion_count = 0
+
+    assert_unexpected "RuntimeError: boom!" do
+      @tc.assert_output "blah\n" do
+        puts "not_blah"
+        raise "boom!"
+      end
+    end
+  end
+
+  def test_assert_output_uncaught_throw
+    @assertion_count = 0
+
+    assert_unexpected "uncaught throw :boom!" do
+      @tc.assert_output "blah\n" do
+        puts "not_blah"
+        throw :boom!
+      end
+    end
+  end
   def test_assert_predicate
     @tc.assert_predicate "", :empty?
   end
@@ -671,6 +784,19 @@ class TestMinitestAssertions < Minitest::Test
     end
   end
 
+  def test_assert_raises_throw_nested_bad
+    @assertion_count = 0
+
+    assert_unexpected "RuntimeError: boom!" do
+      @tc.assert_raises do
+        @tc.assert_throws :blah do
+          raise "boom!"
+          throw :not_blah
+        end
+      end
+    end
+  end
+
   ##
   # *sigh* This is quite an odd scenario, but it is from real (albeit
   # ugly) test code in ruby-core:
@@ -875,7 +1001,9 @@ class TestMinitestAssertions < Minitest::Test
   end
 
   def test_assert_throws_argument_exception
-    @tc.assert_raises ArgumentError do
+    @assertion_count = 0
+
+    assert_unexpected "ArgumentError" do
       @tc.assert_throws :blah do
         raise ArgumentError
       end
@@ -891,7 +1019,9 @@ class TestMinitestAssertions < Minitest::Test
   end
 
   def test_assert_throws_name_error
-    @tc.assert_raises NameError do
+    @assertion_count = 0
+
+    assert_unexpected "NameError" do
       @tc.assert_throws :blah do
         raise NameError
       end
@@ -906,6 +1036,16 @@ class TestMinitestAssertions < Minitest::Test
     end
   end
 
+  def test_assert_path_exists
+    @tc.assert_path_exists __FILE__
+  end
+
+  def test_assert_path_exists_triggered
+    assert_triggered "Expected path 'blah' to exist." do
+      @tc.assert_path_exists "blah"
+    end
+  end
+
   def test_capture_io
     @assertion_count = 0
 
@@ -978,6 +1118,23 @@ class TestMinitestAssertions < Minitest::Test
     end
   end
 
+  def assert_fail_after t
+    @tc.fail_after t.year, t.month, t.day, "remove the deprecations"
+  end
+
+  def test_fail_after
+    d0 = Time.now
+    d1 = d0 + 86_400 # I am an idiot
+
+    assert_silent do
+      assert_fail_after d1
+    end
+
+    assert_triggered "remove the deprecations" do
+      assert_fail_after d0
+    end
+  end
+
   def test_flunk
     assert_triggered "Epic Fail!" do
       @tc.flunk
@@ -997,7 +1154,7 @@ class TestMinitestAssertions < Minitest::Test
   def test_refute
     @assertion_count = 2
 
-    @tc.assert_equal false, @tc.refute(false), "returns false on success"
+    @tc.assert_equal true, @tc.refute(false), "returns true on success"
   end
 
   def test_refute_empty
@@ -1029,7 +1186,7 @@ class TestMinitestAssertions < Minitest::Test
   end
 
   def test_refute_in_delta_triggered
-    x = maglev? ? "0.100000xxx" : "0.1"
+    x = "0.1"
     assert_triggered "Expected |0.0 - 0.001| (0.001) to not be <= #{x}." do
       @tc.refute_in_delta 0.0, 1.0 / 1000, 0.1
     end
@@ -1171,6 +1328,16 @@ class TestMinitestAssertions < Minitest::Test
     end
   end
 
+  def test_refute_path_exists
+    @tc.refute_path_exists "blah"
+  end
+
+  def test_refute_path_exists_triggered
+    assert_triggered "Expected path '#{__FILE__}' to not exist." do
+      @tc.refute_path_exists __FILE__
+    end
+  end
+
   def test_skip
     @assertion_count = 0
 
@@ -1179,6 +1346,25 @@ class TestMinitestAssertions < Minitest::Test
     end
   end
 
+  def assert_skip_until t, msg
+    @tc.skip_until t.year, t.month, t.day, msg
+  end
+
+  def test_skip_until
+    @assertion_count = 0
+
+    d0 = Time.now
+    d1 = d0 + 86_400 # I am an idiot
+
+    assert_output "", /Stale skip_until \"not yet\" at .*?:\d+$/ do
+      assert_skip_until d0, "not yet"
+    end
+
+    assert_triggered "not ready yet", Minitest::Skip do
+      assert_skip_until d1, "not ready yet"
+    end
+  end
+
   def util_msg exp, act, msg = nil
     s = "Expected: #{exp.inspect}\n  Actual: #{act.inspect}"
     s = "#{msg}.\n#{s}" if msg

data/test/minitest/test_minitest_mock.rb

@@ -64,8 +64,6 @@ class TestMinitestMock < Minitest::Test
   end
 
   def test_mock_args_does_not_raise
-    skip "non-opaque use of ==" if maglev?
-
     arg = Minitest::Mock.new
     mock = Minitest::Mock.new
     mock.expect(:foo, nil, [arg])

data/test/minitest/test_minitest_spec.rb

@@ -26,9 +26,8 @@ describe Minitest::Spec do
 
     msg = e.message.sub(/(---Backtrace---).*/m, '\1')
     msg.gsub!(/\(oid=[-0-9]+\)/, "(oid=N)")
-    msg.gsub!(/@.+>/, "@PATH>")
     msg.gsub!(/(\d\.\d{6})\d+/, '\1xxx') # normalize: ruby version, impl, platform
-    msg.gsub!(/:0x[a-fA-F0-9]{4,}/m, ":0xXXXXXX")
+    msg.gsub!(/:0x[Xa-fA-F0-9]{4,}[ @].+?>/, ":0xXXXXXX@PATH>")
 
     if expected
       @assertion_count += 1
@@ -44,6 +43,10 @@ describe Minitest::Spec do
     end
   end
 
+  def assert_success spec
+    assert_equal true, spec
+  end
+
   before do
     @assertion_count = 4
   end
@@ -60,10 +63,30 @@ describe Minitest::Spec do
     end
   end
 
+  it "needs to check for file existence" do
+    @assertion_count = 3
+
+    assert_success _(__FILE__).path_must_exist
+
+    assert_triggered "Expected path 'blah' to exist." do
+      _("blah").path_must_exist
+    end
+  end
+
+  it "needs to check for file non-existence" do
+    @assertion_count = 3
+
+    assert_success _("blah").path_wont_exist
+
+    assert_triggered "Expected path '#{__FILE__}' to not exist." do
+      _(__FILE__).path_wont_exist
+    end
+  end
+
   it "needs to be sensible about must_include order" do
     @assertion_count += 3 # must_include is 2 assertions
 
-    _(_([1, 2, 3]).must_include(2)).must_equal true
+    assert_success _([1, 2, 3]).must_include(2)
 
     assert_triggered "Expected [1, 2, 3] to include 5." do
       _([1, 2, 3]).must_include 5
@@ -77,7 +100,7 @@ describe Minitest::Spec do
   it "needs to be sensible about wont_include order" do
     @assertion_count += 3 # wont_include is 2 assertions
 
-    _(_([1, 2, 3]).wont_include(5)).must_equal false
+    assert_success _([1, 2, 3]).wont_include(5)
 
     assert_triggered "Expected [1, 2, 3] to not include 2." do
       _([1, 2, 3]).wont_include 2
@@ -118,7 +141,7 @@ describe Minitest::Spec do
     @assertion_count -= 1 # no msg
     @assertion_count += 2 # assert_output is 2 assertions
 
-    _(expect {}.must_be_silent).must_equal true
+    assert_success expect {}.must_be_silent
 
     assert_triggered "In stdout.\nExpected: \"\"\n  Actual: \"xxx\"" do
       expect { print "xxx" }.must_be_silent
@@ -130,10 +153,10 @@ describe Minitest::Spec do
 
     @assertion_count = 2
 
-    methods = Object.public_instance_methods.find_all { |n| n =~ /^must|^wont/ }
+    methods = Minitest::Expectations.public_instance_methods.grep(/must|wont/)
     methods.map!(&:to_s) if Symbol === methods.first
 
-    musts, wonts = methods.sort.partition { |m| m =~ /^must/ }
+    musts, wonts = methods.sort.partition { |m| m =~ /must/ }
 
     expected_musts = %w[must_be
                         must_be_close_to
@@ -151,11 +174,12 @@ describe Minitest::Spec do
                         must_output
                         must_raise
                         must_respond_to
-                        must_throw]
+                        must_throw
+                        path_must_exist]
 
     bad = %w[not raise throw send output be_silent]
 
-    expected_wonts = expected_musts.map { |m| m.sub(/^must/, "wont") }
+    expected_wonts = expected_musts.map { |m| m.sub(/must/, "wont") }.sort
     expected_wonts.reject! { |m| m =~ /wont_#{Regexp.union(*bad)}/ }
 
     _(musts).must_equal expected_musts
@@ -175,7 +199,7 @@ describe Minitest::Spec do
   end
 
   it "needs to verify binary messages" do
-    _(_(42).wont_be(:<, 24)).must_equal false
+    assert_success _(42).wont_be(:<, 24)
 
     assert_triggered "Expected 24 to not be < 42." do
       _(24).wont_be :<, 42
@@ -189,7 +213,7 @@ describe Minitest::Spec do
   it "needs to verify emptyness" do
     @assertion_count += 3 # empty is 2 assertions
 
-    _(_([]).must_be_empty).must_equal true
+    assert_success _([]).must_be_empty
 
     assert_triggered "Expected [42] to be empty." do
       _([42]).must_be_empty
@@ -203,7 +227,7 @@ describe Minitest::Spec do
   it "needs to verify equality" do
     @assertion_count += 1
 
-    _(_(6 * 7).must_equal(42)).must_equal true
+    assert_success _(6 * 7).must_equal(42)
 
     assert_triggered "Expected: 42\n  Actual: 54" do
       _(6 * 9).must_equal 42
@@ -213,7 +237,7 @@ describe Minitest::Spec do
       _(6 * 9).must_equal 42, "msg"
     end
 
-    assert_triggered(/^-42\n\+#<Proc:0xXXXXXX@PATH>\n/) do
+    assert_triggered(/^-42\n\+#<Proc:0xXXXXXX[ @]PATH>\n/) do
       _(proc { 42 }).must_equal 42 # proc isn't called, so expectation fails
     end
   end
@@ -222,7 +246,7 @@ describe Minitest::Spec do
     @assertion_count += 1 # extra test
 
     out, err = capture_io do
-      _(_(nil).must_equal(nil)).must_equal true
+      assert_success _(nil).must_equal(nil)
     end
 
     exp = "DEPRECATED: Use assert_nil if expecting nil from #{__FILE__}:#{__LINE__-3}. " \
@@ -236,13 +260,13 @@ describe Minitest::Spec do
   it "needs to verify floats outside a delta" do
     @assertion_count += 1 # extra test
 
-    _(_(24).wont_be_close_to(42)).must_equal false
+    assert_success _(24).wont_be_close_to(42)
 
     assert_triggered "Expected |42 - 42.0| (0.0) to not be <= 0.001." do
       _(6 * 7.0).wont_be_close_to 42
     end
 
-    x = maglev? ? "1.0000000000000001e-05" : "1.0e-05"
+    x = "1.0e-05"
     assert_triggered "Expected |42 - 42.0| (0.0) to not be <= #{x}." do
       _(6 * 7.0).wont_be_close_to 42, 0.00001
     end
@@ -255,14 +279,14 @@ describe Minitest::Spec do
   it "needs to verify floats outside an epsilon" do
     @assertion_count += 1 # extra test
 
-    _(_(24).wont_be_within_epsilon(42)).must_equal false
+    assert_success _(24).wont_be_within_epsilon(42)
 
-    x = maglev? ? "0.042000000000000003" : "0.042"
+    x = "0.042"
     assert_triggered "Expected |42 - 42.0| (0.0) to not be <= #{x}." do
       _(6 * 7.0).wont_be_within_epsilon 42
     end
 
-    x = maglev? ? "0.00042000000000000002" : "0.00042"
+    x = "0.00042"
     assert_triggered "Expected |42 - 42.0| (0.0) to not be <= #{x}." do
       _(6 * 7.0).wont_be_within_epsilon 42, 0.00001
     end
@@ -275,13 +299,13 @@ describe Minitest::Spec do
   it "needs to verify floats within a delta" do
     @assertion_count += 1 # extra test
 
-    _(_(6.0 * 7).must_be_close_to(42.0)).must_equal true
+    assert_success _(6.0 * 7).must_be_close_to(42.0)
 
     assert_triggered "Expected |0.0 - 0.01| (0.01) to be <= 0.001." do
       _(1.0 / 100).must_be_close_to 0.0
     end
 
-    x = maglev? ? "9.9999999999999995e-07" : "1.0e-06"
+    x = "1.0e-06"
     assert_triggered "Expected |0.0 - 0.001| (0.001) to be <= #{x}." do
       _(1.0 / 1000).must_be_close_to 0.0, 0.000001
     end
@@ -294,7 +318,7 @@ describe Minitest::Spec do
   it "needs to verify floats within an epsilon" do
     @assertion_count += 1 # extra test
 
-    _(_(6.0 * 7).must_be_within_epsilon(42.0)).must_equal true
+    assert_success _(6.0 * 7).must_be_within_epsilon(42.0)
 
     assert_triggered "Expected |0.0 - 0.01| (0.01) to be <= 0.0." do
       _(1.0 / 100).must_be_within_epsilon 0.0
@@ -310,7 +334,7 @@ describe Minitest::Spec do
   end
 
   it "needs to verify identity" do
-    _(_(1).must_be_same_as(1)).must_equal true
+    assert_success _(1).must_be_same_as(1)
 
     assert_triggered "Expected 1 (oid=N) to be the same as 2 (oid=N)." do
       _(1).must_be_same_as 2
@@ -323,8 +347,8 @@ describe Minitest::Spec do
 
   it "needs to verify inequality" do
     @assertion_count += 2
-    _(_(42).wont_equal(6 * 9)).must_equal false
-    _(_(proc {}).wont_equal(42)).must_equal false
+    assert_success _(42).wont_equal(6 * 9)
+    assert_success _(proc {}).wont_equal(42)
 
     assert_triggered "Expected 1 to not be equal to 1." do
       _(1).wont_equal 1
@@ -336,7 +360,7 @@ describe Minitest::Spec do
   end
 
   it "needs to verify instances of a class" do
-    _(_(42).wont_be_instance_of(String)).must_equal false
+    assert_success _(42).wont_be_instance_of(String)
 
     assert_triggered "Expected 42 to not be a kind of #{Int.name}." do
       _(42).wont_be_kind_of Int
@@ -350,8 +374,8 @@ describe Minitest::Spec do
   it "needs to verify kinds of a class" do
     @assertion_count += 2
 
-    _(_(42).wont_be_kind_of(String)).must_equal false
-    _(_(proc {}).wont_be_kind_of(String)).must_equal false
+    assert_success _(42).wont_be_kind_of(String)
+    assert_success _(proc {}).wont_be_kind_of(String)
 
     assert_triggered "Expected 42 to not be a kind of #{Int.name}." do
       _(42).wont_be_kind_of Int
@@ -365,8 +389,8 @@ describe Minitest::Spec do
   it "needs to verify kinds of objects" do
     @assertion_count += 3 # extra test
 
-    _(_(6 * 7).must_be_kind_of(Int)).must_equal true
-    _(_(6 * 7).must_be_kind_of(Numeric)).must_equal true
+    assert_success _(6 * 7).must_be_kind_of(Int)
+    assert_success _(6 * 7).must_be_kind_of(Numeric)
 
     assert_triggered "Expected 42 to be a kind of String, not #{Int.name}." do
       _(6 * 7).must_be_kind_of String
@@ -385,7 +409,7 @@ describe Minitest::Spec do
   it "needs to verify mismatch" do
     @assertion_count += 3 # match is 2
 
-    _(_("blah").wont_match(/\d+/)).must_equal false
+    assert_success _("blah").wont_match(/\d+/)
 
     assert_triggered "Expected /\\w+/ to not match \"blah\"." do
       _("blah").wont_match(/\w+/)
@@ -397,7 +421,7 @@ describe Minitest::Spec do
   end
 
   it "needs to verify nil" do
-    _(_(nil).must_be_nil).must_equal true
+    assert_success _(nil).must_be_nil
 
     assert_triggered "Expected 42 to be nil." do
       _(42).must_be_nil
@@ -411,7 +435,7 @@ describe Minitest::Spec do
   it "needs to verify non-emptyness" do
     @assertion_count += 3 # empty is 2 assertions
 
-    _(_(["some item"]).wont_be_empty).must_equal false
+    assert_success _(["some item"]).wont_be_empty
 
     assert_triggered "Expected [] to not be empty." do
       _([]).wont_be_empty
@@ -423,7 +447,7 @@ describe Minitest::Spec do
   end
 
   it "needs to verify non-identity" do
-    _(_(1).wont_be_same_as(2)).must_equal false
+    assert_success _(1).wont_be_same_as(2)
 
     assert_triggered "Expected 1 (oid=N) to not be the same as 1 (oid=N)." do
       _(1).wont_be_same_as 1
@@ -435,7 +459,7 @@ describe Minitest::Spec do
   end
 
   it "needs to verify non-nil" do
-    _(_(42).wont_be_nil).must_equal false
+    assert_success _(42).wont_be_nil
 
     assert_triggered "Expected nil to not be nil." do
       _(nil).wont_be_nil
@@ -447,7 +471,7 @@ describe Minitest::Spec do
   end
 
   it "needs to verify objects not responding to a message" do
-    _(_("").wont_respond_to(:woot!)).must_equal false
+    assert_success _("").wont_respond_to(:woot!)
 
     assert_triggered "Expected \"\" to not respond to to_s." do
       _("").wont_respond_to :to_s
@@ -461,7 +485,7 @@ describe Minitest::Spec do
   it "needs to verify output in stderr" do
     @assertion_count -= 1 # no msg
 
-    _(expect { $stderr.print "blah" }.must_output(nil, "blah")).must_equal true
+    assert_success expect { $stderr.print "blah" }.must_output(nil, "blah")
 
     assert_triggered "In stderr.\nExpected: \"blah\"\n  Actual: \"xxx\"" do
       expect { $stderr.print "xxx" }.must_output(nil, "blah")
@@ -471,7 +495,7 @@ describe Minitest::Spec do
   it "needs to verify output in stdout" do
     @assertion_count -= 1 # no msg
 
-    _(expect { print "blah" }.must_output("blah")).must_equal true
+    assert_success expect { print "blah" }.must_output("blah")
 
     assert_triggered "In stdout.\nExpected: \"blah\"\n  Actual: \"xxx\"" do
       expect { print "xxx" }.must_output("blah")
@@ -481,7 +505,7 @@ describe Minitest::Spec do
   it "needs to verify regexp matches" do
     @assertion_count += 3 # must_match is 2 assertions
 
-    _(_("blah").must_match(/\w+/)).must_equal true
+    assert_success _("blah").must_match(/\w+/)
 
     assert_triggered "Expected /\\d+/ to match \"blah\"." do
       _("blah").must_match(/\d+/)
@@ -547,12 +571,28 @@ describe Minitest::Spec do
         (1 + 1).must_equal 2
       end
     end
+
+    # https://github.com/seattlerb/minitest/issues/837
+    # https://github.com/rails/rails/pull/39304
+    it "deprecates expectation used without _ with empty backtrace_filter" do
+      skip "N/A" if ENV["MT_NO_EXPECTATIONS"]
+
+      @assertion_count += 3
+
+      exp = /DEPRECATED: global use of must_equal from/
+
+      with_empty_backtrace_filter do
+        assert_output "", exp do
+          (1 + 1).must_equal 2
+        end
+      end
+    end
   end
 
   it "needs to verify throw" do
     @assertion_count += 2 # 2 extra tests
 
-    _(expect { throw :blah }.must_throw(:blah)).must_equal true
+    assert_success expect { throw :blah }.must_throw(:blah)
 
     assert_triggered "Expected :blah to have been thrown." do
       expect {}.must_throw :blah
@@ -572,7 +612,7 @@ describe Minitest::Spec do
   end
 
   it "needs to verify types of objects" do
-    _(_(6 * 7).must_be_instance_of(Int)).must_equal true
+    assert_success _(6 * 7).must_be_instance_of(Int)
 
     exp = "Expected 42 to be an instance of String, not #{Int.name}."
 
@@ -588,7 +628,7 @@ describe Minitest::Spec do
   it "needs to verify using any (negative) predicate" do
     @assertion_count -= 1 # doesn"t take a message
 
-    _(_("blah").wont_be(:empty?)).must_equal false
+    assert_success _("blah").wont_be(:empty?)
 
     assert_triggered "Expected \"\" to not be empty?." do
       _("").wont_be :empty?
@@ -598,7 +638,7 @@ describe Minitest::Spec do
   it "needs to verify using any binary operator" do
     @assertion_count -= 1 # no msg
 
-    _(_(41).must_be(:<, 42)).must_equal true
+    assert_success _(41).must_be(:<, 42)
 
     assert_triggered "Expected 42 to be < 41." do
       _(42).must_be(:<, 41)
@@ -608,7 +648,7 @@ describe Minitest::Spec do
   it "needs to verify using any predicate" do
     @assertion_count -= 1 # no msg
 
-    _(_("").must_be(:empty?)).must_equal true
+    assert_success _("").must_be(:empty?)
 
     assert_triggered "Expected \"blah\" to be empty?." do
       _("blah").must_be :empty?
@@ -616,7 +656,7 @@ describe Minitest::Spec do
   end
 
   it "needs to verify using respond_to" do
-    _(_(42).must_respond_to(:+)).must_equal true
+    assert_success _(42).must_respond_to(:+)
 
     assert_triggered "Expected 42 (#{Int.name}) to respond to #clear." do
       _(42).must_respond_to :clear