* vm.c, eval_intern.h (PASS_PASSED_BLOCK):
set a VM_FRAME_FLAG_PASSED flag to skip this frame when
searching ruby-level-cfp.
* eval.c, eval_intern.h, proc.c: fix to check cfp. if there is
no valid ruby-level-cfp, cause RuntimeError exception.
[ruby-dev:34128]
* vm_core.h, vm_evalbody.c, vm.c, vm_dump.c, vm_insnhelper.c,
insns.def: rename FRAME_MAGIC_* to VM_FRAME_MAGIC_*.
* KNOWNBUGS.rb, bootstraptest/test*.rb: move solved bugs.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@17084 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2008-06-10 17:46:43 -04:00
|
|
|
# Thread and Fiber
|
|
|
|
|
2007-06-27 12:26:31 -04:00
|
|
|
assert_equal %q{ok}, %q{
|
|
|
|
Thread.new{
|
|
|
|
}.join
|
|
|
|
:ok
|
|
|
|
}
|
|
|
|
assert_equal %q{ok}, %q{
|
|
|
|
Thread.new{
|
|
|
|
:ok
|
|
|
|
}.value
|
|
|
|
}
|
|
|
|
assert_equal %q{20100}, %q{
|
|
|
|
v = 0
|
|
|
|
(1..200).map{|i|
|
|
|
|
Thread.new{
|
|
|
|
i
|
|
|
|
}
|
|
|
|
}.each{|t|
|
|
|
|
v += t.value
|
|
|
|
}
|
|
|
|
v
|
|
|
|
}
|
|
|
|
assert_equal %q{5000}, %q{
|
|
|
|
5000.times{|e|
|
|
|
|
(1..2).map{
|
|
|
|
Thread.new{
|
|
|
|
}
|
|
|
|
}.each{|e|
|
2007-12-24 23:16:06 -05:00
|
|
|
e.join()
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
assert_equal %q{5000}, %q{
|
|
|
|
5000.times{|e|
|
|
|
|
(1..2).map{
|
|
|
|
Thread.new{
|
|
|
|
}
|
|
|
|
}.each{|e|
|
|
|
|
e.join(1000000000)
|
2007-06-27 12:26:31 -04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
assert_equal %q{5000}, %q{
|
|
|
|
5000.times{
|
|
|
|
t = Thread.new{}
|
|
|
|
while t.alive?
|
|
|
|
Thread.pass
|
|
|
|
end
|
|
|
|
}
|
|
|
|
}
|
|
|
|
assert_equal %q{100}, %q{
|
|
|
|
100.times{
|
|
|
|
Thread.new{loop{Thread.pass}}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
assert_equal %q{ok}, %q{
|
|
|
|
Thread.new{
|
|
|
|
:ok
|
|
|
|
}.join.value
|
|
|
|
}
|
|
|
|
assert_equal %q{ok}, %q{
|
|
|
|
begin
|
|
|
|
Thread.new{
|
|
|
|
raise "ok"
|
|
|
|
}.join
|
|
|
|
rescue => e
|
|
|
|
e
|
|
|
|
end
|
|
|
|
}
|
|
|
|
assert_equal %q{ok}, %q{
|
|
|
|
ans = nil
|
|
|
|
t = Thread.new{
|
|
|
|
begin
|
|
|
|
sleep 0.5
|
|
|
|
ensure
|
|
|
|
ans = :ok
|
|
|
|
end
|
|
|
|
}
|
|
|
|
Thread.pass
|
|
|
|
t.kill
|
|
|
|
t.join
|
|
|
|
ans
|
|
|
|
}
|
|
|
|
assert_equal %q{ok}, %q{
|
|
|
|
t = Thread.new{
|
|
|
|
sleep
|
|
|
|
}
|
|
|
|
sleep 0.1
|
|
|
|
t.raise
|
|
|
|
begin
|
|
|
|
t.join
|
|
|
|
:ng
|
|
|
|
rescue
|
|
|
|
:ok
|
|
|
|
end
|
|
|
|
}
|
|
|
|
assert_equal %q{ok}, %q{
|
|
|
|
t = Thread.new{
|
|
|
|
loop{}
|
|
|
|
}
|
|
|
|
Thread.pass
|
|
|
|
t.raise
|
|
|
|
begin
|
|
|
|
t.join
|
|
|
|
:ng
|
|
|
|
rescue
|
|
|
|
:ok
|
|
|
|
end
|
|
|
|
}
|
|
|
|
assert_equal %q{ok}, %q{
|
|
|
|
t = Thread.new{
|
|
|
|
}
|
|
|
|
Thread.pass
|
|
|
|
t.join
|
|
|
|
t.raise # raise to exited thread
|
|
|
|
begin
|
|
|
|
t.join
|
|
|
|
:ok
|
|
|
|
rescue
|
|
|
|
:ng
|
|
|
|
end
|
|
|
|
}
|
|
|
|
assert_equal %q{run}, %q{
|
|
|
|
t = Thread.new{
|
|
|
|
loop{}
|
|
|
|
}
|
|
|
|
st = t.status
|
|
|
|
t.kill
|
|
|
|
st
|
|
|
|
}
|
|
|
|
assert_equal %q{sleep}, %q{
|
|
|
|
t = Thread.new{
|
|
|
|
sleep
|
|
|
|
}
|
|
|
|
sleep 0.1
|
|
|
|
st = t.status
|
|
|
|
t.kill
|
|
|
|
st
|
|
|
|
}
|
|
|
|
assert_equal %q{false}, %q{
|
|
|
|
t = Thread.new{
|
|
|
|
}
|
|
|
|
t.kill
|
|
|
|
sleep 0.1
|
|
|
|
t.status
|
|
|
|
}
|
|
|
|
assert_equal %q{[ThreadGroup, true]}, %q{
|
|
|
|
ptg = Thread.current.group
|
|
|
|
Thread.new{
|
|
|
|
ctg = Thread.current.group
|
|
|
|
[ctg.class, ctg == ptg]
|
|
|
|
}.value
|
|
|
|
}
|
|
|
|
assert_equal %q{[1, 1]}, %q{
|
|
|
|
thg = ThreadGroup.new
|
|
|
|
|
|
|
|
t = Thread.new{
|
|
|
|
thg.add Thread.current
|
|
|
|
sleep
|
|
|
|
}
|
|
|
|
sleep 0.1
|
|
|
|
[thg.list.size, ThreadGroup::Default.list.size]
|
|
|
|
}
|
2008-01-18 09:49:43 -05:00
|
|
|
assert_equal %q{true}, %q{
|
|
|
|
thg = ThreadGroup.new
|
|
|
|
|
|
|
|
t = Thread.new{sleep 5}
|
|
|
|
thg.add t
|
|
|
|
thg.list.include?(t)
|
|
|
|
}
|
2007-06-27 12:26:31 -04:00
|
|
|
assert_equal %q{[true, nil, true]}, %q{
|
|
|
|
/a/ =~ 'a'
|
|
|
|
$a = $~
|
|
|
|
Thread.new{
|
|
|
|
$b = $~
|
|
|
|
/a/ =~ 'a'
|
|
|
|
$c = $~
|
|
|
|
}
|
|
|
|
$d = $~
|
|
|
|
[$a == $d, $b, $c != $d]
|
|
|
|
}
|
|
|
|
assert_equal %q{11}, %q{
|
|
|
|
Thread.current[:a] = 1
|
|
|
|
Thread.new{
|
|
|
|
Thread.current[:a] = 10
|
|
|
|
Thread.pass
|
|
|
|
Thread.current[:a]
|
|
|
|
}.value + Thread.current[:a]
|
|
|
|
}
|
2009-09-11 08:06:34 -04:00
|
|
|
assert_normal_exit %q{
|
2007-08-12 16:06:59 -04:00
|
|
|
begin
|
2007-12-09 18:16:54 -05:00
|
|
|
100.times do |i|
|
2007-08-12 16:06:59 -04:00
|
|
|
begin
|
2009-09-11 08:06:34 -04:00
|
|
|
th = Thread.start(Thread.current) {|u| u.raise }
|
2007-08-12 16:06:59 -04:00
|
|
|
raise
|
|
|
|
rescue
|
|
|
|
ensure
|
2009-09-11 08:06:34 -04:00
|
|
|
th.join
|
2007-08-12 16:06:59 -04:00
|
|
|
end
|
|
|
|
end
|
|
|
|
rescue
|
|
|
|
end
|
|
|
|
}, '[ruby-dev:31371]'
|
2008-01-25 13:02:01 -05:00
|
|
|
|
2008-01-14 05:02:51 -05:00
|
|
|
assert_equal 'true', %{
|
|
|
|
t = Thread.new { loop {} }
|
2008-01-22 21:23:21 -05:00
|
|
|
begin
|
|
|
|
pid = fork {
|
2008-01-14 05:02:51 -05:00
|
|
|
exit t.status != "run"
|
2008-01-22 21:23:21 -05:00
|
|
|
}
|
|
|
|
Process.wait pid
|
|
|
|
$?.success?
|
|
|
|
rescue NotImplementedError
|
|
|
|
true
|
|
|
|
end
|
2008-01-14 05:02:51 -05:00
|
|
|
}
|
2008-04-22 00:13:01 -04:00
|
|
|
|
2009-02-23 11:20:06 -05:00
|
|
|
assert_equal 'ok', %{
|
|
|
|
open("zzz.rb", "w") do |f|
|
|
|
|
f.puts <<-END
|
2009-02-23 11:24:46 -05:00
|
|
|
begin
|
|
|
|
Thread.new { fork { GC.start } }.join
|
|
|
|
pid, status = Process.wait2
|
|
|
|
$result = status.success? ? :ok : :ng
|
|
|
|
rescue NotImplementedError
|
2009-02-26 00:01:03 -05:00
|
|
|
$result = :ok
|
2009-02-23 11:24:46 -05:00
|
|
|
end
|
2009-02-23 11:20:06 -05:00
|
|
|
END
|
|
|
|
end
|
2009-06-22 03:28:33 -04:00
|
|
|
require "./zzz.rb"
|
2009-02-23 11:20:06 -05:00
|
|
|
$result
|
|
|
|
}
|
|
|
|
|
2008-04-22 00:13:01 -04:00
|
|
|
assert_finish 3, %{
|
|
|
|
th = Thread.new {sleep 2}
|
|
|
|
th.join(1)
|
|
|
|
th.join
|
|
|
|
}
|
|
|
|
|
|
|
|
assert_finish 3, %{
|
|
|
|
require 'timeout'
|
|
|
|
th = Thread.new {sleep 2}
|
|
|
|
begin
|
|
|
|
Timeout.timeout(1) {th.join}
|
|
|
|
rescue Timeout::Error
|
|
|
|
end
|
|
|
|
th.join
|
|
|
|
}
|
2008-04-22 00:26:44 -04:00
|
|
|
|
|
|
|
assert_normal_exit %q{
|
|
|
|
STDERR.reopen(STDOUT)
|
|
|
|
exec "/"
|
|
|
|
}
|
2008-05-08 02:59:03 -04:00
|
|
|
|
|
|
|
assert_normal_exit %q{
|
|
|
|
(0..10).map {
|
|
|
|
Thread.new {
|
|
|
|
10000.times {
|
|
|
|
Object.new.to_s
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}.each {|t|
|
|
|
|
t.join
|
|
|
|
}
|
|
|
|
}
|
2008-05-19 01:20:21 -04:00
|
|
|
|
|
|
|
assert_equal 'ok', %q{
|
|
|
|
def m
|
|
|
|
t = Thread.new { while true do // =~ "" end }
|
|
|
|
sleep 0.1
|
|
|
|
10.times {
|
|
|
|
if /((ab)*(ab)*)*(b)/ =~ "ab"*7
|
|
|
|
return :ng if !$4
|
|
|
|
return :ng if $~.size != 5
|
|
|
|
end
|
|
|
|
}
|
|
|
|
:ok
|
|
|
|
ensure
|
|
|
|
Thread.kill t
|
|
|
|
end
|
|
|
|
m
|
|
|
|
}, '[ruby-dev:34492]'
|
|
|
|
|
|
|
|
assert_normal_exit %q{
|
|
|
|
at_exit { Fiber.new{}.resume }
|
|
|
|
}
|
|
|
|
|
* vm.c, eval_intern.h (PASS_PASSED_BLOCK):
set a VM_FRAME_FLAG_PASSED flag to skip this frame when
searching ruby-level-cfp.
* eval.c, eval_intern.h, proc.c: fix to check cfp. if there is
no valid ruby-level-cfp, cause RuntimeError exception.
[ruby-dev:34128]
* vm_core.h, vm_evalbody.c, vm.c, vm_dump.c, vm_insnhelper.c,
insns.def: rename FRAME_MAGIC_* to VM_FRAME_MAGIC_*.
* KNOWNBUGS.rb, bootstraptest/test*.rb: move solved bugs.
git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@17084 b2dd03c8-39d4-4d8f-98ff-823fe69b080e
2008-06-10 17:46:43 -04:00
|
|
|
assert_normal_exit %q{
|
|
|
|
g = enum_for(:local_variables)
|
|
|
|
loop { g.next }
|
|
|
|
}, '[ruby-dev:34128]'
|
|
|
|
|
|
|
|
assert_normal_exit %q{
|
|
|
|
g = enum_for(:block_given?)
|
|
|
|
loop { g.next }
|
|
|
|
}, '[ruby-dev:34128]'
|
|
|
|
|
|
|
|
assert_normal_exit %q{
|
|
|
|
g = enum_for(:binding)
|
|
|
|
loop { g.next }
|
|
|
|
}, '[ruby-dev:34128]'
|
|
|
|
|
|
|
|
assert_normal_exit %q{
|
|
|
|
g = "abc".enum_for(:scan, /./)
|
|
|
|
loop { g.next }
|
|
|
|
}, '[ruby-dev:34128]'
|
|
|
|
|
|
|
|
assert_normal_exit %q{
|
|
|
|
g = Module.enum_for(:new)
|
|
|
|
loop { g.next }
|
|
|
|
}, '[ruby-dev:34128]'
|
|
|
|
|
|
|
|
assert_normal_exit %q{
|
|
|
|
Fiber.new(&Object.method(:class_eval)).resume("foo")
|
|
|
|
}, '[ruby-dev:34128]'
|
|
|
|
|
|
|
|
assert_normal_exit %q{
|
|
|
|
Thread.new("foo", &Object.method(:class_eval)).join
|
|
|
|
}, '[ruby-dev:34128]'
|
2008-06-12 09:01:38 -04:00
|
|
|
|
|
|
|
assert_equal 'ok', %q{
|
|
|
|
begin
|
|
|
|
Thread.new { Thread.stop }
|
|
|
|
Thread.stop
|
|
|
|
:ng
|
|
|
|
rescue Exception
|
|
|
|
:ok
|
|
|
|
end
|
|
|
|
}
|
|
|
|
|
|
|
|
assert_equal 'ok', %q{
|
|
|
|
begin
|
|
|
|
m1, m2 = Mutex.new, Mutex.new
|
|
|
|
Thread.new { m1.lock; sleep 1; m2.lock }
|
|
|
|
m2.lock; sleep 1; m1.lock
|
|
|
|
:ng
|
|
|
|
rescue Exception
|
|
|
|
:ok
|
|
|
|
end
|
|
|
|
}
|
|
|
|
|
|
|
|
assert_equal 'ok', %q{
|
|
|
|
m = Mutex.new
|
|
|
|
Thread.new { m.lock }; sleep 1; m.lock
|
|
|
|
:ok
|
|
|
|
}
|
|
|
|
|
|
|
|
assert_equal 'ok', %q{
|
|
|
|
m = Mutex.new
|
|
|
|
Thread.new { m.lock }; m.lock
|
|
|
|
:ok
|
|
|
|
}
|
|
|
|
|
|
|
|
assert_equal 'ok', %q{
|
|
|
|
m = Mutex.new
|
|
|
|
Thread.new { m.lock }.join; m.lock
|
|
|
|
:ok
|
|
|
|
}
|
|
|
|
|
|
|
|
assert_equal 'ok', %q{
|
|
|
|
m = Mutex.new
|
|
|
|
Thread.new { m.lock; sleep 2 }
|
|
|
|
sleep 1; m.lock
|
|
|
|
:ok
|
|
|
|
}
|
|
|
|
|
|
|
|
assert_equal 'ok', %q{
|
|
|
|
m = Mutex.new
|
|
|
|
Thread.new { m.lock; sleep 2; m.unlock }
|
|
|
|
sleep 1; m.lock
|
|
|
|
:ok
|
|
|
|
}
|
2008-07-09 23:10:00 -04:00
|
|
|
|
|
|
|
assert_equal 'ok', %q{
|
|
|
|
t = Thread.new {`echo`}
|
|
|
|
t.join
|
|
|
|
$? ? :ng : :ok
|
2008-07-10 10:52:24 -04:00
|
|
|
}, '[ruby-dev:35414]'
|
2008-08-31 03:39:45 -04:00
|
|
|
|
|
|
|
assert_equal 'ok', %q{
|
2008-10-27 20:52:32 -04:00
|
|
|
begin
|
|
|
|
10000.times { Thread.new(true) {|x| x == false } }
|
|
|
|
rescue NoMemoryError, StandardError
|
|
|
|
end
|
|
|
|
:ok
|
2008-08-31 03:39:45 -04:00
|
|
|
}
|
2009-11-15 10:10:49 -05:00
|
|
|
|
|
|
|
assert_equal 'ok', %{
|
|
|
|
open("zzz.rb", "w") do |f|
|
|
|
|
f.puts <<-END
|
|
|
|
begin
|
|
|
|
m = Mutex.new
|
|
|
|
Thread.new { m.lock; sleep 1 }
|
|
|
|
sleep 0.3
|
2009-11-23 20:30:00 -05:00
|
|
|
parent = Thread.current
|
2009-11-15 10:10:49 -05:00
|
|
|
Thread.new do
|
|
|
|
sleep 0.3
|
2009-11-23 20:30:00 -05:00
|
|
|
begin
|
|
|
|
fork { GC.start }
|
|
|
|
rescue Exception
|
|
|
|
parent.raise $!
|
|
|
|
end
|
2009-11-15 10:10:49 -05:00
|
|
|
end
|
|
|
|
m.lock
|
|
|
|
pid, status = Process.wait2
|
|
|
|
$result = status.success? ? :ok : :ng
|
|
|
|
rescue NotImplementedError
|
|
|
|
$result = :ok
|
|
|
|
end
|
|
|
|
END
|
|
|
|
end
|
|
|
|
require "./zzz.rb"
|
|
|
|
$result
|
|
|
|
}
|
2009-11-18 04:25:11 -05:00
|
|
|
|
|
|
|
assert_finish 3, %q{
|
|
|
|
require 'thread'
|
|
|
|
|
|
|
|
lock = Mutex.new
|
|
|
|
cond = ConditionVariable.new
|
|
|
|
t = Thread.new do
|
|
|
|
lock.synchronize do
|
|
|
|
cond.wait(lock)
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2009-11-18 19:56:44 -05:00
|
|
|
begin
|
|
|
|
pid = fork do
|
|
|
|
# Child
|
|
|
|
STDOUT.write "This is the child process.\n"
|
|
|
|
STDOUT.write "Child process exiting.\n"
|
|
|
|
end
|
|
|
|
Process.waitpid(pid)
|
|
|
|
rescue NotImplementedError
|
2009-11-18 04:25:11 -05:00
|
|
|
end
|
|
|
|
}, '[ruby-core:26361]'
|