2008-05-21 11:31:15 -04:00
|
|
|
require 'test/unit'
|
|
|
|
|
|
|
|
require 'tempfile'
|
|
|
|
require_relative 'envutil'
|
2010-01-11 19:32:22 -05:00
|
|
|
require 'tmpdir'
|
2008-05-21 11:31:15 -04:00
|
|
|
|
|
|
|
class TestRequire < Test::Unit::TestCase
|
2012-03-06 18:38:33 -05:00
|
|
|
def test_load_error_path
|
|
|
|
filename = "should_not_exist"
|
2012-03-14 21:31:43 -04:00
|
|
|
error = assert_raise(LoadError) do
|
2012-03-06 18:38:33 -05:00
|
|
|
require filename
|
|
|
|
end
|
|
|
|
assert_equal filename, error.path
|
|
|
|
end
|
|
|
|
|
2008-05-21 11:31:15 -04:00
|
|
|
def test_require_invalid_shared_object
|
|
|
|
t = Tempfile.new(["test_ruby_test_require", ".so"])
|
|
|
|
t.puts "dummy"
|
|
|
|
t.close
|
|
|
|
|
2008-07-15 11:26:04 -04:00
|
|
|
assert_in_out_err([], <<-INPUT, %w(:ok), [])
|
2012-12-19 22:43:53 -05:00
|
|
|
$:.replace([IO::NULL])
|
2008-07-15 11:26:04 -04:00
|
|
|
begin
|
|
|
|
require \"#{ t.path }\"
|
|
|
|
rescue LoadError
|
|
|
|
p :ok
|
|
|
|
end
|
|
|
|
INPUT
|
2008-05-21 11:31:15 -04:00
|
|
|
end
|
|
|
|
|
|
|
|
def test_require_too_long_filename
|
2010-08-08 17:51:02 -04:00
|
|
|
assert_in_out_err(["RUBYOPT"=>nil], <<-INPUT, %w(:ok), [])
|
2012-12-19 22:43:53 -05:00
|
|
|
$:.replace([IO::NULL])
|
2008-07-15 11:26:04 -04:00
|
|
|
begin
|
|
|
|
require '#{ "foo/" * 10000 }foo'
|
|
|
|
rescue LoadError
|
|
|
|
p :ok
|
|
|
|
end
|
|
|
|
INPUT
|
2008-07-28 08:00:43 -04:00
|
|
|
|
2008-10-28 08:03:14 -04:00
|
|
|
begin
|
2011-03-14 08:27:31 -04:00
|
|
|
assert_in_out_err(["-S", "-w", "foo/" * 1024 + "foo"], "") do |r, e|
|
2008-10-28 08:03:14 -04:00
|
|
|
assert_equal([], r)
|
|
|
|
assert_operator(2, :<=, e.size)
|
2011-01-28 02:31:44 -05:00
|
|
|
assert_match(/warning: openpath: pathname too long \(ignored\)/, e.first)
|
2008-10-28 08:03:14 -04:00
|
|
|
assert_match(/\(LoadError\)/, e.last)
|
|
|
|
end
|
|
|
|
rescue Errno::EINVAL
|
|
|
|
# too long commandline may be blocked by OS.
|
2008-07-28 08:00:43 -04:00
|
|
|
end
|
2008-05-21 11:31:15 -04:00
|
|
|
end
|
|
|
|
|
2010-08-28 23:20:04 -04:00
|
|
|
def test_require_nonascii
|
|
|
|
bug3758 = '[ruby-core:31915]'
|
2012-03-07 02:30:31 -05:00
|
|
|
["\u{221e}", "\x82\xa0".force_encoding("cp932")].each do |path|
|
|
|
|
e = assert_raise(LoadError, bug3758) {require path}
|
|
|
|
assert_match(/#{path}\z/, e.message, bug3758)
|
|
|
|
end
|
2010-08-28 23:20:04 -04:00
|
|
|
end
|
|
|
|
|
2011-01-28 02:06:48 -05:00
|
|
|
def test_require_path_home_1
|
2008-05-21 11:31:15 -04:00
|
|
|
env_rubypath, env_home = ENV["RUBYPATH"], ENV["HOME"]
|
2010-09-11 03:47:44 -04:00
|
|
|
pathname_too_long = /pathname too long \(ignored\).*\(LoadError\)/m
|
2008-05-21 11:31:15 -04:00
|
|
|
|
|
|
|
ENV["RUBYPATH"] = "~"
|
2011-03-14 08:27:31 -04:00
|
|
|
ENV["HOME"] = "/foo" * 1024
|
2011-01-28 02:21:38 -05:00
|
|
|
assert_in_out_err(%w(-S -w test_ruby_test_require), "", [], pathname_too_long)
|
2008-05-21 11:31:15 -04:00
|
|
|
|
2011-01-28 02:06:48 -05:00
|
|
|
ensure
|
|
|
|
env_rubypath ? ENV["RUBYPATH"] = env_rubypath : ENV.delete("RUBYPATH")
|
|
|
|
env_home ? ENV["HOME"] = env_home : ENV.delete("HOME")
|
|
|
|
end
|
|
|
|
|
|
|
|
def test_require_path_home_2
|
|
|
|
env_rubypath, env_home = ENV["RUBYPATH"], ENV["HOME"]
|
|
|
|
pathname_too_long = /pathname too long \(ignored\).*\(LoadError\)/m
|
|
|
|
|
2011-03-14 08:27:31 -04:00
|
|
|
ENV["RUBYPATH"] = "~" + "/foo" * 1024
|
2008-05-21 11:31:15 -04:00
|
|
|
ENV["HOME"] = "/foo"
|
2011-01-28 02:21:38 -05:00
|
|
|
assert_in_out_err(%w(-S -w test_ruby_test_require), "", [], pathname_too_long)
|
2008-05-21 11:31:15 -04:00
|
|
|
|
2011-01-28 02:06:48 -05:00
|
|
|
ensure
|
|
|
|
env_rubypath ? ENV["RUBYPATH"] = env_rubypath : ENV.delete("RUBYPATH")
|
|
|
|
env_home ? ENV["HOME"] = env_home : ENV.delete("HOME")
|
|
|
|
end
|
|
|
|
|
|
|
|
def test_require_path_home_3
|
|
|
|
env_rubypath, env_home = ENV["RUBYPATH"], ENV["HOME"]
|
|
|
|
|
2008-05-21 11:31:15 -04:00
|
|
|
t = Tempfile.new(["test_ruby_test_require", ".rb"])
|
|
|
|
t.puts "p :ok"
|
|
|
|
t.close
|
2010-09-11 03:47:44 -04:00
|
|
|
|
2008-05-21 11:31:15 -04:00
|
|
|
ENV["RUBYPATH"] = "~"
|
2010-09-11 03:47:44 -04:00
|
|
|
ENV["HOME"] = t.path
|
|
|
|
assert_in_out_err(%w(-S test_ruby_test_require), "", [], /\(LoadError\)/)
|
|
|
|
|
2008-05-21 11:31:15 -04:00
|
|
|
ENV["HOME"], name = File.split(t.path)
|
2008-07-15 11:26:04 -04:00
|
|
|
assert_in_out_err(["-S", name], "", %w(:ok), [])
|
2008-05-21 11:31:15 -04:00
|
|
|
|
|
|
|
ensure
|
|
|
|
env_rubypath ? ENV["RUBYPATH"] = env_rubypath : ENV.delete("RUBYPATH")
|
|
|
|
env_home ? ENV["HOME"] = env_home : ENV.delete("HOME")
|
|
|
|
end
|
|
|
|
|
2010-06-29 02:22:08 -04:00
|
|
|
def test_require_with_unc
|
2011-02-01 01:15:14 -05:00
|
|
|
assert(system(File.expand_path(EnvUtil.rubybin).sub(/\A(\w):/, '//127.0.0.1/\1$/'), "-rabbrev", "-e0"))
|
2010-06-29 02:22:08 -04:00
|
|
|
end if /mswin|mingw/ =~ RUBY_PLATFORM
|
|
|
|
|
2012-08-06 22:59:04 -04:00
|
|
|
def test_require_twice
|
|
|
|
Dir.mktmpdir do |tmp|
|
|
|
|
req = File.join(tmp, "very_long_file_name.rb")
|
|
|
|
File.write(req, "p :ok\n")
|
2012-10-16 00:02:04 -04:00
|
|
|
assert_file.exist?(req)
|
2012-08-06 22:59:04 -04:00
|
|
|
req[/.rb$/i] = ""
|
|
|
|
assert_in_out_err(['--disable-gems'], <<-INPUT, %w(:ok), [])
|
|
|
|
require "#{req}"
|
|
|
|
require "#{req}"
|
|
|
|
INPUT
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2008-05-21 11:31:15 -04:00
|
|
|
def test_define_class
|
|
|
|
begin
|
|
|
|
require "socket"
|
|
|
|
rescue LoadError
|
|
|
|
return
|
|
|
|
end
|
|
|
|
|
2008-07-15 11:26:04 -04:00
|
|
|
assert_in_out_err([], <<-INPUT, %w(:ok), [])
|
|
|
|
BasicSocket = 1
|
|
|
|
begin
|
|
|
|
require 'socket'
|
|
|
|
p :ng
|
|
|
|
rescue TypeError
|
|
|
|
p :ok
|
|
|
|
end
|
|
|
|
INPUT
|
|
|
|
|
|
|
|
assert_in_out_err([], <<-INPUT, %w(:ok), [])
|
|
|
|
class BasicSocket; end
|
|
|
|
begin
|
|
|
|
require 'socket'
|
|
|
|
p :ng
|
2010-01-21 11:06:39 -05:00
|
|
|
rescue TypeError
|
2008-07-15 11:26:04 -04:00
|
|
|
p :ok
|
|
|
|
end
|
|
|
|
INPUT
|
|
|
|
|
|
|
|
assert_in_out_err([], <<-INPUT, %w(:ok), [])
|
|
|
|
class BasicSocket < IO; end
|
|
|
|
begin
|
|
|
|
require 'socket'
|
|
|
|
p :ok
|
|
|
|
rescue Exception
|
|
|
|
p :ng
|
|
|
|
end
|
|
|
|
INPUT
|
2008-05-21 11:31:15 -04:00
|
|
|
end
|
|
|
|
|
|
|
|
def test_define_class_under
|
|
|
|
begin
|
|
|
|
require "zlib"
|
|
|
|
rescue LoadError
|
|
|
|
return
|
|
|
|
end
|
|
|
|
|
2008-07-15 11:26:04 -04:00
|
|
|
assert_in_out_err([], <<-INPUT, %w(:ok), [])
|
|
|
|
module Zlib; end
|
|
|
|
Zlib::Error = 1
|
|
|
|
begin
|
|
|
|
require 'zlib'
|
|
|
|
p :ng
|
|
|
|
rescue TypeError
|
|
|
|
p :ok
|
|
|
|
end
|
|
|
|
INPUT
|
|
|
|
|
|
|
|
assert_in_out_err([], <<-INPUT, %w(:ok), [])
|
|
|
|
module Zlib; end
|
|
|
|
class Zlib::Error; end
|
|
|
|
begin
|
|
|
|
require 'zlib'
|
|
|
|
p :ng
|
|
|
|
rescue NameError
|
|
|
|
p :ok
|
|
|
|
end
|
|
|
|
INPUT
|
|
|
|
|
|
|
|
assert_in_out_err([], <<-INPUT, %w(:ok), [])
|
|
|
|
module Zlib; end
|
|
|
|
class Zlib::Error < StandardError; end
|
|
|
|
begin
|
|
|
|
require 'zlib'
|
|
|
|
p :ok
|
|
|
|
rescue Exception
|
|
|
|
p :ng
|
|
|
|
end
|
|
|
|
INPUT
|
2008-05-21 11:31:15 -04:00
|
|
|
end
|
|
|
|
|
|
|
|
def test_define_module
|
|
|
|
begin
|
|
|
|
require "zlib"
|
|
|
|
rescue LoadError
|
|
|
|
return
|
|
|
|
end
|
|
|
|
|
2008-07-15 11:26:04 -04:00
|
|
|
assert_in_out_err([], <<-INPUT, %w(:ok), [])
|
|
|
|
Zlib = 1
|
|
|
|
begin
|
|
|
|
require 'zlib'
|
|
|
|
p :ng
|
|
|
|
rescue TypeError
|
|
|
|
p :ok
|
|
|
|
end
|
|
|
|
INPUT
|
2008-05-21 11:31:15 -04:00
|
|
|
end
|
|
|
|
|
|
|
|
def test_define_module_under
|
|
|
|
begin
|
|
|
|
require "socket"
|
|
|
|
rescue LoadError
|
|
|
|
return
|
|
|
|
end
|
|
|
|
|
2008-07-15 11:26:04 -04:00
|
|
|
assert_in_out_err([], <<-INPUT, %w(:ok), [])
|
|
|
|
class BasicSocket < IO; end
|
|
|
|
class Socket < BasicSocket; end
|
|
|
|
Socket::Constants = 1
|
|
|
|
begin
|
|
|
|
require 'socket'
|
|
|
|
p :ng
|
|
|
|
rescue TypeError
|
|
|
|
p :ok
|
|
|
|
end
|
|
|
|
INPUT
|
2008-05-21 11:31:15 -04:00
|
|
|
end
|
2008-05-29 09:51:52 -04:00
|
|
|
|
|
|
|
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
|
|
|
|
|
2008-07-15 11:26:04 -04:00
|
|
|
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
|
2008-05-29 09:51:52 -04:00
|
|
|
|
|
|
|
assert_raise(ArgumentError) { at_exit }
|
|
|
|
end
|
2009-02-02 06:33:08 -05:00
|
|
|
|
2010-04-27 09:42:29 -04:00
|
|
|
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
|
|
|
|
end
|
|
|
|
|
2009-02-02 06:33:08 -05:00
|
|
|
def test_tainted_loadpath
|
|
|
|
t = Tempfile.new(["test_ruby_test_require", ".rb"])
|
2009-09-09 03:21:49 -04:00
|
|
|
abs_dir, file = File.split(t.path)
|
2009-02-02 06:33:08 -05:00
|
|
|
abs_dir = File.expand_path(abs_dir).untaint
|
|
|
|
|
|
|
|
assert_in_out_err([], <<-INPUT, %w(:ok), [])
|
|
|
|
abs_dir = "#{ abs_dir }"
|
|
|
|
$: << abs_dir
|
|
|
|
require "#{ file }"
|
|
|
|
p :ok
|
|
|
|
INPUT
|
|
|
|
|
|
|
|
assert_in_out_err([], <<-INPUT, %w(:ok), [])
|
|
|
|
abs_dir = "#{ abs_dir }"
|
|
|
|
$: << abs_dir.taint
|
|
|
|
require "#{ file }"
|
|
|
|
p :ok
|
|
|
|
INPUT
|
|
|
|
|
|
|
|
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
|
|
|
|
|
|
|
|
assert_in_out_err([], <<-INPUT, %w(:ok), [])
|
|
|
|
abs_dir = "#{ abs_dir }"
|
|
|
|
$: << abs_dir.taint
|
|
|
|
$SAFE = 1
|
2009-06-26 08:48:15 -04:00
|
|
|
begin
|
|
|
|
require "#{ file }"
|
|
|
|
rescue SecurityError
|
|
|
|
p :ok
|
|
|
|
end
|
2009-02-02 06:33:08 -05:00
|
|
|
INPUT
|
|
|
|
|
|
|
|
assert_in_out_err([], <<-INPUT, %w(:ok), [])
|
|
|
|
abs_dir = "#{ abs_dir }"
|
|
|
|
$: << abs_dir << 'elsewhere'.taint
|
|
|
|
require "#{ file }"
|
|
|
|
p :ok
|
|
|
|
INPUT
|
|
|
|
end
|
2009-09-09 03:21:49 -04:00
|
|
|
|
|
|
|
def test_relative
|
2009-09-12 11:52:03 -04:00
|
|
|
load_path = $:.dup
|
|
|
|
$:.delete(".")
|
2009-09-09 03:21:49 -04:00
|
|
|
Dir.mktmpdir do |tmp|
|
|
|
|
Dir.chdir(tmp) do
|
|
|
|
Dir.mkdir('x')
|
|
|
|
File.open('x/t.rb', 'wb') {}
|
|
|
|
File.open('x/a.rb', 'wb') {|f| f.puts("require_relative('t.rb')")}
|
|
|
|
assert require('./x/t.rb')
|
|
|
|
assert !require(File.expand_path('x/t.rb'))
|
|
|
|
assert_nothing_raised(LoadError) {require('./x/a.rb')}
|
|
|
|
assert_raise(LoadError) {require('x/t.rb')}
|
|
|
|
File.unlink(*Dir.glob('x/*'))
|
|
|
|
Dir.rmdir("#{tmp}/x")
|
2009-09-12 11:52:03 -04:00
|
|
|
$:.replace(load_path)
|
|
|
|
load_path = nil
|
2009-09-09 03:21:49 -04:00
|
|
|
assert(!require('tmpdir'))
|
|
|
|
end
|
|
|
|
end
|
2009-09-12 11:52:03 -04:00
|
|
|
ensure
|
|
|
|
$:.replace(load_path) if load_path
|
2009-09-09 03:21:49 -04:00
|
|
|
end
|
2010-01-11 19:32:22 -05:00
|
|
|
|
|
|
|
def test_relative_symlink
|
|
|
|
Dir.mktmpdir {|tmp|
|
|
|
|
Dir.chdir(tmp) {
|
|
|
|
Dir.mkdir "a"
|
|
|
|
Dir.mkdir "b"
|
|
|
|
File.open("a/lib.rb", "w") {|f| f.puts 'puts "a/lib.rb"' }
|
|
|
|
File.open("b/lib.rb", "w") {|f| f.puts 'puts "b/lib.rb"' }
|
|
|
|
File.open("a/tst.rb", "w") {|f| f.puts 'require_relative "lib"' }
|
2010-05-04 12:02:17 -04:00
|
|
|
begin
|
|
|
|
File.symlink("../a/tst.rb", "b/tst.rb")
|
|
|
|
result = IO.popen([EnvUtil.rubybin, "b/tst.rb"]).read
|
|
|
|
assert_equal("a/lib.rb\n", result, "[ruby-dev:40040]")
|
|
|
|
rescue NotImplementedError
|
|
|
|
skip "File.symlink is not implemented"
|
|
|
|
end
|
2010-01-11 19:32:22 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
end
|
2010-08-28 23:51:39 -04:00
|
|
|
|
|
|
|
def test_frozen_loaded_features
|
|
|
|
bug3756 = '[ruby-core:31913]'
|
|
|
|
assert_in_out_err(['-e', '$LOADED_FEATURES.freeze; require "ostruct"'], "",
|
|
|
|
[], /\$LOADED_FEATURES is frozen; cannot append feature \(RuntimeError\)$/,
|
|
|
|
bug3756)
|
|
|
|
end
|
2011-12-13 02:13:31 -05:00
|
|
|
|
2011-12-14 20:10:45 -05:00
|
|
|
def test_race_exception
|
2011-12-13 02:13:31 -05:00
|
|
|
bug5754 = '[ruby-core:41618]'
|
|
|
|
tmp = Tempfile.new(%w"bug5754 .rb")
|
|
|
|
path = tmp.path
|
2011-12-20 00:57:53 -05:00
|
|
|
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
|
|
|
|
end
|
|
|
|
}
|
2011-12-13 02:13:31 -05:00
|
|
|
tmp.close
|
|
|
|
|
2011-12-20 00:57:53 -05:00
|
|
|
start = false
|
2011-12-13 02:13:31 -05:00
|
|
|
|
2011-12-20 00:57:53 -05:00
|
|
|
scratch = []
|
2011-12-13 02:13:31 -05:00
|
|
|
t1_res = nil
|
|
|
|
t2_res = nil
|
|
|
|
|
|
|
|
t1 = Thread.new do
|
2011-12-20 00:57:53 -05:00
|
|
|
Thread.pass until start
|
2011-12-13 02:13:31 -05:00
|
|
|
begin
|
|
|
|
require(path)
|
|
|
|
rescue RuntimeError
|
|
|
|
end
|
|
|
|
|
|
|
|
t1_res = require(path)
|
|
|
|
end
|
|
|
|
|
|
|
|
t2 = Thread.new do
|
|
|
|
Thread.pass until scratch[0]
|
2011-12-20 00:57:53 -05:00
|
|
|
t2_res = require(path)
|
2011-12-13 02:13:31 -05:00
|
|
|
end
|
|
|
|
|
2011-12-20 00:57:53 -05:00
|
|
|
t1[:scratch] = t2[:scratch] = scratch
|
|
|
|
t1[:t] = t2
|
|
|
|
t2[:t] = t1
|
|
|
|
|
|
|
|
start = true
|
|
|
|
|
2011-12-13 02:13:31 -05:00
|
|
|
assert_nothing_raised(ThreadError, bug5754) {t1.join}
|
|
|
|
assert_nothing_raised(ThreadError, bug5754) {t2.join}
|
|
|
|
|
2011-12-20 00:57:53 -05:00
|
|
|
assert_equal(true, (t1_res ^ t2_res), bug5754 + " t1:#{t1_res} t2:#{t2_res}")
|
|
|
|
assert_equal([:pre, :post], scratch, bug5754)
|
2011-12-14 20:10:45 -05:00
|
|
|
ensure
|
2011-12-20 15:37:43 -05:00
|
|
|
$".delete(path)
|
2011-12-14 20:10:45 -05:00
|
|
|
tmp.close(true) if tmp
|
2011-12-13 02:13:31 -05:00
|
|
|
end
|
2012-08-23 03:46:12 -04:00
|
|
|
|
|
|
|
def test_loaded_features_encoding
|
|
|
|
bug6377 = '[ruby-core:44750]'
|
|
|
|
loadpath = $:.dup
|
|
|
|
features = $".dup
|
|
|
|
$".clear
|
|
|
|
$:.clear
|
|
|
|
Dir.mktmpdir {|tmp|
|
|
|
|
$: << tmp
|
|
|
|
open(File.join(tmp, "foo.rb"), "w") {}
|
|
|
|
require "foo"
|
2012-12-13 00:11:02 -05:00
|
|
|
assert(Encoding.compatible?(tmp, $"[0]), bug6377)
|
2012-08-23 03:46:12 -04:00
|
|
|
}
|
|
|
|
ensure
|
|
|
|
$:.replace(loadpath)
|
|
|
|
$".replace(features)
|
|
|
|
end
|
2012-11-05 10:27:08 -05:00
|
|
|
|
|
|
|
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([], <<-INPUT, %w(:ok), [], bug7158)
|
2012-12-19 22:43:53 -05:00
|
|
|
$:.replace([IO::NULL])
|
2012-11-05 10:27:08 -05:00
|
|
|
$: << "."
|
|
|
|
Dir.chdir("a")
|
|
|
|
require "foo"
|
|
|
|
Dir.chdir("../b")
|
|
|
|
p :ng unless require "bar"
|
|
|
|
Dir.chdir("..")
|
|
|
|
p :ng if require "b/bar"
|
|
|
|
INPUT
|
|
|
|
}
|
|
|
|
}
|
|
|
|
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([], <<-INPUT, %w(:ok), [], bug7158)
|
2012-12-19 22:43:53 -05:00
|
|
|
$:.replace([IO::NULL])
|
2012-11-05 10:27:08 -05:00
|
|
|
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
|
|
|
|
INPUT
|
|
|
|
}
|
|
|
|
}
|
|
|
|
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([], <<-INPUT, %w(:ok), [], bug7158)
|
2012-12-19 22:43:53 -05:00
|
|
|
$:.replace([IO::NULL])
|
2012-11-05 10:27:08 -05:00
|
|
|
$: << '~'
|
|
|
|
ENV['HOME'] = "#{tmp}"
|
|
|
|
require "foo"
|
|
|
|
ENV['HOME'] = "#{tmp}/a"
|
|
|
|
p :ok if require "bar"
|
|
|
|
INPUT
|
|
|
|
}
|
|
|
|
}
|
|
|
|
end
|
|
|
|
|
|
|
|
def test_require_to_path_redefined_in_load_path
|
|
|
|
bug7158 = '[ruby-core:47970]'
|
|
|
|
Dir.mktmpdir {|tmp|
|
|
|
|
Dir.chdir(tmp) {
|
|
|
|
open("foo.rb", "w") {}
|
2012-11-05 15:55:30 -05:00
|
|
|
assert_in_out_err(["RUBYOPT"=>nil], <<-INPUT, %w(:ok), [], bug7158)
|
2012-12-19 22:43:53 -05:00
|
|
|
$:.replace([IO::NULL])
|
2012-11-05 10:27:08 -05:00
|
|
|
a = Object.new
|
|
|
|
def a.to_path
|
|
|
|
"bar"
|
|
|
|
end
|
|
|
|
$: << a
|
|
|
|
begin
|
|
|
|
require "foo"
|
2012-12-17 21:06:39 -05:00
|
|
|
p [:ng, $LOAD_PATH, ENV['RUBYLIB']]
|
2012-11-05 10:27:08 -05:00
|
|
|
rescue LoadError
|
|
|
|
end
|
|
|
|
def a.to_path
|
|
|
|
"#{tmp}"
|
|
|
|
end
|
|
|
|
p :ok if require "foo"
|
|
|
|
INPUT
|
|
|
|
}
|
|
|
|
}
|
|
|
|
end
|
|
|
|
|
|
|
|
def test_require_to_str_redefined_in_load_path
|
|
|
|
bug7158 = '[ruby-core:47970]'
|
|
|
|
Dir.mktmpdir {|tmp|
|
|
|
|
Dir.chdir(tmp) {
|
|
|
|
open("foo.rb", "w") {}
|
2012-11-05 15:55:30 -05:00
|
|
|
assert_in_out_err(["RUBYOPT"=>nil], <<-INPUT, %w(:ok), [], bug7158)
|
2012-12-19 22:43:53 -05:00
|
|
|
$:.replace([IO::NULL])
|
2012-11-05 10:27:08 -05:00
|
|
|
a = Object.new
|
|
|
|
def a.to_str
|
|
|
|
"foo"
|
|
|
|
end
|
|
|
|
$: << a
|
|
|
|
begin
|
|
|
|
require "foo"
|
2012-12-17 21:06:39 -05:00
|
|
|
p [:ng, $LOAD_PATH, ENV['RUBYLIB']]
|
2012-11-05 10:27:08 -05:00
|
|
|
rescue LoadError
|
|
|
|
end
|
|
|
|
def a.to_str
|
|
|
|
"#{tmp}"
|
|
|
|
end
|
|
|
|
p :ok if require "foo"
|
|
|
|
INPUT
|
|
|
|
}
|
|
|
|
}
|
|
|
|
end
|
2012-11-22 09:55:32 -05:00
|
|
|
|
|
|
|
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([], <<-INPUT, %w(:ok), [], bug7383)
|
2012-12-19 22:43:53 -05:00
|
|
|
$:.replace([IO::NULL])
|
2012-11-22 09:55:32 -05:00
|
|
|
$:.#{add} "#{tmp}"
|
|
|
|
$:.#{add} "#{tmp}/a"
|
|
|
|
require "foo"
|
|
|
|
$:.#{del}
|
|
|
|
# Expanded load path cache should be rebuilt.
|
|
|
|
begin
|
|
|
|
require "bar"
|
|
|
|
rescue LoadError
|
|
|
|
p :ok
|
|
|
|
end
|
|
|
|
INPUT
|
|
|
|
}
|
|
|
|
}
|
|
|
|
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
|
2012-12-21 05:53:57 -05:00
|
|
|
|
|
|
|
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], <<-INPUT, %w([:lib] 2), [], bug7536)
|
|
|
|
puts TOPLEVEL_BINDING.eval("local_variables").inspect
|
|
|
|
puts TOPLEVEL_BINDING.eval("lib").inspect
|
|
|
|
INPUT
|
|
|
|
}
|
|
|
|
}
|
|
|
|
end
|
2008-05-21 11:31:15 -04:00
|
|
|
end
|