# frozen_string_literal: true

class TestGem

TEST_PLUGIN_LOAD = :loaded

end

# frozen_string_literal: true

class Gem::Commands::CrashCommand < Gem::Command

raise "crash"

end

end

class Gem::Commands::InterruptCommand < Gem::Command

def initialize

super('interrupt', 'Raises an Interrupt Exception', {})

end

def execute

raise Interrupt, "Interrupt exception"

end

end

Gem::CommandManager.instance.register_command :interrupt

if ENV["CI"] || ENV["TEST_SSL"]

class TestBundledCA < Gem::TestCase

THIS_FILE = File.expand_path __FILE__

def bundled_certificate_store

def test_accessing_new_index

assert_https('fastly.rubygems.org')

end

end

end

require 'shellwords'

class TestConfig < Gem::TestCase

def test_datadir

util_make_gems

spec = Gem::Specification.find_by_name("a")

assert_equal(Gem.ruby, ruby)

assert_match(/\/bad_rake.rb\z/, rake)

end

end

require 'rubygems/deprecate'

class TestDeprecate < Gem::TestCase

def setup

super

end

class Thing

extend Gem::Deprecate

attr_accessor :message

def foo

@message = "bar"

end

rubygems_deprecate :foo, :bar

end

class OtherThing

extend Gem::Deprecate

attr_accessor :message

def foo

@message = "bar"

end

deprecate :foo, :bar, 2099, 3

end

def test_deprecated_method_calls_the_old_method

assert_match(/Thing#foo is deprecated; use bar instead\./, err)

assert_match(/on or after 2099-03-01/, err)

end

end

require 'rbconfig'

class TestGem < Gem::TestCase

PLUGINS_LOADED = [] # rubocop:disable Style/MutableConstant

PROJECT_DIR = File.expand_path('../../..', __FILE__).tap(&Gem::UNTAINT)

def util_cache_dir

File.join Gem.dir, "cache"

end

end

require 'rubygems/security'

class TestGemAvailableSet < Gem::TestCase

def setup

super

assert_equal [a3a, a2, a2a, a1, a1a], g

end

end

require 'rubygems/test_case'

class TestGemBundlerVersionFinder < Gem::TestCase

def setup

super

bvf.filter!(specs)

specs

end

end

require 'rubygems/command'

class Gem::Command

public :parser

end

class TestGemCommand < Gem::TestCase

def setup

super

assert_equal expected, @ui.error

end

end

require 'rubygems/command_manager'

class TestGemCommandManager < Gem::TestCase

PROJECT_DIR = File.expand_path('../../..', __FILE__).tap(&Gem::UNTAINT)

def setup

ensure

Gem::Commands.send(:remove_const, :FooCommand)

end

end

require 'rubygems/package'

class TestGemCommandsBuildCommand < Gem::TestCase

CERT_FILE = cert_path 'public3072'

SIGNING_KEY = key_path 'private3072'

ensure

ENV["SOURCE_DATE_EPOCH"] = epoch

end

end

end

class TestGemCommandsCertCommand < Gem::TestCase

ALTERNATE_CERT = load_cert 'alternate'

EXPIRED_PUBLIC_CERT = load_cert 'expired'

assert_equal "invalid argument: --sign #{nonexistent}: does not exist",

e.message

end

end if defined?(OpenSSL::SSL) && !Gem.java_platform?

require 'rubygems/commands/check_command'

class TestGemCommandsCheckCommand < Gem::TestCase

def setup

super

refute_path_exists b.gem_dir

refute_path_exists b.spec_file

end

end

require 'rubygems/installer'

class TestGemCommandsCleanupCommand < Gem::TestCase

def setup

super

assert_path_exists d_1.gem_dir

assert_path_exists d_2.gem_dir

end

end

require 'rubygems/commands/contents_command'

class TestGemCommandsContentsCommand < Gem::TestCase

def setup

super

assert_equal Gem::Requirement.new('0.0.2'), @cmd.options[:version]

assert @cmd.options[:show_install_dir]

end

end

require 'rubygems/commands/dependency_command'

class TestGemCommandsDependencyCommand < Gem::TestCase

def setup

super

@stub_ui = Gem::MockGemUi.new

assert_equal "Gem a-2.a\n\n", @stub_ui.output

assert_equal '', @stub_ui.error

end

end

require 'rubygems/commands/environment_command'

class TestGemCommandsEnvironmentCommand < Gem::TestCase

def setup

super

assert_equal "#{Gem.platforms.join File::PATH_SEPARATOR}\n", @ui.output

assert_equal '', @ui.error

end

end

require 'rubygems/commands/fetch_command'

class TestGemCommandsFetchCommand < Gem::TestCase

def setup

super

assert_path_exists(File.join(@tempdir, a1.file_name),

"#{a1.full_name} not fetched")

end

end

require 'rubygems/commands/generate_index_command'

class TestGemCommandsGenerateIndexCommand < Gem::TestCase

def setup

super

"WARNING: The \"--no-modern\" option has been deprecated and will be removed in Rubygems 4.0. The `--no-modern` option is currently ignored. Modern indexes (specs, latest_specs, and prerelease_specs) are always generated.\n",

@ui.error

end

end

require "rubygems/command_manager"

class TestGemCommandsHelpCommand < Gem::TestCase

def setup

super

yield @ui.output, @ui.error

end

end

require 'rubygems/commands/info_command'

class TestGemCommandsInfoCommand < Gem::TestCase

def setup

super

assert_match %r{#{@gem.summary}\n}, @ui.output

assert_match "", @ui.error

end

end

require 'rubygems/rdoc'

class TestGemCommandsInstallCommand < Gem::TestCase

def setup

super

common_installer_setup

assert_equal " a-3", out.shift

assert_empty out

end

end

require 'rubygems/commands/list_command'

class TestGemCommandsListCommand < Gem::TestCase

def setup

super

assert_equal "true\n", @ui.output

assert_equal '', @ui.error

end

end

require 'rubygems/commands/lock_command'

class TestGemCommandsLockCommand < Gem::TestCase

def setup

super

assert_equal 'Could not find gem c-1, try using the full name', e.message

end

end

require 'rubygems/commands/mirror_command'

class TestGemCommandsMirrorCommand < Gem::TestCase

def setup

super

assert_match %r{Install the rubygems-mirror}i, @ui.error

end

end

require 'rubygems/commands/open_command'

class TestGemCommandsOpenCommand < Gem::TestCase

def setup

super

assert_match %r{'foo' is a default gem and can't be opened\.} , @ui.output

assert_equal "", @ui.error

end

end

require 'rubygems/commands/outdated_command'

class TestGemCommandsOutdatedCommand < Gem::TestCase

def setup

super

assert_equal "foo (0.2 < 2.0)\n", @ui.output

assert_equal "", @ui.error

end

end

require 'rubygems/commands/owner_command'

class TestGemCommandsOwnerCommand < Gem::TestCase

def setup

super

assert_match 'Code: ', @otp_ui.output

assert_equal '111111', @stub_fetcher.last_request['OTP']

end

end

require 'rubygems/commands/pristine_command'

class TestGemCommandsPristineCommand < Gem::TestCase

def setup

super

common_installer_setup

assert @cmd.options[:extensions]

assert @cmd.options[:extensions_set]

end

end

require 'rubygems/commands/push_command'

class TestGemCommandsPushCommand < Gem::TestCase

def setup

super

def singleton_gem_class

class << Gem; self; end

end

end

end

class TestGemCommandsQueryCommandWithInstalledGems < Gem::TestCase

include TestGemCommandsQueryCommandSetup

def test_execute

fetcher.spec 'a', '3.a'

end

end

end

class TestGemCommandsQueryCommandWithoutInstalledGems < Gem::TestCase

include TestGemCommandsQueryCommandSetup

def test_execute_platform

fetcher.download 'a', '3.a'

end

end

end

require 'rubygems/commands/search_command'

class TestGemCommandsSearchCommand < Gem::TestCase

def setup

super

def test_initialize

assert_equal :remote, @cmd.defaults[:domain]

end

end

require 'rubygems/commands/server_command'

class TestGemCommandsServerCommand < Gem::TestCase

def setup

super

assert_equal 'invalid argument: -p 65536: not a port number',

e.message

end

end

require 'rubygems/commands/setup_command'

class TestGemCommandsSetupCommand < Gem::TestCase

bundler_gemspec = File.expand_path("../../../bundler/lib/bundler/version.rb", __FILE__)

if File.exist?(bundler_gemspec)

BUNDLER_VERS = File.read(bundler_gemspec).match(/VERSION = "(#{Gem::Version::VERSION_PATTERN})"/)[1]

bundle_exec = sprintf Gem.default_exec_format, 'bundle'

File.join @install_dir, 'bin', bundle_exec

end

end unless Gem.java_platform?

require 'rubygems/installer'

class TestGemCommandsSigninCommand < Gem::TestCase

def setup

super

sign_in_ui

end

end

require 'rubygems/installer'

class TestGemCommandsSignoutCommand < Gem::TestCase

def setup

super

@cmd = Gem::Commands::SignoutCommand.new

assert_match %r{You are not currently signed in}, @sign_out_ui.error

end

end

require 'rubygems/commands/sources_command'

class TestGemCommandsSourcesCommand < Gem::TestCase

def setup

super

assert_equal "source cache successfully updated\n", @ui.output

assert_equal '', @ui.error

end

end

require 'rubygems/commands/specification_command'

class TestGemCommandsSpecificationCommand < Gem::TestCase

def setup

super

assert_match %r{s.name = "foo"}, @ui.output

assert_equal '', @ui.error

end

end

require 'rubygems/commands/stale_command'

class TestGemCommandsStaleCommand < Gem::TestCase

def setup

super

@stub_ui = Gem::MockGemUi.new

assert_equal("#{foo_bar.name}-#{foo_bar.version}", lines[0].split.first)

assert_equal("#{bar_baz.name}-#{bar_baz.version}", lines[1].split.first)

end

end

require 'rubygems/commands/uninstall_command'

class TestGemCommandsUninstallCommand < Gem::InstallerTestCase

def setup

super

@cmd = Gem::Commands::UninstallCommand.new

end

end

end

end

require 'rubygems/commands/unpack_command'

class TestGemCommandsUnpackCommand < Gem::TestCase

def setup

super

assert @cmd.options[:spec]

end

end

require 'rubygems/commands/update_command'

class TestGemCommandsUpdateCommand < Gem::TestCase

def setup

super

common_installer_setup

assert_equal " a-2", out.shift

assert_empty out

end

end

require 'rubygems/commands/which_command'

class TestGemCommandsWhichCommand < Gem::TestCase

def setup

super

Gem::Specification.reset

FileUtils.touch filename

end

end

end

require 'rubygems/commands/yank_command'

class TestGemCommandsYankCommand < Gem::TestCase

def setup

super

assert_equal 'key', @fetcher.last_request['Authorization']

assert_equal [yank_uri], @fetcher.paths

end

end

require 'rubygems/config_file'

class TestGemConfigFile < Gem::TestCase

def setup

super

util_config_file

assert_equal(true, @cfg.disable_default_gem_server)

end

end

require 'rubygems/dependency'

class TestGemDependency < Gem::TestCase

def test_initialize

d = dep "pkg", "> 1.0"

assert_equal dep("a", " >= 1.a").identity, :abs_latest

assert_equal dep("a").identity, :latest

end

end

require 'rubygems/security'

class TestGemDependencyInstaller < Gem::TestCase

def setup

super

common_installer_setup

@d1, @d2, @x1_m, @x1_o, @w1, @y1,

@y1_1_p, @z1].compact)

end

end

require 'rubygems/dependency_list'

class TestGemDependencyList < Gem::TestCase

def setup

super

@deplist.add @a1, @a2, @b1, @c2, @d1

end

end

require 'rubygems/test_case'

class TestGemDependencyResolutionError < Gem::TestCase

def setup

super

assert_match %r{^conflicting dependencies a \(= 1\) and a \(= 2\)$},

@error.message

end

end

require 'rubygems/doctor'

class TestGemDoctor < Gem::TestCase

def gem(name)

spec = quick_gem name do |gem|

gem.files = %W[lib/#{name}.rb Rakefile]

assert doctor.gem_repository?, 'gems installed'

end

end

require 'rubygems/installer'

class TestGemExtBuilder < Gem::TestCase

def setup

super

def test_build_extensions_install_ext_only

class << Gem

alias orig_install_extension_in_lib install_extension_in_lib

remove_method :install_extension_in_lib

def Gem.install_extension_in_lib

false

end

end

@spec.extensions << 'ext/extconf.rb'

refute_path_exists File.join @spec.gem_dir, 'lib', 'a', 'b.rb'

ensure

class << Gem

remove_method :install_extension_in_lib

alias install_extension_in_lib orig_install_extension_in_lib

end

end

assert_equal %w[--with-foo-dir=/nonexistent], builder.build_args

end

end unless Gem.java_platform?

require 'rubygems/ext'

class TestGemExtCmakeBuilder < Gem::TestCase

def setup

super

assert_contains_make_command '', output

assert_contains_make_command 'install', output

end

end

require 'rubygems/ext'

class TestGemExtConfigureBuilder < Gem::TestCase

def setup

super

assert_contains_make_command '', output[4]

assert_contains_make_command 'install', output[7]

end

end

require 'rubygems/ext'

class TestGemExtExtConfBuilder < Gem::TestCase

def setup

super

RbConfig::CONFIG.delete 'configure_args'

end

end

end

require 'rubygems/ext'

class TestGemExtRakeBuilder < Gem::TestCase

def setup

super

EO_MKRF

end

end

end

require 'rubygems/test_case'

class TestGemGemRunner < Gem::TestCase

def setup

super

assert_empty @ui.error

end

end

require 'rubygems/gemcutter_utilities'

class TestGemGemcutterUtilities < Gem::TestCase

def setup

super

@cmd.verify_api_key :missing

end

end

end

require 'rubygems/test_case'

class TestGemImpossibleDependenciesError < Gem::TestCase

def test_message_conflict

request = dependency_request dep('net-ssh', '>= 2.0.13'), 'rye', '0.9.8'

assert_equal expected, error.message

end

end

require 'rubygems/indexer'

class TestGemIndexer < Gem::TestCase

def setup

super

file = File.join dir, name

refute File.exist?(file), "#{file} exists"

end

end

require 'rubygems/dependency_installer'

class TestGemInstallUpdateOptions < Gem::InstallerTestCase

def setup

super

assert_equal true, @cmd.options[:post_install_message]

end

end

require 'rubygems/installer_test_case'

class TestGemInstaller < Gem::InstallerTestCase

def setup

super

common_installer_setup

def mask

0100755

end

end

require 'rubygems/command'

class TestGemLocalRemoteOptions < Gem::TestCase

def setup

super

assert_equal [@gem_repo], Gem.sources

end

end

require 'rubygems/name_tuple'

class TestGemNameTuple < Gem::TestCase

def test_full_name

n = Gem::NameTuple.new "a", Gem::Version.new(0), "ruby"

assert_equal "a-0", n.full_name

assert_equal 1, a_p.<=>(a)

end

end

require 'digest'

class TestGemPackage < Gem::Package::TarTestCase

def setup

super

StringIO.new tgz_io.string

end

end

require 'rubygems/simple_gem'

class TestGemPackageOld < Gem::TestCase

def setup

super

'and cannot be verified',

e.message

end

end

end

require 'rubygems/package'

class TestGemPackageTarHeader < Gem::Package::TarTestCase

def setup

super

assert_equal 0, tar_header.uid

assert_equal 0, tar_header.gid

end

end

require 'rubygems/package'

class TestGemPackageTarReader < Gem::Package::TarTestCase

def test_each_entry

tar = tar_dir_header "foo", "bar", 0, Time.now

tar << tar_file_header("bar", "baz", 0, 0, Time.now)

ensure

io.close!

end

end

require 'rubygems/package'

class TestGemPackageTarReaderEntry < Gem::Package::TarTestCase

def setup

super

assert_equal char, @entry.getc

end

end

require 'minitest/mock'

class TestGemPackageTarWriter < Gem::Package::TarTestCase

def setup

super

end

assert_includes exception.message, name

end

end

end

class TestGemPackageTask < Gem::TestCase

def test_gem_package

original_rake_fileutils_verbosity = RakeFileUtils.verbose_flag

RakeFileUtils.verbose_flag = false

assert_equal 'pkg/nokogiri-1.5.0-java', pkg.package_dir_path

end

end if defined?(Rake::PackageTask)

require 'fileutils'

class TestGemPathSupport < Gem::TestCase

def setup

super

assert_equal dir, ps.home

assert_equal [dir, not_existing], ps.path

end

end

require 'rbconfig'

class TestGemPlatform < Gem::TestCase

def test_self_local

util_set_arch 'i686-darwin8.10.1'

def refute_local_match(name)

refute_match Gem::Platform.local, name

end

end

require 'rubygems/rdoc'

class TestGemRDoc < Gem::TestCase

Gem::RDoc.load_rdoc

def setup

FileUtils.rm_r @a.doc_dir

end

end

end

# proxy is configured.

class TestGemRemoteFetcher < Gem::TestCase

include Gem::DefaultUserInteraction

SERVER_DATA = <<-EOY.freeze

end

class NilLog < WEBrick::Log

def log(level, data) #Do nothing

end

end

private

def key(filename)

OpenSSL::PKey::RSA.new(File.read(File.join(__dir__, filename)))

end

end if defined?(OpenSSL::SSL)

end

class TestGemRequest < Gem::TestCase

CA_CERT_FILE = cert_path 'ca'

CHILD_CERT = load_cert 'child'

EXPIRED_CERT = load_cert 'expired'

end

class Conn

attr_accessor :payload

def new(*args); self; end

self.payload = req

@response

end

end

end if defined?(OpenSSL::SSL)

require 'timeout'

class TestGemRequestConnectionPool < Gem::TestCase

class FakeHttp

def initialize(*args)

end

def start

end

end

def setup

end

end.join

end

end

require 'rubygems/request_set'

class TestGemRequestSet < Gem::TestCase

def setup

super

assert_empty deps

end

end

require 'rubygems/request_set'

class TestGemRequestSetGemDependencyAPI < Gem::TestCase

def setup

super

assert_equal engine_version, RUBY_ENGINE_VERSION if engine

end

end unless Gem.java_platform?

require 'rubygems/request_set/lockfile'

class TestGemRequestSetLockfile < Gem::TestCase

def setup

super

assert_equal 'hello', File.read(gem_deps_lock_file)

end

end

require 'rubygems/request_set/lockfile/parser'

class TestGemRequestSetLockfileParser < Gem::TestCase

def setup

super

@gem_deps_file = 'gem.deps.rb'

parser = tokenizer.make_parser set, platforms

parser.parse

end

end

require 'rubygems/request_set/lockfile/parser'

class TestGemRequestSetLockfileTokenizer < Gem::TestCase

def setup

super

def tokenize_lockfile

Gem::RequestSet::Lockfile::Tokenizer.from_file(@lock_file).to_a

end

end

require "rubygems/requirement"

class TestGemRequirement < Gem::TestCase

def test_concat

r = req '>= 1'

refute req(requirement).satisfied_by?(v(version)),

"#{requirement} is not satisfied by #{version}"

end

end

require 'rubygems/test_case'

class TestGemResolver < Gem::TestCase

def setup

super

assert_match "No match for 'a (= 1)' on this platform. Found: c-p-1",

e.message

end

end

require 'rubygems/test_case'

class TestGemResolverActivationRequest < Gem::TestCase

def setup

super

assert @req.installed?

end

end

require 'rubygems/test_case'

class TestGemResolverAPISet < Gem::TestCase

def setup

super

assert_empty set.instance_variable_get :@data

end

end

require 'rubygems/test_case'

class TestGemResolverAPISpecification < Gem::TestCase

def test_initialize

set = Gem::Resolver::APISet.new

data = {

assert_kind_of Gem::Specification, spec

assert_equal 'j-1-java', spec.full_name

end

end

require 'rubygems/test_case'

class TestGemResolverBestSet < Gem::TestCase

def setup

super

assert_equal error, e

end

end

require 'rubygems/test_case'

class TestGemResolverComposedSet < Gem::TestCase

def test_errors

index_set = Gem::Resolver::IndexSet.new

current_set = Gem::Resolver::CurrentSet.new

refute best_set.remote?

refute current_set.remote?

end

end

require 'rubygems/test_case'

class TestGemResolverConflict < Gem::TestCase

def test_explanation

root =

dependency_request dep('net-ssh', '>= 2.0.13'), 'rye', '0.9.8'

assert_equal expected, conflict.request_path(child.requester)

end

end

require 'rubygems/test_case'

class TestGemResolverDependencyRequest < Gem::TestCase

def setup

super

assert_equal dependency, dr.dependency

end

end

require 'rubygems/test_case'

class TestGemResolverGitSet < Gem::TestCase

def setup

super

assert_equal "#{@gemhome}2", spec.source.root_dir

end

end

require 'rubygems/installer'

class TestGemResolverGitSpecification < Gem::TestCase

def setup

super

assert called

end

end

require 'rubygems/test_case'

class TestGemResolverIndexSet < Gem::TestCase

def setup

super

assert_equal %w[a-1.a], found.map {|s| s.full_name }

end

end

require 'rubygems/available_set'

class TestGemResolverIndexSpecification < Gem::TestCase

def test_initialize

set = Gem::Resolver::IndexSet.new

source = Gem::Source.new @gem_repo

assert_equal a_2_p.full_name, spec.full_name

end

end

require 'rubygems/test_case'

class TestGemResolverInstalledSpecification < Gem::TestCase

def setup

super

assert b_spec.installable_platform?

end

end

require 'rubygems/test_case'

class TestGemResolverInstallerSet < Gem::TestCase

def test_add_always_install

spec_fetcher do |fetcher|

fetcher.download 'a', 1

refute set.consider_local?

refute set.consider_remote?

end

end

require 'rubygems/available_set'

class TestGemResolverLocalSpecification < Gem::TestCase

def setup

super

assert b_spec.installable_platform?

end

end

require 'rubygems/test_case'

class TestGemResolverLockSet < Gem::TestCase

def setup

super

def test_prefetch

assert_respond_to @set, :prefetch

end

end

require 'rubygems/resolver'

class TestGemResolverLockSpecification < Gem::TestCase

def setup

super

assert_same real_spec, l_spec.spec

end

end

require 'rubygems/test_case'

class TestGemResolverRequirementList < Gem::TestCase

def setup

super

assert_equal [req], @list.each.to_a

end

end

require 'rubygems/test_case'

class TestGemResolverSpecification < Gem::TestCase

class TestSpec < Gem::Resolver::Specification

attr_writer :source

attr_reader :spec

@spec = spec

end

end

def test_install

assert_equal source, a_spec.source

end

end

require 'rubygems/test_case'

class TestGemResolverVendorSet < Gem::TestCase

def setup

super

@set.load_spec 'b', v(1), Gem::Platform::RUBY, nil

end

end

end

require 'rubygems/test_case'

class TestGemResolverVendorSpecification < Gem::TestCase

def setup

super

assert_equal v(1), v_spec.version

end

end

end

class TestGemSecurity < Gem::TestCase

CHILD_KEY = load_key 'child'

ALTERNATE_CERT = load_cert 'child'

assert_equal key.to_pem, key_from_file.to_pem

end

end if defined?(OpenSSL::SSL) && !Gem.java_platform?

end

class TestGemSecurityPolicy < Gem::TestCase

ALTERNATE_KEY = load_key 'alternate'

INVALID_KEY = load_key 'invalid'

CHILD_KEY = load_key 'child'

return digests, signatures

end

end if defined?(OpenSSL::SSL)

end

class TestGemSecuritySigner < Gem::TestCase

ALTERNATE_KEY = load_key 'alternate'

CHILD_KEY = load_key 'child'

GRANDCHILD_KEY = load_key 'grandchild'

signer.sign 'hello'

end

end

end if defined?(OpenSSL::SSL)

end

class TestGemSecurityTrustDir < Gem::TestCase

CHILD_CERT = load_cert 'child'

def setup

assert_equal mask, File.stat(@dest_dir).mode unless win_platform?

end

end if defined?(OpenSSL::SSL)

require 'stringio'

class Gem::Server

attr_reader :server

end

class TestGemServer < Gem::TestCase

def process_based_port

0

end

@server.instance_variable_set :@server, webrick

end

end

require 'timeout'

class TestGemSilentUI < Gem::TestCase

def setup

super

@sui = Gem::SilentUI.new

assert_empty out, 'No output'

assert_empty err, 'No output'

end

end

require 'rubygems/indexer'

class TestGemSource < Gem::TestCase

def tuple(*args)

Gem::NameTuple.new(*args)

end

distance_threshold = 5

assert rubygems_source.typo_squatting?("rubysertgems.org", distance_threshold)

end

end

require 'rubygems/test_case'

class TestGemSourceFetchProblem < Gem::TestCase

def test_exception

source = Gem::Source.new @gem_repo

error = RuntimeError.new 'test'

refute_match sf.wordy, 'secret'

end

end

require 'rubygems/source'

class TestGemSourceGit < Gem::TestCase

def setup

super

assert_equal '291c4caac7feba8bb64c297987028acb3dde6cfe',

source.uri_hash

end

end

require 'rubygems/source'

class TestGemSourceInstalled < Gem::TestCase

def test_spaceship

a1 = quick_gem 'a', '1'

util_build_gem a1

assert_equal(1, vendor.<=>(installed), 'vendor <=> installed')

assert_equal(-1, installed.<=>(vendor), 'installed <=> vendor')

end

end

require 'rubygems/test_case'

class TestGemSourceList < Gem::TestCase

def setup

super

@sl.delete Gem::Source.new(@uri)

assert_equal @sl.sources, []

end

end

require 'fileutils'

class TestGemSourceLocal < Gem::TestCase

def setup

super

assert_equal(-1, specific.<=>(local), 'specific <=> local')

assert_equal(1, local.<=>(specific), 'local <=> specific')

end

end

require 'rubygems/test_case'

class TestGemSourceLock < Gem::TestCase

def test_fetch_spec

spec_fetcher do |fetcher|

fetcher.spec 'a', 1

assert_equal URI(@gem_repo), lock.uri

end

end

require 'rubygems/source'

class TestGemSourceSpecificFile < Gem::TestCase

def setup

super

assert_equal(0, a1_source.<=>(a1_source), 'a1_source <=> a1_source')

assert_equal(1, a2_source.<=>(a1_source), 'a2_source <=> a1_source')

end

end

require 'rubygems/source'

class TestGemSourceVendor < Gem::TestCase

def test_initialize

source = Gem::Source::Vendor.new 'vendor/foo'

assert_equal(1, vendor.<=>(installed), 'vendor <=> installed')

assert_equal(-1, installed.<=>(vendor), 'installed <=> vendor')

end

end

require 'rubygems/spec_fetcher'

class TestGemSpecFetcher < Gem::TestCase

def tuple(*args)

Gem::NameTuple.new(*args)

end

assert_equal({}, specs)

assert_kind_of Gem::SourceFetchProblem, errors.first

end

end

require 'rubygems/platform'

class TestGemSpecification < Gem::TestCase

LEGACY_YAML_SPEC = <<-EOF.freeze

--- !ruby/object:Gem::Specification

rubygems_version: "1.0"

RbConfig::CONFIG['ENABLE_SHARED'], 'no'

class << Gem

alias orig_default_ext_dir_for default_ext_dir_for

remove_method :default_ext_dir_for

def Gem.default_ext_dir_for(base_dir)

'elsewhere'

end

end

ext_spec

RbConfig::CONFIG['ENABLE_SHARED'] = enable_shared

class << Gem

remove_method :default_ext_dir_for

alias default_ext_dir_for orig_default_ext_dir_for

end

end

def test_require_paths_default_ext_dir_for

class << Gem

send :alias_method, :orig_default_ext_dir_for, :default_ext_dir_for

remove_method :default_ext_dir_for

end

def Gem.default_ext_dir_for(base_dir)

end

ensure

class << Gem

send :remove_method, :default_ext_dir_for

send :alias_method, :default_ext_dir_for, :orig_default_ext_dir_for

send :remove_method, :orig_default_ext_dir_for

end

end

ensure

$VERBOSE = old_verbose

end

end

require 'timeout'

class TestGemStreamUI < Gem::TestCase

# increase timeout with MJIT for --jit-wait testing

mjit_enabled = defined?(RubyVM::MJIT) && RubyVM::MJIT.enabled?

SHORT_TIMEOUT = (RUBY_ENGINE == "ruby" && !mjit_enabled) ? 0.1 : 1.0

reporter.fetch 'a.gem', 1024

assert_equal "", @out.string

end

end

require "rubygems/stub_specification"

class TestStubSpecification < Gem::TestCase

FOO = File.join SPECIFICATIONS, "foo-0.0.1-x86-mswin32.gemspec"

BAR = File.join SPECIFICATIONS, "bar-0.0.2.gemspec"

return stub

end

end

end

require "rubygems/text"

class TestGemText < Gem::TestCase

include Gem::Text

def test_format_text

def test_clean_text

assert_equal ".]2;nyan.", clean_text("\e]2;nyan\a")

end

end

require 'rubygems/uninstaller'

class TestGemUninstaller < Gem::InstallerTestCase

def setup

super

@installer = setup_base_installer

refute File.exist?(plugin_path), 'last version uninstalled, but plugin still present'

end

end

require 'rubygems/test_case'

class TestGemUnsatisfiableDependencyError < Gem::TestCase

def setup

super

def test_version

assert_equal @a_dep.requirement, @e.version

end

end

require 'rubygems/uri_formatter'

class TestGemUriFormatter < Gem::TestCase

def test_normalize_uri

assert_equal 'FILE://example/',

Gem::UriFormatter.new('FILE://example/').normalize

def test_unescape

assert_equal 'a@b\c', Gem::UriFormatter.new('a%40b%5Cc').unescape

end

end

require 'rubygems/util'

class TestGemUtil < Gem::TestCase

def test_class_popen

skip "popen with a block does not behave well on jruby" if Gem.java_platform?

assert_equal "0\n", Gem::Util.popen(*ruby_with_rubygems_in_load_path, '-e', 'p 0')

path = "/home/skillet"

assert_equal "/home/skillet", Gem::Util.correct_for_windows_path(path)

end

end

require "rubygems/validator"

class TestGemValidator < Gem::TestCase

def setup

super

assert_empty alien

end

end

require "minitest/benchmark"

class TestGemVersion < Gem::TestCase

class V < ::Gem::Version

end

def refute_version_equal(unexpected, actual)

refute_equal v(unexpected), v(actual)

end

end

require 'rubygems/version_option'

class TestGemVersionOption < Gem::TestCase

def setup

super

assert_equal expected, @cmd.options

end

end

require 'rubygems/test_case'

class TestKernel < Gem::TestCase

def setup

super

assert $:.any? {|p| %r{bundler-1/lib} =~ p }

end

end

end

require "open3"

class TestProjectSanity < Gem::TestCase

def test_manifest_is_up_to_date

skip unless File.exist?(File.expand_path("../../../Rakefile", __FILE__))

assert status.success?, err

end

end

require 'rubygems/test_case'

class TestRemoteFetchError < Gem::TestCase

def test_password_redacted

error = Gem::RemoteFetcher::FetchError.new('There was an error fetching', 'https://user:[email protected]')

refute_match 'secret', error.to_s

error = Gem::RemoteFetcher::FetchError.new('There was an error fetching', 'https://gemsource.org')

assert_equal error.to_s, 'There was an error fetching (https://gemsource.org)'

end

end

require 'rubygems'

class TestGemRequire < Gem::TestCase

class Latch

def initialize(count = 1)

@count = count

@lock = Monitor.new

@cv.wait_while { @count > 0 }

end

end

end

def setup

def test_try_activate_error_unlocks_require_monitor

silence_warnings do

class << ::Gem

alias old_try_activate try_activate

def try_activate(*); raise 'raised from try_activate'; end

end

end

ensure

silence_warnings do

class << ::Gem

alias try_activate old_try_activate

end

end

Kernel::RUBYGEMS_ACTIVATION_MONITOR.exit

dash_i_lib_arg

end

end