* lib/rubygems: Update to RubyGems master 4bdc4f2. Important changes

  in this commit:

  RubyGems now chooses the test server port reliably.  Patch by akr.

  Partial implementation of bundler's Gemfile format.

  Refactorings to improve the new resolver.

  Fixes bugs in the resolver.

* test/rubygems:  Tests for the above.


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

33 files changed, 1587 insertions, 302 deletions

diff --git a/test/rubygems/test_bundled_ca.rb b/test/rubygems/test_bundled_ca.rb
index d2ccdaf484..711cd1b8f2 100644
--- a/test/rubygems/test_bundled_ca.rb
+++ b/test/rubygems/test_bundled_ca.rb
@@ -34,7 +34,7 @@ class TestBundledCA < Gem::TestCase
     http.verify_mode = OpenSSL::SSL::VERIFY_PEER
     http.cert_store = bundled_certificate_store
     http.get('/')
-  rescue Errno::ENOENT
+  rescue Errno::ENOENT, Errno::ETIMEDOUT
     skip "#{host} seems offline, I can't tell whether ssl would work."
   rescue OpenSSL::SSL::SSLError => e
     # Only fail for certificate verification errors
diff --git a/test/rubygems/test_gem.rb b/test/rubygems/test_gem.rb
index 88d0b1c432..f42225635e 100644
--- a/test/rubygems/test_gem.rb
+++ b/test/rubygems/test_gem.rb
@@ -420,12 +420,13 @@ class TestGem < Gem::TestCase
   end
 
   def test_self_latest_spec_for
-    a1  = quick_spec 'a', 1
-    a2  = quick_spec 'a', 2
-    a3a = quick_spec 'a', '3.a'
+    a2 = nil
 
-    util_setup_fake_fetcher
-    util_setup_spec_fetcher a1, a2, a3a
+    spec_fetcher do |fetcher|
+      fetcher.spec 'a', 1
+      fetcher.spec 'a', '3.a'
+      a2 = fetcher.spec 'a', 2
+    end
 
     spec = Gem.latest_spec_for 'a'
 
@@ -433,12 +434,11 @@ class TestGem < Gem::TestCase
   end
 
   def test_self_latest_rubygems_version
-    r1 = quick_spec 'rubygems-update', '1.8.23'
-    r2 = quick_spec 'rubygems-update', '1.8.24'
-    r3 = quick_spec 'rubygems-update', '2.0.0.preview3'
-
-    util_setup_fake_fetcher
-    util_setup_spec_fetcher r1, r2, r3
+    spec_fetcher do |fetcher|
+      fetcher.spec 'rubygems-update', '1.8.23'
+      fetcher.spec 'rubygems-update', '1.8.24'
+      fetcher.spec 'rubygems-update', '2.0.0.preview3'
+    end
 
     version = Gem.latest_rubygems_version
 
@@ -446,12 +446,11 @@ class TestGem < Gem::TestCase
   end
 
   def test_self_latest_version_for
-    a1  = quick_spec 'a', 1
-    a2  = quick_spec 'a', 2
-    a3a = quick_spec 'a', '3.a'
-
-    util_setup_fake_fetcher
-    util_setup_spec_fetcher a1, a2, a3a
+    spec_fetcher do |fetcher|
+      fetcher.spec 'a', 1
+      fetcher.spec 'a', 2
+      fetcher.spec 'a', '3.a'
+    end
 
     version = Gem.latest_version_for 'a'
 
diff --git a/test/rubygems/test_gem_commands_dependency_command.rb b/test/rubygems/test_gem_commands_dependency_command.rb
index a5670e7575..99b04bcd19 100644
--- a/test/rubygems/test_gem_commands_dependency_command.rb
+++ b/test/rubygems/test_gem_commands_dependency_command.rb
@@ -168,17 +168,10 @@ ERROR:  Only reverse dependencies for local gems are supported.
   end
 
   def test_execute_remote
-    foo = quick_gem 'foo' do |gem|
-      gem.add_dependency 'bar', '> 1'
+    spec_fetcher do |fetcher|
+      fetcher.spec 'foo', 2, 'bar' => '> 1'
     end
 
-    @fetcher = Gem::FakeFetcher.new
-    Gem::RemoteFetcher.fetcher = @fetcher
-
-    util_setup_spec_fetcher foo
-
-    FileUtils.rm File.join(@gemhome, 'specifications', foo.spec_name)
-
     @cmd.options[:args] = %w[foo]
     @cmd.options[:domain] = :remote
 
diff --git a/test/rubygems/test_gem_commands_install_command.rb b/test/rubygems/test_gem_commands_install_command.rb
index 625d85e372..55246502a5 100644
--- a/test/rubygems/test_gem_commands_install_command.rb
+++ b/test/rubygems/test_gem_commands_install_command.rb
@@ -855,4 +855,14 @@ ERROR:  Possible alternatives: non_existent_with_hint
     assert_equal 'gem.deps.rb', @cmd.options[:gemdeps]
   end
 
+  def test_handle_options_without
+    @cmd.handle_options %w[--without test]
+
+    assert_equal [:test], @cmd.options[:without_groups]
+
+    @cmd.handle_options %w[--without test,development]
+
+    assert_equal [:test, :development], @cmd.options[:without_groups]
+  end
+
 end
diff --git a/test/rubygems/test_gem_commands_outdated_command.rb b/test/rubygems/test_gem_commands_outdated_command.rb
index 72696d6549..eee273af5c 100644
--- a/test/rubygems/test_gem_commands_outdated_command.rb
+++ b/test/rubygems/test_gem_commands_outdated_command.rb
@@ -14,13 +14,10 @@ class TestGemCommandsOutdatedCommand < Gem::TestCase
   end
 
   def test_execute
-    remote_10 = quick_spec 'foo', '1.0'
-    remote_20 = quick_spec 'foo', '2.0'
-
-    Gem::RemoteFetcher.fetcher = @fetcher = Gem::FakeFetcher.new
-
-    util_clear_gems
-    util_setup_spec_fetcher remote_10, remote_20
+    spec_fetcher do |fetcher|
+      fetcher.spec 'foo', '1.0'
+      fetcher.spec 'foo', '2.0'
+    end
 
     quick_gem 'foo', '0.1'
     quick_gem 'foo', '0.2'
diff --git a/test/rubygems/test_gem_commands_specification_command.rb b/test/rubygems/test_gem_commands_specification_command.rb
index 252d0bdd55..fb28302cc3 100644
--- a/test/rubygems/test_gem_commands_specification_command.rb
+++ b/test/rubygems/test_gem_commands_specification_command.rb
@@ -152,14 +152,9 @@ class TestGemCommandsSpecificationCommand < Gem::TestCase
   end
 
   def test_execute_remote
-    foo = quick_gem 'foo'
-
-    @fetcher = Gem::FakeFetcher.new
-    Gem::RemoteFetcher.fetcher = @fetcher
-
-    util_setup_spec_fetcher foo
-
-    FileUtils.rm File.join(@gemhome, 'specifications', foo.spec_name)
+    spec_fetcher do |fetcher|
+      fetcher.spec 'foo', 1
+    end
 
     @cmd.options[:args] = %w[foo]
     @cmd.options[:domain] = :remote
@@ -173,16 +168,10 @@ class TestGemCommandsSpecificationCommand < Gem::TestCase
   end
 
   def test_execute_remote_with_version
-    foo1 = quick_gem 'foo', "1"
-    foo2 = quick_gem 'foo', "2"
-
-    @fetcher = Gem::FakeFetcher.new
-    Gem::RemoteFetcher.fetcher = @fetcher
-
-    util_setup_spec_fetcher foo1, foo2
-
-    FileUtils.rm File.join(@gemhome, 'specifications', foo1.spec_name)
-    FileUtils.rm File.join(@gemhome, 'specifications', foo2.spec_name)
+    spec_fetcher do |fetcher|
+      fetcher.spec 'foo', "1"
+      fetcher.spec 'foo', "2"
+    end
 
     @cmd.options[:args] = %w[foo]
     @cmd.options[:version] = "1"
@@ -198,16 +187,12 @@ class TestGemCommandsSpecificationCommand < Gem::TestCase
   end
 
   def test_execute_remote_without_prerelease
-    foo = new_spec 'foo', '2.0.0'
-    foo_pre = new_spec 'foo', '2.0.1.pre'
-
-    install_specs foo, foo_pre
+    spec_fetcher do |fetcher|
+      foo     = fetcher.spec 'foo', '2.0.0'
+      foo_pre = fetcher.spec 'foo', '2.0.1.pre'
 
-    @fetcher = Gem::FakeFetcher.new
-    Gem::RemoteFetcher.fetcher = @fetcher
-
-    util_setup_spec_fetcher foo
-    util_setup_spec_fetcher foo_pre
+      install_specs foo, foo_pre
+    end
 
     @cmd.options[:args] = %w[foo]
     @cmd.options[:domain] = :remote
@@ -225,16 +210,12 @@ class TestGemCommandsSpecificationCommand < Gem::TestCase
   end
 
   def test_execute_remote_with_prerelease
-    foo = new_spec 'foo', '2.0.0'
-    foo_pre = new_spec 'foo', '2.0.1.pre'
+    spec_fetcher do |fetcher|
+      foo     = fetcher.spec 'foo', '2.0.0'
+      foo_pre = fetcher.spec 'foo', '2.0.1.pre'
 
-    install_specs foo, foo_pre
-
-    @fetcher = Gem::FakeFetcher.new
-    Gem::RemoteFetcher.fetcher = @fetcher
-
-    util_setup_spec_fetcher foo
-    util_setup_spec_fetcher foo_pre
+      install_specs foo, foo_pre
+    end
 
     @cmd.options[:args] = %w[foo]
     @cmd.options[:domain] = :remote
diff --git a/test/rubygems/test_gem_dependency_installer.rb b/test/rubygems/test_gem_dependency_installer.rb
index 8433be6bd0..f8c3dd493b 100644
--- a/test/rubygems/test_gem_dependency_installer.rb
+++ b/test/rubygems/test_gem_dependency_installer.rb
@@ -682,7 +682,7 @@ class TestGemDependencyInstaller < Gem::TestCase
         inst.install 'b'
       end
 
-      expected = "Unable to resolve dependency: b (= 1) requires a (>= 0)"
+      expected = "Unable to resolve dependency: 'b (= 1)' requires 'a (>= 0)'"
       assert_equal expected, e.message
     end
 
@@ -816,6 +816,17 @@ class TestGemDependencyInstaller < Gem::TestCase
     assert_equal %w[a-1], inst.installed_gems.map { |s| s.full_name }
   end
 
+  def test_install_platform_is_ignored_when_a_file_is_specified
+    _, a_gem = util_gem 'a', '1' do |s|
+      s.platform = Gem::Platform.new %w[cpu other_platform 1]
+    end
+
+    inst = Gem::DependencyInstaller.new :domain => :local
+    inst.install a_gem
+
+    assert_equal %w[a-1-cpu-other_platform-1], inst.installed_gems.map { |s| s.full_name }
+  end
+
   if defined? OpenSSL then
     def test_install_security_policy
       util_setup_gems
@@ -904,6 +915,29 @@ class TestGemDependencyInstaller < Gem::TestCase
     assert_equal Gem::Source.new(@gem_repo), s.source
   end
 
+  def test_find_spec_by_name_and_version_wildcard
+    util_gem 'a', 1
+    FileUtils.mv 'gems/a-1.gem', @tempdir
+
+    FileUtils.touch 'rdoc.gem'
+
+    inst = Gem::DependencyInstaller.new
+
+    available = inst.find_spec_by_name_and_version('*.gem')
+
+    assert_equal %w[a-1], available.each_spec.map { |spec| spec.full_name }
+  end
+
+  def test_find_spec_by_name_and_version_wildcard_bad_gem
+    FileUtils.touch 'rdoc.gem'
+
+    inst = Gem::DependencyInstaller.new
+
+    assert_raises Gem::Package::FormatError do
+      inst.find_spec_by_name_and_version '*.gem'
+    end
+  end
+
   def test_find_spec_by_name_and_version_bad_gem
     FileUtils.touch 'rdoc.gem'
 
diff --git a/test/rubygems/test_gem_dependency_resolution_error.rb b/test/rubygems/test_gem_dependency_resolution_error.rb
new file mode 100644
index 0000000000..7f8cf0c5cc
--- /dev/null
+++ b/test/rubygems/test_gem_dependency_resolution_error.rb
@@ -0,0 +1,28 @@
+require 'rubygems/test_case'
+
+class TestGemDependencyResolutionError < Gem::TestCase
+
+  def setup
+    super
+
+    @DR = Gem::DependencyResolver
+
+    @spec = quick_spec 'a', 2
+
+    @a1_req = @DR::DependencyRequest.new dep('a', '= 1'), nil
+    @a2_req = @DR::DependencyRequest.new dep('a', '= 2'), nil
+
+    @activated = @DR::ActivationRequest.new @spec, @a2_req
+
+    @conflict = @DR::DependencyConflict.new @a1_req, @activated
+
+    @error = Gem::DependencyResolutionError.new @conflict
+  end
+
+  def test_message
+    assert_match %r%^conflicting dependencies a \(= 1\) and a \(= 2\)$%,
+                 @error.message
+  end
+
+end
+
diff --git a/test/rubygems/test_gem_dependency_resolver.rb b/test/rubygems/test_gem_dependency_resolver.rb
index bd349996c1..7d968494b8 100644
--- a/test/rubygems/test_gem_dependency_resolver.rb
+++ b/test/rubygems/test_gem_dependency_resolver.rb
@@ -3,6 +3,12 @@ require 'rubygems/dependency_resolver'
 
 class TestGemDependencyResolver < Gem::TestCase
 
+  def setup
+    super
+
+    @DR = Gem::DependencyResolver
+  end
+
   def make_dep(name, *req)
     Gem::Dependency.new(name, *req)
   end
@@ -21,7 +27,58 @@ class TestGemDependencyResolver < Gem::TestCase
 
     assert_equal exp, act, msg
   rescue Gem::DependencyResolutionError => e
-    flunk "#{e.message}\n#{e.conflict.explanation}"
+    flunk e.message
+  end
+
+  def test_self_compose_sets_multiple
+    index_set  = @DR::IndexSet.new
+    vendor_set = @DR::VendorSet.new
+
+    composed = @DR.compose_sets index_set, vendor_set
+
+    assert_kind_of Gem::DependencyResolver::ComposedSet, composed
+
+    assert_equal [index_set, vendor_set], composed.sets
+  end
+
+  def test_self_compose_sets_nil
+    index_set  = @DR::IndexSet.new
+
+    composed = @DR.compose_sets index_set, nil
+
+    assert_same index_set, composed
+
+    e = assert_raises ArgumentError do
+      @DR.compose_sets nil
+    end
+
+    assert_equal 'one set in the composition must be non-nil', e.message
+  end
+
+  def test_self_compose_sets_single
+    index_set  = @DR::IndexSet.new
+
+    composed = @DR.compose_sets index_set
+
+    assert_same index_set, composed
+  end
+
+  def test_handle_conflict
+    a1 = util_spec 'a', 1
+
+    r1 = Gem::DependencyResolver::DependencyRequest.new dep('a', '= 1'), nil
+    r2 = Gem::DependencyResolver::DependencyRequest.new dep('a', '= 2'), nil
+    r3 = Gem::DependencyResolver::DependencyRequest.new dep('a', '= 3'), nil
+
+    existing = Gem::DependencyResolver::ActivationRequest.new a1, r1, false
+
+    res = Gem::DependencyResolver.new [a1]
+
+    res.handle_conflict r2, existing
+    res.handle_conflict r2, existing
+    res.handle_conflict r3, existing
+
+    assert_equal 2, res.conflicts.length
   end
 
   def test_no_overlap_specificly
@@ -71,10 +128,15 @@ class TestGemDependencyResolver < Gem::TestCase
   end
 
   def test_picks_best_platform
-    is = Gem::DependencyResolver::IndexSpecification
+    is      = Gem::DependencyResolver::IndexSpecification
     unknown = Gem::Platform.new 'unknown'
-    a2_p1 = quick_spec 'a', 2 do |s| s.platform = Gem::Platform.local end
-    a3_p2 = quick_spec 'a', 3 do |s| s.platform = unknown end
+    a2_p1   = a3_p2 = nil
+
+    spec_fetcher do |fetcher|
+      a2_p1 = fetcher.spec 'a', 2 do |s| s.platform = Gem::Platform.local end
+      a3_p2 = fetcher.spec 'a', 3 do |s| s.platform = unknown end
+    end
+
     v2 = v(2)
     v3 = v(3)
     source = Gem::Source.new @gem_repo
@@ -183,8 +245,6 @@ class TestGemDependencyResolver < Gem::TestCase
       r.resolve
     end
 
-    assert_equal "unable to resolve conflicting dependencies 'c (= 2)' and 'c (= 1)'", e.message
-
     deps = [make_dep("c", "= 2"), make_dep("c", "= 1")]
     assert_equal deps, e.conflicting_dependencies
 
@@ -209,7 +269,7 @@ class TestGemDependencyResolver < Gem::TestCase
       r.resolve
     end
 
-    assert_equal "Unable to resolve dependency: (unknown) requires a (>= 0)",
+    assert_equal "Unable to resolve dependency: user requested 'a (>= 0)'",
                  e.message
 
     assert_equal "a (>= 0)", e.dependency.to_s
@@ -229,6 +289,37 @@ class TestGemDependencyResolver < Gem::TestCase
     assert_equal "a (= 3)", e.dependency.to_s
   end
 
+  def test_raises_and_reports_a_toplevel_request_properly
+    a1 = util_spec "a", "1"
+    ad = make_dep "a", "= 3"
+
+    r = Gem::DependencyResolver.new([ad], set(a1))
+
+    e = assert_raises Gem::UnsatisfiableDepedencyError do
+      r.resolve
+    end
+
+    assert_equal "Unable to resolve dependency: user requested 'a (= 3)'",
+                 e.message
+  end
+
+  def test_raises_and_reports_an_implicit_request_properly
+    a1 = util_spec "a", "1" do |s|
+      s.add_runtime_dependency 'b', '= 2'
+    end
+
+    ad = make_dep "a", "= 1"
+
+    r = Gem::DependencyResolver.new([ad], set(a1))
+
+    e = assert_raises Gem::UnsatisfiableDepedencyError do
+      r.resolve
+    end
+
+    assert_equal "Unable to resolve dependency: 'a (= 1)' requires 'b (= 2)'",
+                 e.message
+  end
+
   def test_raises_when_possibles_are_exhausted
     a1 = util_spec "a", "1", "c" => ">= 2"
     b1 = util_spec "b", "1", "c" => "= 1"
@@ -244,18 +335,22 @@ class TestGemDependencyResolver < Gem::TestCase
 
     r = Gem::DependencyResolver.new([ad, bd], s)
 
-    e = assert_raises Gem::ImpossibleDependenciesError do
+    e = assert_raises Gem::DependencyResolutionError do
       r.resolve
     end
 
-    assert_match "a-1 requires c (>= 2) but it conflicted", e.message
+    dependency = e.conflict.dependency
 
-    assert_equal "c (>= 2)", e.dependency.to_s
+    assert_equal 'a', dependency.name
+    assert_equal req('>= 0'), dependency.requirement
 
-    s, con = e.conflicts[0]
-    assert_equal "c-3", s.full_name
-    assert_equal "c (= 1)", con.dependency.to_s
-    assert_equal "b-1", con.requester.full_name
+    activated = e.conflict.activated
+    assert_equal 'c-2', activated.full_name
+
+    assert_equal dep('c', '>= 2'), activated.request.dependency
+
+    assert_equal [dep('c', '= 1'), dep('c', '>= 2')],
+                 e.conflict.conflicting_dependencies
   end
 
   def test_keeps_resolving_after_seeing_satisfied_dep
@@ -312,7 +407,7 @@ class TestGemDependencyResolver < Gem::TestCase
 
     r = Gem::DependencyResolver.new([d1, d2, d3], s)
 
-    assert_raises Gem::ImpossibleDependenciesError do
+    assert_raises Gem::DependencyResolutionError do
       r.resolve
     end
   end
@@ -335,6 +430,42 @@ class TestGemDependencyResolver < Gem::TestCase
     end
   end
 
+  def test_resolve_bug_699
+    a1 = util_spec 'a', '1', 'b' => '= 2',
+                             'c' => '~> 1.0.3'
+
+    b1 = util_spec 'b', '2', 'c' => '~> 1.0'
+
+    c1 = util_spec 'c', '1.0.9'
+    c2 = util_spec 'c', '1.1.0'
+    c3 = util_spec 'c', '1.2.0'
+
+    s = set a1, b1, c1, c2, c3
+
+    a_dep = dep 'a', '= 1'
+
+    r = Gem::DependencyResolver.new [a_dep], s
+
+    assert_resolves_to [a1, b1, c1], r
+  end
+
+  def test_resolve_rollback
+    a1 = util_spec 'a', 1
+    a2 = util_spec 'a', 2
+
+    b1 = util_spec 'b', 1, 'a' => '~> 1.0'
+    b2 = util_spec 'b', 2, 'a' => '~> 2.0'
+
+    s = set a1, a2, b1, b2
+
+    a_dep = dep 'a', '~> 1.0'
+    b_dep = dep 'b'
+
+    r = Gem::DependencyResolver.new [a_dep, b_dep], s
+
+    assert_resolves_to [a1, b1], r
+  end
+
   # actionmailer 2.3.4
   # activemerchant 1.5.0
   # activesupport 2.3.5, 2.3.4
@@ -388,5 +519,22 @@ class TestGemDependencyResolver < Gem::TestCase
     assert_equal [a1, a1_p1], selected
   end
 
+  def test_raises_and_explains_when_platform_prevents_install
+    a1 = util_spec "a", "1" do |s|
+      s.platform = Gem::Platform.new %w[c p 1]
+    end
+
+    ad = make_dep "a", "= 1"
+
+    r = Gem::DependencyResolver.new([ad], set(a1))
+
+    e = assert_raises Gem::UnsatisfiableDepedencyError do
+      r.resolve
+    end
+
+    assert_match "No match for 'a (= 1)' on this platform. Found: c-p-1",
+                 e.message
+  end
+
 end
 
diff --git a/test/rubygems/test_gem_dependency_resolver_activation_request.rb b/test/rubygems/test_gem_dependency_resolver_activation_request.rb
new file mode 100644
index 0000000000..ac554d128c
--- /dev/null
+++ b/test/rubygems/test_gem_dependency_resolver_activation_request.rb
@@ -0,0 +1,63 @@
+require 'rubygems/test_case'
+
+class TestGemDependencyResolverActivationRequest < Gem::TestCase
+
+  def setup
+    super
+
+    @DR = Gem::DependencyResolver
+
+    @dep = @DR::DependencyRequest.new dep('a', '>= 0'), nil
+
+    source   = Gem::Source::Local.new
+    platform = Gem::Platform::RUBY
+
+    @a1 = @DR::IndexSpecification.new nil, 'a', v(1), source, platform
+    @a2 = @DR::IndexSpecification.new nil, 'a', v(2), source, platform
+    @a3 = @DR::IndexSpecification.new nil, 'a', v(3), source, platform
+
+    @req = @DR::ActivationRequest.new @a3, @dep, [@a1, @a2]
+  end
+
+  def test_inspect
+    assert_match 'a-3',                         @req.inspect
+    assert_match 'from a (>= 0)',               @req.inspect
+    assert_match '(others possible: a-1, a-2)', @req.inspect
+  end
+
+  def test_inspect_legacy
+    req = @DR::ActivationRequest.new @a3, @dep, true
+
+    assert_match '(others possible)', req.inspect
+
+    req = @DR::ActivationRequest.new @a3, @dep, false
+
+    refute_match '(others possible)', req.inspect
+  end
+
+  def test_installed_eh
+    v_spec = Gem::DependencyResolver::VendorSpecification.new nil, @a3
+
+    @req = @DR::ActivationRequest.new v_spec, @dep, [@a1, @a2]
+
+    assert @req.installed?
+  end
+
+  def test_others_possible_eh
+    assert @req.others_possible?
+
+    req = @DR::ActivationRequest.new @a3, @dep, []
+
+    refute req.others_possible?
+
+    req = @DR::ActivationRequest.new @a3, @dep, true
+
+    assert req.others_possible?
+
+    req = @DR::ActivationRequest.new @a3, @dep, false
+
+    refute req.others_possible?
+  end
+
+end
+
diff --git a/test/rubygems/test_gem_dependency_resolver_api_set.rb b/test/rubygems/test_gem_dependency_resolver_api_set.rb
index c1e7eda191..ef99b6ca7f 100644
--- a/test/rubygems/test_gem_dependency_resolver_api_set.rb
+++ b/test/rubygems/test_gem_dependency_resolver_api_set.rb
@@ -7,73 +7,20 @@ class TestGemDependencyResolverAPISet < Gem::TestCase
     super
 
     @DR = Gem::DependencyResolver
-
-    @api_set = @DR::APISet.new
-    @uri = 'https://rubygems.org/api/v1/dependencies'
-    @fetcher = Gem::FakeFetcher.new
-    Gem::RemoteFetcher.fetcher = @fetcher
-  end
-
-  def test_find_all
-    b_entry = {
-      :name         => 'b',
-      :number       => '2',
-      :platform     => 'ruby',
-      :dependencies => [['a', '>= 0']],
-    }
-
-    @fetcher.data["#{@uri}?gems=b"] = Marshal.dump [b_entry]
-
-    b_req = @DR::DependencyRequest.new dep('b', '>= 0'), nil
-
-    expected = [
-      @DR::APISpecification.new(@api_set, b_entry)
-    ]
-
-    assert_equal expected, @api_set.find_all(b_req)
   end
 
-  def test_prefetch
-    b_entry = {
-      :name         => 'b',
-      :number       => '2',
-      :platform     => 'ruby',
-      :dependencies => [['a', '>= 0']],
-    }
+  def test_initialize
+    set = @DR::APISet.new
 
-    a_entry = {
-      :name         => 'a',
-      :number       => '2',
-      :platform     => 'ruby',
-      :dependencies => [],
-    }
-
-    @fetcher.data["#{@uri}?gems=a,b"] = Marshal.dump [a_entry, b_entry]
-
-    a_req = @DR::DependencyRequest.new dep('a', '>= 0'), nil
-    b_req = @DR::DependencyRequest.new dep('b', '>= 0'), nil
-
-    @api_set.prefetch([b_req, a_req])
-
-    assert_equal [a_entry], @api_set.versions('a')
-    assert_equal [b_entry], @api_set.versions('b')
+    assert_equal URI('https://rubygems.org/api/v1/dependencies'),
+                 set.dep_uri
   end
 
-  def test_versions_cache
-    entry = {
-      :name         => 'b',
-      :number       => '2',
-      :platform     => 'ruby',
-      :dependencies => [['a', '>= 0']],
-    }
-
-    @fetcher.data["#{@uri}?gems=b"] = Marshal.dump [entry]
-
-    assert_equal [entry], @api_set.versions('b')
-
-    @fetcher.data["#{@uri}?gems=b"] = 'garbage'
+  def test_initialize_uri
+    set = @DR::APISet.new @gem_repo
 
-    assert_equal [entry], @api_set.versions('b'), 'version data must be cached'
+    assert_equal URI('http://gems.example.com/'),
+                 set.dep_uri
   end
 
 end
diff --git a/test/rubygems/test_gem_dependency_resolver_best_set.rb b/test/rubygems/test_gem_dependency_resolver_best_set.rb
new file mode 100644
index 0000000000..20fbf4514f
--- /dev/null
+++ b/test/rubygems/test_gem_dependency_resolver_best_set.rb
@@ -0,0 +1,31 @@
+require 'rubygems/test_case'
+require 'rubygems/dependency_resolver'
+
+class TestGemDependencyResolverBestSet < Gem::TestCase
+
+  def setup
+    super
+
+    @DR = Gem::DependencyResolver
+  end
+
+  def test_find_all_index
+    spec_fetcher do |fetcher|
+      fetcher.spec 'a', 1
+      fetcher.spec 'a', 2
+      fetcher.spec 'b', 1
+    end
+
+    set = @DR::BestSet.new
+
+    dependency = dep 'a', '~> 1'
+
+    req = @DR::DependencyRequest.new dependency, nil
+
+    found = set.find_all req
+
+    assert_equal %w[a-1], found.map { |s| s.full_name }
+  end
+
+end
+
diff --git a/test/rubygems/test_gem_dependency_resolver_dependency_conflict.rb b/test/rubygems/test_gem_dependency_resolver_dependency_conflict.rb
index 5043865e5c..964997568a 100644
--- a/test/rubygems/test_gem_dependency_resolver_dependency_conflict.rb
+++ b/test/rubygems/test_gem_dependency_resolver_dependency_conflict.rb
@@ -20,6 +20,26 @@ class TestGemDependencyResolverDependencyConflict < Gem::TestCase
     assert_equal expected, conflict.explanation
   end
 
+  def test_explanation_user_request
+    @DR = Gem::DependencyResolver
+
+    spec = quick_spec 'a', 2
+
+    a1_req = @DR::DependencyRequest.new dep('a', '= 1'), nil
+    a2_req = @DR::DependencyRequest.new dep('a', '= 2'), nil
+
+    activated = @DR::ActivationRequest.new spec, a2_req
+
+    conflict = @DR::DependencyConflict.new a1_req, activated
+
+    expected = <<-EXPECTED
+  Activated a-2 instead of (= 1) via:
+    user request (gem command or Gemfile)
+    EXPECTED
+
+    assert_equal expected, conflict.explanation
+  end
+
   def test_request_path
     root  =
       dependency_request dep('net-ssh', '>= 2.0.13'), 'rye', '0.9.8'
diff --git a/test/rubygems/test_gem_dependency_resolver_dependency_request.rb b/test/rubygems/test_gem_dependency_resolver_dependency_request.rb
new file mode 100644
index 0000000000..f5b3a6960e
--- /dev/null
+++ b/test/rubygems/test_gem_dependency_resolver_dependency_request.rb
@@ -0,0 +1,20 @@
+require 'rubygems/test_case'
+
+class TestGemDependencyResolverDependencyRequest < Gem::TestCase
+
+  def setup
+    super
+
+    @DR = Gem::DependencyResolver::DependencyRequest
+  end
+
+  def test_requirement
+    dependency = dep 'a', '>= 1'
+
+    dr = @DR.new dependency, nil
+
+    assert_equal dependency, dr.dependency
+  end
+
+end
+
diff --git a/test/rubygems/test_gem_dependency_resolver_index_set.rb b/test/rubygems/test_gem_dependency_resolver_index_set.rb
index 82ea486792..83b7cce501 100644
--- a/test/rubygems/test_gem_dependency_resolver_index_set.rb
+++ b/test/rubygems/test_gem_dependency_resolver_index_set.rb
@@ -3,50 +3,26 @@ require 'rubygems/dependency_resolver'
 
 class TestGemDependencyResolverIndexSet < Gem::TestCase
 
-  def test_load_spec
-    @fetcher = Gem::FakeFetcher.new
-    Gem::RemoteFetcher.fetcher = @fetcher
+  def setup
+    super
 
-    a_2   = quick_spec 'a', 2
-    a_2_p = quick_spec 'a', 2 do |s| s.platform = Gem::Platform.local end
-
-    Gem::Specification.add_specs a_2, a_2_p
-
-    util_setup_spec_fetcher a_2, a_2_p
-
-    source = Gem::Source.new @gem_repo
-    version = v 2
-
-    set = Gem::DependencyResolver::IndexSet.new
-
-    spec = set.load_spec 'a', version, Gem::Platform.local, source
-
-    assert_equal a_2_p.full_name, spec.full_name
+    @DR = Gem::DependencyResolver
   end
 
-  def test_load_spec_cached
-    @fetcher = Gem::FakeFetcher.new
-    Gem::RemoteFetcher.fetcher = @fetcher
+  def test_initialize
+    set = @DR::IndexSet.new
 
-    a_2   = quick_spec 'a', 2
-    a_2_p = quick_spec 'a', 2 do |s| s.platform = Gem::Platform.local end
+    fetcher = set.instance_variable_get :@f
 
-    Gem::Specification.add_specs a_2, a_2_p
-
-    util_setup_spec_fetcher a_2, a_2_p
-
-    source = Gem::Source.new @gem_repo
-    version = v 2
-
-    set = Gem::DependencyResolver::IndexSet.new
-
-    first = set.load_spec 'a', version, Gem::Platform.local, source
+    assert_same Gem::SpecFetcher.fetcher, fetcher
+  end
 
-    util_setup_spec_fetcher # clear
+  def test_initialize_source
+    set = @DR::IndexSet.new 'http://alternate.example'
 
-    second = set.load_spec 'a', version, Gem::Platform.local, source
+    fetcher = set.instance_variable_get :@f
 
-    assert_same first, second
+    refute_same Gem::SpecFetcher.fetcher, fetcher
   end
 
 end
diff --git a/test/rubygems/test_gem_dependency_resolver_index_specification.rb b/test/rubygems/test_gem_dependency_resolver_index_specification.rb
index b1e74a3cd1..c8e02ff62d 100644
--- a/test/rubygems/test_gem_dependency_resolver_index_specification.rb
+++ b/test/rubygems/test_gem_dependency_resolver_index_specification.rb
@@ -31,15 +31,12 @@ class TestGemDependencyResolverIndexSpecification < Gem::TestCase
   end
 
   def test_spec
-    @fetcher = Gem::FakeFetcher.new
-    Gem::RemoteFetcher.fetcher = @fetcher
+    a_2_p = nil
 
-    a_2   = quick_spec 'a', 2
-    a_2_p = quick_spec 'a', 2 do |s| s.platform = Gem::Platform.local end
-
-    Gem::Specification.add_specs a_2, a_2_p
-
-    util_setup_spec_fetcher a_2, a_2_p
+    spec_fetcher do |fetcher|
+      fetcher.spec 'a', 2
+      a_2_p = fetcher.spec 'a', 2 do |s| s.platform = Gem::Platform.local end
+    end
 
     source = Gem::Source.new @gem_repo
     version = v 2
diff --git a/test/rubygems/test_gem_dependency_resolver_installer_set.rb b/test/rubygems/test_gem_dependency_resolver_installer_set.rb
index b6b50a12fe..516a4d03fe 100644
--- a/test/rubygems/test_gem_dependency_resolver_installer_set.rb
+++ b/test/rubygems/test_gem_dependency_resolver_installer_set.rb
@@ -4,15 +4,12 @@ require 'rubygems/dependency_resolver'
 class TestGemDependencyResolverInstallerSet < Gem::TestCase
 
   def test_load_spec
-    @fetcher = Gem::FakeFetcher.new
-    Gem::RemoteFetcher.fetcher = @fetcher
+    a_2_p = nil
 
-    a_2   = quick_spec 'a', 2
-    a_2_p = quick_spec 'a', 2 do |s| s.platform = Gem::Platform.local end
-
-    Gem::Specification.add_specs a_2, a_2_p
-
-    util_setup_spec_fetcher a_2, a_2_p
+    spec_fetcher do |fetcher|
+      fetcher.spec 'a', 2
+      a_2_p = fetcher.spec 'a', 2 do |s| s.platform = Gem::Platform.local end
+    end
 
     source = Gem::Source.new @gem_repo
     version = v 2
diff --git a/test/rubygems/test_gem_dependency_resolver_lock_set.rb b/test/rubygems/test_gem_dependency_resolver_lock_set.rb
new file mode 100644
index 0000000000..6142f2b8d0
--- /dev/null
+++ b/test/rubygems/test_gem_dependency_resolver_lock_set.rb
@@ -0,0 +1,57 @@
+require 'rubygems/test_case'
+require 'rubygems/dependency_resolver'
+
+class TestGemDependencyResolverLockSet < Gem::TestCase
+
+  def setup
+    super
+
+    @source = Gem::Source.new @gem_repo
+
+    @set = Gem::DependencyResolver::LockSet.new @source
+  end
+
+  def test_add
+    @set.add 'a', '2', Gem::Platform::RUBY
+
+    assert_equal %w[a-2], @set.specs.map { |t| t.full_name }
+
+    spec = @set.specs.first
+
+    assert_equal @set,                spec.set
+    assert_equal 'a',                 spec.name
+    assert_equal v(2),                spec.version
+    assert_equal Gem::Platform::RUBY, spec.platform
+    assert_equal @source,             spec.source
+  end
+
+  def test_find_all
+    @set.add 'a', '2', Gem::Platform::RUBY
+    @set.add 'b', '2', Gem::Platform::RUBY
+
+    found = @set.find_all dep 'a'
+
+    assert_equal %w[a-2], found.map { |s| s.full_name }
+  end
+
+  def test_load_spec
+    spec_fetcher do |fetcher|
+      fetcher.spec 'a', 2
+    end
+
+    version = v(2)
+    @set.add 'a', version, Gem::Platform::RUBY
+
+    loaded = @set.load_spec 'a', version, Gem::Platform::RUBY, @source
+
+    assert_kind_of Gem::Specification, loaded
+
+    assert_equal 'a-2', loaded.full_name
+  end
+
+  def test_prefetch
+    assert_respond_to @set, :prefetch
+  end
+
+end
+
diff --git a/test/rubygems/test_gem_dependency_resolver_vendor_set.rb b/test/rubygems/test_gem_dependency_resolver_vendor_set.rb
index b925ff3f47..227cf369c8 100644
--- a/test/rubygems/test_gem_dependency_resolver_vendor_set.rb
+++ b/test/rubygems/test_gem_dependency_resolver_vendor_set.rb
@@ -20,7 +20,7 @@ class TestGemDependencyResolverVendorSet < Gem::TestCase
   end
 
   def test_add_vendor_gem_missing
-    name, version, directory = vendor_gem
+    name, _, directory = vendor_gem
 
     FileUtils.rm_r directory
 
@@ -45,15 +45,19 @@ class TestGemDependencyResolverVendorSet < Gem::TestCase
 
     spec = @set.load_spec name, version, Gem::Platform::RUBY, nil
 
+    source = Gem::Source::Vendor.new directory
+
     expected = [
-      Gem::DependencyResolver::VendorSpecification.new(@set, spec, nil)
+      Gem::DependencyResolver::VendorSpecification.new(@set, spec, source)
     ]
 
     assert_equal expected, found
   end
 
   def test_load_spec
-    assert_raises KeyError do
+    error = Object.const_defined?(:KeyError) ? KeyError : IndexError
+
+    assert_raises error do
       @set.load_spec 'a', v(1), Gem::Platform::RUBY, nil
     end
   end
diff --git a/test/rubygems/test_gem_dependency_resolver_vendor_specification.rb b/test/rubygems/test_gem_dependency_resolver_vendor_specification.rb
index c1d668c777..77d78d1dc7 100644
--- a/test/rubygems/test_gem_dependency_resolver_vendor_specification.rb
+++ b/test/rubygems/test_gem_dependency_resolver_vendor_specification.rb
@@ -60,12 +60,6 @@ class TestGemDependencyResolverVendorSpecification < Gem::TestCase
     assert_equal Gem::Platform::RUBY, v_spec.platform
   end
 
-  def test_source
-    v_spec = Gem::DependencyResolver::VendorSpecification.new @set, @spec
-
-    assert_equal Gem::Source::Vendor.new, v_spec.source
-  end
-
   def test_version
     spec = Gem::Specification.new 'a', 1
 
diff --git a/test/rubygems/test_gem_remote_fetcher.rb b/test/rubygems/test_gem_remote_fetcher.rb
index fe6da708b6..5f36e71807 100644
--- a/test/rubygems/test_gem_remote_fetcher.rb
+++ b/test/rubygems/test_gem_remote_fetcher.rb
@@ -75,12 +75,6 @@ gems:
 
   PROXY_DATA = SERVER_DATA.gsub(/0.4.11/, '0.4.2')
 
-  # don't let 1.8 and 1.9 autotest collide
-  RUBY_VERSION =~ /(\d+)\.(\d+)\.(\d+)/
-  # don't let parallel runners collide
-  PROXY_PORT = process_based_port + 100 + $1.to_i * 100 + $2.to_i * 10 + $3.to_i
-  SERVER_PORT = process_based_port + 200 + $1.to_i * 100 + $2.to_i * 10 + $3.to_i
-
   DIR = File.expand_path(File.dirname(__FILE__))
 
   def setup
@@ -93,8 +87,8 @@ gems:
     self.class.enable_yaml = true
     self.class.enable_zip = false
 
-    base_server_uri = "http://localhost:#{SERVER_PORT}"
-    @proxy_uri = "http://localhost:#{PROXY_PORT}"
+    base_server_uri = "http://localhost:#{self.class.normal_server_port}"
+    @proxy_uri = "http://localhost:#{self.class.proxy_server_port}"
 
     @server_uri = base_server_uri + "/yaml"
     @server_z_uri = base_server_uri + "/yaml.Z"
@@ -712,12 +706,20 @@ gems:
     attr_accessor :enable_zip, :enable_yaml
 
     def start_servers
-      @normal_server ||= start_server(SERVER_PORT, SERVER_DATA)
-      @proxy_server  ||= start_server(PROXY_PORT, PROXY_DATA)
+      @normal_server ||= start_server(SERVER_DATA)
+      @proxy_server  ||= start_server(PROXY_DATA)
       @enable_yaml = true
       @enable_zip = false
     end
 
+    def normal_server_port
+      @normal_server[:server].config[:Port]
+    end
+
+    def proxy_server_port
+      @proxy_server[:server].config[:Port]
+    end
+
     DIR = File.expand_path(File.dirname(__FILE__))
 
     def start_ssl_server(config = {})
@@ -763,45 +765,45 @@ gems:
 
     private
 
-    def start_server(port, data)
-      Thread.new do
+    def start_server(data)
+      null_logger = NilLog.new
+      s = WEBrick::HTTPServer.new(
+        :Port            => 0,
+        :DocumentRoot    => nil,
+        :Logger          => null_logger,
+        :AccessLog       => null_logger
+        )
+      s.mount_proc("/kill") { |req, res| s.shutdown }
+      s.mount_proc("/yaml") { |req, res|
+        if @enable_yaml
+          res.body = data
+          res['Content-Type'] = 'text/plain'
+          res['content-length'] = data.size
+        else
+          res.status = "404"
+          res.body = "<h1>NOT FOUND</h1>"
+          res['Content-Type'] = 'text/html'
+        end
+      }
+      s.mount_proc("/yaml.Z") { |req, res|
+        if @enable_zip
+          res.body = Zlib::Deflate.deflate(data)
+          res['Content-Type'] = 'text/plain'
+        else
+          res.status = "404"
+          res.body = "<h1>NOT FOUND</h1>"
+          res['Content-Type'] = 'text/html'
+        end
+      }
+      th = Thread.new do
         begin
-          null_logger = NilLog.new
-          s = WEBrick::HTTPServer.new(
-            :Port            => port,
-            :DocumentRoot    => nil,
-            :Logger          => null_logger,
-            :AccessLog       => null_logger
-            )
-          s.mount_proc("/kill") { |req, res| s.shutdown }
-          s.mount_proc("/yaml") { |req, res|
-            if @enable_yaml
-              res.body = data
-              res['Content-Type'] = 'text/plain'
-              res['content-length'] = data.size
-            else
-              res.status = "404"
-              res.body = "<h1>NOT FOUND</h1>"
-              res['Content-Type'] = 'text/html'
-            end
-          }
-          s.mount_proc("/yaml.Z") { |req, res|
-            if @enable_zip
-              res.body = Zlib::Deflate.deflate(data)
-              res['Content-Type'] = 'text/plain'
-            else
-              res.status = "404"
-              res.body = "<h1>NOT FOUND</h1>"
-              res['Content-Type'] = 'text/html'
-            end
-          }
           s.start
         rescue Exception => ex
-          abort ex.message
-          puts "ERROR during server thread: #{ex.message}"
+          abort "ERROR during server thread: #{ex.message}"
         end
       end
-      sleep 0.2                 # Give the servers time to startup
+      th[:server] = s
+      th
     end
 
     def cert(filename)
diff --git a/test/rubygems/test_gem_request_set.rb b/test/rubygems/test_gem_request_set.rb
index 12a1942d54..4aaa15ac68 100644
--- a/test/rubygems/test_gem_request_set.rb
+++ b/test/rubygems/test_gem_request_set.rb
@@ -6,6 +6,8 @@ class TestGemRequestSet < Gem::TestCase
     super
 
     Gem::RemoteFetcher.fetcher = @fetcher = Gem::FakeFetcher.new
+
+    @DR = Gem::DependencyResolver
   end
 
   def test_gem
@@ -17,6 +19,15 @@ class TestGemRequestSet < Gem::TestCase
     assert_equal [Gem::Dependency.new("a", "=2")], rs.dependencies
   end
 
+  def test_gem_duplicate
+    rs = Gem::RequestSet.new
+
+    rs.gem 'a', '1'
+    rs.gem 'a', '2'
+
+    assert_equal [dep('a', '= 1', '= 2')], rs.dependencies
+  end
+
   def test_import
     rs = Gem::RequestSet.new
     rs.gem 'a'
@@ -26,6 +37,26 @@ class TestGemRequestSet < Gem::TestCase
     assert_equal [dep('a'), dep('b')], rs.dependencies
   end
 
+  def test_install_from_gemdeps
+    spec_fetcher do |fetcher|
+      fetcher.gem 'a', 2
+    end
+
+    rs = Gem::RequestSet.new
+    installed = []
+
+    Tempfile.open 'gem.deps.rb' do |io|
+      io.puts 'gem "a"'
+      io.flush
+
+      rs.install_from_gemdeps :gemdeps => io.path do |req, installer|
+        installed << req.full_name
+      end
+    end
+
+    assert_includes installed, 'a-2'
+  end
+
   def test_load_gemdeps
     rs = Gem::RequestSet.new
 
@@ -41,6 +72,19 @@ class TestGemRequestSet < Gem::TestCase
     assert rs.vendor_set
   end
 
+  def test_load_gemdeps_without_groups
+    rs = Gem::RequestSet.new
+
+    Tempfile.open 'gem.deps.rb' do |io|
+      io.puts 'gem "a", :group => :test'
+      io.flush
+
+      rs.load_gemdeps io.path, [:test]
+    end
+
+    assert_empty rs.dependencies
+  end
+
   def test_resolve
     a = util_spec "a", "2", "b" => ">= 2"
     b = util_spec "b", "2"
@@ -56,6 +100,21 @@ class TestGemRequestSet < Gem::TestCase
     assert_equal ["a-2", "b-2"], names
   end
 
+  def test_resolve_incompatible
+    a1 = util_spec 'a', 1
+    a2 = util_spec 'a', 2
+
+    rs = Gem::RequestSet.new
+    rs.gem 'a', '= 1'
+    rs.gem 'a', '= 2'
+
+    set = StaticSet.new [a1, a2]
+
+    assert_raises Gem::UnsatisfiableDependencyError do
+      rs.resolve set
+    end
+  end
+
   def test_resolve_vendor
     a_name, _, a_directory = vendor_gem 'a', 1 do |s|
       s.add_dependency 'b', '~> 2.0'
@@ -82,6 +141,9 @@ class TestGemRequestSet < Gem::TestCase
     names = res.map { |s| s.full_name }.sort
 
     assert_equal ["a-1", "b-2"], names
+
+    assert_equal [@DR::IndexSet, @DR::VendorSet],
+                 rs.sets.map { |set| set.class }
   end
 
   def test_sorted_requests
@@ -99,13 +161,10 @@ class TestGemRequestSet < Gem::TestCase
   end
 
   def test_install_into
-    a, ad = util_gem "a", "1", "b" => "= 1"
-    b, bd = util_gem "b", "1"
-
-    util_setup_spec_fetcher a, b
-
-    @fetcher.data["http://gems.example.com/gems/#{a.file_name}"] = Gem.read_binary(ad)
-    @fetcher.data["http://gems.example.com/gems/#{b.file_name}"] = Gem.read_binary(bd)
+    spec_fetcher do |fetcher|
+      fetcher.gem "a", "1", "b" => "= 1"
+      fetcher.gem "b", "1"
+    end
 
     rs = Gem::RequestSet.new
     rs.gem "a"
diff --git a/test/rubygems/test_gem_request_set_gem_dependency_api.rb b/test/rubygems/test_gem_request_set_gem_dependency_api.rb
index 5c35484421..367f3ba20a 100644
--- a/test/rubygems/test_gem_request_set_gem_dependency_api.rb
+++ b/test/rubygems/test_gem_request_set_gem_dependency_api.rb
@@ -16,20 +16,56 @@ class TestGemRequestSetGemDependencyAPI < Gem::TestCase
     @gda.instance_variable_set :@vendor_set, @vendor_set
   end
 
+  def with_engine_version name, version
+    engine               = RUBY_ENGINE if Object.const_defined? :RUBY_ENGINE
+    engine_version_const = "#{Gem.ruby_engine.upcase}_VERSION"
+    engine_version       = Object.const_get engine_version_const
+
+    Object.send :remove_const, :RUBY_ENGINE         if engine
+    Object.send :remove_const, engine_version_const if name == 'ruby' and
+      Object.const_defined? engine_version_const
+
+    new_engine_version_const = "#{name.upcase}_VERSION"
+    Object.const_set :RUBY_ENGINE,             name    if name
+    Object.const_set new_engine_version_const, version if version
+
+    Gem.instance_variable_set :@ruby_version, Gem::Version.new(version)
+
+    yield
+
+  ensure
+    Object.send :remove_const, :RUBY_ENGINE             if name
+    Object.send :remove_const, new_engine_version_const if version
+
+    Object.send :remove_const, engine_version_const     if name == 'ruby' and
+      Object.const_defined? engine_version_const
+
+    Object.const_set :RUBY_ENGINE,         engine         if engine
+    Object.const_set engine_version_const, engine_version unless
+      Object.const_defined? engine_version_const
+
+    Gem.send :remove_instance_variable, :@ruby_version if
+      Gem.instance_variables.include? :@ruby_version
+  end
+
   def test_gem
     @gda.gem 'a'
 
     assert_equal [dep('a')], @set.dependencies
+
+    assert_equal %w[a], @gda.requires['a']
   end
 
   def test_gem_group
     @gda.gem 'a', :group => :test
 
-    expected = {
-      :test => [['a']],
-    }
+    assert_equal [dep('a')], @set.dependencies
+  end
 
-    assert_equal expected, @gda.dependency_groups
+  def test_gem_group_without
+    @gda.without_groups << :test
+
+    @gda.gem 'a', :group => :test
 
     assert_empty @set.dependencies
   end
@@ -37,14 +73,7 @@ class TestGemRequestSetGemDependencyAPI < Gem::TestCase
   def test_gem_groups
     @gda.gem 'a', :groups => [:test, :development]
 
-    expected = {
-      :development => [['a']],
-      :test        => [['a']],
-    }
-
-    assert_equal expected, @gda.dependency_groups
-
-    assert_empty @set.dependencies
+    assert_equal [dep('a')], @set.dependencies
   end
 
   def test_gem_path
@@ -59,6 +88,133 @@ class TestGemRequestSetGemDependencyAPI < Gem::TestCase
     assert_equal "#{name}-#{version}", loaded.full_name
   end
 
+  def test_gem_platforms
+    with_engine_version 'ruby', '2.0.0' do
+      @gda.gem 'a', :platforms => :ruby
+
+      refute_empty @set.dependencies
+    end
+  end
+
+  def test_gem_platforms_bundler_ruby
+    win_platform, Gem.win_platform = Gem.win_platform?, false
+
+    with_engine_version 'ruby', '2.0.0' do
+      set = Gem::RequestSet.new
+      gda = @GDA.new set, 'gem.deps.rb'
+      gda.gem 'a', :platforms => :ruby
+
+      refute_empty set.dependencies
+    end
+
+    with_engine_version 'rbx', '2.0.0' do
+      set = Gem::RequestSet.new
+      gda = @GDA.new set, 'gem.deps.rb'
+      gda.gem 'a', :platforms => :ruby
+
+      refute_empty set.dependencies
+    end
+
+    with_engine_version 'jruby', '1.7.6' do
+      set = Gem::RequestSet.new
+      gda = @GDA.new set, 'gem.deps.rb'
+      gda.gem 'a', :platforms => :ruby
+
+      assert_empty set.dependencies
+    end
+
+    Gem.win_platform = true
+
+    with_engine_version 'ruby', '2.0.0' do
+      set = Gem::RequestSet.new
+      gda = @GDA.new set, 'gem.deps.rb'
+      gda.gem 'a', :platforms => :ruby
+
+      assert_empty set.dependencies
+    end
+
+    Gem.win_platform = win_platform
+  end
+
+  def test_gem_platforms_engine
+    with_engine_version 'jruby', '1.7.6' do
+      @gda.gem 'a', :platforms => :mri
+
+      assert_empty @set.dependencies
+    end
+  end
+
+  def test_gem_platforms_maglev
+    with_engine_version 'maglev', '1.0.0' do
+      set = Gem::RequestSet.new
+      gda = @GDA.new set, 'gem.deps.rb'
+      gda.gem 'a', :platforms => :ruby
+
+      refute_empty set.dependencies
+
+      set = Gem::RequestSet.new
+      gda = @GDA.new set, 'gem.deps.rb'
+      gda.gem 'a', :platforms => :maglev
+
+      refute_empty set.dependencies
+    end
+  end
+
+  def test_gem_platforms_multiple
+    win_platform, Gem.win_platform = Gem.win_platform?, false
+
+    with_engine_version 'ruby', '2.0.0' do
+      @gda.gem 'a', :platforms => [:mswin, :jruby]
+
+      assert_empty @set.dependencies
+    end
+
+  ensure
+    Gem.win_platform = win_platform
+  end
+
+  def test_gem_platforms_version
+    with_engine_version 'ruby', '2.0.0' do
+      @gda.gem 'a', :platforms => :ruby_18
+
+      assert_empty @set.dependencies
+    end
+  end
+
+  def test_gem_platforms_unknown
+    e = assert_raises ArgumentError do
+      @gda.gem 'a', :platforms => :unknown
+    end
+
+    assert_equal 'unknown platform :unknown', e.message
+  end
+
+  def test_gem_require
+    @gda.gem 'a', :require => %w[b c]
+
+    assert_equal [dep('a')], @set.dependencies
+
+    assert_equal %w[b c], @gda.requires['a']
+  end
+
+  def test_gem_require_false
+    @gda.gem 'a', :require => false
+
+    assert_equal [dep('a')], @set.dependencies
+
+    assert_empty @gda.requires
+  end
+
+  def test_gem_require_without_group
+    @gda.without_groups << :test
+
+    @gda.gem 'a', :group => :test
+
+    assert_empty @set.dependencies
+
+    assert_empty @gda.requires['a']
+  end
+
   def test_gem_requirement
     @gda.gem 'a', '~> 1.0'
 
@@ -77,6 +233,31 @@ class TestGemRequestSetGemDependencyAPI < Gem::TestCase
     assert_equal [dep('c')], @set.dependencies
   end
 
+  def test_gem_source_mismatch
+    name, _, directory = vendor_gem
+
+    gda = @GDA.new @set, nil
+    gda.gem name
+
+    e = assert_raises ArgumentError do
+      gda.gem name, :path => directory
+    end
+
+    assert_equal "duplicate source path: #{directory} for gem #{name}",
+                 e.message
+
+    gda = @GDA.new @set, nil
+    gda.instance_variable_set :@vendor_set, @vendor_set
+    gda.gem name, :path => directory
+
+    e = assert_raises ArgumentError do
+      gda.gem name
+    end
+
+    assert_equal "duplicate source (default) for gem #{name}",
+                 e.message
+  end
+
   def test_gem_deps_file
     assert_equal 'gem.deps.rb', @gda.gem_deps_file
 
@@ -85,25 +266,22 @@ class TestGemRequestSetGemDependencyAPI < Gem::TestCase
     assert_equal 'Gemfile', gda.gem_deps_file
   end
 
-  def test_group
-    @gda.group :test do
-      @gda.gem 'a'
-    end
+  def test_gem_group_method
+    groups = []
 
-    assert_equal [['a']], @gda.dependency_groups[:test]
+    @gda.group :a do
+      groups = @gda.send :gem_group, 'a', :group => :b, :groups => [:c, :d]
+    end
 
-    assert_empty @set.dependencies
+    assert_equal [:a, :b, :c, :d], groups.sort_by { |group| group.to_s }
   end
 
-  def test_group_multiple
-    @gda.group :a do
-      @gda.gem 'a', :group => :b, :groups => [:c, :d]
+  def test_group
+    @gda.group :test do
+      @gda.gem 'a'
     end
 
-    assert_equal [['a']], @gda.dependency_groups[:a]
-    assert_equal [['a']], @gda.dependency_groups[:b]
-    assert_equal [['a']], @gda.dependency_groups[:c]
-    assert_equal [['a']], @gda.dependency_groups[:d]
+    assert_equal [dep('a')], @set.dependencies
   end
 
   def test_load
@@ -121,18 +299,12 @@ end
 
       gda.load
 
-      expected = {
-        :test => [['b']],
-      }
-
-      assert_equal expected, gda.dependency_groups
-
-      assert_equal [dep('a')], @set.dependencies
+      assert_equal [dep('a'), dep('b')], @set.dependencies
     end
   end
 
   def test_name_typo
-    assert_same @GDA, Gem::RequestSet::DepedencyAPI
+    assert_same @GDA, Gem::RequestSet::GemDepedencyAPI
   end
 
   def test_platform_mswin
@@ -152,11 +324,30 @@ end
   end
 
   def test_platforms
+    win_platform, Gem.win_platform = Gem.win_platform?, false
+
     @gda.platforms :ruby do
       @gda.gem 'a'
     end
 
     assert_equal [dep('a')], @set.dependencies
+
+    @gda.platforms :mswin do
+      @gda.gem 'b'
+    end
+
+    assert_equal [dep('a')], @set.dependencies
+
+    Gem.win_platform = true
+
+    @gda.platforms :mswin do
+      @gda.gem 'c'
+    end
+
+    assert_equal [dep('a'), dep('c')], @set.dependencies
+
+  ensure
+    Gem.win_platform = win_platform
   end
 
   def test_ruby
@@ -164,8 +355,42 @@ end
   end
 
   def test_ruby_engine
-    assert @gda.ruby RUBY_VERSION,
-                     :engine => 'jruby', :engine_version => '1.7.4'
+    with_engine_version 'jruby', '1.7.6' do
+      assert @gda.ruby RUBY_VERSION,
+               :engine => 'jruby', :engine_version => '1.7.6'
+
+    end
+  end
+
+  def test_ruby_engine_mismatch_engine
+    with_engine_version 'ruby', '2.0.0' do
+      e = assert_raises Gem::RubyVersionMismatch do
+        @gda.ruby RUBY_VERSION, :engine => 'jruby', :engine_version => '1.7.4'
+      end
+
+      assert_equal 'Your ruby engine is ruby, but your gem.deps.rb requires jruby',
+                   e.message
+    end
+  end
+
+  def test_ruby_engine_mismatch_version
+    with_engine_version 'jruby', '1.7.6' do
+      e = assert_raises Gem::RubyVersionMismatch do
+        @gda.ruby RUBY_VERSION, :engine => 'jruby', :engine_version => '1.7.4'
+      end
+
+      assert_equal 'Your ruby engine version is jruby 1.7.6, but your gem.deps.rb requires jruby 1.7.4',
+                   e.message
+    end
+  end
+
+  def test_ruby_engine_no_engine_version
+    e = assert_raises ArgumentError do
+      @gda.ruby RUBY_VERSION, :engine => 'jruby'
+    end
+
+    assert_equal 'you must specify engine_version along with the ruby engine',
+                 e.message
   end
 
   def test_ruby_mismatch
@@ -173,7 +398,42 @@ end
       @gda.ruby '1.8.0'
     end
 
-    assert_equal "Your Ruby version is #{RUBY_VERSION}, but your gem.deps.rb specified 1.8.0", e.message
+    assert_equal "Your Ruby version is #{RUBY_VERSION}, but your gem.deps.rb requires 1.8.0", e.message
+  end
+
+  def test_source
+    sources = Gem.sources
+
+    @gda.source 'http://first.example'
+
+    assert_equal %w[http://first.example], Gem.sources
+
+    assert_same sources, Gem.sources
+
+    @gda.source 'http://second.example'
+
+    assert_equal %w[http://first.example http://second.example], Gem.sources
+  end
+
+  def test_with_engine_version
+    version = RUBY_VERSION
+    engine  = Gem.ruby_engine
+
+    engine_version_const = "#{Gem.ruby_engine.upcase}_VERSION"
+    engine_version       = Object.const_get engine_version_const
+
+    with_engine_version 'other', '1.2.3' do
+      assert_equal 'other', Gem.ruby_engine
+      assert_equal '1.2.3', OTHER_VERSION
+
+      assert_equal version, RUBY_VERSION if engine
+    end
+
+    assert_equal version, RUBY_VERSION
+    assert_equal engine,  Gem.ruby_engine
+
+    assert_equal engine_version, Object.const_get(engine_version_const) if
+      engine
   end
 
 end
diff --git a/test/rubygems/test_gem_request_set_lockfile.rb b/test/rubygems/test_gem_request_set_lockfile.rb
new file mode 100644
index 0000000000..9e947f54ec
--- /dev/null
+++ b/test/rubygems/test_gem_request_set_lockfile.rb
@@ -0,0 +1,404 @@
+require 'rubygems/test_case'
+require 'rubygems/request_set'
+require 'rubygems/request_set/lockfile'
+
+class TestGemRequestSetLockfile < Gem::TestCase
+
+  def setup
+    super
+
+    Gem::RemoteFetcher.fetcher = @fetcher = Gem::FakeFetcher.new
+
+    util_set_arch 'i686-darwin8.10.1'
+
+    @set = Gem::RequestSet.new
+
+    @vendor_set = Gem::DependencyResolver::VendorSet.new
+
+    @set.instance_variable_set :@vendor_set, @vendor_set
+
+    @gem_deps_file = 'gem.deps.rb'
+
+    @lockfile = Gem::RequestSet::Lockfile.new @set, @gem_deps_file
+  end
+
+  def write_gem_deps gem_deps
+    open @gem_deps_file, 'w' do |io|
+      io.write gem_deps
+    end
+  end
+
+  def write_lockfile lockfile
+    @lock_file = File.expand_path "#{@gem_deps_file}.lock"
+
+    open @lock_file, 'w' do |io|
+      io.write lockfile
+    end
+  end
+
+  def test_get
+    @lockfile.instance_variable_set :@tokens, [:token]
+
+    assert_equal :token, @lockfile.get
+  end
+
+  def test_get_type_mismatch
+    @lockfile.instance_variable_set :@tokens, [[:section, 'x', 5, 1]]
+
+    e = assert_raises Gem::RequestSet::Lockfile::ParseError do
+      @lockfile.get :text
+    end
+
+    expected = 'unexpected token [:section, "x"], expected :text (at 5:1)'
+
+    assert_equal expected, e.message
+
+    assert_equal 5, e.line
+    assert_equal 1, e.column
+    assert_equal File.expand_path("#{@gem_deps_file}.lock"), e.path
+  end
+
+  def test_get_type_value_mismatch
+    @lockfile.instance_variable_set :@tokens, [[:section, 'x', 5, 1]]
+
+    e = assert_raises Gem::RequestSet::Lockfile::ParseError do
+      @lockfile.get :section, 'y'
+    end
+
+    expected =
+      'unexpected token [:section, "x"], expected [:section, "y"] (at 5:1)'
+
+    assert_equal expected, e.message
+
+    assert_equal 5, e.line
+    assert_equal 1, e.column
+    assert_equal File.expand_path("#{@gem_deps_file}.lock"), e.path
+  end
+
+  def test_parse
+    write_lockfile <<-LOCKFILE
+GEM
+  remote: #{@gem_repo}
+  specs:
+    a (2)
+
+PLATFORMS
+  #{Gem::Platform::RUBY}
+
+DEPENDENCIES
+  a
+    LOCKFILE
+
+    @lockfile.parse
+
+    assert_equal [dep('a')], @set.dependencies
+
+    assert_equal [Gem::Platform::RUBY], @lockfile.platforms
+
+    lockfile_set = @set.sets.find do |set|
+      Gem::DependencyResolver::LockSet === set
+    end
+
+    assert lockfile_set, 'could not find a LockSet'
+
+    assert_equal %w[a-2], lockfile_set.specs.map { |tuple| tuple.full_name }
+  end
+
+  def test_peek
+    @lockfile.instance_variable_set :@tokens, [:token]
+
+    assert_equal :token, @lockfile.peek
+
+    assert_equal :token, @lockfile.get
+  end
+
+  def test_skip
+    tokens = [[:token]]
+
+    @lockfile.instance_variable_set :@tokens, tokens
+
+    @lockfile.skip :token
+
+    assert_empty tokens
+  end
+
+  def test_token_pos
+    assert_equal [5, 0], @lockfile.token_pos(5)
+
+    @lockfile.instance_variable_set :@line_pos, 2
+    @lockfile.instance_variable_set :@line, 1
+
+    assert_equal [3, 1], @lockfile.token_pos(5)
+  end
+
+  def test_tokenize
+    write_lockfile <<-LOCKFILE
+GEM
+  remote: #{@gem_repo}
+  specs:
+    a (2)
+
+PLATFORMS
+  #{Gem::Platform::RUBY}
+
+DEPENDENCIES
+  a
+    LOCKFILE
+
+    expected = [
+      [:section, 'GEM',                0, 0],
+      [:newline, nil,                  3, 0],
+      [:entry,   'remote',             2, 1],
+      [:text,    @gem_repo,           10, 1],
+      [:newline, nil,                 34, 1],
+      [:entry,   'specs',              2, 2],
+      [:newline, nil,                  8, 2],
+      [:text,    'a',                  4, 3],
+      [:l_paren, nil,                  6, 3],
+      [:text,    '2',                  7, 3],
+      [:r_paren, nil,                  8, 3],
+      [:newline, nil,                  9, 3],
+      [:newline, nil,                  0, 4],
+      [:section, 'PLATFORMS',          0, 5],
+      [:newline, nil,                  9, 5],
+      [:text,    Gem::Platform::RUBY,  2, 6],
+      [:newline, nil,                  6, 6],
+      [:newline, nil,                  0, 7],
+      [:section, 'DEPENDENCIES',       0, 8],
+      [:newline, nil,                 12, 8],
+      [:text,    'a',                  2, 9],
+      [:newline, nil,                  3, 9],
+    ]
+
+    assert_equal expected, @lockfile.tokenize
+  end
+
+  def test_tokenize_conflict_markers
+    write_lockfile '<<<<<<<'
+
+    e = assert_raises Gem::RequestSet::Lockfile::ParseError do
+      @lockfile.tokenize
+    end
+
+    assert_equal "your #{@lock_file} contains merge conflict markers (at 0:0)",
+                 e.message
+
+    write_lockfile '|||||||'
+
+    e = assert_raises Gem::RequestSet::Lockfile::ParseError do
+      @lockfile.tokenize
+    end
+
+    assert_equal "your #{@lock_file} contains merge conflict markers (at 0:0)",
+                 e.message
+
+    write_lockfile '======='
+
+    e = assert_raises Gem::RequestSet::Lockfile::ParseError do
+      @lockfile.tokenize
+    end
+
+    assert_equal "your #{@lock_file} contains merge conflict markers (at 0:0)",
+                 e.message
+
+    write_lockfile '>>>>>>>'
+
+    e = assert_raises Gem::RequestSet::Lockfile::ParseError do
+      @lockfile.tokenize
+    end
+
+    assert_equal "your #{@lock_file} contains merge conflict markers (at 0:0)",
+                 e.message
+  end
+
+  def test_to_s_gem
+    spec_fetcher do |fetcher|
+      fetcher.spec 'a', 2
+    end
+
+    @set.gem 'a'
+
+    expected = <<-LOCKFILE
+GEM
+  remote: #{@gem_repo}
+  specs:
+    a (2)
+
+PLATFORMS
+  #{Gem::Platform::RUBY}
+
+DEPENDENCIES
+  a
+    LOCKFILE
+
+    assert_equal expected, @lockfile.to_s
+  end
+
+  def test_to_s_gem_dependency
+    spec_fetcher do |fetcher|
+      fetcher.spec 'a', 2, 'c' => '>= 0', 'b' => '>= 0'
+      fetcher.spec 'b', 2
+      fetcher.spec 'c', 2
+    end
+
+    @set.gem 'a'
+
+    expected = <<-LOCKFILE
+GEM
+  remote: #{@gem_repo}
+  specs:
+    a (2)
+      b
+      c
+    b (2)
+    c (2)
+
+PLATFORMS
+  #{Gem::Platform::RUBY}
+
+DEPENDENCIES
+  a
+    LOCKFILE
+
+    assert_equal expected, @lockfile.to_s
+  end
+
+  def test_to_s_gem_dependency_non_default
+    spec_fetcher do |fetcher|
+      fetcher.spec 'a', 2, 'b' => '>= 1'
+      fetcher.spec 'b', 2
+    end
+
+    @set.gem 'b'
+    @set.gem 'a'
+
+    expected = <<-LOCKFILE
+GEM
+  remote: #{@gem_repo}
+  specs:
+    a (2)
+      b (>= 1)
+    b (2)
+
+PLATFORMS
+  #{Gem::Platform::RUBY}
+
+DEPENDENCIES
+  a
+  b
+    LOCKFILE
+
+    assert_equal expected, @lockfile.to_s
+  end
+
+  def test_to_s_gem_dependency_requirement
+    spec_fetcher do |fetcher|
+      fetcher.spec 'a', 2, 'b' => '>= 0'
+      fetcher.spec 'b', 2
+    end
+
+    @set.gem 'a', '>= 1'
+
+    expected = <<-LOCKFILE
+GEM
+  remote: #{@gem_repo}
+  specs:
+    a (2)
+      b
+    b (2)
+
+PLATFORMS
+  #{Gem::Platform::RUBY}
+
+DEPENDENCIES
+  a (>= 1)
+    LOCKFILE
+
+    assert_equal expected, @lockfile.to_s
+  end
+
+  def test_to_s_gem_path
+    name, version, directory = vendor_gem
+
+    @vendor_set.add_vendor_gem name, directory
+
+    @set.gem 'a'
+
+    expected = <<-LOCKFILE
+PATH
+  remote: #{directory}
+  specs:
+    #{name} (#{version})
+
+GEM
+
+PLATFORMS
+  #{Gem::Platform::RUBY}
+
+DEPENDENCIES
+  a!
+    LOCKFILE
+
+    assert_equal expected, @lockfile.to_s
+  end
+
+  def test_to_s_gem_path_absolute
+    name, version, directory = vendor_gem
+
+    @vendor_set.add_vendor_gem name, File.expand_path(directory)
+
+    @set.gem 'a'
+
+    expected = <<-LOCKFILE
+PATH
+  remote: #{directory}
+  specs:
+    #{name} (#{version})
+
+GEM
+
+PLATFORMS
+  #{Gem::Platform::RUBY}
+
+DEPENDENCIES
+  a!
+    LOCKFILE
+
+    assert_equal expected, @lockfile.to_s
+  end
+
+  def test_to_s_gem_platform
+    spec_fetcher do |fetcher|
+      fetcher.spec 'a', 2 do |spec|
+        spec.platform = Gem::Platform.local
+      end
+    end
+
+    @set.gem 'a'
+
+    expected = <<-LOCKFILE
+GEM
+  remote: #{@gem_repo}
+  specs:
+    a (2-#{Gem::Platform.local})
+
+PLATFORMS
+  #{Gem::Platform.local}
+
+DEPENDENCIES
+  a
+    LOCKFILE
+
+    assert_equal expected, @lockfile.to_s
+  end
+
+  def test_unget
+    @lockfile.instance_variable_set :@current_token, :token
+
+    @lockfile.unget
+
+    assert_equal :token, @lockfile.get
+  end
+
+end
+
diff --git a/test/rubygems/test_gem_requirement.rb b/test/rubygems/test_gem_requirement.rb
index 01db08e84f..29a4675bc9 100644
--- a/test/rubygems/test_gem_requirement.rb
+++ b/test/rubygems/test_gem_requirement.rb
@@ -3,6 +3,14 @@ require "rubygems/requirement"
 
 class TestGemRequirement < Gem::TestCase
 
+  def test_concat
+    r = req '>= 1'
+
+    r.concat ['< 2']
+
+    assert_equal [['>=', v(1)], ['<', v(2)]], r.requirements
+  end
+
   def test_equals2
     r = req "= 1.2"
     assert_equal r, r.dup
@@ -36,6 +44,12 @@ class TestGemRequirement < Gem::TestCase
     assert_equal false, r.none?
   end
 
+  def test_for_lockfile
+    assert_equal ' (~> 1.0)', req('~> 1.0').for_lockfile
+
+    assert_nil Gem::Requirement.default.for_lockfile
+  end
+
   def test_parse
     assert_equal ['=', Gem::Version.new(1)], Gem::Requirement.parse('  1')
     assert_equal ['=', Gem::Version.new(1)], Gem::Requirement.parse('= 1')
diff --git a/test/rubygems/test_gem_server.rb b/test/rubygems/test_gem_server.rb
index d50d3525ff..bf30399db2 100644
--- a/test/rubygems/test_gem_server.rb
+++ b/test/rubygems/test_gem_server.rb
@@ -85,6 +85,30 @@ class TestGemServer < Gem::TestCase
     Marshal.load(@res.body)
   end
 
+  def test_latest_specs_gemdirs
+    data = StringIO.new "GET /latest_specs.#{Gem.marshal_version} HTTP/1.0\r\n\r\n"
+    dir = "#{@gemhome}2"
+
+    spec = quick_spec 'z', 9
+
+    specs_dir = File.join dir, 'specifications'
+    FileUtils.mkdir_p specs_dir
+
+    open File.join(specs_dir, spec.spec_name), 'w' do |io|
+      io.write spec.to_ruby
+    end
+
+    server = Gem::Server.new dir, process_based_port, false
+
+    @req.parse data
+
+    server.latest_specs @req, @res
+
+    assert_equal 200, @res.status
+
+    assert_equal [['z', v(9), Gem::Platform::RUBY]], Marshal.load(@res.body)
+  end
+
   def test_latest_specs_gz
     data = StringIO.new "GET /latest_specs.#{Gem.marshal_version}.gz HTTP/1.0\r\n\r\n"
     @req.parse data
@@ -120,8 +144,41 @@ class TestGemServer < Gem::TestCase
     assert_equal 2, @server.server.listeners.length
   end
 
+  def test_quick_gemdirs
+    data = StringIO.new "GET /quick/Marshal.4.8/z-9.gemspec.rz HTTP/1.0\r\n\r\n"
+    dir = "#{@gemhome}2"
+
+    server = Gem::Server.new dir, process_based_port, false
+
+    @req.parse data
+
+    server.quick @req, @res
+
+    assert_equal 404, @res.status
+
+    spec = quick_spec 'z', 9
+
+    specs_dir = File.join dir, 'specifications'
+
+    FileUtils.mkdir_p specs_dir
+
+    open File.join(specs_dir, spec.spec_name), 'w' do |io|
+      io.write spec.to_ruby
+    end
+
+    data.rewind
+
+    req = WEBrick::HTTPRequest.new :Logger => nil
+    res = WEBrick::HTTPResponse.new :HTTPVersion => '1.0'
+    req.parse data
+
+    server.quick req, res
+
+    assert_equal 200, res.status
+  end
+
   def test_quick_missing
-    data = StringIO.new "GET /quick/z-9.gemspec.rz HTTP/1.0\r\n\r\n"
+    data = StringIO.new "GET /quick/Marshal.4.8/z-9.gemspec.rz HTTP/1.0\r\n\r\n"
     @req.parse data
 
     @server.quick @req, @res
@@ -188,6 +245,29 @@ class TestGemServer < Gem::TestCase
     assert_equal 'text/html', @res['content-type']
   end
 
+  def test_root_gemdirs
+    data = StringIO.new "GET / HTTP/1.0\r\n\r\n"
+    dir = "#{@gemhome}2"
+
+    spec = quick_spec 'z', 9
+
+    specs_dir = File.join dir, 'specifications'
+    FileUtils.mkdir_p specs_dir
+
+    open File.join(specs_dir, spec.spec_name), 'w' do |io|
+      io.write spec.to_ruby
+    end
+
+    server = Gem::Server.new dir, process_based_port, false
+
+    @req.parse data
+
+    server.root @req, @res
+
+    assert_equal 200, @res.status
+    assert_match 'z 9', @res.body
+  end
+
   def test_specs
     data = StringIO.new "GET /specs.#{Gem.marshal_version} HTTP/1.0\r\n\r\n"
     @req.parse data
@@ -203,6 +283,30 @@ class TestGemServer < Gem::TestCase
                  Marshal.load(@res.body)
   end
 
+  def test_specs_gemdirs
+    data = StringIO.new "GET /specs.#{Gem.marshal_version} HTTP/1.0\r\n\r\n"
+    dir = "#{@gemhome}2"
+
+    spec = quick_spec 'z', 9
+
+    specs_dir = File.join dir, 'specifications'
+    FileUtils.mkdir_p specs_dir
+
+    open File.join(specs_dir, spec.spec_name), 'w' do |io|
+      io.write spec.to_ruby
+    end
+
+    server = Gem::Server.new dir, process_based_port, false
+
+    @req.parse data
+
+    server.specs @req, @res
+
+    assert_equal 200, @res.status
+
+    assert_equal [['z', v(9), Gem::Platform::RUBY]], Marshal.load(@res.body)
+  end
+
   def test_specs_gz
     data = StringIO.new "GET /specs.#{Gem.marshal_version}.gz HTTP/1.0\r\n\r\n"
     @req.parse data
diff --git a/test/rubygems/test_gem_source.rb b/test/rubygems/test_gem_source.rb
index 61fb682001..ed981cbc09 100644
--- a/test/rubygems/test_gem_source.rb
+++ b/test/rubygems/test_gem_source.rb
@@ -68,6 +68,20 @@ class TestGemSource < Gem::TestCase
     assert cache_dir !~ /:/, "#{cache_dir} should not contain a :"
   end
 
+  def test_dependency_resolver_set_bundler_api
+    @fetcher.data["#{@gem_repo}api/v1/dependencies"] = 'data'
+
+    set = @source.dependency_resolver_set
+
+    assert_kind_of Gem::DependencyResolver::APISet, set
+  end
+
+  def test_dependency_resolver_set_marshal_api
+    set = @source.dependency_resolver_set
+
+    assert_kind_of Gem::DependencyResolver::IndexSet, set
+  end
+
   def test_fetch_spec
     spec_uri = "#{@gem_repo}#{Gem::MARSHAL_SPEC_DIR}#{@a1.spec_name}"
     @fetcher.data["#{spec_uri}.rz"] = util_zip(Marshal.dump(@a1))
diff --git a/test/rubygems/test_gem_source_list.rb b/test/rubygems/test_gem_source_list.rb
index e2d6da62cd..43db204a50 100644
--- a/test/rubygems/test_gem_source_list.rb
+++ b/test/rubygems/test_gem_source_list.rb
@@ -18,6 +18,10 @@ class TestGemSourceList < Gem::TestCase
     assert_equal [Gem::Source.new(@uri)], sl.sources
   end
 
+  def test_Enumerable
+    assert_includes Gem::SourceList.ancestors, Enumerable
+  end
+
   def test_append
     sl = Gem::SourceList.new
     source = (sl << @uri)
@@ -30,6 +34,16 @@ class TestGemSourceList < Gem::TestCase
     assert_equal [source], sl.sources
   end
 
+  def test_clear
+    sl = Gem::SourceList.new
+
+    sl << 'http://source.example'
+
+    sl.clear
+
+    assert_empty sl
+  end
+
   def test_replace
     sl = Gem::SourceList.new
     sl.replace [@uri]
@@ -49,6 +63,16 @@ class TestGemSourceList < Gem::TestCase
     end
   end
 
+  def test_empty?
+    sl = Gem::SourceList.new
+
+    assert_empty sl
+
+    sl << 'http://source.example'
+
+    refute_empty sl
+  end
+
   def test_equal_to_another_list
     sl2 = Gem::SourceList.new
     sl2 << Gem::Source.new(@uri)
diff --git a/test/rubygems/test_gem_source_local.rb b/test/rubygems/test_gem_source_local.rb
index b3b444ccde..19e1c4b759 100644
--- a/test/rubygems/test_gem_source_local.rb
+++ b/test/rubygems/test_gem_source_local.rb
@@ -1,5 +1,5 @@
 require 'rubygems/test_case'
-require 'rubygems/source/local'
+require 'rubygems/source'
 
 require 'fileutils'
 
diff --git a/test/rubygems/test_gem_source_vendor.rb b/test/rubygems/test_gem_source_vendor.rb
new file mode 100644
index 0000000000..17403a1fc8
--- /dev/null
+++ b/test/rubygems/test_gem_source_vendor.rb
@@ -0,0 +1,13 @@
+require 'rubygems/test_case'
+require 'rubygems/source'
+
+class TestGemSourceVendor < Gem::TestCase
+
+  def test_initialize
+    source = Gem::Source::Vendor.new 'vendor/foo'
+
+    assert_equal 'vendor/foo', source.uri
+  end
+
+end
+
diff --git a/test/rubygems/test_gem_spec_fetcher.rb b/test/rubygems/test_gem_spec_fetcher.rb
index 9e9a8e4d69..54e6e4176f 100644
--- a/test/rubygems/test_gem_spec_fetcher.rb
+++ b/test/rubygems/test_gem_spec_fetcher.rb
@@ -52,7 +52,22 @@ class TestGemSpecFetcher < Gem::TestCase
                   ['x',  Gem::Version.new(1),     'ruby']]
   end
 
-  def test_initialize_unwritable_home_dir
+  def test_initialize
+    fetcher = Gem::SpecFetcher.new
+
+    assert_same Gem.sources, fetcher.sources
+  end
+
+  def test_initialize_source
+    alternate = 'http://alternate.example'
+    fetcher = Gem::SpecFetcher.new alternate
+
+    refute_same Gem.sources, fetcher.sources
+
+    assert_equal alternate, fetcher.sources
+  end
+
+  def test_initialize_nonexistent_home_dir
     FileUtils.rmdir Gem.user_home
 
     assert Gem::SpecFetcher.new
diff --git a/test/rubygems/test_gem_specification.rb b/test/rubygems/test_gem_specification.rb
index 0623e8d51d..3936bc0681 100644
--- a/test/rubygems/test_gem_specification.rb
+++ b/test/rubygems/test_gem_specification.rb
@@ -873,6 +873,31 @@ dependencies: []
                  Gem::Specification.outdated_and_latest_version.to_a
   end
 
+  def test_self_remove_spec
+    assert_includes Gem::Specification.all_names, 'a-1'
+    assert_includes Gem::Specification.stubs.map { |s| s.full_name }, 'a-1'
+
+    Gem::Specification.remove_spec @a1
+
+    refute_includes Gem::Specification.all_names, 'a-1'
+    refute_includes Gem::Specification.stubs.map { |s| s.full_name }, 'a-1'
+  end
+
+  def test_self_remove_spec_removed
+    open @a1.spec_file, 'w' do |io|
+      io.write @a1.to_ruby
+    end
+
+    Gem::Specification.reset
+
+    FileUtils.rm @a1.spec_file # bug #698
+
+    Gem::Specification.remove_spec @a1
+
+    refute_includes Gem::Specification.all_names, 'a-1'
+    refute_includes Gem::Specification.stubs.map { |s| s.full_name }, 'a-1'
+  end
+
   DATA_PATH = File.expand_path "../data", __FILE__
 
   def test_handles_private_null_type
@@ -1886,7 +1911,7 @@ Gem::Specification.new do |s|
   s.rubygems_version = "#{Gem::VERSION}"
   s.summary = "this is a summary"
 
-  s.installed_by_version = "#{Gem::VERSION}"
+  s.installed_by_version = "#{Gem::VERSION}" if s.respond_to? :installed_by_version
 
   if s.respond_to? :specification_version then
     s.specification_version = #{Gem::Specification::CURRENT_SPECIFICATION_VERSION}
@@ -2128,6 +2153,15 @@ end
     Dir.chdir @tempdir do
       @a1.add_runtime_dependency     'b', '>= 1.0.rc1'
       @a1.add_development_dependency 'c', '>= 2.0.rc2'
+      @a1.add_runtime_dependency     'd', '~> 1.2.3'
+      @a1.add_runtime_dependency     'e', '~> 1.2.3.4'
+      @a1.add_runtime_dependency     'g', '~> 1.2.3', '>= 1.2.3.4'
+      @a1.add_runtime_dependency     'h', '>= 1.2.3', '<= 2'
+      @a1.add_runtime_dependency     'i', '>= 1.2'
+      @a1.add_runtime_dependency     'j', '>= 1.2.3'
+      @a1.add_runtime_dependency     'k', '> 1.2'
+      @a1.add_runtime_dependency     'l', '> 1.2.3'
+      @a1.add_runtime_dependency     'm', '~> 2.1.0'
 
       use_ui @ui do
         @a1.validate
@@ -2136,9 +2170,57 @@ end
       expected = <<-EXPECTED
 #{w}:  prerelease dependency on b (>= 1.0.rc1) is not recommended
 #{w}:  prerelease dependency on c (>= 2.0.rc2, development) is not recommended
+#{w}:  pessimistic dependency on d (~> 1.2.3) may be overly strict
+  if d is semantically versioned, use:
+    add_runtime_dependency 'd', '~> 1.2', '>= 1.2.3'
+#{w}:  pessimistic dependency on e (~> 1.2.3.4) may be overly strict
+  if e is semantically versioned, use:
+    add_runtime_dependency 'e', '~> 1.2', '>= 1.2.3.4'
+#{w}:  open-ended dependency on i (>= 1.2) is not recommended
+  if i is semantically versioned, use:
+    add_runtime_dependency 'i', '~> 1.2'
+#{w}:  open-ended dependency on j (>= 1.2.3) is not recommended
+  if j is semantically versioned, use:
+    add_runtime_dependency 'j', '~> 1.2', '>= 1.2.3'
+#{w}:  open-ended dependency on k (> 1.2) is not recommended
+  if k is semantically versioned, use:
+    add_runtime_dependency 'k', '~> 1.2', '> 1.2'
+#{w}:  open-ended dependency on l (> 1.2.3) is not recommended
+  if l is semantically versioned, use:
+    add_runtime_dependency 'l', '~> 1.2', '> 1.2.3'
+#{w}:  pessimistic dependency on m (~> 2.1.0) may be overly strict
+  if m is semantically versioned, use:
+    add_runtime_dependency 'm', '~> 2.1', '>= 2.1.0'
+#{w}:  See http://guides.rubygems.org/specification-reference/ for help
       EXPECTED
 
-      assert_match expected, @ui.error, 'warning'
+      assert_equal expected, @ui.error, 'warning'
+    end
+  end
+
+  def test_validate_dependencies_open_ended
+    util_setup_validate
+
+    Dir.chdir @tempdir do
+      @a1.add_runtime_dependency 'b', '~> 1.2'
+      @a1.add_runtime_dependency 'b', '>= 1.2.3'
+
+      use_ui @ui do
+        e = assert_raises Gem::InvalidSpecificationException do
+          @a1.validate
+        end
+
+        expected = <<-EXPECTED
+duplicate dependency on b (>= 1.2.3), (~> 1.2) use:
+    add_runtime_dependency 'b', '>= 1.2.3', '~> 1.2'
+        EXPECTED
+
+        assert_equal expected, e.message
+      end
+
+      assert_equal <<-EXPECTED, @ui.error
+#{w}:  See http://guides.rubygems.org/specification-reference/ for help
+      EXPECTED
     end
   end
 
diff --git a/test/rubygems/test_gem_stub_specification.rb b/test/rubygems/test_gem_stub_specification.rb
index 1c200ec1ed..bb04fb4dcc 100644
--- a/test/rubygems/test_gem_stub_specification.rb
+++ b/test/rubygems/test_gem_stub_specification.rb
@@ -23,8 +23,6 @@ class TestStubSpecification < Gem::TestCase
   def test_initialize_extension
     stub = stub_with_extension
 
-    gem_dir = File.join stub.gems_dir, stub.full_name
-
     ext_install_dir = Pathname(stub.extension_install_dir)
     full_gem_path = Pathname(stub.full_gem_path)
     relative_install_dir = ext_install_dir.relative_path_from full_gem_path