Split test files for test-framework that are test-unit and minitest to tool direcotry.

17 files changed, 0 insertions, 2800 deletions

diff --git a/test/minitest/metametameta.rb b/test/minitest/metametameta.rb
deleted file mode 100644
index a12717c8b1..0000000000
--- a/test/minitest/metametameta.rb
+++ /dev/null
@@ -1,71 +0,0 @@
-# encoding: utf-8
-# frozen_string_literal: false
-
-require 'tempfile'
-require 'stringio'
-require 'minitest/autorun'
-
-class MiniTest::Unit::TestCase
-  def clean s
-    s.gsub(/^ {6}/, '')
-  end
-end
-
-class MetaMetaMetaTestCase < MiniTest::Unit::TestCase
-  def assert_report expected, flags = %w[--seed 42]
-    header = clean <<-EOM
-      Run options: #{flags.map { |s| s =~ /\|/ ? s.inspect : s }.join " "}
-
-      # Running tests:
-
-    EOM
-
-    with_output do
-      @tu.run flags
-    end
-
-    output = @output.string.dup
-    output.sub!(/Finished tests in .*/, "Finished tests in 0.00")
-    output.sub!(/Loaded suite .*/, 'Loaded suite blah')
-
-    output.gsub!(/ = \d+.\d\d s = /, ' = 0.00 s = ')
-    output.gsub!(/0x[A-Fa-f0-9]+/, '0xXXX')
-
-    if windows? then
-      output.gsub!(/\[(?:[A-Za-z]:)?[^\]:]+:\d+\]/, '[FILE:LINE]')
-      output.gsub!(/^(\s+)(?:[A-Za-z]:)?[^:]+:\d+:in/, '\1FILE:LINE:in')
-    else
-      output.gsub!(/\[[^\]:]+:\d+\]/, '[FILE:LINE]')
-      output.gsub!(/^(\s+)[^:]+:\d+:in/, '\1FILE:LINE:in')
-    end
-
-    assert_equal header + expected, output
-  end
-
-  def setup
-    super
-    srand 42
-    MiniTest::Unit::TestCase.reset
-    @tu = MiniTest::Unit.new
-
-    MiniTest::Unit.runner = nil # protect the outer runner from the inner tests
-  end
-
-  def teardown
-    super
-  end
-
-  def with_output
-    synchronize do
-      begin
-        save = MiniTest::Unit.output
-        @output = StringIO.new("")
-        MiniTest::Unit.output = @output
-
-        yield
-      ensure
-        MiniTest::Unit.output = save
-      end
-    end
-  end
-end
diff --git a/test/minitest/test_minitest_benchmark.rb b/test/minitest/test_minitest_benchmark.rb
deleted file mode 100644
index a783e684c2..0000000000
--- a/test/minitest/test_minitest_benchmark.rb
+++ /dev/null
@@ -1,131 +0,0 @@
-# encoding: utf-8
-# frozen_string_literal: false
-
-require 'minitest/autorun'
-require 'minitest/benchmark'
-
-##
-# Used to verify data:
-# http://www.wolframalpha.com/examples/RegressionAnalysis.html
-
-class TestMiniTestBenchmark < MiniTest::Unit::TestCase
-  def test_cls_bench_exp
-    assert_equal [2, 4, 8, 16, 32], self.class.bench_exp(2, 32, 2)
-  end
-
-  def test_cls_bench_linear
-    assert_equal [2, 4, 6, 8, 10], self.class.bench_linear(2, 10, 2)
-  end
-
-  def test_cls_benchmark_methods
-    assert_equal [], self.class.benchmark_methods
-
-    c = Class.new(MiniTest::Unit::TestCase) do
-      def bench_blah
-      end
-    end
-
-    assert_equal ["bench_blah"], c.benchmark_methods
-  end
-
-  def test_cls_bench_range
-    assert_equal [1, 10, 100, 1_000, 10_000], self.class.bench_range
-  end
-
-  def test_fit_exponential_clean
-    x = [1.0, 2.0, 3.0, 4.0, 5.0]
-    y = x.map { |n| 1.1 * Math.exp(2.1 * n) }
-
-    assert_fit :exponential, x, y, 1.0, 1.1, 2.1
-  end
-
-  def test_fit_exponential_noisy
-    x = [1.0, 1.9, 2.6, 3.4, 5.0]
-    y = [12, 10, 8.2, 6.9, 5.9]
-
-    # verified with Numbers and R
-    assert_fit :exponential, x, y, 0.95, 13.81148, -0.1820
-  end
-
-  def test_fit_logarithmic_clean
-    x = [1.0, 2.0, 3.0, 4.0, 5.0]
-    y = x.map { |n| 1.1 + 2.1 * Math.log(n) }
-
-    assert_fit :logarithmic, x, y, 1.0, 1.1, 2.1
-  end
-
-  def test_fit_logarithmic_noisy
-    x = [1.0, 2.0, 3.0, 4.0, 5.0]
-    # Generated with
-    # y = x.map { |n| jitter = 0.999 + 0.002 * rand; (Math.log(n) ) * jitter }
-    y = [0.0, 0.6935, 1.0995, 1.3873, 1.6097]
-
-    assert_fit :logarithmic, x, y, 0.95, 0, 1
-  end
-
-  def test_fit_constant_clean
-    x = (1..5).to_a
-    y = [5.0, 5.0, 5.0, 5.0, 5.0]
-
-    assert_fit :linear, x, y, nil, 5.0, 0
-  end
-
-  def test_fit_constant_noisy
-    x = (1..5).to_a
-    y = [1.0, 1.2, 1.0, 0.8, 1.0]
-
-    # verified in numbers and R
-    assert_fit :linear, x, y, nil, 1.12, -0.04
-  end
-
-  def test_fit_linear_clean
-    # y = m * x + b where m = 2.2, b = 3.1
-    x = (1..5).to_a
-    y = x.map { |n| 2.2 * n + 3.1 }
-
-    assert_fit :linear, x, y, 1.0, 3.1, 2.2
-  end
-
-  def test_fit_linear_noisy
-    x = [ 60,  61,  62,  63,  65]
-    y = [3.1, 3.6, 3.8, 4.0, 4.1]
-
-    # verified in numbers and R
-    assert_fit :linear, x, y, 0.8315, -7.9635, 0.1878
-  end
-
-  def test_fit_power_clean
-    # y = A x ** B, where B = b and A = e ** a
-    # if, A = 1, B = 2, then
-
-    x = [1.0, 2.0, 3.0, 4.0, 5.0]
-    y = [1.0, 4.0, 9.0, 16.0, 25.0]
-
-    assert_fit :power, x, y, 1.0, 1.0, 2.0
-  end
-
-  def test_fit_power_noisy
-    # from www.engr.uidaho.edu/thompson/courses/ME330/lecture/least_squares.html
-    x = [10, 12, 15, 17, 20, 22, 25, 27, 30, 32, 35]
-    y = [95, 105, 125, 141, 173, 200, 253, 298, 385, 459, 602]
-
-    # verified in numbers
-    assert_fit :power, x, y, 0.90, 2.6217, 1.4556
-
-    # income to % of households below income amount
-    # http://library.wolfram.com/infocenter/Conferences/6461/PowerLaws.nb
-    x = [15000, 25000, 35000, 50000, 75000, 100000]
-    y = [0.154, 0.283, 0.402, 0.55, 0.733, 0.843]
-
-    # verified in numbers
-    assert_fit :power, x, y, 0.96, 3.119e-5, 0.8959
-  end
-
-  def assert_fit msg, x, y, fit, exp_a, exp_b
-    a, b, rr = send "fit_#{msg}", x, y
-
-    assert_operator rr, :>=, fit if fit
-    assert_in_delta exp_a, a
-    assert_in_delta exp_b, b
-  end
-end
diff --git a/test/minitest/test_minitest_mock.rb b/test/minitest/test_minitest_mock.rb
deleted file mode 100644
index 6dcf39b75e..0000000000
--- a/test/minitest/test_minitest_mock.rb
+++ /dev/null
@@ -1,404 +0,0 @@
-# encoding: utf-8
-# frozen_string_literal: false
-
-require 'minitest/autorun'
-
-class TestMiniTestMock < MiniTest::Unit::TestCase
-  def setup
-    @mock = MiniTest::Mock.new.expect(:foo, nil)
-    @mock.expect(:meaning_of_life, 42)
-  end
-
-  def test_create_stub_method
-    assert_nil @mock.foo
-  end
-
-  def test_allow_return_value_specification
-    assert_equal 42, @mock.meaning_of_life
-  end
-
-  def test_blow_up_if_not_called
-    @mock.foo
-
-    util_verify_bad "expected meaning_of_life() => 42, got []"
-  end
-
-  def test_not_blow_up_if_everything_called
-    @mock.foo
-    @mock.meaning_of_life
-
-    assert @mock.verify
-  end
-
-  def test_allow_expectations_to_be_added_after_creation
-    @mock.expect(:bar, true)
-    assert @mock.bar
-  end
-
-  def test_not_verify_if_new_expected_method_is_not_called
-    @mock.foo
-    @mock.meaning_of_life
-    @mock.expect(:bar, true)
-
-    util_verify_bad "expected bar() => true, got []"
-  end
-
-  def test_blow_up_on_wrong_number_of_arguments
-    @mock.foo
-    @mock.meaning_of_life
-    @mock.expect(:sum, 3, [1, 2])
-
-    e = assert_raises ArgumentError do
-      @mock.sum
-    end
-
-    assert_equal "mocked method :sum expects 2 arguments, got 0", e.message
-  end
-
-  def test_return_mock_does_not_raise
-    retval = MiniTest::Mock.new
-    mock = MiniTest::Mock.new
-    mock.expect(:foo, retval)
-    mock.foo
-
-    assert mock.verify
-  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])
-    mock.foo(arg)
-
-    assert mock.verify
-  end
-
-  def test_blow_up_on_wrong_arguments
-    @mock.foo
-    @mock.meaning_of_life
-    @mock.expect(:sum, 3, [1, 2])
-
-    e = assert_raises MockExpectationError do
-      @mock.sum(2, 4)
-    end
-
-    exp = "mocked method :sum called with unexpected arguments [2, 4]"
-    assert_equal exp, e.message
-  end
-
-  def test_expect_with_non_array_args
-    e = assert_raises ArgumentError do
-      @mock.expect :blah, 3, false
-    end
-
-    assert_equal "args must be an array", e.message
-  end
-
-  def test_respond_appropriately
-    assert @mock.respond_to?(:foo)
-    assert @mock.respond_to?(:foo, true)
-    assert @mock.respond_to?('foo')
-    assert !@mock.respond_to?(:bar)
-  end
-
-  def test_no_method_error_on_unexpected_methods
-    e = assert_raises NoMethodError do
-      @mock.bar
-    end
-
-    expected = "unmocked method :bar, expected one of [:foo, :meaning_of_life]"
-
-    assert_equal expected, e.message
-  end
-
-  def test_assign_per_mock_return_values
-    a = MiniTest::Mock.new
-    b = MiniTest::Mock.new
-
-    a.expect(:foo, :a)
-    b.expect(:foo, :b)
-
-    assert_equal :a, a.foo
-    assert_equal :b, b.foo
-  end
-
-  def test_do_not_create_stub_method_on_new_mocks
-    a = MiniTest::Mock.new
-    a.expect(:foo, :a)
-
-    assert !MiniTest::Mock.new.respond_to?(:foo)
-  end
-
-  def test_mock_is_a_blank_slate
-    @mock.expect :kind_of?, true, [Integer]
-    @mock.expect :==, true, [1]
-
-    assert @mock.kind_of?(Integer), "didn't mock :kind_of\?"
-    assert @mock == 1, "didn't mock :=="
-  end
-
-  def test_verify_allows_called_args_to_be_loosely_specified
-    mock = MiniTest::Mock.new
-    mock.expect :loose_expectation, true, [Integer]
-    mock.loose_expectation 1
-
-    assert mock.verify
-  end
-
-  def test_verify_raises_with_strict_args
-    mock = MiniTest::Mock.new
-    mock.expect :strict_expectation, true, [2]
-
-    e = assert_raises MockExpectationError do
-      mock.strict_expectation 1
-    end
-
-    exp = "mocked method :strict_expectation called with unexpected arguments [1]"
-    assert_equal exp, e.message
-  end
-
-  def test_method_missing_empty
-    mock = MiniTest::Mock.new
-
-    mock.expect :a, nil
-
-    mock.a
-
-    e = assert_raises MockExpectationError do
-      mock.a
-    end
-
-    assert_equal "No more expects available for :a: []", e.message
-  end
-
-  def test_same_method_expects_are_verified_when_all_called
-    mock = MiniTest::Mock.new
-    mock.expect :foo, nil, [:bar]
-    mock.expect :foo, nil, [:baz]
-
-    mock.foo :bar
-    mock.foo :baz
-
-    assert mock.verify
-  end
-
-  def test_same_method_expects_blow_up_when_not_all_called
-    mock = MiniTest::Mock.new
-    mock.expect :foo, nil, [:bar]
-    mock.expect :foo, nil, [:baz]
-
-    mock.foo :bar
-
-    e = assert_raises(MockExpectationError) { mock.verify }
-
-    exp = "expected foo(:baz) => nil, got [foo(:bar) => 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
-      true
-    end
-
-    mock.foo
-
-    assert mock.verify
-  end
-
-  def test_mock_block_is_passed_function_params
-    arg1, arg2, arg3 = :bar, [1,2,3], {:a => 'a'}
-    mock = MiniTest::Mock.new
-    mock.expect :foo, nil do |a1, a2, a3|
-      a1 == arg1 &&
-      a2 == arg2 &&
-      a3 == arg3
-    end
-
-    mock.foo arg1, arg2, arg3
-
-    assert mock.verify
-  end
-
-  def test_verify_fails_when_mock_block_returns_false
-    mock = MiniTest::Mock.new
-    mock.expect :foo, nil do
-      false
-    end
-
-    e = assert_raises(MockExpectationError) { mock.foo }
-    exp = "mocked method :foo failed block w/ []"
-
-    assert_equal exp, e.message
-  end
-
-  def test_mock_block_throws_if_args_passed
-    mock = MiniTest::Mock.new
-
-    e = assert_raises(ArgumentError) do
-      mock.expect :foo, nil, [:a, :b, :c] do
-        true
-      end
-    end
-
-    exp = "args ignored when block given"
-
-    assert_equal exp, e.message
-  end
-
-  def test_mock_returns_retval_when_called_with_block
-    mock = MiniTest::Mock.new
-    mock.expect(:foo, 32) do
-      true
-    end
-
-    rs = mock.foo
-
-    assert_equal rs, 32
-  end
-
-  def util_verify_bad exp
-    e = assert_raises MockExpectationError do
-      @mock.verify
-    end
-
-    assert_equal exp, e.message
-  end
-end
-
-require "minitest/metametameta"
-
-class TestMiniTestStub < MiniTest::Unit::TestCase
-  def setup
-    super
-    MiniTest::Unit::TestCase.reset
-
-    @tc = MiniTest::Unit::TestCase.new 'fake tc'
-    @assertion_count = 1
-  end
-
-  def teardown
-    super
-    assert_equal @assertion_count, @tc._assertions
-  end
-
-  class Time
-    def self.now
-      24
-    end
-  end
-
-  def assert_stub val_or_callable
-    @assertion_count += 1
-
-    t = Time.now.to_i
-
-    Time.stub :now, val_or_callable do
-      @tc.assert_equal 42, Time.now
-    end
-
-    @tc.assert_operator Time.now.to_i, :>=, t
-  end
-
-  def test_stub_private_module_method
-    @assertion_count += 1
-
-    t0 = Time.now
-
-    self.stub :sleep, nil do
-      @tc.assert_nil sleep(10)
-    end
-
-    @tc.assert_operator Time.now - t0, :<=, 1
-  end
-
-  def test_stub_private_module_method_indirect
-    @assertion_count += 1
-
-    slow_clapper = Class.new do
-      def slow_clap
-        sleep 3
-        :clap
-      end
-    end.new
-
-    slow_clapper.stub :sleep, nil do |fast_clapper|
-      @tc.assert_equal :clap, fast_clapper.slow_clap # either form works
-      @tc.assert_equal :clap, slow_clapper.slow_clap # yay closures
-    end
-  end
-
-  def test_stub_public_module_method
-    Math.stub(:log10, 42.0) do
-      @tc.assert_in_delta 42.0, Math.log10(1000)
-    end
-  end
-
-  def test_stub_value
-    assert_stub 42
-  end
-
-  def test_stub_block
-    assert_stub lambda { 42 }
-  end
-
-  def test_stub_block_args
-    @assertion_count += 1
-
-    t = Time.now.to_i
-
-    Time.stub :now,  lambda { |n| n * 2 } do
-      @tc.assert_equal 42, Time.now(21)
-    end
-
-    @tc.assert_operator Time.now.to_i, :>=, t
-  end
-
-  def test_stub_callable
-    obj = Object.new
-
-    def obj.call
-      42
-    end
-
-    assert_stub obj
-  end
-
-  def test_stub_yield_self
-    obj = "foo"
-
-    val = obj.stub :to_s, "bar" do |s|
-      s.to_s
-    end
-
-    @tc.assert_equal "bar", val
-  end
-
-  def test_dynamic_method
-    @assertion_count = 2
-
-    dynamic = Class.new do
-      def self.respond_to?(meth)
-        meth == :found
-      end
-
-      def self.method_missing(meth, *args, &block)
-        if meth == :found
-          false
-        else
-          super
-        end
-      end
-    end
-
-    val = dynamic.stub(:found, true) do |s|
-      s.found
-    end
-
-    @tc.assert_equal true, val
-    @tc.assert_equal false, dynamic.found
-  end
-end
diff --git a/test/minitest/test_minitest_unit.rb b/test/minitest/test_minitest_unit.rb
deleted file mode 100644
index c6c8830f20..0000000000
--- a/test/minitest/test_minitest_unit.rb
+++ /dev/null
@@ -1,1790 +0,0 @@
-# encoding: utf-8
-# frozen_string_literal: false
-
-require 'pathname'
-require 'minitest/metametameta'
-
-module MyModule; end
-class AnError < StandardError; include MyModule; end
-class ImmutableString < String; def inspect; super.freeze; end; end
-
-class TestMiniTestUnit < MetaMetaMetaTestCase
-  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
-  MINITEST_BASE_DIR = basedir[/\A\./] ? basedir : "./#{basedir}"
-  BT_MIDDLE = ["#{MINITEST_BASE_DIR}/test.rb:161:in `each'",
-               "#{MINITEST_BASE_DIR}/test.rb:158:in `each'",
-               "#{MINITEST_BASE_DIR}/test.rb:139:in `run'",
-               "#{MINITEST_BASE_DIR}/test.rb:106:in `run'"]
-
-  def test_class_puke_with_assertion_failed
-    exception = MiniTest::Assertion.new "Oh no!"
-    exception.set_backtrace ["unhappy"]
-    assert_equal 'F', @tu.puke('SomeClass', 'method_name', exception)
-    assert_equal 1, @tu.failures
-    assert_match(/^Failure.*Oh no!/m, @tu.report.first)
-    assert_match("SomeClass#method_name [unhappy]", @tu.report.first)
-  end
-
-  def test_class_puke_with_assertion_failed_and_long_backtrace
-    bt = (["test/test_some_class.rb:615:in `method_name'",
-           "#{MINITEST_BASE_DIR}/unit.rb:140:in `assert_raises'",
-           "test/test_some_class.rb:615:in `each'",
-           "test/test_some_class.rb:614:in `test_method_name'",
-           "#{MINITEST_BASE_DIR}/test.rb:165:in `__send__'"] +
-          BT_MIDDLE +
-          ["#{MINITEST_BASE_DIR}/test.rb:29"])
-    bt = util_expand_bt bt
-
-    ex_location = util_expand_bt(["test/test_some_class.rb:615"]).first
-
-    exception = MiniTest::Assertion.new "Oh no!"
-    exception.set_backtrace bt
-    assert_equal 'F', @tu.puke('TestSomeClass', 'test_method_name', exception)
-    assert_equal 1, @tu.failures
-    assert_match(/^Failure.*Oh no!/m, @tu.report.first)
-    assert_match("TestSomeClass#test_method_name [#{ex_location}]", @tu.report.first)
-  end
-
-  def test_class_puke_with_assertion_failed_and_user_defined_assertions
-    bt = (["lib/test/my/util.rb:16:in `another_method_name'",
-           "#{MINITEST_BASE_DIR}/unit.rb:140:in `assert_raises'",
-           "lib/test/my/util.rb:15:in `block in assert_something'",
-           "lib/test/my/util.rb:14:in `each'",
-           "lib/test/my/util.rb:14:in `assert_something'",
-           "test/test_some_class.rb:615:in `each'",
-           "test/test_some_class.rb:614:in `test_method_name'",
-           "#{MINITEST_BASE_DIR}/test.rb:165:in `__send__'"] +
-          BT_MIDDLE +
-          ["#{MINITEST_BASE_DIR}/test.rb:29"])
-    bt = util_expand_bt bt
-
-    ex_location = util_expand_bt(["test/test_some_class.rb:615"]).first
-
-    exception = MiniTest::Assertion.new "Oh no!"
-    exception.set_backtrace bt
-    assert_equal 'F', @tu.puke('TestSomeClass', 'test_method_name', exception)
-    assert_equal 1, @tu.failures
-    assert_match(/^Failure.*Oh no!/m, @tu.report.first)
-    assert_match("TestSomeClass#test_method_name [#{ex_location}]", @tu.report.first)
-  end
-
-  def test_class_puke_with_failure_and_flunk_in_backtrace
-    exception = begin
-                  MiniTest::Unit::TestCase.new('fake tc').flunk
-                rescue MiniTest::Assertion => failure
-                  failure
-                end
-    assert_equal 'F', @tu.puke('SomeClass', 'method_name', exception)
-    refute @tu.report.any?{|line| line =~ /in .flunk/}
-  end
-
-  def test_class_puke_with_flunk_and_user_defined_assertions
-    bt = (["lib/test/my/util.rb:16:in `flunk'",
-           "#{MINITEST_BASE_DIR}/unit.rb:140:in `assert_raises'",
-           "lib/test/my/util.rb:15:in `block in assert_something'",
-           "lib/test/my/util.rb:14:in `each'",
-           "lib/test/my/util.rb:14:in `assert_something'",
-           "test/test_some_class.rb:615:in `each'",
-           "test/test_some_class.rb:614:in `test_method_name'",
-           "#{MINITEST_BASE_DIR}/test.rb:165:in `__send__'"] +
-          BT_MIDDLE +
-          ["#{MINITEST_BASE_DIR}/test.rb:29"])
-    bt = util_expand_bt bt
-
-    ex_location = util_expand_bt(["test/test_some_class.rb:615"]).first
-
-    exception = MiniTest::Assertion.new "Oh no!"
-    exception.set_backtrace bt
-    assert_equal 'F', @tu.puke('TestSomeClass', 'test_method_name', exception)
-    assert_equal 1, @tu.failures
-    assert_match(/^Failure.*Oh no!/m, @tu.report.first)
-    assert_match("TestSomeClass#test_method_name [#{ex_location}]", @tu.report.first)
-  end
-
-  def test_class_puke_with_non_failure_exception
-    exception = Exception.new("Oh no again!")
-    assert_equal 'E', @tu.puke('SomeClass', 'method_name', exception)
-    assert_equal 1, @tu.errors
-    assert_match(/^Exception.*Oh no again!/m, @tu.report.first)
-  end
-
-  def test_filter_backtrace
-    # this is a semi-lame mix of relative paths.
-    # I cheated by making the autotest parts not have ./
-    bt = (["lib/autotest.rb:571:in `add_exception'",
-           "test/test_autotest.rb:62:in `test_add_exception'",
-           "#{MINITEST_BASE_DIR}/test.rb:165:in `__send__'"] +
-          BT_MIDDLE +
-          ["#{MINITEST_BASE_DIR}/test.rb:29",
-           "test/test_autotest.rb:422"])
-    bt = util_expand_bt bt
-
-    ex = ["lib/autotest.rb:571:in `add_exception'",
-          "test/test_autotest.rb:62:in `test_add_exception'"]
-    ex = util_expand_bt ex
-
-    fu = MiniTest::filter_backtrace(bt)
-
-    assert_equal ex, fu
-  end
-
-  def test_filter_backtrace_all_unit
-    bt = (["#{MINITEST_BASE_DIR}/test.rb:165:in `__send__'"] +
-          BT_MIDDLE +
-          ["#{MINITEST_BASE_DIR}/test.rb:29"])
-    ex = bt.clone
-    fu = MiniTest::filter_backtrace(bt)
-    assert_equal ex, fu
-  end
-
-  def test_filter_backtrace_unit_starts
-    bt = (["#{MINITEST_BASE_DIR}/test.rb:165:in `__send__'"] +
-          BT_MIDDLE +
-          ["#{MINITEST_BASE_DIR}/mini/test.rb:29",
-           "-e:1"])
-
-    bt = util_expand_bt bt
-
-    ex = ["-e:1"]
-    fu = MiniTest::filter_backtrace bt
-    assert_equal ex, fu
-  end
-
-  def test_default_runner_is_minitest_unit
-    assert_instance_of MiniTest::Unit, MiniTest::Unit.runner
-  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_skipped
-    test_class = Class.new MiniTest::Unit::TestCase do
-      def teardown; assert true; end
-      def test_omg; skip "bork"; 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
-    bt.map { |f| (f =~ /^\./) ? File.expand_path(f) : f }
-  end
-end
-
-class TestMiniTestUnitInherited < MetaMetaMetaTestCase
-  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
-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
-
-      def run_test name
-        @foo = "hi mom!"
-        super
-        @foo = "okay"
-      end
-
-      def test_something
-        assert_equal "hi mom!", foo
-      end
-    end
-
-    expected = clean <<-EOM
-      .
-
-      Finished tests in 0.00
-
-      1 tests, 1 assertions, 0 failures, 0 errors, 0 skips
-    EOM
-
-    assert_report expected
-  end
-
-  def test_run_error
-    Class.new MiniTest::Unit::TestCase do
-      def test_something
-        assert true
-      end
-
-      def test_error
-        raise "unhandled exception"
-      end
-    end
-
-    expected = clean <<-EOM
-      E.
-
-      Finished tests in 0.00
-
-        1) Error:
-      #<Class:0xXXX>#test_error:
-      RuntimeError: unhandled exception
-          FILE:LINE:in \`test_error\'
-
-      2 tests, 1 assertions, 0 failures, 1 errors, 0 skips
-    EOM
-
-    assert_report expected
-  end
-
-  def test_run_error_teardown
-    Class.new MiniTest::Unit::TestCase do
-      def test_something
-        assert true
-      end
-
-      def teardown
-        raise "unhandled exception"
-      end
-    end
-
-    expected = clean <<-EOM
-      E
-
-      Finished tests in 0.00
-
-        1) Error:
-      #<Class:0xXXX>#test_something:
-      RuntimeError: unhandled exception
-          FILE:LINE:in \`teardown\'
-
-      1 tests, 1 assertions, 0 failures, 1 errors, 0 skips
-    EOM
-
-    assert_report expected
-  end
-
-  def test_run_failing
-    Class.new MiniTest::Unit::TestCase do
-      def test_something
-        assert true
-      end
-
-      def test_failure
-        assert false
-      end
-    end
-
-    expected = clean <<-EOM
-      F.
-
-      Finished tests in 0.00
-
-        1) Failure:
-      #<Class:0xXXX>#test_failure [FILE:LINE]:
-      Failed assertion, no message given.
-
-      2 tests, 2 assertions, 1 failures, 0 errors, 0 skips
-    EOM
-
-    assert_report expected
-  end
-
-  def test_run_failing_filtered
-    Class.new MiniTest::Unit::TestCase do
-      def test_something
-        assert true
-      end
-
-      def test_failure
-        assert false
-      end
-    end
-
-    expected = clean <<-EOM
-      .
-
-      Finished tests in 0.00
-
-      1 tests, 1 assertions, 0 failures, 0 errors, 0 skips
-    EOM
-
-    assert_report expected, %w[--name /some|thing/ --seed 42]
-  end
-
-  def assert_filtering name, expected, a = false
-    args = %W[--name #{name} --seed 42]
-
-    alpha = Class.new MiniTest::Unit::TestCase do
-      define_method :test_something do
-        assert a
-      end
-    end
-    Object.const_set(:Alpha, alpha)
-
-    beta = Class.new MiniTest::Unit::TestCase do
-      define_method :test_something do
-        assert true
-      end
-    end
-    Object.const_set(:Beta, beta)
-
-    assert_report expected, args
-  ensure
-    Object.send :remove_const, :Alpha
-    Object.send :remove_const, :Beta
-  end
-
-  def test_run_filtered_including_suite_name
-    expected = clean <<-EOM
-      .
-
-      Finished tests in 0.00
-
-      1 tests, 1 assertions, 0 failures, 0 errors, 0 skips
-    EOM
-
-    assert_filtering "/Beta#test_something/", expected
-  end
-
-  def test_run_filtered_including_suite_name_string
-    expected = clean <<-EOM
-      .
-
-      Finished tests in 0.00
-
-      1 tests, 1 assertions, 0 failures, 0 errors, 0 skips
-    EOM
-
-    assert_filtering "Beta#test_something", expected
-  end
-
-  def test_run_filtered_string_method_only
-    expected = clean <<-EOM
-      ..
-
-      Finished tests in 0.00
-
-      2 tests, 2 assertions, 0 failures, 0 errors, 0 skips
-    EOM
-
-    assert_filtering "test_something", expected, :pass
-  end
-
-  def test_run_passing
-    Class.new MiniTest::Unit::TestCase do
-      def test_something
-        assert true
-      end
-    end
-
-    expected = clean <<-EOM
-      .
-
-      Finished tests in 0.00
-
-      1 tests, 1 assertions, 0 failures, 0 errors, 0 skips
-    EOM
-
-    assert_report expected
-  end
-
-  def test_run_skip
-    Class.new MiniTest::Unit::TestCase do
-      def test_something
-        assert true
-      end
-
-      def test_skip
-        skip "not yet"
-      end
-    end
-
-    expected = clean <<-EOM
-      S.
-
-      Finished tests in 0.00
-
-      2 tests, 1 assertions, 0 failures, 0 errors, 1 skips
-    EOM
-
-    assert_report expected
-  end
-
-  def test_run_skip_verbose
-    Class.new MiniTest::Unit::TestCase do
-      def test_something
-        assert true
-      end
-
-      def test_skip
-        skip "not yet"
-      end
-    end
-
-    expected = clean <<-EOM
-      #<Class:0xXXX>#test_skip = 0.00 s = S
-      #<Class:0xXXX>#test_something = 0.00 s = .
-
-
-      Finished tests in 0.00
-
-        1) Skipped:
-      #<Class:0xXXX>#test_skip [FILE:LINE]:
-      not yet
-
-      2 tests, 1 assertions, 0 failures, 0 errors, 1 skips
-    EOM
-
-    assert_report expected, %w[--seed 42 --verbose]
-  end
-
-  def test_run_with_other_runner
-    MiniTest::Unit.runner = Class.new MiniTest::Unit do
-      def _run_suite suite, type
-        suite.before_suite # Run once before each suite
-        super suite, type
-      end
-    end.new
-
-    Class.new MiniTest::Unit::TestCase do
-      def self.name; "wacky!" end
-
-      def self.before_suite
-        MiniTest::Unit.output.puts "Running #{self.name} tests"
-        @@foo = 1
-      end
-
-      def test_something
-        assert_equal 1, @@foo
-      end
-
-      def test_something_else
-        assert_equal 1, @@foo
-      end
-    end
-
-    expected = clean <<-EOM
-      Running wacky! tests
-      ..
-
-      Finished tests in 0.00
-
-      2 tests, 2 assertions, 0 failures, 0 errors, 0 skips
-    EOM
-
-    assert_report expected
-  end
-
-  require 'monitor'
-
-  class Latch
-    def initialize count = 1
-      @count = count
-      @lock  = Monitor.new
-      @cv    = @lock.new_cond
-    end
-
-    def release
-      @lock.synchronize do
-        @count -= 1 if @count > 0
-        @cv.broadcast if @count == 0
-      end
-    end
-
-    def await
-      @lock.synchronize { @cv.wait_while { @count > 0 } }
-    end
-  end
-end
-
-class TestMiniTestUnitOrder < MetaMetaMetaTestCase
-  # do not parallelize this suite... it just can't handle it.
-
-  def test_before_setup
-    call_order = []
-    Class.new MiniTest::Unit::TestCase do
-      define_method :setup do
-        super()
-        call_order << :setup
-      end
-
-      define_method :before_setup do
-        call_order << :before_setup
-      end
-
-      def test_omg; assert true; end
-    end
-
-    with_output do
-      @tu.run %w[--seed 42]
-    end
-
-    expected = [:before_setup, :setup]
-    assert_equal expected, call_order
-  end
-
-  def test_after_teardown
-    call_order = []
-    Class.new MiniTest::Unit::TestCase do
-      define_method :teardown do
-        super()
-        call_order << :teardown
-      end
-
-      define_method :after_teardown do
-        call_order << :after_teardown
-      end
-
-      def test_omg; assert true; end
-    end
-
-    with_output do
-      @tu.run %w[--seed 42]
-    end
-
-    expected = [:teardown, :after_teardown]
-    assert_equal expected, call_order
-  end
-
-  def test_all_teardowns_are_guaranteed_to_run
-    call_order = []
-    Class.new MiniTest::Unit::TestCase do
-      define_method :after_teardown do
-        super()
-        call_order << :after_teardown
-        raise
-      end
-
-      define_method :teardown do
-        super()
-        call_order << :teardown
-        raise
-      end
-
-      define_method :before_teardown do
-        super()
-        call_order << :before_teardown
-        raise
-      end
-
-      def test_omg; assert true; end
-    end
-
-    with_output do
-      @tu.run %w[--seed 42]
-    end
-
-    expected = [:before_teardown, :teardown, :after_teardown]
-    assert_equal expected, call_order
-  end
-
-  def test_setup_and_teardown_survive_inheritance
-    call_order = []
-
-    parent = Class.new MiniTest::Unit::TestCase do
-      define_method :setup do
-        call_order << :setup_method
-      end
-
-      define_method :teardown do
-        call_order << :teardown_method
-      end
-
-      define_method :test_something do
-        call_order << :test
-      end
-    end
-
-    _ = Class.new parent
-
-    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
-end
-
-class TestMiniTestUnitTestCase < MiniTest::Unit::TestCase
-  # do not call parallelize_me! - teardown accesses @tc._assertions
-  # which is not threadsafe. Nearly every method in here is an
-  # assertion test so it isn't worth splitting it out further.
-
-  RUBY18 = ! defined? Encoding
-
-  def setup
-    super
-
-    MiniTest::Unit::TestCase.reset
-
-    @tc = MiniTest::Unit::TestCase.new 'fake tc'
-    @zomg = "zomg ponies!"
-    @assertion_count = 1
-  end
-
-  def teardown
-    assert_equal(@assertion_count, @tc._assertions,
-                 "expected #{@assertion_count} assertions to be fired during the test, not #{@tc._assertions}") if @tc.passed?
-  end
-
-  def non_verbose
-    orig_verbose = $VERBOSE
-    $VERBOSE = false
-
-    yield
-  ensure
-    $VERBOSE = orig_verbose
-  end
-
-  def test_assert
-    @assertion_count = 2
-
-    @tc.assert_equal true, @tc.assert(true), "returns true on success"
-  end
-
-  def test_assert__triggered
-    util_assert_triggered "Failed assertion, no message given." do
-      @tc.assert false
-    end
-  end
-
-  def test_assert__triggered_message
-    util_assert_triggered @zomg do
-      @tc.assert false, @zomg
-    end
-  end
-
-  def test_assert_empty
-    @assertion_count = 2
-
-    @tc.assert_empty []
-  end
-
-  def test_assert_empty_triggered
-    @assertion_count = 2
-
-    util_assert_triggered "Expected [1] to be empty." do
-      @tc.assert_empty [1]
-    end
-  end
-
-  def test_assert_equal
-    @tc.assert_equal 1, 1
-  end
-
-  def test_assert_equal_different_collection_array_hex_invisible
-    object1 = Object.new
-    object2 = Object.new
-    msg = "No visible difference in the Array#inspect output.
-           You should look at the implementation of #== on Array or its members.
-           [#<Object:0xXXXXXX>]".gsub(/^ +/, "")
-    util_assert_triggered msg do
-      @tc.assert_equal [object1], [object2]
-    end
-  end
-
-  def test_assert_equal_different_collection_hash_hex_invisible
-    h1, h2 = {}, {}
-    h1[1] = Object.new
-    h2[1] = Object.new
-    msg = "No visible difference in the Hash#inspect output.
-           You should look at the implementation of #== on Hash or its members.
-           {1=>#<Object:0xXXXXXX>}".gsub(/^ +/, "")
-
-    util_assert_triggered msg do
-      @tc.assert_equal h1, h2
-    end
-  end
-
-  def test_assert_equal_different_diff_deactivated
-    skip "https://github.com/MagLev/maglev/issues/209" if maglev?
-
-    without_diff do
-      util_assert_triggered util_msg("haha" * 10, "blah" * 10) do
-        o1 = "haha" * 10
-        o2 = "blah" * 10
-
-        @tc.assert_equal o1, o2
-      end
-    end
-  end
-
-  def test_assert_equal_different_hex
-    c = Class.new do
-      def initialize s; @name = s; end
-    end
-
-    o1 = c.new "a"
-    o2 = c.new "b"
-    msg = "--- expected
-           +++ actual
-           @@ -1 +1 @@
-           -#<#<Class:0xXXXXXX>:0xXXXXXX @name=\"a\">
-           +#<#<Class:0xXXXXXX>:0xXXXXXX @name=\"b\">
-           ".gsub(/^ +/, "")
-
-    util_assert_triggered msg do
-      @tc.assert_equal o1, o2
-    end
-  end
-
-  def test_assert_equal_different_hex_invisible
-    o1 = Object.new
-    o2 = Object.new
-
-    msg = "No visible difference in the Object#inspect output.
-           You should look at the implementation of #== on Object or its members.
-           #<Object:0xXXXXXX>".gsub(/^ +/, "")
-
-    util_assert_triggered msg do
-      @tc.assert_equal o1, o2
-    end
-  end
-
-  def test_assert_equal_different_long
-    msg = "--- expected
-           +++ actual
-           @@ -1 +1 @@
-           -\"hahahahahahahahahahahahahahahahahahahaha\"
-           +\"blahblahblahblahblahblahblahblahblahblah\"
-           ".gsub(/^ +/, "")
-
-    util_assert_triggered msg do
-      o1 = "haha" * 10
-      o2 = "blah" * 10
-
-      @tc.assert_equal o1, o2
-    end
-  end
-
-  def test_assert_equal_different_long_invisible
-    msg = "No visible difference in the String#inspect output.
-           You should look at the implementation of #== on String or its members.
-           \"blahblahblahblahblahblahblahblahblahblah\"".gsub(/^ +/, "")
-
-    util_assert_triggered msg do
-      o1 = "blah" * 10
-      o2 = "blah" * 10
-      def o1.== o
-        false
-      end
-      @tc.assert_equal o1, o2
-    end
-  end
-
-  def test_assert_equal_different_long_msg
-    msg = "message.
-           --- expected
-           +++ actual
-           @@ -1 +1 @@
-           -\"hahahahahahahahahahahahahahahahahahahaha\"
-           +\"blahblahblahblahblahblahblahblahblahblah\"
-           ".gsub(/^ +/, "")
-
-    util_assert_triggered msg do
-      o1 = "haha" * 10
-      o2 = "blah" * 10
-      @tc.assert_equal o1, o2, "message"
-    end
-  end
-
-  def test_assert_equal_different_short
-    util_assert_triggered util_msg(1, 2) do
-      @tc.assert_equal 1, 2
-    end
-  end
-
-  def test_assert_equal_different_short_msg
-    util_assert_triggered util_msg(1, 2, "message") do
-      @tc.assert_equal 1, 2, "message"
-    end
-  end
-
-  def test_assert_equal_different_short_multiline
-    msg = "--- expected\n+++ actual\n@@ -1,2 +1,2 @@\n \"a\n-b\"\n+c\"\n"
-    util_assert_triggered msg do
-      @tc.assert_equal "a\nb", "a\nc"
-    end
-  end
-
-  def test_assert_equal_different_escaped_newline
-    msg = "--- expected\n+++ actual\n@@ -1,2 +1,2 @@\n \"xxx\n-a\\\\nb\"\n+a\\\\nc\"\n"
-    util_assert_triggered msg do
-      @tc.assert_equal "xxx\na\\nb", "xxx\na\\nc"
-    end
-  end
-
-  def test_assert_in_delta
-    @tc.assert_in_delta 0.0, 1.0 / 1000, 0.1
-  end
-
-  def test_delta_consistency
-    @tc.assert_in_delta 0, 1, 1
-
-    util_assert_triggered "Expected |0 - 1| (1) to not be <= 1." do
-      @tc.refute_in_delta 0, 1, 1
-    end
-  end
-
-  def test_assert_in_delta_triggered
-    x = maglev? ? "9.999999xxxe-07" : "1.0e-06"
-    util_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
-  end
-
-  def test_assert_in_epsilon
-    @assertion_count = 10
-
-    @tc.assert_in_epsilon 10000, 9991
-    @tc.assert_in_epsilon 9991, 10000
-    @tc.assert_in_epsilon 1.0, 1.001
-    @tc.assert_in_epsilon 1.001, 1.0
-
-    @tc.assert_in_epsilon 10000, 9999.1, 0.0001
-    @tc.assert_in_epsilon 9999.1, 10000, 0.0001
-    @tc.assert_in_epsilon 1.0, 1.0001, 0.0001
-    @tc.assert_in_epsilon 1.0001, 1.0, 0.0001
-
-    @tc.assert_in_epsilon(-1, -1)
-    @tc.assert_in_epsilon(-10000, -9991)
-  end
-
-  def test_epsilon_consistency
-    @tc.assert_in_epsilon 1.0, 1.001
-
-    msg = "Expected |1.0 - 1.001| (0.000999xxx) to not be <= 0.001."
-    util_assert_triggered msg do
-      @tc.refute_in_epsilon 1.0, 1.001
-    end
-  end
-
-  def test_assert_in_epsilon_triggered
-    util_assert_triggered 'Expected |10000 - 9990| (10) to be <= 9.99.' do
-      @tc.assert_in_epsilon 10000, 9990
-    end
-  end
-
-  def test_assert_in_epsilon_triggered_negative_case
-    x = (RUBY18 and not maglev?) ? "0.1" : "0.100000xxx"
-    y = maglev? ? "0.100000xxx" : "0.1"
-    util_assert_triggered "Expected |-1.1 - -1| (#{x}) to be <= #{y}." do
-      @tc.assert_in_epsilon(-1.1, -1, 0.1)
-    end
-  end
-
-  def test_assert_includes
-    @assertion_count = 2
-
-    @tc.assert_includes [true], true
-  end
-
-  def test_assert_includes_triggered
-    @assertion_count = 3
-
-    e = @tc.assert_raises MiniTest::Assertion do
-      @tc.assert_includes [true], false
-    end
-
-    expected = "Expected [true] to include false."
-    assert_equal expected, e.message
-  end
-
-  def test_assert_instance_of
-    @tc.assert_instance_of String, "blah"
-  end
-
-  def test_assert_instance_of_triggered
-    util_assert_triggered 'Expected "blah" to be an instance of Array, not String.' do
-      @tc.assert_instance_of Array, "blah"
-    end
-  end
-
-  def test_assert_kind_of
-    @tc.assert_kind_of String, "blah"
-  end
-
-  def test_assert_kind_of_triggered
-    util_assert_triggered 'Expected "blah" to be a kind of Array, not String.' do
-      @tc.assert_kind_of Array, "blah"
-    end
-  end
-
-  def test_assert_match
-    @assertion_count = 2
-    @tc.assert_match(/\w+/, "blah blah blah")
-  end
-
-  def test_assert_match_matcher_object
-    @assertion_count = 2
-
-    pattern = Object.new
-    def pattern.=~(other) true end
-
-    @tc.assert_match pattern, 5
-  end
-
-  def test_assert_match_matchee_to_str
-    @assertion_count = 2
-
-    obj = Object.new
-    def obj.to_str; "blah" end
-
-    @tc.assert_match "blah", obj
-  end
-
-  def test_assert_match_object_triggered
-    @assertion_count = 2
-
-    pattern = Object.new
-    def pattern.=~(other) false end
-    def pattern.inspect; "[Object]" end
-
-    util_assert_triggered 'Expected [Object] to match 5.' do
-      @tc.assert_match pattern, 5
-    end
-  end
-
-  def test_assert_match_triggered
-    @assertion_count = 2
-    util_assert_triggered 'Expected /\d+/ to match "blah blah blah".' do
-      @tc.assert_match(/\d+/, "blah blah blah")
-    end
-  end
-
-  def test_assert_nil
-    @tc.assert_nil nil
-  end
-
-  def test_assert_nil_triggered
-    util_assert_triggered 'Expected 42 to be nil.' do
-      @tc.assert_nil 42
-    end
-  end
-
-  def test_assert_operator
-    @tc.assert_operator 2, :>, 1
-  end
-
-  def test_assert_operator_bad_object
-    bad = Object.new
-    def bad.==(other) true end
-
-    @tc.assert_operator bad, :equal?, bad
-  end
-
-  def test_assert_operator_triggered
-    util_assert_triggered "Expected 2 to be < 1." do
-      @tc.assert_operator 2, :<, 1
-    end
-  end
-
-  def test_assert_output_both
-    @assertion_count = 2
-
-    @tc.assert_output "yay", "blah" do
-      print "yay"
-      $stderr.print "blah"
-    end
-  end
-
-  def test_assert_output_both_regexps
-    @assertion_count = 4
-
-    @tc.assert_output(/y.y/, /bl.h/) do
-      print "yay"
-      $stderr.print "blah"
-    end
-  end
-
-  def test_assert_output_err
-    @tc.assert_output nil, "blah" do
-      $stderr.print "blah"
-    end
-  end
-
-  def test_assert_output_neither
-    @assertion_count = 0
-
-    @tc.assert_output do
-      # do nothing
-    end
-  end
-
-  def test_assert_output_out
-    @tc.assert_output "blah" do
-      print "blah"
-    end
-  end
-
-  def test_assert_output_triggered_both
-    util_assert_triggered util_msg("blah", "blah blah", "In stderr") do
-      @tc.assert_output "yay", "blah" do
-        print "boo"
-        $stderr.print "blah blah"
-      end
-    end
-  end
-
-  def test_assert_output_triggered_err
-    util_assert_triggered util_msg("blah", "blah blah", "In stderr") do
-      @tc.assert_output nil, "blah" do
-        $stderr.print "blah blah"
-      end
-    end
-  end
-
-  def test_assert_output_triggered_out
-    util_assert_triggered util_msg("blah", "blah blah", "In stdout") do
-      @tc.assert_output "blah" do
-        print "blah blah"
-      end
-    end
-  end
-
-  def test_assert_predicate
-    @tc.assert_predicate "", :empty?
-  end
-
-  def test_assert_predicate_triggered
-    util_assert_triggered 'Expected "blah" to be empty?.' do
-      @tc.assert_predicate "blah", :empty?
-    end
-  end
-
-  def test_assert_raises
-    @tc.assert_raises RuntimeError do
-      raise "blah"
-    end
-  end
-
-  def test_assert_raises_module
-    @tc.assert_raises MyModule do
-      raise AnError
-    end
-  end
-
-  ##
-  # *sigh* This is quite an odd scenario, but it is from real (albeit
-  # ugly) test code in ruby-core:
-  #
-  # https://github.com/ruby/ruby/commit/6bab4ea9917dc05cd2c94aead2e96eb7df7d4be1
-
-  def test_assert_raises_skip
-    @assertion_count = 0
-
-    util_assert_triggered "skipped", MiniTest::Skip do
-      @tc.assert_raises ArgumentError do
-        begin
-          raise "blah"
-        rescue
-          skip "skipped"
-        end
-      end
-    end
-  end
-
-  def test_assert_raises_triggered_different
-    e = assert_raises MiniTest::Assertion do
-      @tc.assert_raises RuntimeError do
-        raise SyntaxError, "icky"
-      end
-    end
-
-    expected = clean <<-EOM.chomp
-      [RuntimeError] exception expected, not
-      Class: <SyntaxError>
-      Message: <\"icky\">
-      ---Backtrace---
-      FILE:LINE:in \`test_assert_raises_triggered_different\'
-      ---------------
-    EOM
-
-    actual = e.message.gsub(/^.+:\d+/, 'FILE:LINE')
-    actual.gsub!(/block \(\d+ levels\) in /, '') if RUBY_VERSION >= '1.9.0'
-
-    assert_equal expected, actual
-  end
-
-  def test_assert_raises_triggered_different_msg
-    e = assert_raises MiniTest::Assertion do
-      @tc.assert_raises RuntimeError, "XXX" do
-        raise SyntaxError, "icky"
-      end
-    end
-
-    expected = clean <<-EOM
-      XXX.
-      [RuntimeError] exception expected, not
-      Class: <SyntaxError>
-      Message: <\"icky\">
-      ---Backtrace---
-      FILE:LINE:in \`test_assert_raises_triggered_different_msg\'
-      ---------------
-    EOM
-
-    actual = e.message.gsub(/^.+:\d+/, 'FILE:LINE')
-    actual.gsub!(/block \(\d+ levels\) in /, '') if RUBY_VERSION >= '1.9.0'
-
-    assert_equal expected.chomp, actual
-  end
-
-  def test_assert_raises_triggered_none
-    e = assert_raises MiniTest::Assertion do
-      @tc.assert_raises MiniTest::Assertion do
-        # do nothing
-      end
-    end
-
-    expected = "MiniTest::Assertion expected but nothing was raised."
-
-    assert_equal expected, e.message
-  end
-
-  def test_assert_raises_triggered_none_msg
-    e = assert_raises MiniTest::Assertion do
-      @tc.assert_raises MiniTest::Assertion, "XXX" do
-        # do nothing
-      end
-    end
-
-    expected = "XXX.\nMiniTest::Assertion expected but nothing was raised."
-
-    assert_equal expected, e.message
-  end
-
-  def test_assert_raises_triggered_subclass
-    e = assert_raises MiniTest::Assertion do
-      @tc.assert_raises StandardError do
-        raise AnError
-      end
-    end
-
-    expected = clean <<-EOM.chomp
-      [StandardError] exception expected, not
-      Class: <AnError>
-      Message: <\"AnError\">
-      ---Backtrace---
-      FILE:LINE:in \`test_assert_raises_triggered_subclass\'
-      ---------------
-    EOM
-
-    actual = e.message.gsub(/^.+:\d+/, 'FILE:LINE')
-    actual.gsub!(/block \(\d+ levels\) in /, '') if RUBY_VERSION >= '1.9.0'
-
-    assert_equal expected, actual
-  end
-
-  def test_assert_respond_to
-    @tc.assert_respond_to "blah", :empty?
-  end
-
-  def test_assert_respond_to_triggered
-    util_assert_triggered 'Expected "blah" (String) to respond to #rawr!.' do
-      @tc.assert_respond_to "blah", :rawr!
-    end
-  end
-
-  def test_assert_same
-    @assertion_count = 3
-
-    o = "blah"
-    @tc.assert_same 1, 1
-    @tc.assert_same :blah, :blah
-    @tc.assert_same o, o
-  end
-
-  def test_assert_same_triggered
-    @assertion_count = 2
-
-    util_assert_triggered 'Expected 2 (oid=N) to be the same as 1 (oid=N).' do
-      @tc.assert_same 1, 2
-    end
-
-    s1 = "blah"
-    s2 = "blah"
-
-    util_assert_triggered 'Expected "blah" (oid=N) to be the same as "blah" (oid=N).' do
-      @tc.assert_same s1, s2
-    end
-  end
-
-  def test_assert_send
-    @tc.assert_send [1, :<, 2]
-  end
-
-  def test_assert_send_bad
-    util_assert_triggered "Expected 1.>(*[2]) to return true." do
-      @tc.assert_send [1, :>, 2]
-    end
-  end
-
-  def test_assert_silent
-    @assertion_count = 2
-
-    @tc.assert_silent do
-      # do nothing
-    end
-  end
-
-  def test_assert_silent_triggered_err
-    util_assert_triggered util_msg("", "blah blah", "In stderr") do
-      @tc.assert_silent do
-        $stderr.print "blah blah"
-      end
-    end
-  end
-
-  def test_assert_silent_triggered_out
-    @assertion_count = 2
-
-    util_assert_triggered util_msg("", "blah blah", "In stdout") do
-      @tc.assert_silent do
-        print "blah blah"
-      end
-    end
-  end
-
-  def test_assert_throws
-    @tc.assert_throws :blah do
-      throw :blah
-    end
-  end
-
-  def test_assert_throws_different
-    util_assert_triggered 'Expected :blah to have been thrown, not :not_blah.' do
-      @tc.assert_throws :blah do
-        throw :not_blah
-      end
-    end
-  end
-
-  def test_assert_throws_unthrown
-    util_assert_triggered 'Expected :blah to have been thrown.' do
-      @tc.assert_throws :blah do
-        # do nothing
-      end
-    end
-  end
-
-  def test_capture_io
-    @assertion_count = 0
-
-    non_verbose do
-      out, err = capture_io do
-        puts 'hi'
-        $stderr.puts 'bye!'
-      end
-
-      assert_equal "hi\n", out
-      assert_equal "bye!\n", err
-    end
-  end
-
-  def test_capture_subprocess_io
-    @assertion_count = 0
-
-    non_verbose do
-      out, err = capture_subprocess_io do
-        system("echo", "hi")
-        system("echo", "bye!", out: :err)
-      end
-
-      assert_equal "hi\n", out
-      assert_equal "bye!\n", err
-    end
-  end
-
-  def test_class_asserts_match_refutes
-    @assertion_count = 0
-
-    methods = MiniTest::Assertions.public_instance_methods
-    methods.map! { |m| m.to_s } if Symbol === methods.first
-
-    # 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
-                 assert_silent assert_throws]
-
-    # These are test/unit methods. I'm not actually sure why they're still here
-    ignores += %w[assert_no_match assert_not_equal assert_not_nil
-                  assert_not_same assert_nothing_raised
-                  assert_nothing_thrown assert_raise]
-
-    asserts = methods.grep(/^assert/).sort - ignores
-    refutes = methods.grep(/^refute/).sort - ignores
-
-    assert_empty refutes.map { |n| n.sub(/^refute/, 'assert') } - asserts
-    assert_empty asserts.map { |n| n.sub(/^assert/, 'refute') } - refutes
-  end
-
-  def test_flunk
-    util_assert_triggered 'Epic Fail!' do
-      @tc.flunk
-    end
-  end
-
-  def test_flunk_message
-    util_assert_triggered @zomg do
-      @tc.flunk @zomg
-    end
-  end
-
-  def test_message
-    @assertion_count = 0
-
-    assert_equal "blah2.",         @tc.message          { "blah2" }.call
-    assert_equal "blah2.",         @tc.message("")      { "blah2" }.call
-    assert_equal "blah1.\nblah2.", @tc.message(:blah1)  { "blah2" }.call
-    assert_equal "blah1.\nblah2.", @tc.message("blah1") { "blah2" }.call
-
-    message = proc { "blah1" }
-    assert_equal "blah1.\nblah2.", @tc.message(message) { "blah2" }.call
-
-    message = @tc.message { "blah1" }
-    assert_equal "blah1.\nblah2.", @tc.message(message) { "blah2" }.call
-  end
-
-  def test_message_message
-    util_assert_triggered "whoops.\nExpected: 1\n  Actual: 2" do
-      @tc.assert_equal 1, 2, message { "whoops" }
-    end
-  end
-
-  def test_message_lambda
-    util_assert_triggered "whoops.\nExpected: 1\n  Actual: 2" do
-      @tc.assert_equal 1, 2, lambda { "whoops" }
-    end
-  end
-
-  def test_message_deferred
-    @assertion_count, var = 0, nil
-
-    msg = message { var = "blah" }
-
-    assert_nil var
-
-    msg.call
-
-    assert_equal "blah", var
-  end
-
-  def test_pass
-    @tc.pass
-  end
-
-  def test_prints
-    printer = Class.new { extend MiniTest::Assertions }
-    @tc.assert_equal '"test"', printer.mu_pp(ImmutableString.new 'test')
-  end
-
-  def test_refute
-    @assertion_count = 2
-
-    @tc.assert_equal false, @tc.refute(false), "returns false on success"
-  end
-
-  def test_refute_empty
-    @assertion_count = 2
-
-    @tc.refute_empty [1]
-  end
-
-  def test_refute_empty_triggered
-    @assertion_count = 2
-
-    util_assert_triggered "Expected [] to not be empty." do
-      @tc.refute_empty []
-    end
-  end
-
-  def test_refute_equal
-    @tc.refute_equal "blah", "yay"
-  end
-
-  def test_refute_equal_triggered
-    util_assert_triggered 'Expected "blah" to not be equal to "blah".' do
-      @tc.refute_equal "blah", "blah"
-    end
-  end
-
-  def test_refute_in_delta
-    @tc.refute_in_delta 0.0, 1.0 / 1000, 0.000001
-  end
-
-  def test_refute_in_delta_triggered
-    x = maglev? ? "0.100000xxx" : "0.1"
-    util_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
-  end
-
-  def test_refute_in_epsilon
-    @tc.refute_in_epsilon 10000, 9990-1
-  end
-
-  def test_refute_in_epsilon_triggered
-    util_assert_triggered 'Expected |10000 - 9990| (10) to not be <= 10.0.' do
-      @tc.refute_in_epsilon 10000, 9990
-      fail
-    end
-  end
-
-  def test_refute_includes
-    @assertion_count = 2
-
-    @tc.refute_includes [true], false
-  end
-
-  def test_refute_includes_triggered
-    @assertion_count = 3
-
-    e = @tc.assert_raises MiniTest::Assertion do
-      @tc.refute_includes [true], true
-    end
-
-    expected = "Expected [true] to not include true."
-    assert_equal expected, e.message
-  end
-
-  def test_refute_instance_of
-    @tc.refute_instance_of Array, "blah"
-  end
-
-  def test_refute_instance_of_triggered
-    util_assert_triggered 'Expected "blah" to not be an instance of String.' do
-      @tc.refute_instance_of String, "blah"
-    end
-  end
-
-  def test_refute_kind_of
-    @tc.refute_kind_of Array, "blah"
-  end
-
-  def test_refute_kind_of_triggered
-    util_assert_triggered 'Expected "blah" to not be a kind of String.' do
-      @tc.refute_kind_of String, "blah"
-    end
-  end
-
-  def test_refute_match
-    @assertion_count = 2
-    @tc.refute_match(/\d+/, "blah blah blah")
-  end
-
-  def test_refute_match_matcher_object
-    @assertion_count = 2
-    non_verbose do
-      obj = Object.new
-      def obj.=~(other); false; end
-      @tc.refute_match obj, 5
-    end
-  end
-
-  def test_refute_match_object_triggered
-    @assertion_count = 2
-
-    pattern = Object.new
-    def pattern.=~(other) true end
-    def pattern.inspect; "[Object]" end
-
-    util_assert_triggered 'Expected [Object] to not match 5.' do
-      @tc.refute_match pattern, 5
-    end
-  end
-
-  def test_refute_match_triggered
-    @assertion_count = 2
-    util_assert_triggered 'Expected /\w+/ to not match "blah blah blah".' do
-      @tc.refute_match(/\w+/, "blah blah blah")
-    end
-  end
-
-  def test_refute_nil
-    @tc.refute_nil 42
-  end
-
-  def test_refute_nil_triggered
-    util_assert_triggered 'Expected nil to not be nil.' do
-      @tc.refute_nil nil
-    end
-  end
-
-  def test_refute_predicate
-    @tc.refute_predicate "42", :empty?
-  end
-
-  def test_refute_predicate_triggered
-    util_assert_triggered 'Expected "" to not be empty?.' do
-      @tc.refute_predicate "", :empty?
-    end
-  end
-
-  def test_refute_operator
-    @tc.refute_operator 2, :<, 1
-  end
-
-  def test_refute_operator_bad_object
-    bad = Object.new
-    def bad.==(other) true end
-
-    @tc.refute_operator true, :equal?, bad
-  end
-
-  def test_refute_operator_triggered
-    util_assert_triggered "Expected 2 to not be > 1." do
-      @tc.refute_operator 2, :>, 1
-    end
-  end
-
-  def test_refute_respond_to
-    @tc.refute_respond_to "blah", :rawr!
-  end
-
-  def test_refute_respond_to_triggered
-    util_assert_triggered 'Expected "blah" to not respond to empty?.' do
-      @tc.refute_respond_to "blah", :empty?
-    end
-  end
-
-  def test_refute_same
-    @tc.refute_same 1, 2
-  end
-
-  def test_refute_same_triggered
-    util_assert_triggered 'Expected 1 (oid=N) to not be the same as 1 (oid=N).' do
-      @tc.refute_same 1, 1
-    end
-  end
-
-  def test_skip
-    @assertion_count = 0
-
-    util_assert_triggered "haha!", MiniTest::Skip do
-      @tc.skip "haha!"
-    end
-  end
-
-  def test_test_methods_random
-    @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
-      @test_order = [1, 0, 2]
-      def self.rand(n) @test_order.shift; end
-    end
-
-    expected = %w(test_test2 test_test1 test_test3)
-    assert_equal expected, sample_test_case.test_methods
-  end
-
-  def test_test_methods_sorted
-    @assertion_count = 0
-
-    sample_test_case = Class.new MiniTest::Unit::TestCase do
-      def self.test_order; :sorted end
-      def test_test3; assert "does not matter" end
-      def test_test2; assert "does not matter" end
-      def test_test1; assert "does not matter" end
-    end
-
-    expected = %w(test_test1 test_test2 test_test3)
-    assert_equal expected, sample_test_case.test_methods
-  end
-
-  def assert_triggered expected, klass = MiniTest::Assertion
-    e = assert_raises klass do
-      yield
-    end
-
-    msg = e.message.sub(/(---Backtrace---).*/m, '\1')
-    msg.gsub!(/\(oid=[-0-9]+\)/, '(oid=N)')
-    msg.gsub!(/(\d\.\d{6})\d+/, '\1xxx') # normalize: ruby version, impl, platform
-
-    assert_equal expected, msg
-  end
-  alias util_assert_triggered assert_triggered
-
-  def util_msg exp, act, msg = nil
-    s = "Expected: #{exp.inspect}\n  Actual: #{act.inspect}"
-    s = "#{msg}.\n#{s}" if msg
-    s
-  end
-
-  def without_diff
-    old_diff = MiniTest::Assertions.diff
-    MiniTest::Assertions.diff = nil
-
-    yield
-  ensure
-    MiniTest::Assertions.diff = old_diff
-  end
-end
-
-class TestMiniTestGuard < MiniTest::Unit::TestCase
-  def test_mri_eh
-    assert self.class.mri? "ruby blah"
-    assert self.mri? "ruby blah"
-  end
-
-  def test_jruby_eh
-    assert self.class.jruby? "java"
-    assert self.jruby? "java"
-  end
-
-  def test_rubinius_eh
-    assert self.class.rubinius? "rbx"
-    assert self.rubinius? "rbx"
-  end
-
-  def test_windows_eh
-    assert self.class.windows? "mswin"
-    assert self.windows? "mswin"
-  end
-end
-
-class TestMiniTestUnitRecording < MetaMetaMetaTestCase
-  # do not parallelize this suite... it just can't handle it.
-
-  def assert_run_record(*expected, &block)
-    def @tu.record suite, method, assertions, time, error
-      recording[method] << error
-    end
-
-    def @tu.recording
-      @recording ||= Hash.new { |h,k| h[k] = [] }
-    end
-
-    MiniTest::Unit.runner = @tu
-
-    Class.new MiniTest::Unit::TestCase, &block
-
-    with_output do
-      @tu.run
-    end
-
-    recorded = @tu.recording.fetch("test_method").map(&:class)
-
-    assert_equal expected, recorded
-  end
-
-  def test_record_passing
-    assert_run_record NilClass do
-      def test_method
-        assert true
-      end
-    end
-  end
-
-  def test_record_failing
-    assert_run_record MiniTest::Assertion do
-      def test_method
-        assert false
-      end
-    end
-  end
-
-  def test_record_error
-    assert_run_record RuntimeError do
-      def test_method
-        raise "unhandled exception"
-      end
-    end
-  end
-
-  def test_record_error_teardown
-    assert_run_record NilClass, RuntimeError do
-      def test_method
-        assert true
-      end
-
-      def teardown
-        raise "unhandled exception"
-      end
-    end
-  end
-
-  def test_record_error_in_test_and_teardown
-    assert_run_record AnError, RuntimeError do
-      def test_method
-        raise AnError
-      end
-
-      def teardown
-        raise "unhandled exception"
-      end
-    end
-  end
-
-  def test_record_skip
-    assert_run_record MiniTest::Skip do
-      def test_method
-        skip "not yet"
-      end
-    end
-  end
-end
diff --git a/test/testunit/test4test_hideskip.rb b/test/testunit/test4test_hideskip.rb
deleted file mode 100644
index b870c76a84..0000000000
--- a/test/testunit/test4test_hideskip.rb
+++ /dev/null
@@ -1,10 +0,0 @@
-# frozen_string_literal: false
-$LOAD_PATH.unshift "#{File.dirname(__FILE__)}/../lib"
-
-require 'test/unit'
-
-class TestForTestHideSkip < Test::Unit::TestCase
-  def test_skip
-    skip "do nothing"
-  end
-end
diff --git a/test/testunit/test4test_redefinition.rb b/test/testunit/test4test_redefinition.rb
deleted file mode 100644
index 894bc3d905..0000000000
--- a/test/testunit/test4test_redefinition.rb
+++ /dev/null
@@ -1,14 +0,0 @@
-# frozen_string_literal: false
-$LOAD_PATH.unshift "#{File.dirname(__FILE__)}/../lib"
-
-require 'test/unit'
-
-class TestForTestRedefinition < Test::Unit::TestCase
-  def test_redefinition
-    skip "do nothing (1)"
-  end
-
-  def test_redefinition
-    skip "do nothing (2)"
-  end
-end
diff --git a/test/testunit/test4test_sorting.rb b/test/testunit/test4test_sorting.rb
deleted file mode 100644
index 4848a78b5d..0000000000
--- a/test/testunit/test4test_sorting.rb
+++ /dev/null
@@ -1,18 +0,0 @@
-# frozen_string_literal: false
-$LOAD_PATH.unshift "#{File.dirname(__FILE__)}/../lib"
-
-require 'test/unit'
-
-class TestForTestHideSkip < Test::Unit::TestCase
-  def test_c
-    skip "do nothing"
-  end
-
-  def test_b
-    assert_equal true, false
-  end
-
-  def test_a
-    raise
-  end
-end
diff --git a/test/testunit/test_assertion.rb b/test/testunit/test_assertion.rb
deleted file mode 100644
index 0c7c4882b8..0000000000
--- a/test/testunit/test_assertion.rb
+++ /dev/null
@@ -1,29 +0,0 @@
-# frozen_string_literal: false
-require 'test/unit'
-class TestAssertion < Test::Unit::TestCase
-  def test_wrong_assertion
-    error, line = assert_raise(ArgumentError) {assert(true, true)}, __LINE__
-    assert_match(/assertion message must be String or Proc, but TrueClass was given/, error.message)
-    assert_match(/\A#{Regexp.quote(__FILE__)}:#{line}:/, error.backtrace[0])
-  end
-
-  def test_timeout_separately
-    assert_raise(Timeout::Error) do
-      assert_separately([], <<~"end;", timeout: 0.1)
-        sleep
-      end;
-    end
-  end
-
-  def return_in_assert_raise
-    assert_raise(RuntimeError) do
-      return
-    end
-  end
-
-  def test_assert_raise
-    assert_raise(MiniTest::Assertion) do
-      return_in_assert_raise
-    end
-  end
-end
diff --git a/test/testunit/test_hideskip.rb b/test/testunit/test_hideskip.rb
deleted file mode 100644
index 0188316a2c..0000000000
--- a/test/testunit/test_hideskip.rb
+++ /dev/null
@@ -1,21 +0,0 @@
-# frozen_string_literal: false
-require 'test/unit'
-
-class TestHideSkip < Test::Unit::TestCase
-  def test_hideskip
-    assert_not_match(/^ *1\) Skipped/, hideskip)
-    assert_match(/^ *1\) Skipped/, hideskip("--show-skip"))
-    output = hideskip("--hide-skip")
-    output.gsub!(/Successful MJIT finish\n/, '') if RubyVM::MJIT.enabled?
-    assert_match(/assertions\/s.\n+1 tests, 0 assertions, 0 failures, 0 errors, 1 skips/, output)
-  end
-
-  private
-
-  def hideskip(*args)
-    IO.popen([*@options[:ruby], "#{File.dirname(__FILE__)}/test4test_hideskip.rb",
-                       "--verbose", *args], err: [:child, :out]) {|f|
-      f.read
-    }
-  end
-end
diff --git a/test/testunit/test_parallel.rb b/test/testunit/test_parallel.rb
deleted file mode 100644
index 6bbe71a749..0000000000
--- a/test/testunit/test_parallel.rb
+++ /dev/null
@@ -1,203 +0,0 @@
-# frozen_string_literal: false
-require 'test/unit'
-require 'timeout'
-
-module TestParallel
-  PARALLEL_RB = "#{File.dirname(__FILE__)}/../lib/test/unit/parallel.rb"
-  TESTS = "#{File.dirname(__FILE__)}/tests_for_parallel"
-  # use large timeout for --jit-wait
-  TIMEOUT = EnvUtil.apply_timeout_scale(RubyVM::MJIT.enabled? ? 100 : 30)
-
-  class TestParallelWorker < Test::Unit::TestCase
-    def setup
-      i, @worker_in = IO.pipe
-      @worker_out, o = IO.pipe
-      @worker_pid = spawn(*@options[:ruby], PARALLEL_RB,
-                          "--ruby", @options[:ruby].join(" "),
-                          "-j", "t1", "-v", out: o, in: i)
-      [i,o].each(&:close)
-    end
-
-    def teardown
-      if @worker_pid && @worker_in
-        begin
-          begin
-            @worker_in.puts "quit"
-          rescue IOError, Errno::EPIPE
-          end
-          Timeout.timeout(2) do
-            Process.waitpid(@worker_pid)
-          end
-        rescue Timeout::Error
-          begin
-            Process.kill(:KILL, @worker_pid)
-          rescue Errno::ESRCH
-          end
-        end
-      end
-    ensure
-      begin
-        @worker_in.close
-        @worker_out.close
-      rescue Errno::EPIPE
-        # may already broken and rescue'ed in above code
-      end
-    end
-
-    def test_run
-      Timeout.timeout(TIMEOUT) do
-        assert_match(/^ready/,@worker_out.gets)
-        @worker_in.puts "run #{TESTS}/ptest_first.rb test"
-        assert_match(/^okay/,@worker_out.gets)
-        assert_match(/^record/,@worker_out.gets)
-        assert_match(/^p/,@worker_out.gets)
-        assert_match(/^done/,@worker_out.gets)
-        assert_match(/^ready/,@worker_out.gets)
-      end
-    end
-
-    def test_run_multiple_testcase_in_one_file
-      Timeout.timeout(TIMEOUT) do
-        assert_match(/^ready/,@worker_out.gets)
-        @worker_in.puts "run #{TESTS}/ptest_second.rb test"
-        assert_match(/^okay/,@worker_out.gets)
-        assert_match(/^record/,@worker_out.gets)
-        assert_match(/^p/,@worker_out.gets)
-        assert_match(/^done/,@worker_out.gets)
-        assert_match(/^record/,@worker_out.gets)
-        assert_match(/^p/,@worker_out.gets)
-        assert_match(/^done/,@worker_out.gets)
-        assert_match(/^ready/,@worker_out.gets)
-      end
-    end
-
-    def test_accept_run_command_multiple_times
-      Timeout.timeout(TIMEOUT) do
-        assert_match(/^ready/,@worker_out.gets)
-        @worker_in.puts "run #{TESTS}/ptest_first.rb test"
-        assert_match(/^okay/,@worker_out.gets)
-        assert_match(/^record/,@worker_out.gets)
-        assert_match(/^p/,@worker_out.gets)
-        assert_match(/^done/,@worker_out.gets)
-        assert_match(/^ready/,@worker_out.gets)
-        @worker_in.puts "run #{TESTS}/ptest_second.rb test"
-        assert_match(/^okay/,@worker_out.gets)
-        assert_match(/^record/,@worker_out.gets)
-        assert_match(/^p/,@worker_out.gets)
-        assert_match(/^done/,@worker_out.gets)
-        assert_match(/^record/,@worker_out.gets)
-        assert_match(/^p/,@worker_out.gets)
-        assert_match(/^done/,@worker_out.gets)
-        assert_match(/^ready/,@worker_out.gets)
-      end
-    end
-
-    def test_p
-      Timeout.timeout(TIMEOUT) do
-        @worker_in.puts "run #{TESTS}/ptest_first.rb test"
-        while buf = @worker_out.gets
-          break if /^p (.+?)$/ =~ buf
-        end
-        assert_match(/TestA#test_nothing_test = \d+\.\d+ s = \.\n/, $1.chomp.unpack("m")[0])
-      end
-    end
-
-    def test_done
-      Timeout.timeout(TIMEOUT) do
-        @worker_in.puts "run #{TESTS}/ptest_forth.rb test"
-        while buf = @worker_out.gets
-          break if /^done (.+?)$/ =~ buf
-        end
-
-        result = Marshal.load($1.chomp.unpack("m")[0])
-
-        assert_equal(5, result[0])
-        assert_equal(2, result[1])
-        assert_kind_of(Array,result[2])
-        assert_kind_of(Array,result[3])
-        assert_kind_of(Array,result[4])
-        assert_kind_of(Array,result[2][1])
-        assert_kind_of(MiniTest::Assertion,result[2][0][2])
-        assert_kind_of(MiniTest::Skip,result[2][1][2])
-        assert_kind_of(MiniTest::Skip,result[2][2][2])
-        assert_kind_of(Exception, result[2][3][2])
-        assert_equal(result[5], "TestE")
-      end
-    end
-
-    def test_quit
-      Timeout.timeout(TIMEOUT) do
-        @worker_in.puts "quit"
-        assert_match(/^bye$/m,@worker_out.read)
-      end
-    end
-  end
-
-  class TestParallel < Test::Unit::TestCase
-    def spawn_runner(*opt_args)
-      @test_out, o = IO.pipe
-      @test_pid = spawn(*@options[:ruby], TESTS+"/runner.rb",
-                        "--ruby", @options[:ruby].join(" "),
-                        "-j","t1",*opt_args, out: o, err: o)
-      o.close
-    end
-
-    def teardown
-      begin
-        if @test_pid
-          Timeout.timeout(2) do
-            Process.waitpid(@test_pid)
-          end
-        end
-      rescue Timeout::Error
-        Process.kill(:KILL, @test_pid) if @test_pid
-      ensure
-        @test_out&.close
-      end
-    end
-
-    def test_ignore_jzero
-      @test_out, o = IO.pipe
-      @test_pid = spawn(*@options[:ruby], TESTS+"/runner.rb",
-                        "--ruby", @options[:ruby].join(" "),
-                        "-j","0", out: File::NULL, err: o)
-      o.close
-      Timeout.timeout(TIMEOUT) {
-        assert_match(/Error: parameter of -j option should be greater than 0/,@test_out.read)
-      }
-    end
-
-    def test_should_run_all_without_any_leaks
-      spawn_runner
-      buf = Timeout.timeout(TIMEOUT) {@test_out.read}
-      assert_match(/^9 tests/,buf)
-    end
-
-    def test_should_retry_failed_on_workers
-      spawn_runner
-      buf = Timeout.timeout(TIMEOUT) {@test_out.read}
-      assert_match(/^Retrying\.+$/,buf)
-    end
-
-    def test_no_retry_option
-      spawn_runner "--no-retry"
-      buf = Timeout.timeout(TIMEOUT) {@test_out.read}
-      refute_match(/^Retrying\.+$/,buf)
-      assert_match(/^ +\d+\) Failure:\nTestD#test_fail_at_worker/,buf)
-    end
-
-    def test_jobs_status
-      spawn_runner "--jobs-status"
-      buf = Timeout.timeout(TIMEOUT) {@test_out.read}
-      assert_match(/\d+=ptest_(first|second|third|forth) */,buf)
-    end
-
-    def test_separate
-      # this test depends to --jobs-status
-      spawn_runner "--jobs-status", "--separate"
-      buf = Timeout.timeout(TIMEOUT) {@test_out.read}
-      assert(buf.scan(/^\[\s*\d+\/\d+\]\s*(\d+?)=/).flatten.uniq.size > 1,
-             message("retried tests should run in different processes") {buf})
-    end
-  end
-end
diff --git a/test/testunit/test_redefinition.rb b/test/testunit/test_redefinition.rb
deleted file mode 100644
index 9129e55489..0000000000
--- a/test/testunit/test_redefinition.rb
+++ /dev/null
@@ -1,16 +0,0 @@
-# frozen_string_literal: false
-require 'test/unit'
-
-class TestRedefinition < Test::Unit::TestCase
-  def test_redefinition
-    assert_match(/^test\/unit warning: method TestForTestRedefinition#test_redefinition is redefined$/,
-                 redefinition)
-  end
-
-  def redefinition(*args)
-    IO.popen([*@options[:ruby], "#{File.dirname(__FILE__)}/test4test_redefinition.rb", *args],
-                      err: [:child, :out]) {|f|
-      f.read
-    }
-  end
-end
diff --git a/test/testunit/test_sorting.rb b/test/testunit/test_sorting.rb
deleted file mode 100644
index f9de3ec154..0000000000
--- a/test/testunit/test_sorting.rb
+++ /dev/null
@@ -1,18 +0,0 @@
-# frozen_string_literal: false
-require 'test/unit'
-
-class TestTestUnitSorting < Test::Unit::TestCase
-  def test_sorting
-    result = sorting("--show-skip")
-    assert_match(/^  1\) Skipped:/, result)
-    assert_match(/^  2\) Failure:/, result)
-    assert_match(/^  3\) Error:/,   result)
-  end
-
-  def sorting(*args)
-    IO.popen([*@options[:ruby], "#{File.dirname(__FILE__)}/test4test_sorting.rb",
-              "--verbose", *args], err: [:child, :out]) {|f|
-      f.read
-    }
-  end
-end
diff --git a/test/testunit/tests_for_parallel/ptest_first.rb b/test/testunit/tests_for_parallel/ptest_first.rb
deleted file mode 100644
index f8687335b5..0000000000
--- a/test/testunit/tests_for_parallel/ptest_first.rb
+++ /dev/null
@@ -1,8 +0,0 @@
-# frozen_string_literal: false
-require 'test/unit'
-
-class TestA < Test::Unit::TestCase
-  def test_nothing_test
-  end
-end
-
diff --git a/test/testunit/tests_for_parallel/ptest_forth.rb b/test/testunit/tests_for_parallel/ptest_forth.rb
deleted file mode 100644
index 8831676e19..0000000000
--- a/test/testunit/tests_for_parallel/ptest_forth.rb
+++ /dev/null
@@ -1,30 +0,0 @@
-# frozen_string_literal: false
-require 'test/unit'
-
-class TestE < Test::Unit::TestCase
-  class UnknownError < RuntimeError; end
-
-  def test_not_fail
-    assert_equal(1,1)
-  end
-
-  def test_always_skip
-    skip "always"
-  end
-
-  def test_always_fail
-    assert_equal(0,1)
-  end
-
-  def test_skip_after_unknown_error
-    begin
-      raise UnknownError, "unknown error"
-    rescue
-      skip "after raise"
-    end
-  end
-
-  def test_unknown_error
-    raise UnknownError, "unknown error"
-  end
-end
diff --git a/test/testunit/tests_for_parallel/ptest_second.rb b/test/testunit/tests_for_parallel/ptest_second.rb
deleted file mode 100644
index a793c17eb3..0000000000
--- a/test/testunit/tests_for_parallel/ptest_second.rb
+++ /dev/null
@@ -1,12 +0,0 @@
-# frozen_string_literal: false
-require 'test/unit'
-
-class TestB < Test::Unit::TestCase
-  def test_nothing
-  end
-end
-
-class TestC < Test::Unit::TestCase
-  def test_nothing
-  end
-end
diff --git a/test/testunit/tests_for_parallel/ptest_third.rb b/test/testunit/tests_for_parallel/ptest_third.rb
deleted file mode 100644
index 3f448ecfc1..0000000000
--- a/test/testunit/tests_for_parallel/ptest_third.rb
+++ /dev/null
@@ -1,11 +0,0 @@
-# frozen_string_literal: false
-require 'test/unit'
-
-class TestD < Test::Unit::TestCase
-  def test_fail_at_worker
-    #if /test\/unit\/parallel\.rb/ =~ $0
-    if on_parallel_worker?
-      assert_equal(0,1)
-    end
-  end
-end
diff --git a/test/testunit/tests_for_parallel/runner.rb b/test/testunit/tests_for_parallel/runner.rb
deleted file mode 100644
index bece739917..0000000000
--- a/test/testunit/tests_for_parallel/runner.rb
+++ /dev/null
@@ -1,14 +0,0 @@
-# frozen_string_literal: false
-require 'rbconfig'
-
-$LOAD_PATH.unshift "#{File.dirname(__FILE__)}/../../lib"
-
-require 'test/unit'
-
-src_testdir = File.dirname(File.expand_path(__FILE__))
-
-class Test::Unit::Runner
-  @@testfile_prefix = "ptest"
-end
-
-exit Test::Unit::AutoRunner.run(true, src_testdir)