rubygems-update 2.6.0 → 3.4.22

data/{lib/rubygems/test_case.rb → test/rubygems/helper.rb}

@@ -1,89 +1,79 @@
 # frozen_string_literal: true
-# TODO: $SAFE = 1
 
-begin
-  gem 'minitest', '~> 4.0'
-rescue NoMethodError, Gem::LoadError
-  # for ruby tests
-end
-
-if defined? Gem::QuickLoader
-  Gem::QuickLoader.load_full_rubygems_library
-else
-  require 'rubygems'
-end
+require "rubygems"
 
 begin
-  gem 'minitest'
+  gem "test-unit", "~> 3.0"
 rescue Gem::LoadError
 end
 
-# We have to load these up front because otherwise we'll try to load
-# them while we're testing rubygems, and thus we can't actually load them.
-unless Gem::Dependency.new('rdoc', '>= 3.10').matching_specs.empty?
-  gem 'rdoc'
-  gem 'json'
-end
+require "test/unit"
 
-require 'minitest/autorun'
+ENV["JARS_SKIP"] = "true" if Gem.java_platform? # avoid unnecessary and noisy `jar-dependencies` post install hook
 
-require 'rubygems/deprecate'
+require "rubygems/deprecate"
 
-require 'fileutils'
-require 'pathname'
-require 'pp'
-require 'rubygems/package'
-require 'shellwords'
-require 'tmpdir'
-require 'uri'
-require 'zlib'
-require 'benchmark' # stdlib
-require 'rubygems/mock_gem_ui'
+require "fileutils"
+require "pathname"
+require "pp"
+require "rubygems/package"
+require "shellwords"
+require "tmpdir"
+require "uri"
+require "zlib"
+require "benchmark" # stdlib
+require "rubygems/mock_gem_ui"
 
 module Gem
 
   ##
-  # Allows setting the gem path searcher.  This method is available when
-  # requiring 'rubygems/test_case'
+  # Allows setting the gem path searcher.
 
   def self.searcher=(searcher)
     @searcher = searcher
   end
 
   ##
-  # Allows toggling Windows behavior.  This method is available when requiring
-  # 'rubygems/test_case'
+  # Allows toggling Windows behavior.
 
   def self.win_platform=(val)
     @@win_platform = val
   end
 
   ##
-  # Allows setting path to Ruby.  This method is available when requiring
-  # 'rubygems/test_case'
+  # Allows setting path to Ruby.
 
-  def self.ruby= ruby
+  def self.ruby=(ruby)
     @ruby = ruby
   end
 
   ##
-  # When rubygems/test_case is required the default user interaction is a
-  # MockGemUi.
+  # Sets the default user interaction to a MockGemUi.
 
   module DefaultUserInteraction
     @ui = Gem::MockGemUi.new
   end
 end
 
+require "rubygems/command"
+
+class Gem::Command
+  ##
+  # Allows resetting the hash of specific args per command.
+
+  def self.specific_extra_args_hash=(value)
+    @specific_extra_args_hash = value
+  end
+end
+
 ##
 # RubyGemTestCase provides a variety of methods for testing rubygems and
 # gem-related behavior in a sandbox.  Through RubyGemTestCase you can install
 # and uninstall gems, fetch remote gems through a stub fetcher and be assured
 # your normal set of gems is not affected.
-#
-# Tests are always run at a safe level of 1.
 
-class Gem::TestCase < MiniTest::Unit::TestCase
+class Gem::TestCase < Test::Unit::TestCase
+  extend Gem::Deprecate
 
   attr_accessor :fetcher # :nodoc:
 
@@ -91,7 +81,7 @@ class Gem::TestCase < MiniTest::Unit::TestCase
 
   attr_accessor :uri # :nodoc:
 
-  def assert_activate expected, *specs
+  def assert_activate(expected, *specs)
     specs.each do |spec|
       case spec
       when String then
@@ -108,85 +98,183 @@ class Gem::TestCase < MiniTest::Unit::TestCase
     assert_equal expected.sort, loaded.sort if expected
   end
 
-  # TODO: move to minitest
-  def assert_path_exists path, msg = nil
-    msg = message(msg) { "Expected path '#{path}' to exist" }
-    assert File.exist?(path), msg
+  def assert_directory_exists(path, msg = nil)
+    msg = build_message(msg, "Expected path '#{path}' to be a directory")
+    assert_path_exist path
+    assert File.directory?(path), msg
+  end
+
+  def refute_directory_exists(path, msg = nil)
+    msg = build_message(msg, "Expected path '#{path}' not to be a directory")
+    assert_path_not_exist path
+    refute File.directory?(path), msg
+  end
+
+  # https://github.com/seattlerb/minitest/blob/21d9e804b63c619f602f3f4ece6c71b48974707a/lib/minitest/assertions.rb#L188
+  def _synchronize
+    yield
+  end
+
+  # https://github.com/seattlerb/minitest/blob/21d9e804b63c619f602f3f4ece6c71b48974707a/lib/minitest/assertions.rb#L546
+  def capture_subprocess_io
+    _synchronize do
+      require "tempfile"
+
+      captured_stdout = Tempfile.new("out")
+      captured_stderr = Tempfile.new("err")
+
+      orig_stdout = $stdout.dup
+      orig_stderr = $stderr.dup
+      $stdout.reopen captured_stdout
+      $stderr.reopen captured_stderr
+
+      yield
+
+      $stdout.rewind
+      $stderr.rewind
+
+      return captured_stdout.read, captured_stderr.read
+    ensure
+      $stdout.reopen orig_stdout
+      $stderr.reopen orig_stderr
+
+      orig_stdout.close
+      orig_stderr.close
+      captured_stdout.close!
+      captured_stderr.close!
+    end
   end
 
   ##
   # Sets the ENABLE_SHARED entry in RbConfig::CONFIG to +value+ and restores
   # the original value when the block ends
 
-  def enable_shared value
-    enable_shared = RbConfig::CONFIG['ENABLE_SHARED']
-    RbConfig::CONFIG['ENABLE_SHARED'] = value
+  def enable_shared(value)
+    enable_shared = RbConfig::CONFIG["ENABLE_SHARED"]
+    RbConfig::CONFIG["ENABLE_SHARED"] = value
 
     yield
   ensure
-    if enable_shared then
-      RbConfig::CONFIG['enable_shared'] = enable_shared
+    if enable_shared
+      RbConfig::CONFIG["ENABLE_SHARED"] = enable_shared
     else
-      RbConfig::CONFIG.delete 'enable_shared'
+      RbConfig::CONFIG.delete "ENABLE_SHARED"
     end
   end
 
-  # TODO: move to minitest
-  def refute_path_exists path, msg = nil
-    msg = message(msg) { "Expected path '#{path}' to not exist" }
-    refute File.exist?(path), msg
+  ##
+  # Sets the vendordir entry in RbConfig::CONFIG to +value+ and restores the
+  # original value when the block ends
+  #
+  def vendordir(value)
+    vendordir = RbConfig::CONFIG["vendordir"]
+
+    if value
+      RbConfig::CONFIG["vendordir"] = value
+    else
+      RbConfig::CONFIG.delete "vendordir"
+    end
+
+    yield
+  ensure
+    if vendordir
+      RbConfig::CONFIG["vendordir"] = vendordir
+    else
+      RbConfig::CONFIG.delete "vendordir"
+    end
+  end
+
+  ##
+  # Sets the bindir entry in RbConfig::CONFIG to +value+ and restores the
+  # original value when the block ends
+  #
+  def bindir(value)
+    with_clean_path_to_ruby do
+      bindir = RbConfig::CONFIG["bindir"]
+
+      if value
+        RbConfig::CONFIG["bindir"] = value
+      else
+        RbConfig::CONFIG.delete "bindir"
+      end
+
+      begin
+        yield
+      ensure
+        if bindir
+          RbConfig::CONFIG["bindir"] = bindir
+        else
+          RbConfig::CONFIG.delete "bindir"
+        end
+      end
+    end
+  end
+
+  ##
+  # Sets the EXEEXT entry in RbConfig::CONFIG to +value+ and restores the
+  # original value when the block ends
+  #
+  def exeext(value)
+    exeext = RbConfig::CONFIG["EXEEXT"]
+
+    if value
+      RbConfig::CONFIG["EXEEXT"] = value
+    else
+      RbConfig::CONFIG.delete "EXEEXT"
+    end
+
+    yield
+  ensure
+    if exeext
+      RbConfig::CONFIG["EXEEXT"] = exeext
+    else
+      RbConfig::CONFIG.delete "EXEEXT"
+    end
   end
 
   def scan_make_command_lines(output)
     output.scan(/^#{Regexp.escape make_command}(?:[[:blank:]].*)?$/)
   end
 
-  def parse_make_command_line(line)
-    command, *args = line.shellsplit
+  def parse_make_command_line_targets(line)
+    args = line.sub(/^#{Regexp.escape make_command}/, "").shellsplit
 
     targets = []
-    macros = {}
 
     args.each do |arg|
       case arg
       when /\A(\w+)=/
-        macros[$1] = $'
       else
         targets << arg
       end
     end
 
-    targets << '' if targets.empty?
+    targets << "" if targets.empty?
 
-    {
-      :command => command,
-      :targets => targets,
-      :macros => macros,
-    }
+    targets
   end
 
   def assert_contains_make_command(target, output, msg = nil)
-    if output.match(/\n/)
-      msg = message(msg) {
-        'Expected output containing make command "%s": %s' % [
-          ('%s %s' % [make_command, target]).rstrip,
-          output.inspect
+    if output.include?("\n")
+      msg = build_message(msg,
+        "Expected output containing make command \"%s\", but was \n\nBEGIN_OF_OUTPUT\n%sEND_OF_OUTPUT" % [
+          ("%s %s" % [make_command, target]).rstrip,
+          output,
         ]
-      }
+      )
     else
-      msg = message(msg) {
-        'Expected make command "%s": %s' % [
-          ('%s %s' % [make_command, target]).rstrip,
-          output.inspect
+      msg = build_message(msg,
+        'Expected make command "%s", but was "%s"' % [
+          ("%s %s" % [make_command, target]).rstrip,
+          output,
         ]
-      }
+      )
     end
 
-    assert scan_make_command_lines(output).any? { |line|
-      make = parse_make_command_line(line)
+    assert scan_make_command_lines(output).any? {|line|
+      targets = parse_make_command_line_targets(line)
 
-      if make[:targets].include?(target)
-        yield make, line if block_given?
+      if targets.include?(target)
         true
       else
         false
@@ -196,13 +284,6 @@ class Gem::TestCase < MiniTest::Unit::TestCase
 
   include Gem::DefaultUserInteraction
 
-  undef_method :default_test if instance_methods.include? 'default_test' or
-                                instance_methods.include? :default_test
-
-  @@project_dir = Dir.pwd.untaint unless defined?(@@project_dir)
-
-  @@initial_reset = false
-
   ##
   # #setup prepares a sandboxed location to install gems.  All installs are
   # directed to a temporary directory.  All install plugins are removed.
@@ -210,103 +291,117 @@ class Gem::TestCase < MiniTest::Unit::TestCase
   # If the +RUBY+ environment variable is set the given path is used for
   # Gem::ruby.  The local platform is set to <tt>i386-mswin32</tt> for Windows
   # or <tt>i686-darwin8.10.1</tt> otherwise.
-  #
-  # If the +KEEP_FILES+ environment variable is set the files will not be
-  # removed from <tt>/tmp/test_rubygems_#{$$}.#{Time.now.to_i}</tt>.
 
   def setup
-    super
+    @orig_hooks = {}
+    @orig_env = ENV.to_hash
+    @tmp = File.expand_path("tmp")
+
+    FileUtils.mkdir_p @tmp
 
-    @orig_gem_home   = ENV['GEM_HOME']
-    @orig_gem_path   = ENV['GEM_PATH']
-    @orig_gem_vendor = ENV['GEM_VENDOR']
-    @orig_gem_spec_cache = ENV['GEM_SPEC_CACHE']
-    @orig_rubygems_gemdeps = ENV['RUBYGEMS_GEMDEPS']
-    @orig_rubygems_host = ENV['RUBYGEMS_HOST']
+    @tempdir = Dir.mktmpdir("test_rubygems_", @tmp)
+    @tempdir.tap(&Gem::UNTAINT)
 
-    ENV['GEM_VENDOR'] = nil
+    ENV["GEM_VENDOR"] = nil
+    ENV["GEMRC"] = nil
+    ENV["XDG_CACHE_HOME"] = nil
+    ENV["XDG_CONFIG_HOME"] = nil
+    ENV["XDG_DATA_HOME"] = nil
+    ENV["XDG_STATE_HOME"] = nil
+    ENV["SOURCE_DATE_EPOCH"] = nil
+    ENV["BUNDLER_VERSION"] = nil
+    ENV["RUBYGEMS_PREVENT_UPDATE_SUGGESTION"] = "true"
 
     @current_dir = Dir.pwd
     @fetcher     = nil
-    @ui          = Gem::MockGemUi.new
-
-    tmpdir = File.expand_path Dir.tmpdir
-    tmpdir.untaint
-
-    if ENV['KEEP_FILES'] then
-      @tempdir = File.join(tmpdir, "test_rubygems_#{$$}.#{Time.now.to_i}")
-    else
-      @tempdir = File.join(tmpdir, "test_rubygems_#{$$}")
-    end
-    @tempdir.untaint
 
-    FileUtils.mkdir_p @tempdir
-
-    # This makes the tempdir consistent on OS X.
-    # File.expand_path Dir.tmpdir                      #=> "/var/..."
-    # Dir.chdir Dir.tmpdir do File.expand_path '.' end #=> "/private/var/..."
-    # TODO use File#realpath above instead of #expand_path once 1.8 support is
-    # dropped.
-    Dir.chdir @tempdir do
-      @tempdir = File.expand_path '.'
-      @tempdir.untaint
+    @back_ui                       = Gem::DefaultUserInteraction.ui
+    @ui                            = Gem::MockGemUi.new
+    # This needs to be a new instance since we call use_ui(@ui) when we want to
+    # capture output
+    Gem::DefaultUserInteraction.ui = Gem::MockGemUi.new
+
+    @orig_SYSTEM_WIDE_CONFIG_FILE = Gem::ConfigFile::SYSTEM_WIDE_CONFIG_FILE
+    Gem::ConfigFile.send :remove_const, :SYSTEM_WIDE_CONFIG_FILE
+    Gem::ConfigFile.send :const_set, :SYSTEM_WIDE_CONFIG_FILE,
+                         File.join(@tempdir, "system-gemrc")
+
+    @gemhome  = File.join @tempdir, "gemhome"
+    @userhome = File.join @tempdir, "userhome"
+    @statehome = File.join @tempdir, "statehome"
+    ENV["GEM_SPEC_CACHE"] = File.join @tempdir, "spec_cache"
+
+    @orig_ruby = if ENV["RUBY"]
+      ruby = Gem.ruby
+      Gem.ruby = ENV["RUBY"]
+      ruby
     end
 
-    @gemhome  = File.join @tempdir, 'gemhome'
-    @userhome = File.join @tempdir, 'userhome'
-    ENV["GEM_SPEC_CACHE"] = File.join @tempdir, 'spec_cache'
-
-    @orig_ruby = if ENV['RUBY'] then
-                   ruby = Gem.ruby
-                   Gem.ruby = ENV['RUBY']
-                   ruby
-                 end
-
-    @git = ENV['GIT'] || 'git'
+    @git = ENV["GIT"] || "git#{RbConfig::CONFIG["EXEEXT"]}"
 
     Gem.ensure_gem_subdirectories @gemhome
+    Gem.ensure_default_gem_subdirectories @gemhome
 
     @orig_LOAD_PATH = $LOAD_PATH.dup
-    $LOAD_PATH.map! { |s|
-      (expand_path = File.expand_path(s)) == s ? s : expand_path.untaint
-    }
+    $LOAD_PATH.map! do |s|
+      expand_path = begin
+                      File.realpath(s)
+                    rescue StandardError
+                      File.expand_path(s)
+                    end
+      if expand_path != s
+        expand_path.tap(&Gem::UNTAINT)
+        if s.instance_variable_defined?(:@gem_prelude_index)
+          expand_path.instance_variable_set(:@gem_prelude_index, expand_path)
+        end
+        expand_path.freeze if s.frozen?
+        s = expand_path
+      end
+      s
+    end
 
     Dir.chdir @tempdir
 
-    @orig_ENV_HOME = ENV['HOME']
-    ENV['HOME'] = @userhome
+    ENV["HOME"] = @userhome
+    Gem.instance_variable_set :@config_file, nil
     Gem.instance_variable_set :@user_home, nil
+    Gem.instance_variable_set :@config_home, nil
+    Gem.instance_variable_set :@data_home, nil
+    Gem.instance_variable_set :@state_home, @statehome
     Gem.instance_variable_set :@gemdeps, nil
+    Gem.instance_variable_set :@env_requirements_by_name, nil
     Gem.send :remove_instance_variable, :@ruby_version if
       Gem.instance_variables.include? :@ruby_version
 
-    FileUtils.mkdir_p @gemhome
     FileUtils.mkdir_p @userhome
 
-    @orig_gem_private_key_passphrase = ENV['GEM_PRIVATE_KEY_PASSPHRASE']
-    ENV['GEM_PRIVATE_KEY_PASSPHRASE'] = PRIVATE_KEY_PASSPHRASE
-
-    @default_dir = File.join @tempdir, 'default'
-    @default_spec_dir = File.join @default_dir, "specifications", "default"
-    Gem.instance_variable_set :@default_dir, @default_dir
-    FileUtils.mkdir_p @default_spec_dir
+    ENV["GEM_PRIVATE_KEY_PASSPHRASE"] = PRIVATE_KEY_PASSPHRASE
 
-    # We use Gem::Specification.reset the first time only so that if there
-    # are unresolved deps that leak into the whole test suite, they're at least
-    # reported once.
-    if @@initial_reset
-      Gem::Specification.unresolved_deps.clear # done to avoid cross-test warnings
+    Gem.instance_variable_set(:@default_specifications_dir, nil)
+    if Gem.java_platform?
+      @orig_default_gem_home = RbConfig::CONFIG["default_gem_home"]
+      RbConfig::CONFIG["default_gem_home"] = @gemhome
     else
-      @@initial_reset = true
-      Gem::Specification.reset
+      Gem.instance_variable_set(:@default_dir, @gemhome)
     end
-    Gem.use_paths(@gemhome)
 
-    Gem::Security.reset
+    @orig_bindir = RbConfig::CONFIG["bindir"]
+    RbConfig::CONFIG["bindir"] = File.join @gemhome, "bin"
+
+    @orig_sitelibdir = RbConfig::CONFIG["sitelibdir"]
+    new_sitelibdir = @orig_sitelibdir.sub(RbConfig::CONFIG["prefix"], @gemhome)
+    $LOAD_PATH.insert(Gem.load_path_insert_index, new_sitelibdir)
+    RbConfig::CONFIG["sitelibdir"] = new_sitelibdir
+
+    @orig_mandir = RbConfig::CONFIG["mandir"]
+    RbConfig::CONFIG["mandir"] = File.join @gemhome, "share", "man"
+
+    Gem::Specification.unresolved_deps.clear
+    Gem.use_paths(@gemhome)
 
     Gem.loaded_specs.clear
+    Gem.instance_variable_set(:@activated_gem_paths, 0)
     Gem.clear_default_specs
-    Gem::Specification.unresolved_deps.clear
 
     Gem.configuration.verbose = true
     Gem.configuration.update_sources = true
@@ -319,15 +414,17 @@ class Gem::TestCase < MiniTest::Unit::TestCase
 
     Gem.searcher = nil
     Gem::SpecFetcher.fetcher = nil
-    @orig_BASERUBY = RbConfig::CONFIG['BASERUBY']
-    RbConfig::CONFIG['BASERUBY'] = RbConfig::CONFIG['ruby_install_name']
 
-    @orig_arch = RbConfig::CONFIG['arch']
+    @orig_arch = RbConfig::CONFIG["arch"]
 
     if win_platform?
-      util_set_arch 'i386-mswin32'
+      util_set_arch "i386-mswin32"
     else
-      util_set_arch 'i686-darwin8.10.1'
+      util_set_arch "i686-darwin8.10.1"
+    end
+
+    %w[post_install_hooks done_installing_hooks post_uninstall_hooks pre_uninstall_hooks pre_install_hooks pre_reset_hooks post_reset_hooks post_build_hooks].each do |name|
+      @orig_hooks[name] = Gem.send(name).dup
     end
 
     @marshal_version = "#{Marshal::MAJOR_VERSION}.#{Marshal::MINOR_VERSION}"
@@ -336,59 +433,68 @@ class Gem::TestCase < MiniTest::Unit::TestCase
 
   ##
   # #teardown restores the process to its original state and removes the
-  # tempdir unless the +KEEP_FILES+ environment variable was set.
+  # tempdir
 
   def teardown
     $LOAD_PATH.replace @orig_LOAD_PATH if @orig_LOAD_PATH
     if @orig_LOADED_FEATURES
       if @orig_LOAD_PATH
-        paths = @orig_LOAD_PATH.map {|path| File.join(File.expand_path(path), "/")}
         ($LOADED_FEATURES - @orig_LOADED_FEATURES).each do |feat|
-          unless paths.any? {|path| feat.start_with?(path)}
-            $LOADED_FEATURES.delete(feat)
-          end
+          $LOADED_FEATURES.delete(feat) if feat.start_with?(@tmp)
         end
       else
         $LOADED_FEATURES.replace @orig_LOADED_FEATURES
       end
     end
 
-    if @orig_BASERUBY
-      RbConfig::CONFIG['BASERUBY'] = @orig_BASERUBY
-    else
-      RbConfig::CONFIG.delete('BASERUBY')
-    end
-    RbConfig::CONFIG['arch'] = @orig_arch
+    RbConfig::CONFIG["arch"] = @orig_arch
 
-    if defined? Gem::RemoteFetcher then
+    if defined? Gem::RemoteFetcher
       Gem::RemoteFetcher.fetcher = nil
     end
 
     Dir.chdir @current_dir
 
-    FileUtils.rm_rf @tempdir unless ENV['KEEP_FILES']
+    FileUtils.rm_rf @tempdir
+
+    restore_env
 
-    ENV['GEM_HOME']   = @orig_gem_home
-    ENV['GEM_PATH']   = @orig_gem_path
-    ENV['GEM_VENDOR'] = @orig_gem_vendor
-    ENV['GEM_SPEC_CACHE'] = @orig_gem_spec_cache
-    ENV['RUBYGEMS_GEMDEPS'] = @orig_rubygems_gemdeps
-    ENV['RUBYGEMS_HOST'] = @orig_rubygems_host
+    Gem::ConfigFile.send :remove_const, :SYSTEM_WIDE_CONFIG_FILE
+    Gem::ConfigFile.send :const_set, :SYSTEM_WIDE_CONFIG_FILE,
+                         @orig_SYSTEM_WIDE_CONFIG_FILE
 
     Gem.ruby = @orig_ruby if @orig_ruby
 
-    if @orig_ENV_HOME then
-      ENV['HOME'] = @orig_ENV_HOME
+    RbConfig::CONFIG["mandir"] = @orig_mandir
+    RbConfig::CONFIG["sitelibdir"] = @orig_sitelibdir
+    RbConfig::CONFIG["bindir"] = @orig_bindir
+
+    Gem.instance_variable_set :@default_specifications_dir, nil
+    if Gem.java_platform?
+      RbConfig::CONFIG["default_gem_home"] = @orig_default_gem_home
     else
-      ENV.delete 'HOME'
+      Gem.instance_variable_set :@default_dir, nil
     end
 
-    Gem.instance_variable_set :@default_dir, nil
+    Gem::Specification.unresolved_deps.clear
+    Gem::refresh
 
-    ENV['GEM_PRIVATE_KEY_PASSPHRASE'] = @orig_gem_private_key_passphrase
+    @orig_hooks.each do |name, hooks|
+      Gem.send(name).replace hooks
+    end
 
-    Gem::Specification._clear_load_cache
-    Gem::Specification.unresolved_deps.clear
+    @back_ui.close
+  end
+
+  def credential_setup
+    @temp_cred = File.join(@userhome, ".gem", "credentials")
+    FileUtils.mkdir_p File.dirname(@temp_cred)
+    File.write @temp_cred, ":rubygems_api_key: 701229f217cdf23b1344c7b4b54ca97"
+    File.chmod 0o600, @temp_cred
+  end
+
+  def credential_teardown
+    FileUtils.rm_rf @temp_cred
   end
 
   def common_installer_setup
@@ -428,16 +534,20 @@ class Gem::TestCase < MiniTest::Unit::TestCase
     Gem.pre_uninstall_hooks.clear
   end
 
+  def without_any_upwards_gemfiles
+    ENV["BUNDLE_GEMFILE"] = File.join(@tempdir, "Gemfile")
+  end
+
   ##
   # A git_gem is used with a gem dependencies file.  The gem created here
   # has no files, just a gem specification for the given +name+ and +version+.
   #
   # Yields the +specification+ to the block, if given
 
-  def git_gem name = 'a', version = 1
+  def git_gem(name = "a", version = 1)
     have_git?
 
-    directory = File.join 'git', name
+    directory = File.join "git", name
     directory = File.expand_path directory
 
     git_spec = Gem::Specification.new name, version do |specification|
@@ -448,25 +558,25 @@ class Gem::TestCase < MiniTest::Unit::TestCase
 
     gemspec = "#{name}.gemspec"
 
-    open File.join(directory, gemspec), 'w' do |io|
+    File.open File.join(directory, gemspec), "w" do |io|
       io.write git_spec.to_ruby
     end
 
     head = nil
 
     Dir.chdir directory do
-      unless File.exist? '.git' then
-        system @git, 'init', '--quiet'
-        system @git, 'config', 'user.name',  'RubyGems Tests'
-        system @git, 'config', 'user.email', 'rubygems@example'
+      unless File.exist? ".git"
+        system @git, "init", "--quiet"
+        system @git, "config", "user.name",  "RubyGems Tests"
+        system @git, "config", "user.email", "rubygems@example"
       end
 
-      system @git, 'add', gemspec
-      system @git, 'commit', '-a', '-m', 'a non-empty commit message', '--quiet'
-      head = Gem::Util.popen('git', 'rev-parse', 'master').strip
+      system @git, "add", gemspec
+      system @git, "commit", "-a", "-m", "a non-empty commit message", "--quiet"
+      head = Gem::Util.popen(@git, "rev-parse", "HEAD").strip
     end
 
-    return name, git_spec.version, directory, head
+    [name, git_spec.version, directory, head]
   end
 
   ##
@@ -475,13 +585,13 @@ class Gem::TestCase < MiniTest::Unit::TestCase
   def have_git?
     return if in_path? @git
 
-    skip 'cannot find git executable, use GIT environment variable to set'
+    pend "cannot find git executable, use GIT environment variable to set"
   end
 
-  def in_path? executable # :nodoc:
-    return true if %r%\A([A-Z]:|/)% =~ executable and File.exist? executable
+  def in_path?(executable) # :nodoc:
+    return true if %r{\A([A-Z]:|/)} =~ executable && File.exist?(executable)
 
-    ENV['PATH'].split(File::PATH_SEPARATOR).any? do |directory|
+    ENV["PATH"].split(File::PATH_SEPARATOR).any? do |directory|
       File.exist? File.join directory, executable
     end
   end
@@ -489,53 +599,41 @@ class Gem::TestCase < MiniTest::Unit::TestCase
   ##
   # Builds and installs the Gem::Specification +spec+
 
-  def install_gem spec, options = {}
-    require 'rubygems/installer'
+  def install_gem(spec, options = {})
+    require "rubygems/installer"
 
-    gem = File.join @tempdir, "gems", "#{spec.full_name}.gem"
+    gem = spec.cache_file
 
-    unless File.exist? gem then
+    unless File.exist? gem
       use_ui Gem::MockGemUi.new do
         Dir.chdir @tempdir do
           Gem::Package.build spec
         end
       end
 
-      gem = File.join(@tempdir, File.basename(spec.cache_file)).untaint
+      gem = File.join(@tempdir, File.basename(gem)).tap(&Gem::UNTAINT)
     end
 
-    Gem::Installer.at(gem, options.merge({:wrappers => true})).install
+    Gem::Installer.at(gem, options.merge({ :wrappers => true })).install
   end
 
   ##
   # Builds and installs the Gem::Specification +spec+ into the user dir
 
-  def install_gem_user spec
+  def install_gem_user(spec)
     install_gem spec, :user_install => true
   end
 
   ##
   # Uninstalls the Gem::Specification +spec+
-  def uninstall_gem spec
-    require 'rubygems/uninstaller'
+  def uninstall_gem(spec)
+    require "rubygems/uninstaller"
 
-    Class.new(Gem::Uninstaller) {
-      def ask_if_ok spec
+    Class.new(Gem::Uninstaller) do
+      def ask_if_ok(spec)
         true
       end
-    }.new(spec.name, :executables => true, :user_install => true).uninstall
-  end
-
-  ##
-  # creates a temporary directory with hax
-  # TODO: deprecate and remove
-
-  def create_tmpdir
-    tmpdir = nil
-    Dir.chdir Dir.tmpdir do tmpdir = Dir.pwd end # HACK OSX /private/tmp
-    tmpdir = File.join tmpdir, "test_rubygems_#{$$}"
-    FileUtils.mkdir_p tmpdir
-    return tmpdir
+    end.new(spec.name, :executables => true, :user_install => true).uninstall
   end
 
   ##
@@ -544,7 +642,7 @@ class Gem::TestCase < MiniTest::Unit::TestCase
   def mu_pp(obj)
     s = String.new
     s = PP.pp obj, s
-    s = s.force_encoding(Encoding.default_external) if defined? Encoding
+    s = s.force_encoding(Encoding.default_external)
     s.chomp
   end
 
@@ -552,7 +650,7 @@ class Gem::TestCase < MiniTest::Unit::TestCase
   # Reads a Marshal file at +path+
 
   def read_cache(path)
-    open path.dup.untaint, 'rb' do |io|
+    File.open path.dup.tap(&Gem::UNTAINT), "rb" do |io|
       Marshal.load io.read
     end
   end
@@ -572,13 +670,32 @@ class Gem::TestCase < MiniTest::Unit::TestCase
     dir = File.dirname path
     FileUtils.mkdir_p dir unless File.directory? dir
 
-    open path, 'wb' do |io|
+    File.open path, "wb" do |io|
       yield io if block_given?
     end
 
     path
   end
 
+  ##
+  # Load a YAML string, the psych 3 way
+
+  def load_yaml(yaml)
+    if Psych.respond_to?(:unsafe_load)
+      Psych.unsafe_load(yaml)
+    else
+      Psych.load(yaml)
+    end
+  end
+
+  ##
+  # Load a YAML file, the psych 3 way
+
+  def load_yaml_file(file)
+    require "rubygems/config_file"
+    Gem::ConfigFile.load_with_rubygems_config_hash(File.read(file))
+  end
+
   def all_spec_names
     Gem::Specification.map(&:full_name)
   end
@@ -593,40 +710,31 @@ class Gem::TestCase < MiniTest::Unit::TestCase
   #
   # Use this with #write_file to build an installed gem.
 
-  def quick_gem(name, version='2')
-    require 'rubygems/specification'
+  def quick_gem(name, version="2")
+    require "rubygems/specification"
 
     spec = Gem::Specification.new do |s|
       s.platform    = Gem::Platform::RUBY
       s.name        = name
       s.version     = version
-      s.author      = 'A User'
-      s.email       = 'example@example.com'
-      s.homepage    = 'http://example.com'
+      s.author      = "A User"
+      s.email       = "example@example.com"
+      s.homepage    = "http://example.com"
       s.summary     = "this is a summary"
       s.description = "This is a test description"
 
       yield(s) if block_given?
     end
 
-    Gem::Specification.map # HACK: force specs to (re-)load before we write
-
     written_path = write_file spec.spec_file do |io|
       io.write spec.to_ruby_for_cache
     end
 
-    spec.loaded_from = spec.loaded_from = written_path
+    spec.loaded_from = written_path
 
     Gem::Specification.reset
 
-    return spec
-  end
-
-  ##
-  # TODO:  remove in RubyGems 3.0
-
-  def quick_spec name, version = '2' # :nodoc:
-    util_spec name, version
+    spec
   end
 
   ##
@@ -641,7 +749,10 @@ class Gem::TestCase < MiniTest::Unit::TestCase
       spec.files.each do |file|
         next if File.exist? file
         FileUtils.mkdir_p File.dirname(file)
-        File.open file, 'w' do |fp| fp.puts "# #{file}" end
+
+        File.open file, "w" do |fp|
+          fp.puts "# #{file}"
+        end
       end
 
       use_ui Gem::MockGemUi.new do
@@ -662,7 +773,7 @@ class Gem::TestCase < MiniTest::Unit::TestCase
   # Removes all installed gems from +@gemhome+.
 
   def util_clear_gems
-    FileUtils.rm_rf File.join(@gemhome, "gems") # TODO: use Gem::Dirs
+    FileUtils.rm_rf File.join(@gemhome, "gems")
     FileUtils.mkdir File.join(@gemhome, "gems")
     FileUtils.rm_rf File.join(@gemhome, "specifications")
     FileUtils.mkdir File.join(@gemhome, "specifications")
@@ -674,7 +785,7 @@ class Gem::TestCase < MiniTest::Unit::TestCase
 
   def install_specs(*specs)
     specs.each do |spec|
-      Gem::Installer.for_spec(spec).install
+      Gem::Installer.for_spec(spec, :force => true).install
     end
 
     Gem.searcher = nil
@@ -684,19 +795,6 @@ class Gem::TestCase < MiniTest::Unit::TestCase
   # Installs the provided default specs including writing the spec file
 
   def install_default_gems(*specs)
-    install_default_specs(*specs)
-
-    specs.each do |spec|
-      open spec.loaded_from, 'w' do |io|
-        io.write spec.to_ruby_for_cache
-      end
-    end
-  end
-
-  ##
-  # Install the provided default specs
-
-  def install_default_specs(*specs)
     specs.each do |spec|
       installer = Gem::Installer.for_spec(spec, :install_as_default => true)
       installer.install
@@ -712,65 +810,15 @@ class Gem::TestCase < MiniTest::Unit::TestCase
     Gem::Specification.unresolved_deps.values.map(&:to_s).sort
   end
 
-  def save_loaded_features
-    old_loaded_features = $LOADED_FEATURES.dup
-    yield
-  ensure
-    $LOADED_FEATURES.replace old_loaded_features
-  end
-
-  ##
-  # new_spec is deprecated as it is never used.
-  #
-  # TODO:  remove in RubyGems 3.0
-
-  def new_spec name, version, deps = nil, *files # :nodoc:
-    require 'rubygems/specification'
-
-    spec = Gem::Specification.new do |s|
-      s.platform    = Gem::Platform::RUBY
-      s.name        = name
-      s.version     = version
-      s.author      = 'A User'
-      s.email       = 'example@example.com'
-      s.homepage    = 'http://example.com'
-      s.summary     = "this is a summary"
-      s.description = "This is a test description"
-
-      Array(deps).each do |n, req|
-        s.add_dependency n, (req || '>= 0')
-      end
-
-      s.files.push(*files) unless files.empty?
-
-      yield s if block_given?
-    end
-
-    spec.loaded_from = spec.spec_file
-
-    unless files.empty? then
-      write_file spec.spec_file do |io|
-        io.write spec.to_ruby_for_cache
-      end
-
-      util_build_gem spec
-
-      cache_file = File.join @tempdir, 'gems', "#{spec.full_name}.gem"
-      FileUtils.mkdir_p File.dirname cache_file
-      FileUtils.mv spec.cache_file, cache_file
-      FileUtils.rm spec.spec_file
-    end
-
-    spec
-  end
-
   def new_default_spec(name, version, deps = nil, *files)
     spec = util_spec name, version, deps
 
-    spec.loaded_from = File.join(@default_spec_dir, spec.spec_name)
+    spec.loaded_from = File.join(@gemhome, "specifications", "default", spec.spec_name)
     spec.files = files
 
     lib_dir = File.join(@tempdir, "default_gems", "lib")
+    lib_dir.instance_variable_set(:@gem_prelude_index, lib_dir)
+    Gem.instance_variable_set(:@default_gem_load_paths, [*Gem.send(:default_gem_load_paths), lib_dir])
     $LOAD_PATH.unshift(lib_dir)
     files.each do |file|
       rb_path = File.join(lib_dir, file)
@@ -787,33 +835,41 @@ class Gem::TestCase < MiniTest::Unit::TestCase
   # Creates a spec with +name+, +version+.  +deps+ can specify the dependency
   # or a +block+ can be given for full customization of the specification.
 
-  def util_spec name, version = 2, deps = nil # :yields: specification
-    raise "deps or block, not both" if deps and block_given?
+  def util_spec(name, version = 2, deps = nil, *files) # :yields: specification
+    raise "deps or block, not both" if deps && block_given?
 
     spec = Gem::Specification.new do |s|
       s.platform    = Gem::Platform::RUBY
       s.name        = name
       s.version     = version
-      s.author      = 'A User'
-      s.email       = 'example@example.com'
-      s.homepage    = 'http://example.com'
+      s.author      = "A User"
+      s.email       = "example@example.com"
+      s.homepage    = "http://example.com"
       s.summary     = "this is a summary"
       s.description = "This is a test description"
 
+      s.files.push(*files) unless files.empty?
+
       yield s if block_given?
     end
 
-    if deps then
-      # Since Hash#each is unordered in 1.8, sort the keys and iterate that
-      # way so the tests are deterministic on all implementations.
-      deps.keys.sort.each do |n|
-        spec.add_dependency n, (deps[n] || '>= 0')
+    if deps
+      deps.keys.each do |n|
+        spec.add_dependency n, (deps[n] || ">= 0")
       end
     end
 
-    Gem::Specification.reset
+    unless files.empty?
+      write_file spec.spec_file do |io|
+        io.write spec.to_ruby_for_cache
+      end
 
-    return spec
+      util_build_gem spec
+
+      FileUtils.rm spec.spec_file
+    end
+
+    spec
   end
 
   ##
@@ -823,16 +879,10 @@ class Gem::TestCase < MiniTest::Unit::TestCase
   # location are returned.
 
   def util_gem(name, version, deps = nil, &block)
-    # TODO: deprecate
-    raise "deps or block, not both" if deps and block
-
-    if deps then
+    if deps
       block = proc do |s|
-        # Since Hash#each is unordered in 1.8, sort
-        # the keys and iterate that way so the tests are
-        # deterministic on all implementations.
-        deps.keys.sort.each do |n|
-          s.add_dependency n, (deps[n] || '>= 0')
+        deps.keys.each do |n|
+          s.add_dependency n, (deps[n] || ">= 0")
         end
       end
     end
@@ -841,7 +891,7 @@ class Gem::TestCase < MiniTest::Unit::TestCase
 
     util_build_gem spec
 
-    cache_file = File.join @tempdir, 'gems', "#{spec.original_name}.gem"
+    cache_file = File.join @tempdir, "gems", "#{spec.original_name}.gem"
     FileUtils.mkdir_p File.dirname cache_file
     FileUtils.mv spec.cache_file, cache_file
     FileUtils.rm spec.spec_file
@@ -883,11 +933,11 @@ class Gem::TestCase < MiniTest::Unit::TestCase
   # TODO: nuke this and fix tests. this should speed up a lot
 
   def util_make_gems(prerelease = false)
-    @a1 = quick_gem 'a', '1' do |s|
+    @a1 = quick_gem "a", "1" do |s|
       s.files = %w[lib/code.rb]
       s.require_paths = %w[lib]
-      s.date = Gem::Specification::TODAY - 86400
-      s.homepage = 'http://a.example.com'
+      s.date = Gem::Specification::TODAY - 86_400
+      s.homepage = "http://a.example.com"
       s.email = %w[example@example.com example2@example.com]
       s.authors = %w[Example Example2]
       s.description = <<-DESC
@@ -904,27 +954,27 @@ Also, a list:
       s.require_paths = %w[lib]
     end
 
-    @a2      = quick_gem('a', '2',      &init)
-    @a3a     = quick_gem('a', '3.a',    &init)
-    @a_evil9 = quick_gem('a_evil', '9', &init)
-    @b2      = quick_gem('b', '2',      &init)
-    @c1_2    = quick_gem('c', '1.2',    &init)
-    @x       = quick_gem('x', '1',      &init)
-    @dep_x   = quick_gem('dep_x', '1') do |s|
+    @a2      = quick_gem("a", "2",      &init)
+    @a3a     = quick_gem("a", "3.a",    &init)
+    @a_evil9 = quick_gem("a_evil", "9", &init)
+    @b2      = quick_gem("b", "2",      &init)
+    @c1_2    = quick_gem("c", "1.2",    &init)
+    @x       = quick_gem("x", "1",      &init)
+    @dep_x   = quick_gem("dep_x", "1") do |s|
       s.files = %w[lib/code.rb]
       s.require_paths = %w[lib]
-      s.add_dependency 'x', '>= 1'
+      s.add_dependency "x", ">= 1"
     end
 
-    @pl1     = quick_gem 'pl', '1' do |s| # l for legacy
+    @pl1 = quick_gem "pl", "1" do |s| # l for legacy
       s.files = %w[lib/code.rb]
       s.require_paths = %w[lib]
-      s.platform = Gem::Platform.new 'i386-linux'
-      s.instance_variable_set :@original_platform, 'i386-linux'
+      s.platform = Gem::Platform.new "i386-linux"
+      s.instance_variable_set :@original_platform, "i386-linux"
     end
 
     if prerelease
-      @a2_pre = quick_gem('a', '2.a', &init)
+      @a2_pre = quick_gem("a", "2.a", &init)
       write_file File.join(*%W[gems #{@a2_pre.original_name} lib code.rb])
       util_build_gem @a2_pre
     end
@@ -950,38 +1000,15 @@ Also, a list:
   # Set the platform to +arch+
 
   def util_set_arch(arch)
-    RbConfig::CONFIG['arch'] = arch
+    RbConfig::CONFIG["arch"] = arch
     platform = Gem::Platform.new arch
 
     Gem.instance_variable_set :@platforms, nil
     Gem::Platform.instance_variable_set :@local, nil
 
-    platform
-  end
-
-  ##
-  # Sets up a fake fetcher using the gems from #util_make_gems.  Optionally
-  # additional +prerelease+ gems may be included.
-  #
-  # Gems created by this method may be fetched using Gem::RemoteFetcher.
-
-  def util_setup_fake_fetcher(prerelease = false)
-    require 'zlib'
-    require 'socket'
-    require 'rubygems/remote_fetcher'
+    yield if block_given?
 
-    @fetcher = Gem::FakeFetcher.new
-
-    util_make_gems(prerelease)
-    Gem::Specification.reset
-
-    @all_gems = [@a1, @a2, @a3a, @a_evil9, @b2, @c1_2].sort
-    @all_gem_names = @all_gems.map { |gem| gem.full_name }
-
-    gem_names = [@a1.full_name, @a2.full_name, @a3a.full_name, @b2.full_name]
-    @gem_names = gem_names.sort.join("\n")
-
-    Gem::RemoteFetcher.fetcher = @fetcher
+    platform
   end
 
   ##
@@ -995,7 +1022,6 @@ Also, a list:
 
   ##
   # Sets up Gem::SpecFetcher to return information from the gems in +specs+.
-  # Best used with +@all_gems+ from #util_setup_fake_fetcher.
 
   def util_setup_spec_fetcher(*specs)
     all_specs = Gem::Specification.to_a + specs
@@ -1003,7 +1029,7 @@ Also, a list:
 
     spec_fetcher = Gem::SpecFetcher.fetcher
 
-    prerelease, all = all_specs.partition { |spec| spec.version.prerelease?  }
+    prerelease, all = all_specs.partition {|spec| spec.version.prerelease? }
     latest = Gem::Specification._latest_specs all_specs
 
     spec_fetcher.specs[@uri] = []
@@ -1021,11 +1047,11 @@ Also, a list:
       spec_fetcher.prerelease_specs[@uri] << spec.name_tuple
     end
 
-    # HACK for test_download_to_cache
-    unless Gem::RemoteFetcher === @fetcher then
+    # HACK: for test_download_to_cache
+    unless Gem::RemoteFetcher === @fetcher
       v = Gem.marshal_version
 
-      specs = all.map { |spec| spec.name_tuple }
+      specs = all.map {|spec| spec.name_tuple }
       s_zip = util_gzip Marshal.dump Gem::NameTuple.to_basic specs
 
       latest_specs = latest.map do |spec|
@@ -1034,26 +1060,30 @@ Also, a list:
 
       l_zip = util_gzip Marshal.dump Gem::NameTuple.to_basic latest_specs
 
-      prerelease_specs = prerelease.map { |spec| spec.name_tuple }
+      prerelease_specs = prerelease.map {|spec| spec.name_tuple }
       p_zip = util_gzip Marshal.dump Gem::NameTuple.to_basic prerelease_specs
 
       @fetcher.data["#{@gem_repo}specs.#{v}.gz"]            = s_zip
       @fetcher.data["#{@gem_repo}latest_specs.#{v}.gz"]     = l_zip
       @fetcher.data["#{@gem_repo}prerelease_specs.#{v}.gz"] = p_zip
 
-      v = Gem.marshal_version
-
-      all_specs.each do |spec|
-        path = "#{@gem_repo}quick/Marshal.#{v}/#{spec.original_name}.gemspec.rz"
-        data = Marshal.dump spec
-        data_deflate = Zlib::Deflate.deflate data
-        @fetcher.data[path] = data_deflate
-      end
+      write_marshalled_gemspecs(*all_specs)
     end
 
     nil # force errors
   end
 
+  def write_marshalled_gemspecs(*all_specs)
+    v = Gem.marshal_version
+
+    all_specs.each do |spec|
+      path = "#{@gem_repo}quick/Marshal.#{v}/#{spec.original_name}.gemspec.rz"
+      data = Marshal.dump spec
+      data_deflate = Zlib::Deflate.deflate data
+      @fetcher.data[path] = data_deflate
+    end
+  end
+
   ##
   # Deflates +data+
 
@@ -1061,35 +1091,49 @@ Also, a list:
     Zlib::Deflate.deflate data
   end
 
-  def util_set_RUBY_VERSION(version, patchlevel = nil, revision = nil)
-    if Gem.instance_variables.include? :@ruby_version or
-       Gem.instance_variables.include? '@ruby_version' then
+  def util_set_RUBY_VERSION(version, patchlevel, revision, description, engine = "ruby", engine_version = nil)
+    if Gem.instance_variables.include? :@ruby_version
       Gem.send :remove_instance_variable, :@ruby_version
     end
 
-    @RUBY_VERSION    = RUBY_VERSION
-    @RUBY_PATCHLEVEL = RUBY_PATCHLEVEL if defined?(RUBY_PATCHLEVEL)
-    @RUBY_REVISION   = RUBY_REVISION   if defined?(RUBY_REVISION)
+    @RUBY_VERSION        = RUBY_VERSION
+    @RUBY_PATCHLEVEL     = RUBY_PATCHLEVEL     if defined?(RUBY_PATCHLEVEL)
+    @RUBY_REVISION       = RUBY_REVISION       if defined?(RUBY_REVISION)
+    @RUBY_DESCRIPTION    = RUBY_DESCRIPTION
+    @RUBY_ENGINE         = RUBY_ENGINE
+    @RUBY_ENGINE_VERSION = RUBY_ENGINE_VERSION if defined?(RUBY_ENGINE_VERSION)
 
-    Object.send :remove_const, :RUBY_VERSION
-    Object.send :remove_const, :RUBY_PATCHLEVEL if defined?(RUBY_PATCHLEVEL)
-    Object.send :remove_const, :RUBY_REVISION   if defined?(RUBY_REVISION)
+    util_clear_RUBY_VERSION
 
-    Object.const_set :RUBY_VERSION,    version
-    Object.const_set :RUBY_PATCHLEVEL, patchlevel if patchlevel
-    Object.const_set :RUBY_REVISION,   revision   if revision
+    Object.const_set :RUBY_VERSION,        version
+    Object.const_set :RUBY_PATCHLEVEL,     patchlevel
+    Object.const_set :RUBY_REVISION,       revision
+    Object.const_set :RUBY_DESCRIPTION,    description
+    Object.const_set :RUBY_ENGINE,         engine
+    Object.const_set :RUBY_ENGINE_VERSION, engine_version if engine_version
   end
 
   def util_restore_RUBY_VERSION
-    Object.send :remove_const, :RUBY_VERSION
-    Object.send :remove_const, :RUBY_PATCHLEVEL if defined?(RUBY_PATCHLEVEL)
-    Object.send :remove_const, :RUBY_REVISION   if defined?(RUBY_REVISION)
+    util_clear_RUBY_VERSION
 
-    Object.const_set :RUBY_VERSION,    @RUBY_VERSION
-    Object.const_set :RUBY_PATCHLEVEL, @RUBY_PATCHLEVEL if
+    Object.const_set :RUBY_VERSION,        @RUBY_VERSION
+    Object.const_set :RUBY_PATCHLEVEL,     @RUBY_PATCHLEVEL  if
       defined?(@RUBY_PATCHLEVEL)
-    Object.const_set :RUBY_REVISION,   @RUBY_REVISION   if
+    Object.const_set :RUBY_REVISION,       @RUBY_REVISION    if
       defined?(@RUBY_REVISION)
+    Object.const_set :RUBY_DESCRIPTION,    @RUBY_DESCRIPTION
+    Object.const_set :RUBY_ENGINE,         @RUBY_ENGINE
+    Object.const_set :RUBY_ENGINE_VERSION, @RUBY_ENGINE_VERSION if
+      defined?(@RUBY_ENGINE_VERSION)
+  end
+
+  def util_clear_RUBY_VERSION
+    Object.send :remove_const, :RUBY_VERSION
+    Object.send :remove_const, :RUBY_PATCHLEVEL     if defined?(RUBY_PATCHLEVEL)
+    Object.send :remove_const, :RUBY_REVISION       if defined?(RUBY_REVISION)
+    Object.send :remove_const, :RUBY_DESCRIPTION    if defined?(RUBY_DESCRIPTION)
+    Object.send :remove_const, :RUBY_ENGINE
+    Object.send :remove_const, :RUBY_ENGINE_VERSION if defined?(RUBY_ENGINE_VERSION)
   end
 
   ##
@@ -1106,12 +1150,26 @@ Also, a list:
     Gem.win_platform?
   end
 
+  ##
+  # Is this test being run on a Java platform?
+
+  def self.java_platform?
+    Gem.java_platform?
+  end
+
+  ##
+  # Is this test being run on a Java platform?
+
+  def java_platform?
+    Gem.java_platform?
+  end
+
   ##
   # Returns whether or not we're on a version of Ruby built with VC++ (or
   # Borland) versus Cygwin, Mingw, etc.
 
   def self.vc_windows?
-    RUBY_PLATFORM.match('mswin')
+    RUBY_PLATFORM.match("mswin")
   end
 
   ##
@@ -1119,7 +1177,29 @@ Also, a list:
   # Borland) versus Cygwin, Mingw, etc.
 
   def vc_windows?
-    RUBY_PLATFORM.match('mswin')
+    RUBY_PLATFORM.match("mswin")
+  end
+
+  ##
+  # Is this test being run on a version of Ruby built with mingw?
+
+  def self.mingw_windows?
+    RUBY_PLATFORM.match("mingw")
+  end
+
+  ##
+  # Is this test being run on a version of Ruby built with mingw?
+
+  def mingw_windows?
+    RUBY_PLATFORM.match("mingw")
+  end
+
+  ##
+  # Is this test being run on a ruby/ruby repository?
+  #
+
+  def ruby_repo?
+    !ENV["GEM_COMMAND"].nil?
   end
 
   ##
@@ -1128,7 +1208,7 @@ Also, a list:
   # other platforms, including Cygwin, it will return 'make'.
 
   def self.make_command
-    ENV["make"] || ENV["MAKE"] || (vc_windows? ? 'nmake' : 'make')
+    ENV["make"] || ENV["MAKE"] || (vc_windows? ? "nmake" : "make")
   end
 
   ##
@@ -1137,14 +1217,14 @@ Also, a list:
   # other platforms, including Cygwin, it will return 'make'.
 
   def make_command
-    ENV["make"] || ENV["MAKE"] || (vc_windows? ? 'nmake' : 'make')
+    ENV["make"] || ENV["MAKE"] || (vc_windows? ? "nmake" : "make")
   end
 
   ##
   # Returns whether or not the nmake command could be found.
 
   def nmake_found?
-    system('nmake /? 1>NUL 2>&1')
+    system("nmake /? 1>NUL 2>&1")
   end
 
   # In case we're building docs in a background process, this method waits for
@@ -1176,7 +1256,7 @@ Also, a list:
 
   def build_rake_in(good=true)
     gem_ruby = Gem.ruby
-    Gem.ruby = @@ruby
+    Gem.ruby = self.class.rubybin
     env_rake = ENV["rake"]
     rake = (good ? @@good_rake : @@bad_rake)
     ENV["rake"] = rake
@@ -1197,36 +1277,89 @@ Also, a list:
     ruby = ENV["RUBY"]
     return ruby if ruby
     ruby = "ruby"
-    rubyexe = "#{ruby}.exe"
+    rubyexe = "#{ruby}#{RbConfig::CONFIG["EXEEXT"]}"
 
     3.times do
-      if File.exist? ruby and File.executable? ruby and !File.directory? ruby
+      if File.exist?(ruby) && File.executable?(ruby) && !File.directory?(ruby)
         return File.expand_path(ruby)
       end
-      if File.exist? rubyexe and File.executable? rubyexe
+      if File.exist?(rubyexe) && File.executable?(rubyexe)
         return File.expand_path(rubyexe)
       end
       ruby = File.join("..", ruby)
     end
 
     begin
-      require "rbconfig"
-      File.join(RbConfig::CONFIG["bindir"],
-                RbConfig::CONFIG["ruby_install_name"] +
-                RbConfig::CONFIG["EXEEXT"])
+      Gem.ruby
     rescue LoadError
       "ruby"
     end
   end
 
-  @@ruby = rubybin
-  @@good_rake = "#{rubybin} \"#{File.expand_path('../../../test/rubygems/good_rake.rb', __FILE__)}\""
-  @@bad_rake = "#{rubybin} \"#{File.expand_path('../../../test/rubygems/bad_rake.rb', __FILE__)}\""
+  def ruby_with_rubygems_in_load_path
+    [Gem.ruby, "-I", rubygems_path]
+  end
+
+  def rubygems_path
+    $LOAD_PATH.find {|p| p == File.dirname($LOADED_FEATURES.find {|f| f.end_with?("/rubygems.rb") }) }
+  end
+
+  def bundler_path
+    $LOAD_PATH.find {|p| p == File.dirname($LOADED_FEATURES.find {|f| f.end_with?("/bundler.rb") }) }
+  end
+
+  def with_clean_path_to_ruby
+    orig_ruby = Gem.ruby
+
+    Gem.instance_variable_set :@ruby, nil
+
+    yield
+  ensure
+    Gem.instance_variable_set :@ruby, orig_ruby
+  end
+
+  def with_internal_encoding(encoding)
+    int_enc = Encoding.default_internal
+    silence_warnings { Encoding.default_internal = encoding }
+
+    yield
+  ensure
+    silence_warnings { Encoding.default_internal = int_enc }
+  end
+
+  def silence_warnings
+    old_verbose = $VERBOSE
+    $VERBOSE = false
+    yield
+  ensure
+    $VERBOSE = old_verbose
+  end
+
+  class << self
+    # :nodoc:
+    ##
+    # Return the join path, with escaping backticks, dollars, and
+    # double-quotes.  Unlike `shellescape`, equal-sign is not escaped.
+
+    private
+
+    def escape_path(*path)
+      path = File.join(*path)
+      if %r{\A[-+:/=@,.\w]+\z}.match?(path)
+        path
+      else
+        "\"#{path.gsub(/[`$"]/, '\\&')}\""
+      end
+    end
+  end
+
+  @@good_rake = "#{rubybin} #{escape_path(__dir__, "good_rake.rb")}"
+  @@bad_rake = "#{rubybin} #{escape_path(__dir__, "bad_rake.rb")}"
 
   ##
   # Construct a new Gem::Dependency.
 
-  def dep name, *requirements
+  def dep(name, *requirements)
     Gem::Dependency.new name, *requirements
   end
 
@@ -1235,10 +1368,10 @@ Also, a list:
   # Gem::Dependency +dep+, a +from_name+ and +from_version+ requesting the
   # dependency and a +parent+ DependencyRequest
 
-  def dependency_request dep, from_name, from_version, parent = nil
+  def dependency_request(dep, from_name, from_version, parent = nil)
     remote = Gem::Source.new @uri
 
-    unless parent then
+    unless parent
       parent_dep = dep from_name, from_version
       parent = Gem::Resolver::DependencyRequest.new parent_dep, nil
     end
@@ -1253,7 +1386,7 @@ Also, a list:
   ##
   # Constructs a new Gem::Requirement.
 
-  def req *requirements
+  def req(*requirements)
     return requirements.first if Gem::Requirement === requirements.first
     Gem::Requirement.create requirements
   end
@@ -1261,7 +1394,7 @@ Also, a list:
   ##
   # Constructs a new Gem::Specification.
 
-  def spec name, version, &block
+  def spec(name, version, &block)
     Gem::Specification.new name, v(version), &block
   end
 
@@ -1285,7 +1418,7 @@ Also, a list:
   #     end
   #   end
 
-  def spec_fetcher repository = @gem_repo
+  def spec_fetcher(repository = @gem_repo)
     Gem::TestCase::SpecFetcherSetup.declare self, repository do |spec_fetcher_setup|
       yield spec_fetcher_setup if block_given?
     end
@@ -1294,7 +1427,7 @@ Also, a list:
   ##
   # Construct a new Gem::Version.
 
-  def v string
+  def v(string)
     Gem::Version.create string
   end
 
@@ -1304,8 +1437,8 @@ Also, a list:
   #
   # Yields the +specification+ to the block, if given
 
-  def vendor_gem name = 'a', version = 1
-    directory = File.join 'vendor', name
+  def vendor_gem(name = "a", version = 1)
+    directory = File.join "vendor", name
 
     FileUtils.mkdir_p directory
 
@@ -1313,21 +1446,21 @@ Also, a list:
   end
 
   ##
-  # create_gemspec creates gem specification in given +direcotry+ or '.'
+  # create_gemspec creates gem specification in given +directory+ or '.'
   # for the given +name+ and +version+.
   #
   # Yields the +specification+ to the block, if given
 
-  def save_gemspec name = 'a', version = 1, directory = '.'
+  def save_gemspec(name = "a", version = 1, directory = ".")
     vendor_spec = Gem::Specification.new name, version do |specification|
       yield specification if block_given?
     end
 
-    open File.join(directory, "#{name}.gemspec"), 'w' do |io|
+    File.open File.join(directory, "#{name}.gemspec"), "w" do |io|
       io.write vendor_spec.to_ruby
     end
 
-    return name, vendor_spec.version, directory
+    [name, vendor_spec.version, directory]
   end
 
   ##
@@ -1335,7 +1468,6 @@ Also, a list:
   # It is available by requiring Gem::TestCase.
 
   class StaticSet < Gem::Resolver::Set
-
     ##
     # A StaticSet ignores remote because it has a fixed set of gems.
 
@@ -1355,7 +1487,7 @@ Also, a list:
     ##
     # Adds +spec+ to this set.
 
-    def add spec
+    def add(spec)
       @specs << spec
     end
 
@@ -1372,14 +1504,14 @@ Also, a list:
     # Finds all gems matching +dep+ in this set.
 
     def find_all(dep)
-      @specs.find_all { |s| dep.match? s, @prerelease }
+      @specs.find_all {|s| dep.match? s, @prerelease }
     end
 
     ##
     # Loads a Gem::Specification from this set which has the given +name+,
     # version +ver+, +platform+.  The +source+ is ignored.
 
-    def load_spec name, ver, platform, source
+    def load_spec(name, ver, platform, source)
       dep = Gem::Dependency.new name, ver
       spec = find_spec dep
 
@@ -1388,14 +1520,14 @@ Also, a list:
       end
     end
 
-    def prefetch reqs # :nodoc:
+    def prefetch(reqs) # :nodoc:
     end
   end
 
   ##
   # Loads certificate named +cert_name+ from <tt>test/rubygems/</tt>.
 
-  def self.load_cert cert_name
+  def self.load_cert(cert_name)
     cert_file = cert_path cert_name
 
     cert = File.read cert_file
@@ -1407,90 +1539,111 @@ Also, a list:
   # Returns the path to the certificate named +cert_name+ from
   # <tt>test/rubygems/</tt>.
 
-  def self.cert_path cert_name
-    if 32 == (Time.at(2**32) rescue 32) then
-      cert_file =
-        File.expand_path "../../../test/rubygems/#{cert_name}_cert_32.pem",
-                         __FILE__
+  def self.cert_path(cert_name)
+    if 32 == begin
+               Time.at(2**32)
+             rescue StandardError
+               32
+             end
+      cert_file = "#{__dir__}/#{cert_name}_cert_32.pem"
 
       return cert_file if File.exist? cert_file
     end
 
-    File.expand_path "../../../test/rubygems/#{cert_name}_cert.pem", __FILE__
+    "#{__dir__}/#{cert_name}_cert.pem"
   end
 
   ##
-  # Loads an RSA private key named +key_name+ with +passphrase+ in <tt>test/rubygems/</tt>
+  # Loads a private key named +key_name+ with +passphrase+ in <tt>test/rubygems/</tt>
 
-  def self.load_key key_name, passphrase = nil
+  def self.load_key(key_name, passphrase = nil)
     key_file = key_path key_name
 
     key = File.read key_file
 
-    OpenSSL::PKey::RSA.new key, passphrase
+    OpenSSL::PKey.read key, passphrase
   end
 
   ##
   # Returns the path to the key named +key_name+ from <tt>test/rubygems</tt>
 
-  def self.key_path key_name
-    File.expand_path "../../../test/rubygems/#{key_name}_key.pem", __FILE__
+  def self.key_path(key_name)
+    "#{__dir__}/#{key_name}_key.pem"
   end
 
   # :stopdoc:
   # only available in RubyGems tests
 
-  PRIVATE_KEY_PASSPHRASE      = 'Foo bar'
+  PRIVATE_KEY_PASSPHRASE = "Foo bar"
 
   begin
-    PRIVATE_KEY                 = load_key 'private'
-    PRIVATE_KEY_PATH            = key_path 'private'
+    PRIVATE_KEY                 = load_key "private"
+    PRIVATE_KEY_PATH            = key_path "private"
 
     # ENCRYPTED_PRIVATE_KEY is PRIVATE_KEY encrypted with PRIVATE_KEY_PASSPHRASE
-    ENCRYPTED_PRIVATE_KEY       = load_key 'encrypted_private', PRIVATE_KEY_PASSPHRASE
-    ENCRYPTED_PRIVATE_KEY_PATH  = key_path 'encrypted_private'
+    ENCRYPTED_PRIVATE_KEY       = load_key "encrypted_private", PRIVATE_KEY_PASSPHRASE
+    ENCRYPTED_PRIVATE_KEY_PATH  = key_path "encrypted_private"
 
     PUBLIC_KEY                  = PRIVATE_KEY.public_key
 
-    PUBLIC_CERT                 = load_cert 'public'
-    PUBLIC_CERT_PATH            = cert_path 'public'
+    PUBLIC_CERT                 = load_cert "public"
+    PUBLIC_CERT_PATH            = cert_path "public"
   rescue Errno::ENOENT
     PRIVATE_KEY = nil
     PUBLIC_KEY  = nil
     PUBLIC_CERT = nil
-  end if defined?(OpenSSL::SSL)
+  end if Gem::HAVE_OPENSSL
 
-end
+  private
 
-# require dependencies that are not discoverable once GEM_HOME and GEM_PATH
-# are wiped
-begin
-  gem 'rake'
-rescue Gem::LoadError
-end
+  def restore_env
+    unless Gem.win_platform?
+      ENV.replace(@orig_env)
+      return
+    end
 
-begin
-  require 'rake/packagetask'
-rescue LoadError
-end
+    # Fallback logic for Windows below to workaround
+    # https://bugs.ruby-lang.org/issues/16798. Can be dropped once all
+    # supported rubies include the fix for that.
 
-begin
-  gem 'rdoc'
-  require 'rdoc'
-rescue LoadError, Gem::LoadError
-end
+    ENV.clear
 
-begin
-  gem 'builder'
-  require 'builder/xchar'
-rescue LoadError, Gem::LoadError
+    @orig_env.each {|k, v| ENV[k] = v }
+  end
 end
 
-require 'rubygems/test_utilities'
-tmpdirs = []
-tmpdirs << (ENV['GEM_HOME'] = Dir.mktmpdir("home"))
-tmpdirs << (ENV['GEM_PATH'] = Dir.mktmpdir("path"))
-pid = $$
-END {tmpdirs.each {|dir| Dir.rmdir(dir)} if $$ == pid}
-Gem.clear_paths
+# https://github.com/seattlerb/minitest/blob/13c48a03d84a2a87855a4de0c959f96800100357/lib/minitest/mock.rb#L192
+class Object
+  def stub(name, val_or_callable, *block_args)
+    new_name = "__minitest_stub__#{name}"
+
+    metaclass = class << self; self; end
+
+    if respond_to?(name) && !methods.map(&:to_s).include?(name.to_s)
+      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, &blk|
+      if val_or_callable.respond_to? :call
+        val_or_callable.call(*args, &blk)
+      else
+        blk&.call(*block_args)
+        val_or_callable
+      end
+    end
+
+    metaclass.send(:ruby2_keywords, name) if metaclass.respond_to?(:ruby2_keywords, true)
+
+    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/resolv/test_dns.rb also has the same method definition
+end
 
+require_relative "utilities"