summaryrefslogtreecommitdiff
path: root/test/ruby/test_require.rb
diff options
context:
space:
mode:
Diffstat (limited to 'test/ruby/test_require.rb')
-rw-r--r--test/ruby/test_require.rb900
1 files changed, 719 insertions, 181 deletions
diff --git a/test/ruby/test_require.rb b/test/ruby/test_require.rb
index a7c75d06bf..a71fe0932e 100644
--- a/test/ruby/test_require.rb
+++ b/test/ruby/test_require.rb
@@ -1,40 +1,57 @@
+# frozen_string_literal: false
require 'test/unit'
require 'tempfile'
-require_relative 'envutil'
require 'tmpdir'
class TestRequire < Test::Unit::TestCase
def test_load_error_path
- filename = "should_not_exist"
- error = assert_raise(LoadError) do
- require filename
- end
- assert_equal filename, error.path
+ Tempfile.create(["should_not_exist", ".rb"]) {|t|
+ filename = t.path
+ t.close
+ File.unlink(filename)
+
+ error = assert_raise(LoadError) do
+ require filename
+ end
+ assert_equal filename, error.path
+
+ # with --disable=gems
+ assert_separately(["-", filename], "#{<<~"begin;"}\n#{<<~'end;'}")
+ begin;
+ filename = ARGV[0]
+ path = Struct.new(:to_path).new(filename)
+ error = assert_raise(LoadError) do
+ require path
+ end
+ assert_equal filename, error.path
+ end;
+ }
end
def test_require_invalid_shared_object
- t = Tempfile.new(["test_ruby_test_require", ".so"])
- t.puts "dummy"
- t.close
-
- assert_in_out_err([], <<-INPUT, %w(:ok), [])
- begin
- require \"#{ t.path }\"
- rescue LoadError
- p :ok
- end
- INPUT
+ Tempfile.create(["test_ruby_test_require", ".so"]) {|t|
+ t.puts "dummy"
+ t.close
+
+ assert_separately([], "#{<<~"begin;"}\n#{<<~"end;"}")
+ begin;
+ $:.replace([IO::NULL])
+ assert_raise(LoadError) do
+ require \"#{ t.path }\"
+ end
+ end;
+ }
end
def test_require_too_long_filename
- assert_in_out_err(["RUBYOPT"=>nil], <<-INPUT, %w(:ok), [])
- begin
+ assert_separately(["RUBYOPT"=>nil], "#{<<~"begin;"}\n#{<<~"end;"}")
+ begin;
+ $:.replace([IO::NULL])
+ assert_raise(LoadError) do
require '#{ "foo/" * 10000 }foo'
- rescue LoadError
- p :ok
end
- INPUT
+ end;
begin
assert_in_out_err(["-S", "-w", "foo/" * 1024 + "foo"], "") do |r, e|
@@ -52,10 +69,78 @@ class TestRequire < Test::Unit::TestCase
bug3758 = '[ruby-core:31915]'
["\u{221e}", "\x82\xa0".force_encoding("cp932")].each do |path|
e = assert_raise(LoadError, bug3758) {require path}
- assert_match(/#{path}\z/, e.message, bug3758)
+ assert_operator(e.message, :end_with?, path, bug3758)
end
end
+ def test_require_nonascii_path
+ bug8165 = '[ruby-core:53733] [Bug #8165]'
+ encoding = 'filesystem'
+ assert_require_nonascii_path(encoding, bug8165)
+ end
+
+ def test_require_nonascii_path_utf8
+ bug8676 = '[ruby-core:56136] [Bug #8676]'
+ encoding = Encoding::UTF_8
+ return if Encoding.find('filesystem') == encoding
+ assert_require_nonascii_path(encoding, bug8676)
+ end
+
+ def test_require_nonascii_path_shift_jis
+ bug8676 = '[ruby-core:56136] [Bug #8676]'
+ encoding = Encoding::Shift_JIS
+ return if Encoding.find('filesystem') == encoding
+ assert_require_nonascii_path(encoding, bug8676)
+ end
+
+ case RUBY_PLATFORM
+ when /cygwin/, /mswin/, /mingw/, /darwin/
+ def self.ospath_encoding(path)
+ Encoding::UTF_8
+ end
+ else
+ def self.ospath_encoding(path)
+ path.encoding
+ end
+ end
+
+ def prepare_require_path(dir, encoding)
+ require 'enc/trans/single_byte'
+ Dir.mktmpdir {|tmp|
+ begin
+ require_path = File.join(tmp, dir, 'foo.rb').encode(encoding)
+ rescue
+ skip "cannot convert path encoding to #{encoding}"
+ end
+ Dir.mkdir(File.dirname(require_path))
+ open(require_path, "wb") {|f| f.puts '$:.push __FILE__'}
+ begin
+ load_path = $:.dup
+ features = $".dup
+ yield require_path
+ ensure
+ $:.replace(load_path)
+ $".replace(features)
+ end
+ }
+ end
+
+ def assert_require_nonascii_path(encoding, bug)
+ prepare_require_path("\u3042" * 5, encoding) {|require_path|
+ begin
+ # leave paths for require encoding objects
+ bug = "#{bug} require #{encoding} path"
+ require_path = "#{require_path}"
+ $:.clear
+ assert_nothing_raised(LoadError, bug) {
+ assert(require(require_path), bug)
+ assert_equal(self.class.ospath_encoding(require_path), $:.last.encoding, '[Bug #8753]')
+ assert(!require(require_path), bug)
+ }
+ end
+ }
+ end
+
def test_require_path_home_1
env_rubypath, env_home = ENV["RUBYPATH"], ENV["HOME"]
pathname_too_long = /pathname too long \(ignored\).*\(LoadError\)/m
@@ -85,24 +170,37 @@ class TestRequire < Test::Unit::TestCase
def test_require_path_home_3
env_rubypath, env_home = ENV["RUBYPATH"], ENV["HOME"]
- t = Tempfile.new(["test_ruby_test_require", ".rb"])
- t.puts "p :ok"
- t.close
-
- ENV["RUBYPATH"] = "~"
- ENV["HOME"] = t.path
- assert_in_out_err(%w(-S test_ruby_test_require), "", [], /\(LoadError\)/)
+ Tempfile.create(["test_ruby_test_require", ".rb"]) {|t|
+ t.puts "p :ok"
+ t.close
- ENV["HOME"], name = File.split(t.path)
- assert_in_out_err(["-S", name], "", %w(:ok), [])
+ ENV["RUBYPATH"] = "~"
+ ENV["HOME"] = t.path
+ assert_in_out_err(%w(-S test_ruby_test_require), "", [], /\(LoadError\)/)
+ ENV["HOME"], name = File.split(t.path)
+ assert_in_out_err(["-S", name], "", %w(:ok), [])
+ }
ensure
env_rubypath ? ENV["RUBYPATH"] = env_rubypath : ENV.delete("RUBYPATH")
env_home ? ENV["HOME"] = env_home : ENV.delete("HOME")
end
def test_require_with_unc
- assert(system(File.expand_path(EnvUtil.rubybin).sub(/\A(\w):/, '//127.0.0.1/\1$/'), "-rabbrev", "-e0"))
+ Tempfile.create(["test_ruby_test_require", ".rb"]) {|t|
+ t.puts "puts __FILE__"
+ t.close
+
+ path = File.expand_path(t.path).sub(/\A(\w):/, '//127.0.0.1/\1$')
+ skip "local drive #$1: is not shared" unless File.exist?(path)
+ args = ['--disable-gems', "-I#{File.dirname(path)}"]
+ assert_in_out_err(args, "#{<<~"END;"}", [path], [])
+ begin
+ require '#{File.basename(path)}'
+ rescue Errno::EPERM
+ end
+ END;
+ }
end if /mswin|mingw/ =~ RUBY_PLATFORM
def test_require_twice
@@ -118,6 +216,35 @@ class TestRequire < Test::Unit::TestCase
end
end
+ def assert_syntax_error_backtrace
+ loaded_features = $LOADED_FEATURES.dup
+ Dir.mktmpdir do |tmp|
+ req = File.join(tmp, "test.rb")
+ File.write(req, ",\n")
+ e = assert_raise_with_message(SyntaxError, /unexpected/) {
+ yield req
+ }
+ assert_not_nil(bt = e.backtrace, "no backtrace")
+ assert_not_empty(bt.find_all {|b| b.start_with? __FILE__}, proc {bt.inspect})
+ end
+ $LOADED_FEATURES.replace loaded_features
+ end
+
+ def test_require_syntax_error
+ assert_syntax_error_backtrace {|req| require req}
+ end
+
+ def test_require_syntax_error_rescued
+ assert_syntax_error_backtrace do |req|
+ assert_raise_with_message(SyntaxError, /unexpected/) {require req}
+ require req
+ end
+ end
+
+ def test_load_syntax_error
+ assert_syntax_error_backtrace {|req| load req}
+ end
+
def test_define_class
begin
require "socket"
@@ -125,33 +252,24 @@ class TestRequire < Test::Unit::TestCase
return
end
- assert_in_out_err([], <<-INPUT, %w(:ok), [])
+ assert_separately([], <<-INPUT)
BasicSocket = 1
- begin
+ assert_raise(TypeError) do
require 'socket'
- p :ng
- rescue TypeError
- p :ok
end
INPUT
- assert_in_out_err([], <<-INPUT, %w(:ok), [])
+ assert_separately([], <<-INPUT)
class BasicSocket; end
- begin
+ assert_raise(TypeError) do
require 'socket'
- p :ng
- rescue TypeError
- p :ok
end
INPUT
- assert_in_out_err([], <<-INPUT, %w(:ok), [])
+ assert_separately([], <<-INPUT)
class BasicSocket < IO; end
- begin
+ assert_nothing_raised do
require 'socket'
- p :ok
- rescue Exception
- p :ng
end
INPUT
end
@@ -163,36 +281,27 @@ class TestRequire < Test::Unit::TestCase
return
end
- assert_in_out_err([], <<-INPUT, %w(:ok), [])
+ assert_separately([], <<-INPUT)
module Zlib; end
Zlib::Error = 1
- begin
+ assert_raise(TypeError) do
require 'zlib'
- p :ng
- rescue TypeError
- p :ok
end
INPUT
- assert_in_out_err([], <<-INPUT, %w(:ok), [])
+ assert_separately([], <<-INPUT)
module Zlib; end
class Zlib::Error; end
- begin
+ assert_raise(TypeError) do
require 'zlib'
- p :ng
- rescue NameError
- p :ok
end
INPUT
- assert_in_out_err([], <<-INPUT, %w(:ok), [])
+ assert_separately([], <<-INPUT)
module Zlib; end
class Zlib::Error < StandardError; end
- begin
+ assert_nothing_raised do
require 'zlib'
- p :ok
- rescue Exception
- p :ng
end
INPUT
end
@@ -204,13 +313,10 @@ class TestRequire < Test::Unit::TestCase
return
end
- assert_in_out_err([], <<-INPUT, %w(:ok), [])
+ assert_separately([], <<-INPUT)
Zlib = 1
- begin
+ assert_raise(TypeError) do
require 'zlib'
- p :ng
- rescue TypeError
- p :ok
end
INPUT
end
@@ -222,100 +328,120 @@ class TestRequire < Test::Unit::TestCase
return
end
- assert_in_out_err([], <<-INPUT, %w(:ok), [])
+ assert_separately([], <<-INPUT)
class BasicSocket < IO; end
class Socket < BasicSocket; end
Socket::Constants = 1
- begin
+ assert_raise(TypeError) do
require 'socket'
- p :ng
- rescue TypeError
- p :ok
end
INPUT
end
def test_load
- t = Tempfile.new(["test_ruby_test_require", ".rb"])
- t.puts "module Foo; end"
- t.puts "at_exit { p :wrap_end }"
- t.puts "at_exit { raise 'error in at_exit test' }"
- t.puts "p :ok"
- t.close
-
- assert_in_out_err([], <<-INPUT, %w(:ok :end :wrap_end), /error in at_exit test/)
- load(#{ t.path.dump }, true)
- GC.start
- p :end
- INPUT
+ Tempfile.create(["test_ruby_test_require", ".rb"]) {|t|
+ t.puts "module Foo; end"
+ t.puts "at_exit { p :wrap_end }"
+ t.puts "at_exit { raise 'error in at_exit test' }"
+ t.puts "p :ok"
+ t.close
+
+ assert_in_out_err([], <<-INPUT, %w(:ok :end :wrap_end), /error in at_exit test/)
+ load(#{ t.path.dump }, true)
+ GC.start
+ p :end
+ INPUT
- assert_raise(ArgumentError) { at_exit }
+ assert_raise(ArgumentError) { at_exit }
+ }
end
- def test_load2 # [ruby-core:25039]
- t = Tempfile.new(["test_ruby_test_require", ".rb"])
- t.puts "Hello = 'hello'"
- t.puts "class Foo"
- t.puts " p Hello"
- t.puts "end"
- t.close
-
- assert_in_out_err([], <<-INPUT, %w("hello"), [])
- load(#{ t.path.dump }, true)
- INPUT
+ def test_require_in_wrapped_load
+ Dir.mktmpdir do |tmp|
+ File.write("#{tmp}/1.rb", "require_relative '2'\n")
+ File.write("#{tmp}/2.rb", "class Foo\n""end\n")
+ assert_separately([], "#{<<~"begin;"}\n#{<<~'end;'}")
+ path = ""#{tmp.dump}"/1.rb"
+ begin;
+ load path, true
+ assert_instance_of(Class, Foo)
+ end;
+ end
end
- def test_tainted_loadpath
- t = Tempfile.new(["test_ruby_test_require", ".rb"])
- abs_dir, file = File.split(t.path)
- abs_dir = File.expand_path(abs_dir).untaint
+ def test_load_scope
+ bug1982 = '[ruby-core:25039] [Bug #1982]'
+ Tempfile.create(["test_ruby_test_require", ".rb"]) {|t|
+ t.puts "Hello = 'hello'"
+ t.puts "class Foo"
+ t.puts " p Hello"
+ t.puts "end"
+ t.close
+
+ assert_in_out_err([], <<-INPUT, %w("hello"), [], bug1982)
+ load(#{ t.path.dump }, true)
+ INPUT
+ }
+ end
- assert_in_out_err([], <<-INPUT, %w(:ok), [])
- abs_dir = "#{ abs_dir }"
- $: << abs_dir
- require "#{ file }"
- p :ok
- INPUT
+ def test_load_into_module
+ Tempfile.create(["test_ruby_test_require", ".rb"]) {|t|
+ t.puts "def b; 1 end"
+ t.puts "class Foo"
+ t.puts " def c; 2 end"
+ t.puts "end"
+ t.close
+
+ m = Module.new
+ load(t.path, m)
+ assert_equal([:b], m.private_instance_methods(false))
+ c = Class.new do
+ include m
+ public :b
+ end
+ assert_equal(1, c.new.b)
+ assert_equal(2, m::Foo.new.c)
+ }
+ end
- assert_in_out_err([], <<-INPUT, %w(:ok), [])
- abs_dir = "#{ abs_dir }"
- $: << abs_dir.taint
- require "#{ file }"
- p :ok
- INPUT
+ def test_load_wrap_nil
+ Dir.mktmpdir do |tmp|
+ File.write("#{tmp}/1.rb", "class LoadWrapNil; end\n")
+ assert_separately([], "#{<<~"begin;"}\n#{<<~'end;'}")
+ path = ""#{tmp.dump}"/1.rb"
+ begin;
+ load path, nil
+ assert_instance_of(Class, LoadWrapNil)
+ end;
+ end
+ end
- assert_in_out_err([], <<-INPUT, %w(:ok), [])
- abs_dir = "#{ abs_dir }"
- $: << abs_dir.taint
- $SAFE = 1
- begin
- require "#{ file }"
- rescue SecurityError
- p :ok
- end
- INPUT
+ def test_load_ospath
+ bug = '[ruby-list:49994] path in ospath'
+ base = "test_load\u{3042 3044 3046 3048 304a}".encode(Encoding::Windows_31J)
+ path = nil
+ Dir.mktmpdir do |dir|
+ path = File.join(dir, base+".rb")
+ assert_raise_with_message(LoadError, /#{base}/) {
+ load(File.join(dir, base))
+ }
- assert_in_out_err([], <<-INPUT, %w(:ok), [])
- abs_dir = "#{ abs_dir }"
- $: << abs_dir.taint
- $SAFE = 1
- begin
- require "#{ file }"
- rescue SecurityError
- p :ok
+ File.open(path, "w+b") do |t|
+ t.puts "warn 'ok'"
end
- INPUT
-
- assert_in_out_err([], <<-INPUT, %w(:ok), [])
- abs_dir = "#{ abs_dir }"
- $: << abs_dir << 'elsewhere'.taint
- require "#{ file }"
- p :ok
- INPUT
+ assert_include(path, base)
+ assert_warn("ok\n", bug) {
+ assert_nothing_raised(LoadError, bug) {
+ load(path)
+ }
+ }
+ end
end
def test_relative
load_path = $:.dup
+ loaded_featrures = $LOADED_FEATURES.dup
+
$:.delete(".")
Dir.mktmpdir do |tmp|
Dir.chdir(tmp) do
@@ -335,6 +461,7 @@ class TestRequire < Test::Unit::TestCase
end
ensure
$:.replace(load_path) if load_path
+ $LOADED_FEATURES.replace loaded_featrures
end
def test_relative_symlink
@@ -347,9 +474,35 @@ class TestRequire < Test::Unit::TestCase
File.open("a/tst.rb", "w") {|f| f.puts 'require_relative "lib"' }
begin
File.symlink("../a/tst.rb", "b/tst.rb")
- result = IO.popen([EnvUtil.rubybin, "b/tst.rb"]).read
+ result = IO.popen([EnvUtil.rubybin, "b/tst.rb"], &:read)
assert_equal("a/lib.rb\n", result, "[ruby-dev:40040]")
- rescue NotImplementedError
+ rescue NotImplementedError, Errno::EACCES
+ skip "File.symlink is not implemented"
+ end
+ }
+ }
+ end
+
+ def test_relative_symlink_realpath
+ Dir.mktmpdir {|tmp|
+ Dir.chdir(tmp) {
+ Dir.mkdir "a"
+ File.open("a/a.rb", "w") {|f| f.puts 'require_relative "b"' }
+ File.open("a/b.rb", "w") {|f| f.puts '$t += 1' }
+ Dir.mkdir "b"
+ File.binwrite("c.rb", <<~RUBY)
+ $t = 0
+ $:.unshift(File.expand_path('../b', __FILE__))
+ require "b"
+ require "a"
+ print $t
+ RUBY
+ begin
+ File.symlink("../a/a.rb", "b/a.rb")
+ File.symlink("../a/b.rb", "b/b.rb")
+ result = IO.popen([EnvUtil.rubybin, "c.rb"], &:read)
+ assert_equal("1", result, "bug17885 [ruby-core:104010]")
+ rescue NotImplementedError, Errno::EACCES
skip "File.symlink is not implemented"
end
}
@@ -365,58 +518,72 @@ class TestRequire < Test::Unit::TestCase
def test_race_exception
bug5754 = '[ruby-core:41618]'
- tmp = Tempfile.new(%w"bug5754 .rb")
- path = tmp.path
- tmp.print %{\
- th = Thread.current
- t = th[:t]
- scratch = th[:scratch]
-
- if scratch.empty?
- scratch << :pre
- Thread.pass until t.stop?
- raise RuntimeError
- else
- scratch << :post
+ path = nil
+ stderr = $stderr
+ verbose = $VERBOSE
+ Tempfile.create(%w"bug5754 .rb") {|tmp|
+ path = tmp.path
+ tmp.print "#{<<~"begin;"}\n#{<<~"end;"}"
+ begin;
+ th = Thread.current
+ t = th[:t]
+ scratch = th[:scratch]
+
+ if scratch.empty?
+ scratch << :pre
+ Thread.pass until t.stop?
+ raise RuntimeError
+ else
+ scratch << :post
+ end
+ end;
+ tmp.close
+
+ class << (output = "")
+ alias write concat
end
- }
- tmp.close
+ $stderr = output
- start = false
+ start = false
- scratch = []
- t1_res = nil
- t2_res = nil
+ scratch = []
+ t1_res = nil
+ t2_res = nil
- t1 = Thread.new do
- Thread.pass until start
- begin
- require(path)
- rescue RuntimeError
+ t1 = Thread.new do
+ Thread.pass until start
+ begin
+ Kernel.send(:require, path)
+ rescue RuntimeError
+ end
+
+ t1_res = require(path)
end
- t1_res = require(path)
- end
+ t2 = Thread.new do
+ Thread.pass until scratch[0]
+ t2_res = Kernel.send(:require, path)
+ end
- t2 = Thread.new do
- Thread.pass until scratch[0]
- t2_res = require(path)
- end
+ t1[:scratch] = t2[:scratch] = scratch
+ t1[:t] = t2
+ t2[:t] = t1
- t1[:scratch] = t2[:scratch] = scratch
- t1[:t] = t2
- t2[:t] = t1
+ $VERBOSE = true
+ start = true
- start = true
+ assert_nothing_raised(ThreadError, bug5754) {t1.join}
+ assert_nothing_raised(ThreadError, bug5754) {t2.join}
- assert_nothing_raised(ThreadError, bug5754) {t1.join}
- assert_nothing_raised(ThreadError, bug5754) {t2.join}
+ $VERBOSE = false
- assert_equal(true, (t1_res ^ t2_res), bug5754 + " t1:#{t1_res} t2:#{t2_res}")
- assert_equal([:pre, :post], scratch, bug5754)
+ assert_equal(true, (t1_res ^ t2_res), bug5754 + " t1:#{t1_res} t2:#{t2_res}")
+ assert_equal([:pre, :post], scratch, bug5754)
+ }
ensure
+ $VERBOSE = verbose
+ $stderr = stderr
$".delete(path)
- tmp.close(true) if tmp
end
def test_loaded_features_encoding
@@ -429,10 +596,381 @@ class TestRequire < Test::Unit::TestCase
$: << tmp
open(File.join(tmp, "foo.rb"), "w") {}
require "foo"
- assert_equal(tmp.encoding, $"[0].encoding, bug6377)
+ assert_send([Encoding, :compatible?, tmp, $"[0]], bug6377)
}
ensure
$:.replace(loadpath)
$".replace(features)
end
+
+ def test_default_loaded_features_encoding
+ Dir.mktmpdir {|tmp|
+ Dir.mkdir("#{tmp}/1")
+ Dir.mkdir("#{tmp}/2")
+ File.write("#{tmp}/1/bug18191-1.rb", "")
+ File.write("#{tmp}/2/bug18191-2.rb", "")
+ assert_separately(%W[-Eutf-8 -I#{tmp}/1 -], "#{<<~"begin;"}\n#{<<~'end;'}")
+ tmp = #{tmp.dump}"/2"
+ begin;
+ $:.unshift(tmp)
+ require "bug18191-1"
+ require "bug18191-2"
+ encs = [Encoding::US_ASCII, Encoding.find("filesystem")]
+ message = -> {
+ require "pp"
+ {filesystem: encs[1], **$".group_by(&:encoding)}.pretty_inspect
+ }
+ assert($".all? {|n| encs.include?(n.encoding)}, message)
+ end;
+ }
+ end
+
+ def test_require_changed_current_dir
+ bug7158 = '[ruby-core:47970]'
+ Dir.mktmpdir {|tmp|
+ Dir.chdir(tmp) {
+ Dir.mkdir("a")
+ Dir.mkdir("b")
+ open(File.join("a", "foo.rb"), "w") {}
+ open(File.join("b", "bar.rb"), "w") {|f|
+ f.puts "p :ok"
+ }
+ assert_in_out_err([], "#{<<~"begin;"}\n#{<<~"end;"}", %w(:ok), [], bug7158)
+ begin;
+ $:.replace([IO::NULL])
+ $: << "."
+ Dir.chdir("a")
+ require "foo"
+ Dir.chdir("../b")
+ p :ng unless require "bar"
+ Dir.chdir("..")
+ p :ng if require "b/bar"
+ end;
+ }
+ }
+ end
+
+ def test_require_not_modified_load_path
+ bug7158 = '[ruby-core:47970]'
+ Dir.mktmpdir {|tmp|
+ Dir.chdir(tmp) {
+ open("foo.rb", "w") {}
+ assert_in_out_err([], "#{<<~"begin;"}\n#{<<~"end;"}", %w(:ok), [], bug7158)
+ begin;
+ $:.replace([IO::NULL])
+ a = Object.new
+ def a.to_str
+ "#{tmp}"
+ end
+ $: << a
+ require "foo"
+ last_path = $:.pop
+ p :ok if last_path == a && last_path.class == Object
+ end;
+ }
+ }
+ end
+
+ def test_require_changed_home
+ bug7158 = '[ruby-core:47970]'
+ Dir.mktmpdir {|tmp|
+ Dir.chdir(tmp) {
+ open("foo.rb", "w") {}
+ Dir.mkdir("a")
+ open(File.join("a", "bar.rb"), "w") {}
+ assert_in_out_err([], "#{<<~"begin;"}\n#{<<~"end;"}", %w(:ok), [], bug7158)
+ begin;
+ $:.replace([IO::NULL])
+ $: << '~'
+ ENV['HOME'] = "#{tmp}"
+ require "foo"
+ ENV['HOME'] = "#{tmp}/a"
+ p :ok if require "bar"
+ end;
+ }
+ }
+ end
+
+ def test_require_to_path_redefined_in_load_path
+ bug7158 = '[ruby-core:47970]'
+ Dir.mktmpdir {|tmp|
+ Dir.chdir(tmp) {
+ open("foo.rb", "w") {}
+ assert_in_out_err([{"RUBYOPT"=>nil}, '--disable-gems'], "#{<<~"begin;"}\n#{<<~"end;"}", %w(:ok), [], bug7158)
+ begin;
+ $:.replace([IO::NULL])
+ a = Object.new
+ def a.to_path
+ "bar"
+ end
+ $: << a
+ begin
+ require "foo"
+ p [:ng, $LOAD_PATH, ENV['RUBYLIB']]
+ rescue LoadError => e
+ raise unless e.path == "foo"
+ end
+ def a.to_path
+ "#{tmp}"
+ end
+ p :ok if require "foo"
+ end;
+ }
+ }
+ end
+
+ def test_require_to_str_redefined_in_load_path
+ bug7158 = '[ruby-core:47970]'
+ Dir.mktmpdir {|tmp|
+ Dir.chdir(tmp) {
+ open("foo.rb", "w") {}
+ assert_in_out_err([{"RUBYOPT"=>nil}, '--disable-gems'], "#{<<~"begin;"}\n#{<<~"end;"}", %w(:ok), [], bug7158)
+ begin;
+ $:.replace([IO::NULL])
+ a = Object.new
+ def a.to_str
+ "foo"
+ end
+ $: << a
+ begin
+ require "foo"
+ p [:ng, $LOAD_PATH, ENV['RUBYLIB']]
+ rescue LoadError => e
+ raise unless e.path == "foo"
+ end
+ def a.to_str
+ "#{tmp}"
+ end
+ p :ok if require "foo"
+ end;
+ }
+ }
+ end
+
+ def assert_require_with_shared_array_modified(add, del)
+ bug7383 = '[ruby-core:49518]'
+ Dir.mktmpdir {|tmp|
+ Dir.chdir(tmp) {
+ open("foo.rb", "w") {}
+ Dir.mkdir("a")
+ open(File.join("a", "bar.rb"), "w") {}
+ assert_in_out_err(['--disable-gems'], "#{<<~"begin;"}\n#{<<~"end;"}", %w(:ok), [], bug7383)
+ begin;
+ $:.replace([IO::NULL])
+ $:.#{add} "#{tmp}"
+ $:.#{add} "#{tmp}/a"
+ require "foo"
+ $:.#{del}
+ # Expanded load path cache should be rebuilt.
+ begin
+ require "bar"
+ rescue LoadError => e
+ if e.path == "bar"
+ p :ok
+ else
+ raise
+ end
+ end
+ end;
+ }
+ }
+ end
+
+ def test_require_with_array_pop
+ assert_require_with_shared_array_modified("push", "pop")
+ end
+
+ def test_require_with_array_shift
+ assert_require_with_shared_array_modified("unshift", "shift")
+ end
+
+ def test_require_local_var_on_toplevel
+ bug7536 = '[ruby-core:50701]'
+ Dir.mktmpdir {|tmp|
+ Dir.chdir(tmp) {
+ open("bar.rb", "w") {|f| f.puts 'TOPLEVEL_BINDING.eval("lib = 2")' }
+ assert_in_out_err(%w[-r./bar.rb], "#{<<~"begin;"}\n#{<<~"end;"}", %w([:lib] 2), [], bug7536)
+ begin;
+ puts TOPLEVEL_BINDING.eval("local_variables").inspect
+ puts TOPLEVEL_BINDING.eval("lib").inspect
+ end;
+ }
+ }
+ end
+
+ def test_require_with_loaded_features_pop
+ bug7530 = '[ruby-core:50645]'
+ Tempfile.create(%w'bug-7530- .rb') {|script|
+ script.close
+ assert_in_out_err([{"RUBYOPT" => nil}, "-", script.path], "#{<<~"begin;"}\n#{<<~"end;"}", %w(:ok), [], bug7530, timeout: 60)
+ begin;
+ PATH = ARGV.shift
+ THREADS = 30
+ ITERATIONS_PER_THREAD = 300
+
+ THREADS.times.map {
+ Thread.new do
+ ITERATIONS_PER_THREAD.times do
+ require PATH
+ $".delete_if {|p| Regexp.new(PATH) =~ p}
+ end
+ end
+ }.each(&:join)
+ p :ok
+ end;
+ }
+ end
+
+ def test_loading_fifo_threading_raise
+ Tempfile.create(%w'fifo .rb') {|f|
+ f.close
+ File.unlink(f.path)
+ File.mkfifo(f.path)
+ assert_separately(["-", f.path], "#{<<~"begin;"}\n#{<<~"end;"}", timeout: 3)
+ begin;
+ th = Thread.current
+ Thread.start {begin sleep(0.001) end until th.stop?; th.raise(IOError)}
+ assert_raise(IOError) do
+ load(ARGV[0])
+ end
+ end;
+ }
+ end if File.respond_to?(:mkfifo)
+
+ def test_loading_fifo_threading_success
+ Tempfile.create(%w'fifo .rb') {|f|
+ f.close
+ File.unlink(f.path)
+ File.mkfifo(f.path)
+
+ assert_separately(["-", f.path], "#{<<~"begin;"}\n#{<<~"end;"}", timeout: 3)
+ begin;
+ path = ARGV[0]
+ th = Thread.current
+ $ok = false
+ Thread.start {
+ begin
+ sleep(0.001)
+ end until th.stop?
+ open(path, File::WRONLY | File::NONBLOCK) {|fifo_w|
+ fifo_w.print "$ok = true\n__END__\n" # ensure finishing
+ }
+ }
+
+ load(path)
+ assert($ok)
+ end;
+ }
+ end if File.respond_to?(:mkfifo)
+
+ def test_loading_fifo_fd_leak
+ skip if RUBY_PLATFORM =~ /android/ # https://rubyci.org/logs/rubyci.s3.amazonaws.com/android29-x86_64/ruby-master/log/20200419T124100Z.fail.html.gz
+
+ Tempfile.create(%w'fifo .rb') {|f|
+ f.close
+ File.unlink(f.path)
+ File.mkfifo(f.path)
+ assert_separately(["-", f.path], "#{<<~"begin;"}\n#{<<~"end;"}", timeout: 3)
+ begin;
+ Process.setrlimit(Process::RLIMIT_NOFILE, 50)
+ th = Thread.current
+ 100.times do |i|
+ Thread.start {begin sleep(0.001) end until th.stop?; th.raise(IOError)}
+ assert_raise(IOError, "\#{i} time") do
+ begin
+ tap {tap {tap {load(ARGV[0])}}}
+ rescue LoadError
+ GC.start
+ retry
+ end
+ end
+ end
+ end;
+ }
+ end if File.respond_to?(:mkfifo) and defined?(Process::RLIMIT_NOFILE)
+
+ def test_throw_while_loading
+ Tempfile.create(%w'bug-11404 .rb') do |f|
+ f.puts 'sleep'
+ f.close
+
+ assert_separately(["-", f.path], "#{<<~"begin;"}\n#{<<~'end;'}")
+ begin;
+ path = ARGV[0]
+ class Error < RuntimeError
+ def exception(*)
+ begin
+ throw :blah
+ rescue UncaughtThrowError
+ end
+ self
+ end
+ end
+
+ assert_throw(:blah) do
+ x = Thread.current
+ Thread.start {
+ sleep 0.00001
+ x.raise Error.new
+ }
+ load path
+ end
+ end;
+ end
+ end
+
+ def test_symlink_load_path
+ Dir.mktmpdir {|tmp|
+ Dir.mkdir(File.join(tmp, "real"))
+ begin
+ File.symlink "real", File.join(tmp, "symlink")
+ rescue NotImplementedError, Errno::EACCES
+ skip "File.symlink is not implemented"
+ end
+ File.write(File.join(tmp, "real/test_symlink_load_path.rb"), "print __FILE__")
+ result = IO.popen([EnvUtil.rubybin, "-I#{tmp}/symlink", "-e", "require 'test_symlink_load_path.rb'"], &:read)
+ assert_operator(result, :end_with?, "/real/test_symlink_load_path.rb")
+ }
+ end
+
+ def test_provide_in_required_file
+ paths, loaded = $:.dup, $".dup
+ Dir.mktmpdir do |tmp|
+ provide = File.realdirpath("provide.rb", tmp)
+ File.write(File.join(tmp, "target.rb"), "raise __FILE__\n")
+ File.write(provide, '$" << '"'target.rb'\n")
+ $:.replace([tmp])
+ assert(require("provide"))
+ assert(!require("target"))
+ assert_equal($".pop, provide)
+ assert_equal($".pop, "target.rb")
+ end
+ ensure
+ $:.replace(paths)
+ $".replace(loaded)
+ end
+
+ if defined?($LOAD_PATH.resolve_feature_path)
+ def test_resolve_feature_path
+ paths, loaded = $:.dup, $".dup
+ Dir.mktmpdir do |tmp|
+ Tempfile.create(%w[feature .rb], tmp) do |file|
+ file.close
+ path = File.realpath(file.path)
+ dir, base = File.split(path)
+ $:.unshift(dir)
+ assert_equal([:rb, path], $LOAD_PATH.resolve_feature_path(base))
+ $".push(path)
+ assert_equal([:rb, path], $LOAD_PATH.resolve_feature_path(base))
+ end
+ end
+ ensure
+ $:.replace(paths)
+ $".replace(loaded)
+ end
+
+ def test_resolve_feature_path_with_missing_feature
+ assert_nil($LOAD_PATH.resolve_feature_path("superkalifragilisticoespialidoso"))
+ end
+ end
end
generated by cgit v1.2.3 (git 2.25.1) at 2026-06-06 22:33:25 +0000