Postponing the Bundler merge.

  I faced a big issue about Bundler with ruby core.
  I have no time to resolve it issue before 2.5 final release.

git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@61416 b2dd03c8-39d4-4d8f-98ff-823fe69b080e

8 files changed, 0 insertions, 2728 deletions

diff --git a/spec/bundler/runtime/executable_spec.rb b/spec/bundler/runtime/executable_spec.rb
deleted file mode 100644
index dcee234e15..0000000000
--- a/spec/bundler/runtime/executable_spec.rb
+++ /dev/null
@@ -1,190 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe "Running bin/* commands" do
-  before :each do
-    install_gemfile! <<-G
-      source "file://#{gem_repo1}"
-      gem "rack"
-    G
-  end
-
-  it "runs the bundled command when in the bundle" do
-    bundle! "binstubs rack"
-
-    build_gem "rack", "2.0", :to_system => true do |s|
-      s.executables = "rackup"
-    end
-
-    gembin "rackup"
-    expect(out).to eq("1.0.0")
-  end
-
-  it "allows the location of the gem stubs to be specified" do
-    bundle! "binstubs rack", :path => "gbin"
-
-    expect(bundled_app("bin")).not_to exist
-    expect(bundled_app("gbin/rackup")).to exist
-
-    gembin bundled_app("gbin/rackup")
-    expect(out).to eq("1.0.0")
-  end
-
-  it "allows absolute paths as a specification of where to install bin stubs" do
-    bundle! "binstubs rack", :path => tmp("bin")
-
-    gembin tmp("bin/rackup")
-    expect(out).to eq("1.0.0")
-  end
-
-  it "uses the default ruby install name when shebang is not specified" do
-    bundle! "binstubs rack"
-    expect(File.open("bin/rackup").gets).to eq("#!/usr/bin/env #{RbConfig::CONFIG["ruby_install_name"]}\n")
-  end
-
-  it "allows the name of the shebang executable to be specified" do
-    bundle! "binstubs rack", :shebang => "ruby-foo"
-    expect(File.open("bin/rackup").gets).to eq("#!/usr/bin/env ruby-foo\n")
-  end
-
-  it "runs the bundled command when out of the bundle" do
-    bundle! "binstubs rack"
-
-    build_gem "rack", "2.0", :to_system => true do |s|
-      s.executables = "rackup"
-    end
-
-    Dir.chdir(tmp) do
-      gembin "rackup"
-      expect(out).to eq("1.0.0")
-    end
-  end
-
-  it "works with gems in path" do
-    build_lib "rack", :path => lib_path("rack") do |s|
-      s.executables = "rackup"
-    end
-
-    gemfile <<-G
-      gem "rack", :path => "#{lib_path("rack")}"
-    G
-
-    bundle! "binstubs rack"
-
-    build_gem "rack", "2.0", :to_system => true do |s|
-      s.executables = "rackup"
-    end
-
-    gembin "rackup"
-    expect(out).to eq("1.0")
-  end
-
-  it "creates a bundle binstub" do
-    build_gem "bundler", Bundler::VERSION, :to_system => true do |s|
-      s.executables = "bundle"
-    end
-
-    gemfile <<-G
-      source "file://#{gem_repo1}"
-      gem "bundler"
-    G
-
-    bundle! "binstubs bundler"
-
-    expect(bundled_app("bin/bundle")).to exist
-  end
-
-  it "does not generate bin stubs if the option was not specified" do
-    bundle! "install"
-
-    expect(bundled_app("bin/rackup")).not_to exist
-  end
-
-  it "allows you to stop installing binstubs", :bundler => "< 2" do
-    bundle! "install --binstubs bin/"
-    bundled_app("bin/rackup").rmtree
-    bundle! "install --binstubs \"\""
-
-    expect(bundled_app("bin/rackup")).not_to exist
-
-    bundle! "config bin"
-    expect(out).to include("You have not configured a value for `bin`")
-  end
-
-  it "remembers that the option was specified", :bundler => "< 2" do
-    gemfile <<-G
-      source "file://#{gem_repo1}"
-      gem "activesupport"
-    G
-
-    bundle! :install, forgotten_command_line_options([:binstubs, :bin] => "bin")
-
-    gemfile <<-G
-      source "file://#{gem_repo1}"
-      gem "activesupport"
-      gem "rack"
-    G
-
-    bundle "install"
-
-    expect(bundled_app("bin/rackup")).to exist
-  end
-
-  it "rewrites bins on --binstubs (to maintain backwards compatibility)", :bundler => "< 2" do
-    gemfile <<-G
-      source "file://#{gem_repo1}"
-      gem "rack"
-    G
-
-    bundle! :install, forgotten_command_line_options([:binstubs, :bin] => "bin")
-
-    File.open(bundled_app("bin/rackup"), "wb") do |file|
-      file.print "OMG"
-    end
-
-    bundle "install"
-
-    expect(bundled_app("bin/rackup").read).to_not eq("OMG")
-  end
-
-  it "rewrites bins on binstubs (to maintain backwards compatibility)" do
-    install_gemfile! <<-G
-      source "file://#{gem_repo1}"
-      gem "rack"
-    G
-
-    create_file("bin/rackup", "OMG")
-
-    bundle! "binstubs rack"
-
-    expect(bundled_app("bin/rackup").read).to_not eq("OMG")
-  end
-
-  it "use BUNDLE_GEMFILE gemfile for binstub" do
-    # context with bin/bunlder w/ default Gemfile
-    bundle! "binstubs bundler"
-
-    # generate other Gemfile with executable gem
-    build_repo2 do
-      build_gem("bindir") {|s| s.executables = "foo" }
-    end
-
-    create_file("OtherGemfile", <<-G)
-      source "file://#{gem_repo2}"
-      gem 'bindir'
-    G
-
-    # generate binstub for executable from non default Gemfile (other then bin/bundler version)
-    ENV["BUNDLE_GEMFILE"] = "OtherGemfile"
-    bundle "install"
-    bundle! "binstubs bindir"
-
-    # remove user settings
-    ENV["BUNDLE_GEMFILE"] = nil
-
-    # run binstub for non default Gemfile
-    gembin "foo"
-
-    expect(exitstatus).to eq(0) if exitstatus
-    expect(out).to eq("1.0")
-  end
-end
diff --git a/spec/bundler/runtime/gem_tasks_spec.rb b/spec/bundler/runtime/gem_tasks_spec.rb
deleted file mode 100644
index 1cf808f35b..0000000000
--- a/spec/bundler/runtime/gem_tasks_spec.rb
+++ /dev/null
@@ -1,44 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe "require 'bundler/gem_tasks'" do
-  before :each do
-    bundled_app("foo.gemspec").open("w") do |f|
-      f.write <<-GEMSPEC
-        Gem::Specification.new do |s|
-          s.name = "foo"
-        end
-      GEMSPEC
-    end
-    bundled_app("Rakefile").open("w") do |f|
-      f.write <<-RAKEFILE
-        $:.unshift("#{bundler_path}")
-        require "bundler/gem_tasks"
-      RAKEFILE
-    end
-  end
-
-  it "includes the relevant tasks" do
-    with_gem_path_as(Spec::Path.base_system_gems.to_s) do
-      sys_exec "#{rake} -T"
-    end
-
-    expect(err).to eq("")
-    expected_tasks = [
-      "rake build",
-      "rake clean",
-      "rake clobber",
-      "rake install",
-      "rake release[remote]",
-    ]
-    tasks = out.lines.to_a.map {|s| s.split("#").first.strip }
-    expect(tasks & expected_tasks).to eq(expected_tasks)
-    expect(exitstatus).to eq(0) if exitstatus
-  end
-
-  it "adds 'pkg' to rake/clean's CLOBBER" do
-    with_gem_path_as(Spec::Path.base_system_gems.to_s) do
-      sys_exec! %(#{rake} -e 'load "Rakefile"; puts CLOBBER.inspect')
-    end
-    expect(last_command.stdout).to eq '["pkg"]'
-  end
-end
diff --git a/spec/bundler/runtime/inline_spec.rb b/spec/bundler/runtime/inline_spec.rb
deleted file mode 100644
index 18ca246199..0000000000
--- a/spec/bundler/runtime/inline_spec.rb
+++ /dev/null
@@ -1,266 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe "bundler/inline#gemfile" do
-  def script(code, options = {})
-    requires = ["bundler/inline"]
-    requires.unshift File.expand_path("../../support/artifice/" + options.delete(:artifice) + ".rb", __FILE__) if options.key?(:artifice)
-    requires = requires.map {|r| "require '#{r}'" }.join("\n")
-    @out = ruby("#{requires}\n\n" + code, options)
-  end
-
-  before :each do
-    build_lib "one", "1.0.0" do |s|
-      s.write "lib/baz.rb", "puts 'baz'"
-      s.write "lib/qux.rb", "puts 'qux'"
-    end
-
-    build_lib "two", "1.0.0" do |s|
-      s.write "lib/two.rb", "puts 'two'"
-      s.add_dependency "three", "= 1.0.0"
-    end
-
-    build_lib "three", "1.0.0" do |s|
-      s.write "lib/three.rb", "puts 'three'"
-      s.add_dependency "seven", "= 1.0.0"
-    end
-
-    build_lib "four", "1.0.0" do |s|
-      s.write "lib/four.rb", "puts 'four'"
-    end
-
-    build_lib "five", "1.0.0", :no_default => true do |s|
-      s.write "lib/mofive.rb", "puts 'five'"
-    end
-
-    build_lib "six", "1.0.0" do |s|
-      s.write "lib/six.rb", "puts 'six'"
-    end
-
-    build_lib "seven", "1.0.0" do |s|
-      s.write "lib/seven.rb", "puts 'seven'"
-    end
-
-    build_lib "eight", "1.0.0" do |s|
-      s.write "lib/eight.rb", "puts 'eight'"
-    end
-  end
-
-  it "requires the gems" do
-    script <<-RUBY
-      gemfile do
-        path "#{lib_path}" do
-          gem "two"
-        end
-      end
-    RUBY
-
-    expect(out).to eq("two")
-    expect(exitstatus).to be_zero if exitstatus
-
-    script <<-RUBY
-      gemfile do
-        path "#{lib_path}" do
-          gem "eleven"
-        end
-      end
-
-      puts "success"
-    RUBY
-
-    expect(err).to include "Could not find gem 'eleven'"
-    expect(out).not_to include "success"
-
-    script <<-RUBY
-      gemfile(true) do
-        source "file://#{gem_repo1}"
-        gem "rack"
-      end
-    RUBY
-
-    expect(out).to include("Rack's post install message")
-    expect(exitstatus).to be_zero if exitstatus
-
-    script <<-RUBY, :artifice => "endpoint"
-      gemfile(true) do
-        source "https://notaserver.com"
-        gem "activesupport", :require => true
-      end
-    RUBY
-
-    expect(out).to include("Installing activesupport")
-    err.gsub! %r{.*lib/sinatra/base\.rb:\d+: warning: constant ::Fixnum is deprecated$}, ""
-    err.strip!
-    expect(err).to lack_errors
-    expect(exitstatus).to be_zero if exitstatus
-  end
-
-  it "lets me use my own ui object" do
-    script <<-RUBY, :artifice => "endpoint"
-      require 'bundler'
-      class MyBundlerUI < Bundler::UI::Silent
-        def confirm(msg, newline = nil)
-          puts "CONFIRMED!"
-        end
-      end
-      gemfile(true, :ui => MyBundlerUI.new) do
-        source "https://notaserver.com"
-        gem "activesupport", :require => true
-      end
-    RUBY
-
-    expect(out).to eq("CONFIRMED!\nCONFIRMED!")
-    expect(exitstatus).to be_zero if exitstatus
-  end
-
-  it "raises an exception if passed unknown arguments" do
-    script <<-RUBY
-      gemfile(true, :arglebargle => true) do
-        path "#{lib_path}"
-        gem "two"
-      end
-
-      puts "success"
-    RUBY
-    expect(err).to include "Unknown options: arglebargle"
-    expect(out).not_to include "success"
-  end
-
-  it "does not mutate the option argument" do
-    script <<-RUBY
-      require 'bundler'
-      options = { :ui => Bundler::UI::Shell.new }
-      gemfile(false, options) do
-        path "#{lib_path}" do
-          gem "two"
-        end
-      end
-      puts "OKAY" if options.key?(:ui)
-    RUBY
-
-    expect(out).to match("OKAY")
-    expect(exitstatus).to be_zero if exitstatus
-  end
-
-  it "installs quietly if necessary when the install option is not set" do
-    script <<-RUBY
-      gemfile do
-        source "file://#{gem_repo1}"
-        gem "rack"
-      end
-
-      puts RACK
-    RUBY
-
-    expect(out).to eq("1.0.0")
-    expect(err).to be_empty
-    expect(exitstatus).to be_zero if exitstatus
-  end
-
-  it "installs quietly from git if necessary when the install option is not set" do
-    build_git "foo", "1.0.0"
-    baz_ref = build_git("baz", "2.0.0").ref_for("HEAD")
-    script <<-RUBY
-      gemfile do
-        gem "foo", :git => #{lib_path("foo-1.0.0").to_s.dump}
-        gem "baz", :git => #{lib_path("baz-2.0.0").to_s.dump}, :ref => #{baz_ref.dump}
-      end
-
-      puts FOO
-      puts BAZ
-    RUBY
-
-    expect(out).to eq("1.0.0\n2.0.0")
-    expect(err).to be_empty
-    expect(exitstatus).to be_zero if exitstatus
-  end
-
-  it "allows calling gemfile twice" do
-    script <<-RUBY
-      gemfile do
-        path "#{lib_path}" do
-          gem "two"
-        end
-      end
-
-      gemfile do
-        path "#{lib_path}" do
-          gem "four"
-        end
-      end
-    RUBY
-
-    expect(out).to eq("two\nfour")
-    expect(err).to be_empty
-    expect(exitstatus).to be_zero if exitstatus
-  end
-
-  it "installs inline gems when a Gemfile.lock is present" do
-    gemfile <<-G
-      source "https://notaserver.com"
-      gem "rake"
-    G
-
-    lockfile <<-G
-      GEM
-        remote: https://rubygems.org/
-        specs:
-          rake (11.3.0)
-
-      PLATFORMS
-        ruby
-
-      DEPENDENCIES
-        rake
-
-      BUNDLED WITH
-         1.13.6
-    G
-
-    in_app_root do
-      script <<-RUBY
-        gemfile do
-          source "file://#{gem_repo1}"
-          gem "rack"
-        end
-
-        puts RACK
-      RUBY
-    end
-
-    expect(err).to be_empty
-    expect(exitstatus).to be_zero if exitstatus
-  end
-
-  it "installs inline gems when BUNDLE_GEMFILE is set to an empty string" do
-    ENV["BUNDLE_GEMFILE"] = ""
-
-    in_app_root do
-      script <<-RUBY
-        gemfile do
-          source "file://#{gem_repo1}"
-          gem "rack"
-        end
-
-        puts RACK
-      RUBY
-    end
-
-    expect(err).to be_empty
-    expect(exitstatus).to be_zero if exitstatus
-  end
-
-  it "installs inline gems when BUNDLE_BIN is set" do
-    ENV["BUNDLE_BIN"] = "/usr/local/bundle/bin"
-
-    script <<-RUBY
-      gemfile do
-        source "file://#{gem_repo1}"
-        gem "rack" # has the rackup executable
-      end
-
-      puts RACK
-    RUBY
-    expect(last_command).to be_success
-    expect(last_command.stdout).to eq "1.0.0"
-  end
-end
diff --git a/spec/bundler/runtime/load_spec.rb b/spec/bundler/runtime/load_spec.rb
deleted file mode 100644
index b74dbde3f6..0000000000
--- a/spec/bundler/runtime/load_spec.rb
+++ /dev/null
@@ -1,111 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe "Bundler.load" do
-  describe "with a gemfile" do
-    before(:each) do
-      install_gemfile! <<-G
-        source "file://#{gem_repo1}"
-        gem "rack"
-      G
-    end
-
-    it "provides a list of the env dependencies" do
-      expect(Bundler.load.dependencies).to have_dep("rack", ">= 0")
-    end
-
-    it "provides a list of the resolved gems" do
-      expect(Bundler.load.gems).to have_gem("rack-1.0.0", "bundler-#{Bundler::VERSION}")
-    end
-
-    it "ignores blank BUNDLE_GEMFILEs" do
-      expect do
-        ENV["BUNDLE_GEMFILE"] = ""
-        Bundler.load
-      end.not_to raise_error
-    end
-  end
-
-  describe "with a gems.rb file" do
-    before(:each) do
-      create_file "gems.rb", <<-G
-        source "file://#{gem_repo1}"
-        gem "rack"
-      G
-      bundle! :install
-    end
-
-    it "provides a list of the env dependencies" do
-      expect(Bundler.load.dependencies).to have_dep("rack", ">= 0")
-    end
-
-    it "provides a list of the resolved gems" do
-      expect(Bundler.load.gems).to have_gem("rack-1.0.0", "bundler-#{Bundler::VERSION}")
-    end
-  end
-
-  describe "without a gemfile" do
-    it "raises an exception if the default gemfile is not found" do
-      expect do
-        Bundler.load
-      end.to raise_error(Bundler::GemfileNotFound, /could not locate gemfile/i)
-    end
-
-    it "raises an exception if a specified gemfile is not found" do
-      expect do
-        ENV["BUNDLE_GEMFILE"] = "omg.rb"
-        Bundler.load
-      end.to raise_error(Bundler::GemfileNotFound, /omg\.rb/)
-    end
-
-    it "does not find a Gemfile above the testing directory" do
-      bundler_gemfile = tmp.join("../Gemfile")
-      unless File.exist?(bundler_gemfile)
-        FileUtils.touch(bundler_gemfile)
-        @remove_bundler_gemfile = true
-      end
-      begin
-        expect { Bundler.load }.to raise_error(Bundler::GemfileNotFound)
-      ensure
-        bundler_gemfile.rmtree if @remove_bundler_gemfile
-      end
-    end
-  end
-
-  describe "when called twice" do
-    it "doesn't try to load the runtime twice" do
-      install_gemfile! <<-G
-        source "file:#{gem_repo1}"
-        gem "rack"
-        gem "activesupport", :group => :test
-      G
-
-      ruby! <<-RUBY
-        require "bundler"
-        Bundler.setup :default
-        Bundler.require :default
-        puts RACK
-        begin
-          require "activesupport"
-        rescue LoadError
-          puts "no activesupport"
-        end
-      RUBY
-
-      expect(out.split("\n")).to eq(["1.0.0", "no activesupport"])
-    end
-  end
-
-  describe "not hurting brittle rubygems" do
-    it "does not inject #source into the generated YAML of the gem specs" do
-      install_gemfile! <<-G
-        source "file:#{gem_repo1}"
-        gem "activerecord"
-      G
-
-      Bundler.load.specs.each do |spec|
-        expect(spec.to_yaml).not_to match(/^\s+source:/)
-        expect(spec.to_yaml).not_to match(/^\s+groups:/)
-      end
-    end
-  end
-end
diff --git a/spec/bundler/runtime/platform_spec.rb b/spec/bundler/runtime/platform_spec.rb
deleted file mode 100644
index f38f733845..0000000000
--- a/spec/bundler/runtime/platform_spec.rb
+++ /dev/null
@@ -1,118 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe "Bundler.setup with multi platform stuff" do
-  it "raises a friendly error when gems are missing locally" do
-    gemfile <<-G
-      source "file://#{gem_repo1}"
-      gem "rack"
-    G
-
-    lockfile <<-G
-      GEM
-        remote: file:#{gem_repo1}/
-        specs:
-          rack (1.0)
-
-      PLATFORMS
-        #{local_tag}
-
-      DEPENDENCIES
-        rack
-    G
-
-    ruby <<-R
-      begin
-        require 'bundler'
-        Bundler.setup
-      rescue Bundler::GemNotFound => e
-        puts "WIN"
-      end
-    R
-
-    expect(out).to eq("WIN")
-  end
-
-  it "will resolve correctly on the current platform when the lockfile was targeted for a different one" do
-    lockfile <<-G
-      GEM
-        remote: file:#{gem_repo1}/
-        specs:
-          nokogiri (1.4.2-java)
-            weakling (= 0.0.3)
-          weakling (0.0.3)
-
-      PLATFORMS
-        java
-
-      DEPENDENCIES
-        nokogiri
-    G
-
-    simulate_platform "x86-darwin-10"
-    install_gemfile! <<-G
-      source "file://#{gem_repo1}"
-      gem "nokogiri"
-    G
-
-    expect(the_bundle).to include_gems "nokogiri 1.4.2"
-  end
-
-  it "will add the resolve for the current platform" do
-    lockfile <<-G
-      GEM
-        remote: file:#{gem_repo1}/
-        specs:
-          nokogiri (1.4.2-java)
-            weakling (= 0.0.3)
-          weakling (0.0.3)
-
-      PLATFORMS
-        java
-
-      DEPENDENCIES
-        nokogiri
-    G
-
-    simulate_platform "x86-darwin-100"
-
-    install_gemfile! <<-G
-      source "file://#{gem_repo1}"
-      gem "nokogiri"
-      gem "platform_specific"
-    G
-
-    expect(the_bundle).to include_gems "nokogiri 1.4.2", "platform_specific 1.0 x86-darwin-100"
-  end
-
-  it "allows specifying only-ruby-platform" do
-    simulate_platform "java"
-
-    install_gemfile! <<-G
-      source "file://#{gem_repo1}"
-      gem "nokogiri"
-      gem "platform_specific"
-    G
-
-    bundle! "config force_ruby_platform true"
-
-    bundle! "install"
-
-    expect(the_bundle).to include_gems "nokogiri 1.4.2", "platform_specific 1.0 RUBY"
-  end
-
-  it "allows specifying only-ruby-platform on windows with dependency platforms" do
-    simulate_windows do
-      install_gemfile! <<-G
-        source "file://#{gem_repo1}"
-        gem "nokogiri", :platforms => [:mingw, :mswin, :x64_mingw, :jruby]
-        gem "platform_specific"
-      G
-
-      bundle! "config force_ruby_platform true"
-
-      bundle! "install"
-
-      expect(the_bundle).to include_gems "platform_specific 1.0 RUBY"
-    end
-  end
-end
diff --git a/spec/bundler/runtime/require_spec.rb b/spec/bundler/runtime/require_spec.rb
deleted file mode 100644
index 0484e38845..0000000000
--- a/spec/bundler/runtime/require_spec.rb
+++ /dev/null
@@ -1,452 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe "Bundler.require" do
-  before :each do
-    build_lib "one", "1.0.0" do |s|
-      s.write "lib/baz.rb", "puts 'baz'"
-      s.write "lib/qux.rb", "puts 'qux'"
-    end
-
-    build_lib "two", "1.0.0" do |s|
-      s.write "lib/two.rb", "puts 'two'"
-      s.add_dependency "three", "= 1.0.0"
-    end
-
-    build_lib "three", "1.0.0" do |s|
-      s.write "lib/three.rb", "puts 'three'"
-      s.add_dependency "seven", "= 1.0.0"
-    end
-
-    build_lib "four", "1.0.0" do |s|
-      s.write "lib/four.rb", "puts 'four'"
-    end
-
-    build_lib "five", "1.0.0", :no_default => true do |s|
-      s.write "lib/mofive.rb", "puts 'five'"
-    end
-
-    build_lib "six", "1.0.0" do |s|
-      s.write "lib/six.rb", "puts 'six'"
-    end
-
-    build_lib "seven", "1.0.0" do |s|
-      s.write "lib/seven.rb", "puts 'seven'"
-    end
-
-    build_lib "eight", "1.0.0" do |s|
-      s.write "lib/eight.rb", "puts 'eight'"
-    end
-
-    build_lib "nine", "1.0.0" do |s|
-      s.write "lib/nine.rb", "puts 'nine'"
-    end
-
-    build_lib "ten", "1.0.0" do |s|
-      s.write "lib/ten.rb", "puts 'ten'"
-    end
-
-    gemfile <<-G
-      path "#{lib_path}" do
-        gem "one", :group => :bar, :require => %w[baz qux]
-        gem "two"
-        gem "three", :group => :not
-        gem "four", :require => false
-        gem "five"
-        gem "six", :group => "string"
-        gem "seven", :group => :not
-        gem "eight", :require => true, :group => :require_true
-        env "BUNDLER_TEST" => "nine" do
-          gem "nine", :require => true
-        end
-        gem "ten", :install_if => lambda { ENV["BUNDLER_TEST"] == "ten" }
-      end
-    G
-  end
-
-  it "requires the gems" do
-    # default group
-    run "Bundler.require"
-    expect(out).to eq("two")
-
-    # specific group
-    run "Bundler.require(:bar)"
-    expect(out).to eq("baz\nqux")
-
-    # default and specific group
-    run "Bundler.require(:default, :bar)"
-    expect(out).to eq("baz\nqux\ntwo")
-
-    # specific group given as a string
-    run "Bundler.require('bar')"
-    expect(out).to eq("baz\nqux")
-
-    # specific group declared as a string
-    run "Bundler.require(:string)"
-    expect(out).to eq("six")
-
-    # required in resolver order instead of gemfile order
-    run("Bundler.require(:not)")
-    expect(out.split("\n").sort).to eq(%w[seven three])
-
-    # test require: true
-    run "Bundler.require(:require_true)"
-    expect(out).to eq("eight")
-  end
-
-  it "allows requiring gems with non standard names explicitly" do
-    run "Bundler.require ; require 'mofive'"
-    expect(out).to eq("two\nfive")
-  end
-
-  it "allows requiring gems which are scoped by env" do
-    ENV["BUNDLER_TEST"] = "nine"
-    run "Bundler.require"
-    expect(out).to eq("two\nnine")
-  end
-
-  it "allows requiring gems which are scoped by install_if" do
-    ENV["BUNDLER_TEST"] = "ten"
-    run "Bundler.require"
-    expect(out).to eq("two\nten")
-  end
-
-  it "raises an exception if a require is specified but the file does not exist" do
-    gemfile <<-G
-      path "#{lib_path}" do
-        gem "two", :require => 'fail'
-      end
-    G
-
-    load_error_run <<-R, "fail"
-      Bundler.require
-    R
-
-    expect(err).to eq_err("ZOMG LOAD ERROR")
-  end
-
-  it "displays a helpful message if the required gem throws an error" do
-    build_lib "faulty", "1.0.0" do |s|
-      s.write "lib/faulty.rb", "raise RuntimeError.new(\"Gem Internal Error Message\")"
-    end
-
-    gemfile <<-G
-      path "#{lib_path}" do
-        gem "faulty"
-      end
-    G
-
-    run "Bundler.require"
-    expect(err).to match("error while trying to load the gem 'faulty'")
-    expect(err).to match("Gem Internal Error Message")
-  end
-
-  it "doesn't swallow the error when the library has an unrelated error" do
-    build_lib "loadfuuu", "1.0.0" do |s|
-      s.write "lib/loadfuuu.rb", "raise LoadError.new(\"cannot load such file -- load-bar\")"
-    end
-
-    gemfile <<-G
-      path "#{lib_path}" do
-        gem "loadfuuu"
-      end
-    G
-
-    cmd = <<-RUBY
-      begin
-        Bundler.require
-      rescue LoadError => e
-        $stderr.puts "ZOMG LOAD ERROR: \#{e.message}"
-      end
-    RUBY
-    run(cmd)
-
-    expect(err).to eq_err("ZOMG LOAD ERROR: cannot load such file -- load-bar")
-  end
-
-  describe "with namespaced gems" do
-    before :each do
-      build_lib "jquery-rails", "1.0.0" do |s|
-        s.write "lib/jquery/rails.rb", "puts 'jquery/rails'"
-      end
-      lib_path("jquery-rails-1.0.0/lib/jquery-rails.rb").rmtree
-    end
-
-    it "requires gem names that are namespaced" do
-      gemfile <<-G
-        path '#{lib_path}' do
-          gem 'jquery-rails'
-        end
-      G
-
-      run "Bundler.require"
-      expect(out).to eq("jquery/rails")
-    end
-
-    it "silently passes if the require fails" do
-      build_lib "bcrypt-ruby", "1.0.0", :no_default => true do |s|
-        s.write "lib/brcrypt.rb", "BCrypt = '1.0.0'"
-      end
-      gemfile <<-G
-        path "#{lib_path}" do
-          gem "bcrypt-ruby"
-        end
-      G
-
-      cmd = <<-RUBY
-        require 'bundler'
-        Bundler.require
-      RUBY
-      ruby(cmd)
-
-      expect(err).to lack_errors
-    end
-
-    it "does not mangle explicitly given requires" do
-      gemfile <<-G
-        path "#{lib_path}" do
-          gem 'jquery-rails', :require => 'jquery-rails'
-        end
-      G
-
-      load_error_run <<-R, "jquery-rails"
-        Bundler.require
-      R
-      expect(err).to eq_err("ZOMG LOAD ERROR")
-    end
-
-    it "handles the case where regex fails" do
-      build_lib "load-fuuu", "1.0.0" do |s|
-        s.write "lib/load-fuuu.rb", "raise LoadError.new(\"Could not open library 'libfuuu-1.0': libfuuu-1.0: cannot open shared object file: No such file or directory.\")"
-      end
-
-      gemfile <<-G
-        path "#{lib_path}" do
-          gem "load-fuuu"
-        end
-      G
-
-      cmd = <<-RUBY
-        begin
-          Bundler.require
-        rescue LoadError => e
-          $stderr.puts "ZOMG LOAD ERROR" if e.message.include?("Could not open library 'libfuuu-1.0'")
-        end
-      RUBY
-      run(cmd)
-
-      expect(err).to eq_err("ZOMG LOAD ERROR")
-    end
-
-    it "doesn't swallow the error when the library has an unrelated error" do
-      build_lib "load-fuuu", "1.0.0" do |s|
-        s.write "lib/load/fuuu.rb", "raise LoadError.new(\"cannot load such file -- load-bar\")"
-      end
-      lib_path("load-fuuu-1.0.0/lib/load-fuuu.rb").rmtree
-
-      gemfile <<-G
-        path "#{lib_path}" do
-          gem "load-fuuu"
-        end
-      G
-
-      cmd = <<-RUBY
-        begin
-          Bundler.require
-        rescue LoadError => e
-          $stderr.puts "ZOMG LOAD ERROR: \#{e.message}"
-        end
-      RUBY
-      run(cmd)
-
-      expect(err).to eq_err("ZOMG LOAD ERROR: cannot load such file -- load-bar")
-    end
-  end
-
-  describe "using bundle exec" do
-    it "requires the locked gems" do
-      bundle "exec ruby -e 'Bundler.require'", :env => { :RUBYOPT => "-r#{spec_dir.join("support/hax")}" }
-      expect(out).to eq("two")
-
-      bundle "exec ruby -e 'Bundler.require(:bar)'", :env => { :RUBYOPT => "-r#{spec_dir.join("support/hax")}" }
-      expect(out).to eq("baz\nqux")
-
-      bundle "exec ruby -e 'Bundler.require(:default, :bar)'", :env => { :RUBYOPT => "-r#{spec_dir.join("support/hax")}" }
-      expect(out).to eq("baz\nqux\ntwo")
-    end
-  end
-
-  describe "order" do
-    before(:each) do
-      build_lib "one", "1.0.0" do |s|
-        s.write "lib/one.rb", <<-ONE
-          if defined?(Two)
-            Two.two
-          else
-            puts "two_not_loaded"
-          end
-          puts 'one'
-        ONE
-      end
-
-      build_lib "two", "1.0.0" do |s|
-        s.write "lib/two.rb", <<-TWO
-          module Two
-            def self.two
-              puts 'module_two'
-            end
-          end
-          puts 'two'
-        TWO
-      end
-    end
-
-    it "works when the gems are in the Gemfile in the correct order" do
-      gemfile <<-G
-        path "#{lib_path}" do
-          gem "two"
-          gem "one"
-        end
-      G
-
-      run "Bundler.require"
-      expect(out).to eq("two\nmodule_two\none")
-    end
-
-    describe "a gem with different requires for different envs" do
-      before(:each) do
-        build_gem "multi_gem", :to_bundle => true do |s|
-          s.write "lib/one.rb", "puts 'ONE'"
-          s.write "lib/two.rb", "puts 'TWO'"
-        end
-
-        install_gemfile <<-G
-          gem "multi_gem", :require => "one", :group => :one
-          gem "multi_gem", :require => "two", :group => :two
-        G
-      end
-
-      it "requires both with Bundler.require(both)" do
-        run "Bundler.require(:one, :two)"
-        expect(out).to eq("ONE\nTWO")
-      end
-
-      it "requires one with Bundler.require(:one)" do
-        run "Bundler.require(:one)"
-        expect(out).to eq("ONE")
-      end
-
-      it "requires :two with Bundler.require(:two)" do
-        run "Bundler.require(:two)"
-        expect(out).to eq("TWO")
-      end
-    end
-
-    it "fails when the gems are in the Gemfile in the wrong order" do
-      gemfile <<-G
-        path "#{lib_path}" do
-          gem "one"
-          gem "two"
-        end
-      G
-
-      run "Bundler.require"
-      expect(out).to eq("two_not_loaded\none\ntwo")
-    end
-
-    describe "with busted gems" do
-      it "should be busted" do
-        build_gem "busted_require", :to_bundle => true do |s|
-          s.write "lib/busted_require.rb", "require 'no_such_file_omg'"
-        end
-
-        install_gemfile <<-G
-          gem "busted_require"
-        G
-
-        load_error_run <<-R, "no_such_file_omg"
-          Bundler.require
-        R
-        expect(err).to eq_err("ZOMG LOAD ERROR")
-      end
-    end
-  end
-
-  it "does not load rubygems gemspecs that are used", :rubygems => ">= 2.5.2" do
-    install_gemfile! <<-G
-      source "file://#{gem_repo1}"
-      gem "rack"
-    G
-
-    run! <<-R
-      path = File.join(Gem.dir, "specifications", "rack-1.0.0.gemspec")
-      contents = File.read(path)
-      contents = contents.lines.to_a.insert(-2, "\n  raise 'broken gemspec'\n").join
-      File.open(path, "w") do |f|
-        f.write contents
-      end
-    R
-
-    run! <<-R
-      Bundler.require
-      puts "WIN"
-    R
-
-    expect(out).to eq("WIN")
-  end
-
-  it "does not load git gemspecs that are used", :rubygems => ">= 2.5.2" do
-    build_git "foo"
-
-    install_gemfile! <<-G
-      gem "foo", :git => "#{lib_path("foo-1.0")}"
-    G
-
-    run! <<-R
-      path = Gem.loaded_specs["foo"].loaded_from
-      contents = File.read(path)
-      contents = contents.lines.to_a.insert(-2, "\n  raise 'broken gemspec'\n").join
-      File.open(path, "w") do |f|
-        f.write contents
-      end
-    R
-
-    run! <<-R
-      Bundler.require
-      puts "WIN"
-    R
-
-    expect(out).to eq("WIN")
-  end
-end
-
-RSpec.describe "Bundler.require with platform specific dependencies" do
-  it "does not require the gems that are pinned to other platforms" do
-    install_gemfile <<-G
-      source "file://#{gem_repo1}"
-
-      platforms :#{not_local_tag} do
-        gem "fail", :require => "omgomg"
-      end
-
-      gem "rack", "1.0.0"
-    G
-
-    run "Bundler.require"
-    expect(err).to lack_errors
-  end
-
-  it "requires gems pinned to multiple platforms, including the current one" do
-    install_gemfile <<-G
-      source "file://#{gem_repo1}"
-
-      platforms :#{not_local_tag}, :#{local_tag} do
-        gem "rack", :require => "rack"
-      end
-    G
-
-    run "Bundler.require; puts RACK"
-
-    expect(out).to eq("1.0.0")
-    expect(err).to lack_errors
-  end
-end
diff --git a/spec/bundler/runtime/setup_spec.rb b/spec/bundler/runtime/setup_spec.rb
deleted file mode 100644
index 97d2ea1918..0000000000
--- a/spec/bundler/runtime/setup_spec.rb
+++ /dev/null
@@ -1,1396 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe "Bundler.setup" do
-  describe "with no arguments" do
-    it "makes all groups available" do
-      install_gemfile <<-G
-        source "file://#{gem_repo1}"
-        gem "rack", :group => :test
-      G
-
-      ruby <<-RUBY
-        require 'rubygems'
-        require 'bundler'
-        Bundler.setup
-
-        require 'rack'
-        puts RACK
-      RUBY
-      expect(err).to lack_errors
-      expect(out).to eq("1.0.0")
-    end
-  end
-
-  describe "when called with groups" do
-    before(:each) do
-      install_gemfile <<-G
-        source "file://#{gem_repo1}"
-        gem "yard"
-        gem "rack", :group => :test
-      G
-    end
-
-    it "doesn't make all groups available" do
-      ruby <<-RUBY
-        require 'rubygems'
-        require 'bundler'
-        Bundler.setup(:default)
-
-        begin
-          require 'rack'
-        rescue LoadError
-          puts "WIN"
-        end
-      RUBY
-      expect(err).to lack_errors
-      expect(out).to eq("WIN")
-    end
-
-    it "accepts string for group name" do
-      ruby <<-RUBY
-        require 'rubygems'
-        require 'bundler'
-        Bundler.setup(:default, 'test')
-
-        require 'rack'
-        puts RACK
-      RUBY
-      expect(err).to lack_errors
-      expect(out).to eq("1.0.0")
-    end
-
-    it "leaves all groups available if they were already" do
-      ruby <<-RUBY
-        require 'rubygems'
-        require 'bundler'
-        Bundler.setup
-        Bundler.setup(:default)
-
-        require 'rack'
-        puts RACK
-      RUBY
-      expect(err).to lack_errors
-      expect(out).to eq("1.0.0")
-    end
-
-    it "leaves :default available if setup is called twice" do
-      ruby <<-RUBY
-        require 'rubygems'
-        require 'bundler'
-        Bundler.setup(:default)
-        Bundler.setup(:default, :test)
-
-        begin
-          require 'yard'
-          puts "WIN"
-        rescue LoadError
-          puts "FAIL"
-        end
-      RUBY
-      expect(err).to lack_errors
-      expect(out).to match("WIN")
-    end
-
-    it "handles multiple non-additive invocations" do
-      ruby <<-RUBY
-        require 'bundler'
-        Bundler.setup(:default, :test)
-        Bundler.setup(:default)
-        require 'rack'
-
-        puts "FAIL"
-      RUBY
-
-      expect(err).to match("rack")
-      expect(err).to match("LoadError")
-      expect(out).not_to match("FAIL")
-    end
-  end
-
-  context "load order" do
-    def clean_load_path(lp)
-      without_bundler_load_path = ruby!("puts $LOAD_PATH").split("\n")
-      lp = lp - [
-        bundler_path.to_s,
-        bundler_path.join("gems/bundler-#{Bundler::VERSION}/lib").to_s,
-        tmp("rubygems/lib").to_s,
-        root.join("../lib").expand_path.to_s,
-      ] - without_bundler_load_path
-      lp.map! {|p| p.sub(/^#{Regexp.union system_gem_path.to_s, default_bundle_path.to_s}/i, "") }
-    end
-
-    it "puts loaded gems after -I and RUBYLIB", :ruby_repo do
-      install_gemfile <<-G
-        source "file://#{gem_repo1}"
-        gem "rack"
-      G
-
-      ENV["RUBYOPT"] = "-Idash_i_dir"
-      ENV["RUBYLIB"] = "rubylib_dir"
-
-      ruby <<-RUBY
-        require 'rubygems'
-        require 'bundler'
-        Bundler.setup
-        puts $LOAD_PATH
-      RUBY
-
-      load_path = out.split("\n")
-      rack_load_order = load_path.index {|path| path.include?("rack") }
-
-      expect(err).to eq("")
-      expect(load_path[1]).to include "dash_i_dir"
-      expect(load_path[2]).to include "rubylib_dir"
-      expect(rack_load_order).to be > 0
-    end
-
-    it "orders the load path correctly when there are dependencies", :ruby_repo do
-      install_gemfile <<-G
-        source "file://#{gem_repo1}"
-        gem "rails"
-      G
-
-      ruby! <<-RUBY
-        require 'rubygems'
-        require 'bundler'
-        Bundler.setup
-        puts $LOAD_PATH
-      RUBY
-
-      load_path = clean_load_path(out.split("\n"))
-
-      expect(load_path).to start_with(
-        "/gems/rails-2.3.2/lib",
-        "/gems/activeresource-2.3.2/lib",
-        "/gems/activerecord-2.3.2/lib",
-        "/gems/actionpack-2.3.2/lib",
-        "/gems/actionmailer-2.3.2/lib",
-        "/gems/activesupport-2.3.2/lib",
-        "/gems/rake-10.0.2/lib"
-      )
-    end
-
-    it "falls back to order the load path alphabetically for backwards compatibility" do
-      install_gemfile! <<-G
-        source "file://#{gem_repo1}"
-        gem "weakling"
-        gem "duradura"
-        gem "terranova"
-      G
-
-      ruby! <<-RUBY
-        require 'rubygems'
-        require 'bundler/setup'
-        puts $LOAD_PATH
-      RUBY
-
-      load_path = clean_load_path(out.split("\n"))
-
-      expect(load_path).to start_with(
-        "/gems/weakling-0.0.3/lib",
-        "/gems/terranova-8/lib",
-        "/gems/duradura-7.0/lib"
-      )
-    end
-  end
-
-  it "raises if the Gemfile was not yet installed" do
-    gemfile <<-G
-      source "file://#{gem_repo1}"
-      gem "rack"
-    G
-
-    ruby <<-R
-      require 'rubygems'
-      require 'bundler'
-
-      begin
-        Bundler.setup
-        puts "FAIL"
-      rescue Bundler::GemNotFound
-        puts "WIN"
-      end
-    R
-
-    expect(out).to eq("WIN")
-  end
-
-  it "doesn't create a Gemfile.lock if the setup fails" do
-    gemfile <<-G
-      source "file://#{gem_repo1}"
-      gem "rack"
-    G
-
-    ruby <<-R
-      require 'rubygems'
-      require 'bundler'
-
-      Bundler.setup
-    R
-
-    expect(bundled_app("Gemfile.lock")).not_to exist
-  end
-
-  it "doesn't change the Gemfile.lock if the setup fails" do
-    install_gemfile <<-G
-      source "file://#{gem_repo1}"
-      gem "rack"
-    G
-
-    lockfile = File.read(bundled_app("Gemfile.lock"))
-
-    gemfile <<-G
-      source "file://#{gem_repo1}"
-      gem "rack"
-      gem "nosuchgem", "10.0"
-    G
-
-    ruby <<-R
-      require 'rubygems'
-      require 'bundler'
-
-      Bundler.setup
-    R
-
-    expect(File.read(bundled_app("Gemfile.lock"))).to eq(lockfile)
-  end
-
-  it "makes a Gemfile.lock if setup succeeds" do
-    install_gemfile <<-G
-      source "file://#{gem_repo1}"
-      gem "rack"
-    G
-
-    File.read(bundled_app("Gemfile.lock"))
-
-    FileUtils.rm(bundled_app("Gemfile.lock"))
-
-    run "1"
-    expect(bundled_app("Gemfile.lock")).to exist
-  end
-
-  describe "$BUNDLE_GEMFILE" do
-    context "user provides an absolute path" do
-      it "uses BUNDLE_GEMFILE to locate the gemfile if present" do
-        gemfile <<-G
-          source "file://#{gem_repo1}"
-          gem "rack"
-        G
-
-        gemfile bundled_app("4realz"), <<-G
-          source "file://#{gem_repo1}"
-          gem "activesupport", "2.3.5"
-        G
-
-        ENV["BUNDLE_GEMFILE"] = bundled_app("4realz").to_s
-        bundle :install
-
-        expect(the_bundle).to include_gems "activesupport 2.3.5"
-      end
-    end
-
-    context "an absolute path is not provided" do
-      it "uses BUNDLE_GEMFILE to locate the gemfile if present" do
-        gemfile <<-G
-          source "file://#{gem_repo1}"
-        G
-
-        bundle "install"
-        bundle "install --deployment"
-
-        ENV["BUNDLE_GEMFILE"] = "Gemfile"
-        ruby <<-R
-          require 'rubygems'
-          require 'bundler'
-
-          begin
-            Bundler.setup
-            puts "WIN"
-          rescue ArgumentError => e
-            puts "FAIL"
-          end
-        R
-
-        expect(out).to eq("WIN")
-      end
-    end
-  end
-
-  it "prioritizes gems in BUNDLE_PATH over gems in GEM_HOME" do
-    ENV["BUNDLE_PATH"] = bundled_app(".bundle").to_s
-    install_gemfile <<-G
-      source "file://#{gem_repo1}"
-      gem "rack", "1.0.0"
-    G
-
-    build_gem "rack", "1.0", :to_system => true do |s|
-      s.write "lib/rack.rb", "RACK = 'FAIL'"
-    end
-
-    expect(the_bundle).to include_gems "rack 1.0.0"
-  end
-
-  describe "integrate with rubygems" do
-    describe "by replacing #gem" do
-      before :each do
-        install_gemfile <<-G
-          source "file://#{gem_repo1}"
-          gem "rack", "0.9.1"
-        G
-      end
-
-      it "replaces #gem but raises when the gem is missing" do
-        run <<-R
-          begin
-            gem "activesupport"
-            puts "FAIL"
-          rescue LoadError
-            puts "WIN"
-          end
-        R
-
-        expect(out).to eq("WIN")
-      end
-
-      it "version_requirement is now deprecated in rubygems 1.4.0+ when gem is missing" do
-        run <<-R
-          begin
-            gem "activesupport"
-            puts "FAIL"
-          rescue LoadError
-            puts "WIN"
-          end
-        R
-
-        expect(err).to lack_errors
-      end
-
-      it "replaces #gem but raises when the version is wrong" do
-        run <<-R
-          begin
-            gem "rack", "1.0.0"
-            puts "FAIL"
-          rescue LoadError
-            puts "WIN"
-          end
-        R
-
-        expect(out).to eq("WIN")
-      end
-
-      it "version_requirement is now deprecated in rubygems 1.4.0+ when the version is wrong" do
-        run <<-R
-          begin
-            gem "rack", "1.0.0"
-            puts "FAIL"
-          rescue LoadError
-            puts "WIN"
-          end
-        R
-
-        expect(err).to lack_errors
-      end
-    end
-
-    describe "by hiding system gems" do
-      before :each do
-        system_gems "activesupport-2.3.5"
-        install_gemfile <<-G
-          source "file://#{gem_repo1}"
-          gem "yard"
-        G
-      end
-
-      it "removes system gems from Gem.source_index" do
-        run "require 'yard'"
-        expect(out).to eq("bundler-#{Bundler::VERSION}\nyard-1.0")
-      end
-
-      context "when the ruby stdlib is a substring of Gem.path" do
-        it "does not reject the stdlib from $LOAD_PATH" do
-          substring = "/" + $LOAD_PATH.find {|p| p =~ /vendor_ruby/ }.split("/")[2]
-          run "puts 'worked!'", :env => { "GEM_PATH" => substring }
-          expect(out).to eq("worked!")
-        end
-      end
-    end
-  end
-
-  describe "with paths" do
-    it "activates the gems in the path source" do
-      system_gems "rack-1.0.0"
-
-      build_lib "rack", "1.0.0" do |s|
-        s.write "lib/rack.rb", "puts 'WIN'"
-      end
-
-      gemfile <<-G
-        source "file://#{gem_repo1}"
-        path "#{lib_path("rack-1.0.0")}" do
-          gem "rack"
-        end
-      G
-
-      run "require 'rack'"
-      expect(out).to eq("WIN")
-    end
-  end
-
-  describe "with git" do
-    before do
-      build_git "rack", "1.0.0"
-
-      gemfile <<-G
-        gem "rack", :git => "#{lib_path("rack-1.0.0")}"
-      G
-    end
-
-    it "provides a useful exception when the git repo is not checked out yet" do
-      run "1"
-      expect(err).to match(/the git source #{lib_path('rack-1.0.0')} is not yet checked out. Please run `bundle install`/i)
-    end
-
-    it "does not hit the git binary if the lockfile is available and up to date" do
-      bundle "install"
-
-      break_git!
-
-      ruby <<-R
-        require 'rubygems'
-        require 'bundler'
-
-        begin
-          Bundler.setup
-          puts "WIN"
-        rescue Exception => e
-          puts "FAIL"
-        end
-      R
-
-      expect(out).to eq("WIN")
-    end
-
-    it "provides a good exception if the lockfile is unavailable" do
-      bundle "install"
-
-      FileUtils.rm(bundled_app("Gemfile.lock"))
-
-      break_git!
-
-      ruby <<-R
-        require "rubygems"
-        require "bundler"
-
-        begin
-          Bundler.setup
-          puts "FAIL"
-        rescue Bundler::GitError => e
-          puts e.message
-        end
-      R
-
-      run "puts 'FAIL'"
-
-      expect(err).not_to include "This is not the git you are looking for"
-    end
-
-    it "works even when the cache directory has been deleted" do
-      bundle! :install, forgotten_command_line_options(:path => "vendor/bundle")
-      FileUtils.rm_rf vendored_gems("cache")
-      expect(the_bundle).to include_gems "rack 1.0.0"
-    end
-
-    it "does not randomly change the path when specifying --path and the bundle directory becomes read only" do
-      bundle! :install, forgotten_command_line_options(:path => "vendor/bundle")
-
-      with_read_only("**/*") do
-        expect(the_bundle).to include_gems "rack 1.0.0"
-      end
-    end
-
-    it "finds git gem when default bundle path becomes read only" do
-      bundle "install"
-
-      with_read_only("#{Bundler.bundle_path}/**/*") do
-        expect(the_bundle).to include_gems "rack 1.0.0"
-      end
-    end
-  end
-
-  describe "when specifying local override" do
-    it "explodes if given path does not exist on runtime" do
-      build_git "rack", "0.8"
-
-      FileUtils.cp_r("#{lib_path("rack-0.8")}/.", lib_path("local-rack"))
-
-      gemfile <<-G
-        source "file://#{gem_repo1}"
-        gem "rack", :git => "#{lib_path("rack-0.8")}", :branch => "master"
-      G
-
-      bundle %(config local.rack #{lib_path("local-rack")})
-      bundle! :install
-
-      FileUtils.rm_rf(lib_path("local-rack"))
-      run "require 'rack'"
-      expect(err).to match(/Cannot use local override for rack-0.8 because #{Regexp.escape(lib_path('local-rack').to_s)} does not exist/)
-    end
-
-    it "explodes if branch is not given on runtime" do
-      build_git "rack", "0.8"
-
-      FileUtils.cp_r("#{lib_path("rack-0.8")}/.", lib_path("local-rack"))
-
-      gemfile <<-G
-        source "file://#{gem_repo1}"
-        gem "rack", :git => "#{lib_path("rack-0.8")}", :branch => "master"
-      G
-
-      bundle %(config local.rack #{lib_path("local-rack")})
-      bundle! :install
-
-      gemfile <<-G
-        source "file://#{gem_repo1}"
-        gem "rack", :git => "#{lib_path("rack-0.8")}"
-      G
-
-      run "require 'rack'"
-      expect(err).to match(/because :branch is not specified in Gemfile/)
-    end
-
-    it "explodes on different branches on runtime" do
-      build_git "rack", "0.8"
-
-      FileUtils.cp_r("#{lib_path("rack-0.8")}/.", lib_path("local-rack"))
-
-      gemfile <<-G
-        source "file://#{gem_repo1}"
-        gem "rack", :git => "#{lib_path("rack-0.8")}", :branch => "master"
-      G
-
-      bundle %(config local.rack #{lib_path("local-rack")})
-      bundle! :install
-
-      gemfile <<-G
-        source "file://#{gem_repo1}"
-        gem "rack", :git => "#{lib_path("rack-0.8")}", :branch => "changed"
-      G
-
-      run "require 'rack'"
-      expect(err).to match(/is using branch master but Gemfile specifies changed/)
-    end
-
-    it "explodes on refs with different branches on runtime" do
-      build_git "rack", "0.8"
-
-      FileUtils.cp_r("#{lib_path("rack-0.8")}/.", lib_path("local-rack"))
-
-      install_gemfile <<-G
-        source "file://#{gem_repo1}"
-        gem "rack", :git => "#{lib_path("rack-0.8")}", :ref => "master", :branch => "master"
-      G
-
-      gemfile <<-G
-        source "file://#{gem_repo1}"
-        gem "rack", :git => "#{lib_path("rack-0.8")}", :ref => "master", :branch => "nonexistant"
-      G
-
-      bundle %(config local.rack #{lib_path("local-rack")})
-      run "require 'rack'"
-      expect(err).to match(/is using branch master but Gemfile specifies nonexistant/)
-    end
-  end
-
-  describe "when excluding groups" do
-    it "doesn't change the resolve if --without is used" do
-      install_gemfile <<-G, forgotten_command_line_options(:without => :rails)
-        source "file://#{gem_repo1}"
-        gem "activesupport"
-
-        group :rails do
-          gem "rails", "2.3.2"
-        end
-      G
-
-      install_gems "activesupport-2.3.5"
-
-      expect(the_bundle).to include_gems "activesupport 2.3.2", :groups => :default
-    end
-
-    it "remembers --without and does not bail on bare Bundler.setup" do
-      install_gemfile <<-G, forgotten_command_line_options(:without => :rails)
-        source "file://#{gem_repo1}"
-        gem "activesupport"
-
-        group :rails do
-          gem "rails", "2.3.2"
-        end
-      G
-
-      install_gems "activesupport-2.3.5"
-
-      expect(the_bundle).to include_gems "activesupport 2.3.2"
-    end
-
-    it "remembers --without and does not include groups passed to Bundler.setup" do
-      install_gemfile <<-G, forgotten_command_line_options(:without => :rails)
-        source "file://#{gem_repo1}"
-        gem "activesupport"
-
-        group :rack do
-          gem "rack"
-        end
-
-        group :rails do
-          gem "rails", "2.3.2"
-        end
-      G
-
-      expect(the_bundle).not_to include_gems "activesupport 2.3.2", :groups => :rack
-      expect(the_bundle).to include_gems "rack 1.0.0", :groups => :rack
-    end
-  end
-
-  # Unfortunately, gem_prelude does not record the information about
-  # activated gems, so this test cannot work on 1.9 :(
-  if RUBY_VERSION < "1.9"
-    describe "preactivated gems" do
-      it "raises an exception if a pre activated gem conflicts with the bundle" do
-        system_gems "thin-1.0", "rack-1.0.0"
-        build_gem "thin", "1.1", :to_system => true do |s|
-          s.add_dependency "rack"
-        end
-
-        gemfile <<-G
-          gem "thin", "1.0"
-        G
-
-        ruby <<-R
-          require 'rubygems'
-          gem "thin"
-          require 'bundler'
-          begin
-            Bundler.setup
-            puts "FAIL"
-          rescue Gem::LoadError => e
-            puts e.message
-          end
-        R
-
-        expect(out).to eq("You have already activated thin 1.1, but your Gemfile requires thin 1.0. Prepending `bundle exec` to your command may solve this.")
-      end
-
-      it "version_requirement is now deprecated in rubygems 1.4.0+" do
-        system_gems "thin-1.0", "rack-1.0.0"
-        build_gem "thin", "1.1", :to_system => true do |s|
-          s.add_dependency "rack"
-        end
-
-        gemfile <<-G
-          gem "thin", "1.0"
-        G
-
-        ruby <<-R
-          require 'rubygems'
-          gem "thin"
-          require 'bundler'
-          begin
-            Bundler.setup
-            puts "FAIL"
-          rescue Gem::LoadError => e
-            puts e.message
-          end
-        R
-
-        expect(err).to lack_errors
-      end
-    end
-  end
-
-  # RubyGems returns loaded_from as a string
-  it "has loaded_from as a string on all specs" do
-    build_git "foo"
-    build_git "no-gemspec", :gemspec => false
-
-    install_gemfile <<-G
-      source "file://#{gem_repo1}"
-      gem "rack"
-      gem "foo", :git => "#{lib_path("foo-1.0")}"
-      gem "no-gemspec", "1.0", :git => "#{lib_path("no-gemspec-1.0")}"
-    G
-
-    run <<-R
-      Gem.loaded_specs.each do |n, s|
-        puts "FAIL" unless s.loaded_from.is_a?(String)
-      end
-    R
-
-    expect(out).to be_empty
-  end
-
-  it "does not load all gemspecs", :rubygems => ">= 2.3" do
-    install_gemfile! <<-G
-      source "file://#{gem_repo1}"
-      gem "rack"
-    G
-
-    run! <<-R
-      File.open(File.join(Gem.dir, "specifications", "broken.gemspec"), "w") do |f|
-        f.write <<-RUBY
-# -*- encoding: utf-8 -*-
-# stub: broken 1.0.0 ruby lib
-
-Gem::Specification.new do |s|
-  s.name = "broken"
-  s.version = "1.0.0"
-  raise "BROKEN GEMSPEC"
-end
-        RUBY
-      end
-    R
-
-    run! <<-R
-      puts "WIN"
-    R
-
-    expect(out).to eq("WIN")
-  end
-
-  it "ignores empty gem paths" do
-    install_gemfile <<-G
-      source "file://#{gem_repo1}"
-      gem "rack"
-    G
-
-    ENV["GEM_HOME"] = ""
-    bundle %(exec ruby -e "require 'set'"), :env => { :RUBYOPT => "-r#{spec_dir.join("support/hax")}" }
-
-    expect(err).to lack_errors
-  end
-
-  describe "$MANPATH" do
-    before do
-      build_repo4 do
-        build_gem "with_man" do |s|
-          s.write("man/man1/page.1", "MANPAGE")
-        end
-      end
-    end
-
-    context "when the user has one set" do
-      before { ENV["MANPATH"] = "/foo:" }
-
-      it "adds the gem's man dir to the MANPATH" do
-        install_gemfile! <<-G
-          source "file:#{gem_repo4}"
-          gem "with_man"
-        G
-
-        run! "puts ENV['MANPATH']"
-        expect(out).to eq("#{default_bundle_path("gems/with_man-1.0/man")}:/foo")
-      end
-    end
-
-    context "when the user does not have one set" do
-      before { ENV.delete("MANPATH") }
-
-      it "adds the gem's man dir to the MANPATH" do
-        install_gemfile! <<-G
-          source "file:#{gem_repo4}"
-          gem "with_man"
-        G
-
-        run! "puts ENV['MANPATH']"
-        expect(out).to eq(default_bundle_path("gems/with_man-1.0/man").to_s)
-      end
-    end
-  end
-
-  it "should prepend gemspec require paths to $LOAD_PATH in order" do
-    update_repo2 do
-      build_gem("requirepaths") do |s|
-        s.write("lib/rq.rb", "puts 'yay'")
-        s.write("src/rq.rb", "puts 'nooo'")
-        s.require_paths = %w[lib src]
-      end
-    end
-
-    install_gemfile <<-G
-      source "file://#{gem_repo2}"
-      gem "requirepaths", :require => nil
-    G
-
-    run "require 'rq'"
-    expect(out).to eq("yay")
-  end
-
-  it "should clean $LOAD_PATH properly", :ruby_repo do
-    gem_name = "very_simple_binary"
-    full_gem_name = gem_name + "-1.0"
-    ext_dir = File.join(tmp "extenstions", full_gem_name)
-
-    install_gem full_gem_name
-
-    install_gemfile <<-G
-      source "file://#{gem_repo1}"
-    G
-
-    ruby <<-R
-      if Gem::Specification.method_defined? :extension_dir
-        s = Gem::Specification.find_by_name '#{gem_name}'
-        s.extension_dir = '#{ext_dir}'
-
-        # Don't build extensions.
-        s.class.send(:define_method, :build_extensions) { nil }
-      end
-
-      require 'bundler'
-      gem '#{gem_name}'
-
-      puts $LOAD_PATH.count {|path| path =~ /#{gem_name}/} >= 2
-
-      Bundler.setup
-
-      puts $LOAD_PATH.count {|path| path =~ /#{gem_name}/} == 0
-    R
-
-    expect(out).to eq("true\ntrue")
-  end
-
-  it "stubs out Gem.refresh so it does not reveal system gems" do
-    system_gems "rack-1.0.0"
-
-    install_gemfile <<-G
-      source "file://#{gem_repo1}"
-      gem "activesupport"
-    G
-
-    run <<-R
-      puts Bundler.rubygems.find_name("rack").inspect
-      Gem.refresh
-      puts Bundler.rubygems.find_name("rack").inspect
-    R
-
-    expect(out).to eq("[]\n[]")
-  end
-
-  describe "when a vendored gem specification uses the :path option" do
-    it "should resolve paths relative to the Gemfile" do
-      path = bundled_app(File.join("vendor", "foo"))
-      build_lib "foo", :path => path
-
-      # If the .gemspec exists, then Bundler handles the path differently.
-      # See Source::Path.load_spec_files for details.
-      FileUtils.rm(File.join(path, "foo.gemspec"))
-
-      install_gemfile <<-G
-        gem 'foo', '1.2.3', :path => 'vendor/foo'
-      G
-
-      Dir.chdir(bundled_app.parent) do
-        run <<-R, :env => { "BUNDLE_GEMFILE" => bundled_app("Gemfile") }
-          require 'foo'
-        R
-      end
-      expect(err).to lack_errors
-    end
-
-    it "should make sure the Bundler.root is really included in the path relative to the Gemfile" do
-      relative_path = File.join("vendor", Dir.pwd[1..-1], "foo")
-      absolute_path = bundled_app(relative_path)
-      FileUtils.mkdir_p(absolute_path)
-      build_lib "foo", :path => absolute_path
-
-      # If the .gemspec exists, then Bundler handles the path differently.
-      # See Source::Path.load_spec_files for details.
-      FileUtils.rm(File.join(absolute_path, "foo.gemspec"))
-
-      gemfile <<-G
-        gem 'foo', '1.2.3', :path => '#{relative_path}'
-      G
-
-      bundle :install
-
-      Dir.chdir(bundled_app.parent) do
-        run <<-R, :env => { "BUNDLE_GEMFILE" => bundled_app("Gemfile") }
-          require 'foo'
-        R
-      end
-
-      expect(err).to lack_errors
-    end
-  end
-
-  describe "with git gems that don't have gemspecs" do
-    before :each do
-      build_git "no-gemspec", :gemspec => false
-
-      install_gemfile <<-G
-        gem "no-gemspec", "1.0", :git => "#{lib_path("no-gemspec-1.0")}"
-      G
-    end
-
-    it "loads the library via a virtual spec" do
-      run <<-R
-        require 'no-gemspec'
-        puts NOGEMSPEC
-      R
-
-      expect(out).to eq("1.0")
-    end
-  end
-
-  describe "with bundled and system gems" do
-    before :each do
-      system_gems "rack-1.0.0"
-
-      install_gemfile <<-G
-        source "file://#{gem_repo1}"
-
-        gem "activesupport", "2.3.5"
-      G
-    end
-
-    it "does not pull in system gems" do
-      run <<-R
-        require 'rubygems'
-
-        begin;
-          require 'rack'
-        rescue LoadError
-          puts 'WIN'
-        end
-      R
-
-      expect(out).to eq("WIN")
-    end
-
-    it "provides a gem method" do
-      run <<-R
-        gem 'activesupport'
-        require 'activesupport'
-        puts ACTIVESUPPORT
-      R
-
-      expect(out).to eq("2.3.5")
-    end
-
-    it "raises an exception if gem is used to invoke a system gem not in the bundle" do
-      run <<-R
-        begin
-          gem 'rack'
-        rescue LoadError => e
-          puts e.message
-        end
-      R
-
-      expect(out).to eq("rack is not part of the bundle. Add it to your Gemfile.")
-    end
-
-    it "sets GEM_HOME appropriately" do
-      run "puts ENV['GEM_HOME']"
-      expect(out).to eq(default_bundle_path.to_s)
-    end
-  end
-
-  describe "with system gems in the bundle" do
-    before :each do
-      bundle! "config path.system true"
-      system_gems "rack-1.0.0"
-
-      install_gemfile <<-G
-        source "file://#{gem_repo1}"
-        gem "rack", "1.0.0"
-        gem "activesupport", "2.3.5"
-      G
-    end
-
-    it "sets GEM_PATH appropriately" do
-      run "puts Gem.path"
-      paths = out.split("\n")
-      expect(paths).to include(system_gem_path.to_s)
-    end
-  end
-
-  describe "with a gemspec that requires other files" do
-    before :each do
-      build_git "bar", :gemspec => false do |s|
-        s.write "lib/bar/version.rb", %(BAR_VERSION = '1.0')
-        s.write "bar.gemspec", <<-G
-          lib = File.expand_path('../lib/', __FILE__)
-          $:.unshift lib unless $:.include?(lib)
-          require 'bar/version'
-
-          Gem::Specification.new do |s|
-            s.name        = 'bar'
-            s.version     = BAR_VERSION
-            s.summary     = 'Bar'
-            s.files       = Dir["lib/**/*.rb"]
-            s.author      = 'no one'
-          end
-        G
-      end
-
-      gemfile <<-G
-        gem "bar", :git => "#{lib_path("bar-1.0")}"
-      G
-    end
-
-    it "evals each gemspec in the context of its parent directory" do
-      bundle :install
-      run "require 'bar'; puts BAR"
-      expect(out).to eq("1.0")
-    end
-
-    it "error intelligently if the gemspec has a LoadError" do
-      ref = update_git "bar", :gemspec => false do |s|
-        s.write "bar.gemspec", "require 'foobarbaz'"
-      end.ref_for("HEAD")
-      bundle :install
-
-      expect(out.lines.map(&:chomp)).to include(
-        a_string_starting_with("[!] There was an error while loading `bar.gemspec`:"),
-        RUBY_VERSION >= "1.9" ? a_string_starting_with("Does it try to require a relative path? That's been removed in Ruby 1.9.") : "",
-        " #  from #{default_bundle_path "bundler", "gems", "bar-1.0-#{ref[0, 12]}", "bar.gemspec"}:1",
-        " >  require 'foobarbaz'"
-      )
-    end
-
-    it "evals each gemspec with a binding from the top level" do
-      bundle "install"
-
-      ruby <<-RUBY
-        require 'bundler'
-        def Bundler.require(path)
-          raise "LOSE"
-        end
-        Bundler.load
-      RUBY
-
-      expect(err).to lack_errors
-      expect(out).to eq("")
-    end
-  end
-
-  describe "when Bundler is bundled" do
-    it "doesn't blow up" do
-      install_gemfile <<-G
-        gem "bundler", :path => "#{File.expand_path("..", lib)}"
-      G
-
-      bundle %(exec ruby -e "require 'bundler'; Bundler.setup"), :env => { :RUBYOPT => "-r#{spec_dir.join("support/hax")}" }
-      expect(err).to lack_errors
-    end
-  end
-
-  describe "when BUNDLED WITH" do
-    def lock_with(bundler_version = nil)
-      lock = <<-L
-        GEM
-          remote: file:#{gem_repo1}/
-          specs:
-            rack (1.0.0)
-
-        PLATFORMS
-          #{lockfile_platforms}
-
-        DEPENDENCIES
-          rack
-      L
-
-      if bundler_version
-        lock += "\n        BUNDLED WITH\n           #{bundler_version}\n"
-      end
-
-      lock
-    end
-
-    before do
-      install_gemfile <<-G
-        source "file://#{gem_repo1}"
-        gem "rack"
-      G
-    end
-
-    context "is not present" do
-      it "does not change the lock" do
-        lockfile lock_with(nil)
-        ruby "require 'bundler/setup'"
-        lockfile_should_be lock_with(nil)
-      end
-    end
-
-    context "is newer" do
-      it "does not change the lock or warn" do
-        lockfile lock_with(Bundler::VERSION.succ)
-        ruby "require 'bundler/setup'"
-        expect(out).to eq("")
-        expect(err).to eq("")
-        lockfile_should_be lock_with(Bundler::VERSION.succ)
-      end
-    end
-
-    context "is older" do
-      it "does not change the lock" do
-        lockfile lock_with("1.10.1")
-        ruby "require 'bundler/setup'"
-        lockfile_should_be lock_with("1.10.1")
-      end
-    end
-  end
-
-  describe "when RUBY VERSION" do
-    let(:ruby_version) { nil }
-
-    def lock_with(ruby_version = nil)
-      lock = <<-L
-        GEM
-          remote: file://localhost#{gem_repo1}/
-          specs:
-            rack (1.0.0)
-
-        PLATFORMS
-          #{lockfile_platforms}
-
-        DEPENDENCIES
-          rack
-      L
-
-      if ruby_version
-        lock += "\n        RUBY VERSION\n           ruby #{ruby_version}\n"
-      end
-
-      lock += <<-L
-
-        BUNDLED WITH
-           #{Bundler::VERSION}
-      L
-
-      lock
-    end
-
-    before do
-      install_gemfile <<-G
-        ruby ">= 0"
-        source "file://localhost#{gem_repo1}"
-        gem "rack"
-      G
-      lockfile lock_with(ruby_version)
-    end
-
-    context "is not present" do
-      it "does not change the lock" do
-        expect { ruby! "require 'bundler/setup'" }.not_to change { lockfile }
-      end
-    end
-
-    context "is newer" do
-      let(:ruby_version) { "5.5.5" }
-      it "does not change the lock or warn" do
-        expect { ruby! "require 'bundler/setup'" }.not_to change { lockfile }
-        expect(out).to eq("")
-        expect(err).to eq("")
-      end
-    end
-
-    context "is older" do
-      let(:ruby_version) { "1.0.0" }
-      it "does not change the lock" do
-        expect { ruby! "require 'bundler/setup'" }.not_to change { lockfile }
-      end
-    end
-  end
-
-  describe "with gemified standard libraries" do
-    it "does not load Psych", :ruby => "~> 2.2" do
-      gemfile ""
-      ruby <<-RUBY
-        require 'bundler/setup'
-        puts defined?(Psych::VERSION) ? Psych::VERSION : "undefined"
-        require 'psych'
-        puts Psych::VERSION
-      RUBY
-      pre_bundler, post_bundler = out.split("\n")
-      expect(pre_bundler).to eq("undefined")
-      expect(post_bundler).to match(/\d+\.\d+\.\d+/)
-    end
-
-    it "does not load openssl" do
-      install_gemfile! ""
-      ruby! <<-RUBY
-        require "bundler/setup"
-        puts defined?(OpenSSL) || "undefined"
-        require "openssl"
-        puts defined?(OpenSSL) || "undefined"
-      RUBY
-      expect(out).to eq("undefined\nconstant")
-    end
-
-    describe "default gem activation", :ruby_repo do
-      let(:exemptions) do
-        if Gem::Version.new(Gem::VERSION) >= Gem::Version.new("2.7") || ENV["RGV"] == "master"
-          []
-        else
-          %w[io-console openssl]
-        end << "bundler"
-      end
-
-      let(:activation_warning_hack) { strip_whitespace(<<-RUBY) }
-        require #{spec_dir.join("support/hax").to_s.dump}
-        require "rubygems"
-
-        if Gem::Specification.instance_methods.map(&:to_sym).include?(:activate)
-          Gem::Specification.send(:alias_method, :bundler_spec_activate, :activate)
-          Gem::Specification.send(:define_method, :activate) do
-            unless #{exemptions.inspect}.include?(name)
-              warn '-' * 80
-              warn "activating \#{full_name}"
-              warn *caller
-              warn '*' * 80
-            end
-            bundler_spec_activate
-          end
-        end
-      RUBY
-
-      let(:activation_warning_hack_rubyopt) do
-        create_file("activation_warning_hack.rb", activation_warning_hack)
-        "-r#{bundled_app("activation_warning_hack.rb")} #{ENV["RUBYOPT"]}"
-      end
-
-      let(:code) { strip_whitespace(<<-RUBY) }
-        require "bundler/setup"
-        require "pp"
-        loaded_specs = Gem.loaded_specs.dup
-        #{exemptions.inspect}.each {|s| loaded_specs.delete(s) }
-        pp loaded_specs
-
-        # not a default gem, but harmful to have loaded
-        open_uri = $LOADED_FEATURES.grep(/open.uri/)
-        unless open_uri.empty?
-          warn "open_uri: \#{open_uri}"
-        end
-      RUBY
-
-      it "activates no gems with -rbundler/setup" do
-        install_gemfile! ""
-        ruby! code, :env => { :RUBYOPT => activation_warning_hack_rubyopt }
-        expect(last_command.stdout).to eq("{}")
-      end
-
-      it "activates no gems with bundle exec" do
-        install_gemfile! ""
-        # ensure we clean out the default gems, bceause bundler's allowed to be activated
-        create_file("script.rb", code)
-        bundle! "exec ruby ./script.rb", :env => { :RUBYOPT => activation_warning_hack_rubyopt + " -rbundler/setup" }
-        expect(last_command.stdout).to eq("{}")
-      end
-
-      it "activates no gems with bundle exec that is loaded" do
-        # TODO: remove once https://github.com/erikhuda/thor/pull/539 is released
-        exemptions << "io-console"
-
-        install_gemfile! ""
-        create_file("script.rb", "#!/usr/bin/env ruby\n\n#{code}")
-        FileUtils.chmod(0o777, bundled_app("script.rb"))
-        bundle! "exec ./script.rb", :artifice => nil, :env => { :RUBYOPT => activation_warning_hack_rubyopt }
-        expect(last_command.stdout).to eq("{}")
-      end
-
-      let(:default_gems) do
-        ruby!(<<-RUBY).split("\n")
-          if Gem::Specification.is_a?(Enumerable)
-            puts Gem::Specification.select(&:default_gem?).map(&:name)
-          end
-        RUBY
-      end
-
-      it "activates newer versions of default gems" do
-        build_repo4 do
-          default_gems.each do |g|
-            build_gem g, "999999"
-          end
-        end
-
-        default_gems.reject! {|g| exemptions.include?(g) }
-
-        install_gemfile! <<-G
-          source "file:#{gem_repo4}"
-          #{default_gems}.each do |g|
-            gem g, "999999"
-          end
-        G
-
-        expect(the_bundle).to include_gems(*default_gems.map {|g| "#{g} 999999" })
-      end
-
-      it "activates older versions of default gems" do
-        build_repo4 do
-          default_gems.each do |g|
-            build_gem g, "0.0.0.a"
-          end
-        end
-
-        default_gems.reject! {|g| exemptions.include?(g) }
-
-        install_gemfile! <<-G
-          source "file:#{gem_repo4}"
-          #{default_gems}.each do |g|
-            gem g, "0.0.0.a"
-          end
-        G
-
-        expect(the_bundle).to include_gems(*default_gems.map {|g| "#{g} 0.0.0.a" })
-      end
-    end
-  end
-
-  describe "after setup" do
-    it "allows calling #gem on random objects", :bundler => "< 2" do
-      install_gemfile <<-G
-        source "file:#{gem_repo1}"
-        gem "rack"
-      G
-
-      ruby! <<-RUBY
-        require "bundler/setup"
-        Object.new.gem "rack"
-        puts Gem.loaded_specs["rack"].full_name
-      RUBY
-
-      expect(out).to eq("rack-1.0.0")
-    end
-
-    it "keeps Kernel#gem private", :bundler => "2" do
-      install_gemfile! <<-G
-        source "file:#{gem_repo1}"
-        gem "rack"
-      G
-
-      ruby <<-RUBY
-        require "bundler/setup"
-        Object.new.gem "rack"
-        puts "FAIL"
-      RUBY
-
-      expect(last_command.stdboth).not_to include "FAIL"
-      expect(last_command.stderr).to include "private method `gem'"
-    end
-
-    it "keeps Kernel#require private" do
-      install_gemfile! <<-G
-        source "file:#{gem_repo1}"
-        gem "rack"
-      G
-
-      ruby <<-RUBY
-        require "bundler/setup"
-        Object.new.require "rack"
-        puts "FAIL"
-      RUBY
-
-      expect(last_command.stdboth).not_to include "FAIL"
-      expect(last_command.stderr).to include "private method `require'"
-    end
-  end
-end
diff --git a/spec/bundler/runtime/with_clean_env_spec.rb b/spec/bundler/runtime/with_clean_env_spec.rb
deleted file mode 100644
index c88da3cd02..0000000000
--- a/spec/bundler/runtime/with_clean_env_spec.rb
+++ /dev/null
@@ -1,151 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe "Bundler.with_env helpers" do
-  def bundle_exec_ruby!(code, *args)
-    opts = args.last.is_a?(Hash) ? args.pop : {}
-    env = opts[:env] ||= {}
-    env[:RUBYOPT] ||= "-r#{spec_dir.join("support/hax")}"
-    args.push opts
-    bundle! "exec '#{Gem.ruby}' -e #{code}", *args
-  end
-
-  describe "Bundler.original_env" do
-    before do
-      bundle "config path vendor/bundle"
-      gemfile ""
-      bundle "install"
-    end
-
-    it "should return the PATH present before bundle was activated", :ruby_repo do
-      code = "print Bundler.original_env['PATH']"
-      path = `getconf PATH`.strip + "#{File::PATH_SEPARATOR}/foo"
-      with_path_as(path) do
-        bundle_exec_ruby!(code.dump)
-        expect(last_command.stdboth).to eq(path)
-      end
-    end
-
-    it "should return the GEM_PATH present before bundle was activated" do
-      code = "print Bundler.original_env['GEM_PATH']"
-      gem_path = ENV["GEM_PATH"] + ":/foo"
-      with_gem_path_as(gem_path) do
-        bundle_exec_ruby!(code.dump)
-        expect(last_command.stdboth).to eq(gem_path)
-      end
-    end
-
-    it "works with nested bundle exec invocations", :ruby_repo do
-      create_file("exe.rb", <<-'RB')
-        count = ARGV.first.to_i
-        exit if count < 0
-        STDERR.puts "#{count} #{ENV["PATH"].end_with?(":/foo")}"
-        if count == 2
-          ENV["PATH"] = "#{ENV["PATH"]}:/foo"
-        end
-        exec(Gem.ruby, __FILE__, (count - 1).to_s)
-      RB
-      path = `getconf PATH`.strip + File::PATH_SEPARATOR + File.dirname(Gem.ruby)
-      with_path_as(path) do
-        bundle! "exec '#{Gem.ruby}' #{bundled_app("exe.rb")} 2", :env => { :RUBYOPT => "-r#{spec_dir.join("support/hax")}" }
-      end
-      expect(err).to eq <<-EOS.strip
-2 false
-1 true
-0 true
-      EOS
-    end
-
-    it "removes variables that bundler added", :ruby_repo do
-      original = ruby!('puts ENV.to_a.map {|e| e.join("=") }.sort.join("\n")', :env => { :RUBYOPT => "-r#{spec_dir.join("support/hax")}" })
-      code = 'puts Bundler.original_env.to_a.map {|e| e.join("=") }.sort.join("\n")'
-      bundle! "exec '#{Gem.ruby}' -e #{code.dump}", :env => { :RUBYOPT => "-r#{spec_dir.join("support/hax")}" }
-      expect(out).to eq original
-    end
-  end
-
-  describe "Bundler.clean_env", :bundler => "< 2" do
-    before do
-      bundle "config path vendor/bundle"
-      gemfile ""
-      bundle "install"
-    end
-
-    it "should delete BUNDLE_PATH" do
-      code = "print Bundler.clean_env.has_key?('BUNDLE_PATH')"
-      ENV["BUNDLE_PATH"] = "./foo"
-      bundle_exec_ruby! code.dump
-      expect(last_command.stdboth).to eq "false"
-    end
-
-    it "should remove '-rbundler/setup' from RUBYOPT" do
-      code = "print Bundler.clean_env['RUBYOPT']"
-      ENV["RUBYOPT"] = "-W2 -rbundler/setup"
-      bundle_exec_ruby! code.dump
-      expect(last_command.stdboth).not_to include("-rbundler/setup")
-    end
-
-    it "should clean up RUBYLIB", :ruby_repo do
-      code = "print Bundler.clean_env['RUBYLIB']"
-      ENV["RUBYLIB"] = root.join("lib").to_s + File::PATH_SEPARATOR + "/foo"
-      bundle_exec_ruby! code.dump
-      expect(last_command.stdboth).to eq("/foo")
-    end
-
-    it "should restore the original MANPATH" do
-      code = "print Bundler.clean_env['MANPATH']"
-      ENV["MANPATH"] = "/foo"
-      ENV["BUNDLER_ORIG_MANPATH"] = "/foo-original"
-      bundle_exec_ruby! code.dump
-      expect(last_command.stdboth).to eq("/foo-original")
-    end
-  end
-
-  describe "Bundler.with_original_env" do
-    it "should set ENV to original_env in the block" do
-      expected = Bundler.original_env
-      actual = Bundler.with_original_env { ENV.to_hash }
-      expect(actual).to eq(expected)
-    end
-
-    it "should restore the environment after execution" do
-      Bundler.with_original_env do
-        ENV["FOO"] = "hello"
-      end
-
-      expect(ENV).not_to have_key("FOO")
-    end
-  end
-
-  describe "Bundler.with_clean_env", :bundler => "< 2" do
-    it "should set ENV to clean_env in the block" do
-      expected = Bundler.clean_env
-      actual = Bundler.with_clean_env { ENV.to_hash }
-      expect(actual).to eq(expected)
-    end
-
-    it "should restore the environment after execution" do
-      Bundler.with_clean_env do
-        ENV["FOO"] = "hello"
-      end
-
-      expect(ENV).not_to have_key("FOO")
-    end
-  end
-
-  describe "Bundler.clean_system", :ruby => ">= 1.9", :bundler => "< 2" do
-    it "runs system inside with_clean_env" do
-      Bundler.clean_system(%(echo 'if [ "$BUNDLE_PATH" = "" ]; then exit 42; else exit 1; fi' | /bin/sh))
-      expect($?.exitstatus).to eq(42)
-    end
-  end
-
-  describe "Bundler.clean_exec", :ruby => ">= 1.9", :bundler => "< 2" do
-    it "runs exec inside with_clean_env" do
-      pid = Kernel.fork do
-        Bundler.clean_exec(%(echo 'if [ "$BUNDLE_PATH" = "" ]; then exit 42; else exit 1; fi' | /bin/sh))
-      end
-      Process.wait(pid)
-      expect($?.exitstatus).to eq(42)
-    end
-  end
-end