diff --git a/test/resolv/test_dns.rb b/test/resolv/test_dns.rb
index 1f1555fecc..5171604a82 100644
--- a/test/resolv/test_dns.rb
+++ b/test/resolv/test_dns.rb
@@ -3,7 +3,36 @@ require 'test/unit'
 require 'resolv'
 require 'socket'
 require 'tempfile'
-require 'minitest/mock'
+
+class Object # :nodoc:
+  def stub name, val_or_callable, &block
+    new_name = "__minitest_stub__#{name}"
+
+    metaclass = class << self; self; end
+
+    if respond_to? name and not methods.map(&:to_s).include? name.to_s then
+      metaclass.send :define_method, name do |*args|
+        super(*args)
+      end
+    end
+
+    metaclass.send :alias_method, new_name, name
+
+    metaclass.send :define_method, name do |*args|
+      if val_or_callable.respond_to? :call then
+        val_or_callable.call(*args)
+      else
+        val_or_callable
+      end
+    end
+
+    yield self
+  ensure
+    metaclass.send :undef_method, name
+    metaclass.send :alias_method, name, new_name
+    metaclass.send :undef_method, new_name
+  end unless method_defined?(:stub) # lib/rubygems/test_case.rb also has the same method definition
+end
 
 class TestResolvDNS < Test::Unit::TestCase
   def setup
diff --git a/tool/lib/minitest/mock.rb b/tool/lib/minitest/mock.rb
deleted file mode 100644
index a723084a0f..0000000000
--- a/tool/lib/minitest/mock.rb
+++ /dev/null
@@ -1,196 +0,0 @@
-# encoding: utf-8
-# frozen_string_literal: true
-
-class MockExpectationError < StandardError; end # :nodoc:
-
-##
-# A simple and clean mock object framework.
-
-module MiniTest # :nodoc:
-
-  ##
-  # All mock objects are an instance of Mock
-
-  class Mock
-    alias :__respond_to? :respond_to?
-
-    skip_methods = %w(object_id respond_to_missing? inspect === to_s)
-
-    instance_methods.each do |m|
-      undef_method m unless skip_methods.include?(m.to_s) || m =~ /^__/
-    end
-
-    def initialize # :nodoc:
-      @expected_calls = Hash.new { |calls, name| calls[name] = [] }
-      @actual_calls   = Hash.new { |calls, name| calls[name] = [] }
-    end
-
-    ##
-    # Expect that method +name+ is called, optionally with +args+ or a
-    # +blk+, and returns +retval+.
-    #
-    #   @mock.expect(:meaning_of_life, 42)
-    #   @mock.meaning_of_life # => 42
-    #
-    #   @mock.expect(:do_something_with, true, [some_obj, true])
-    #   @mock.do_something_with(some_obj, true) # => true
-    #
-    #   @mock.expect(:do_something_else, true) do |a1, a2|
-    #     a1 == "buggs" && a2 == :bunny
-    #   end
-    #
-    # +args+ is compared to the expected args using case equality (ie, the
-    # '===' operator), allowing for less specific expectations.
-    #
-    #   @mock.expect(:uses_any_string, true, [String])
-    #   @mock.uses_any_string("foo") # => true
-    #   @mock.verify  # => true
-    #
-    #   @mock.expect(:uses_one_string, true, ["foo"]
-    #   @mock.uses_one_string("bar") # => true
-    #   @mock.verify  # => raises MockExpectationError
-
-    def expect(name, retval, args=[], &blk)
-      if block_given?
-        raise ArgumentError, "args ignored when block given" unless args.empty?
-        @expected_calls[name] << { :retval => retval, :block => blk }
-      else
-        raise ArgumentError, "args must be an array" unless Array === args
-        @expected_calls[name] << { :retval => retval, :args => args }
-      end
-      self
-    end
-
-    def __call name, data # :nodoc:
-      case data
-      when Hash then
-        "#{name}(#{data[:args].inspect[1..-2]}) => #{data[:retval].inspect}"
-      else
-        data.map { |d| __call name, d }.join ", "
-      end
-    end
-
-    ##
-    # Verify that all methods were called as expected. Raises
-    # +MockExpectationError+ if the mock object was not called as
-    # expected.
-
-    def verify
-      @expected_calls.each do |name, calls|
-        calls.each do |expected|
-          msg1 = "expected #{__call name, expected}"
-          msg2 = "#{msg1}, got [#{__call name, @actual_calls[name]}]"
-
-          raise MockExpectationError, msg2 if
-            @actual_calls.has_key?(name) and
-            not @actual_calls[name].include?(expected)
-
-          raise MockExpectationError, msg1 unless
-            @actual_calls.has_key?(name) and
-            @actual_calls[name].include?(expected)
-        end
-      end
-      true
-    end
-
-    def method_missing(sym, *args) # :nodoc:
-      unless @expected_calls.has_key?(sym) then
-        raise NoMethodError, "unmocked method %p, expected one of %p" %
-          [sym, @expected_calls.keys.sort_by(&:to_s)]
-      end
-
-      index = @actual_calls[sym].length
-      expected_call = @expected_calls[sym][index]
-
-      unless expected_call then
-        raise MockExpectationError, "No more expects available for %p: %p" %
-          [sym, args]
-      end
-
-      expected_args, retval, val_block =
-        expected_call.values_at(:args, :retval, :block)
-
-      if val_block then
-        raise MockExpectationError, "mocked method %p failed block w/ %p" %
-          [sym, args] unless val_block.call(args)
-
-        # keep "verify" happy
-        @actual_calls[sym] << expected_call
-        return retval
-      end
-
-      if expected_args.size != args.size then
-        raise ArgumentError, "mocked method %p expects %d arguments, got %d" %
-          [sym, expected_args.size, args.size]
-      end
-
-      fully_matched = expected_args.zip(args).all? { |mod, a|
-        mod === a or mod == a
-      }
-
-      unless fully_matched then
-        raise MockExpectationError, "mocked method %p called with unexpected arguments %p" %
-          [sym, args]
-      end
-
-      @actual_calls[sym] << {
-        :retval => retval,
-        :args => expected_args.zip(args).map { |mod, a| mod === a ? mod : a }
-      }
-
-      retval
-    end
-
-    def respond_to?(sym, include_private = false) # :nodoc:
-      return true if @expected_calls.has_key?(sym.to_sym)
-      return __respond_to?(sym, include_private)
-    end
-  end
-end
-
-class Object # :nodoc:
-
-  ##
-  # Add a temporary stubbed method replacing +name+ for the duration
-  # of the +block+. If +val_or_callable+ responds to #call, then it
-  # returns the result of calling it, otherwise returns the value
-  # as-is. Cleans up the stub at the end of the +block+. The method
-  # +name+ must exist before stubbing.
-  #
-  #     def test_stale_eh
-  #       obj_under_test = Something.new
-  #       refute obj_under_test.stale?
-  #
-  #       Time.stub :now, Time.at(0) do
-  #         assert obj_under_test.stale?
-  #       end
-  #     end
-
-  def stub name, val_or_callable, &block
-    new_name = "__minitest_stub__#{name}"
-
-    metaclass = class << self; self; end
-
-    if respond_to? name and not methods.map(&:to_s).include? name.to_s then
-      metaclass.send :define_method, name do |*args|
-        super(*args)
-      end
-    end
-
-    metaclass.send :alias_method, new_name, name
-
-    metaclass.send :define_method, name do |*args|
-      if val_or_callable.respond_to? :call then
-        val_or_callable.call(*args)
-      else
-        val_or_callable
-      end
-    end
-
-    yield self
-  ensure
-    metaclass.send :undef_method, name
-    metaclass.send :alias_method, name, new_name
-    metaclass.send :undef_method, new_name
-  end unless method_defined?(:stub) # lib/rubygems/test_case.rb also has the same method definition
-end
diff --git a/tool/test/minitest/test_minitest_mock.rb b/tool/test/minitest/test_minitest_mock.rb
deleted file mode 100644
index fe9a62e62c..0000000000
--- a/tool/test/minitest/test_minitest_mock.rb
+++ /dev/null
@@ -1,404 +0,0 @@
-# encoding: utf-8
-# frozen_string_literal: false
-
-require 'minitest/mock'
-
-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_relative "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