diff options
Diffstat (limited to 'bootstraptest/test_thread.rb')
| -rw-r--r-- | bootstraptest/test_thread.rb | 360 |
1 files changed, 338 insertions, 22 deletions
diff --git a/bootstraptest/test_thread.rb b/bootstraptest/test_thread.rb index b3592e9bd7..7ff5bb4a38 100644 --- a/bootstraptest/test_thread.rb +++ b/bootstraptest/test_thread.rb @@ -1,3 +1,15 @@ +show_limit %q{ + threads = [] + begin + threads << Thread.new{sleep} + + raise Exception, "skipping" if threads.count >= 10_000 + rescue Exception => error + puts "Thread count: #{threads.count} (#{error})" + break + end while true +} if false # disable to pass CI + assert_equal %q{ok}, %q{ Thread.new{ }.join @@ -8,7 +20,8 @@ assert_equal %q{ok}, %q{ :ok }.value } -assert_equal %q{20100}, %q{ +assert_equal %q{ok}, %q{ +begin v = 0 (1..200).map{|i| Thread.new{ @@ -17,10 +30,14 @@ assert_equal %q{20100}, %q{ }.each{|t| v += t.value } - v + v == 20100 ? :ok : v +rescue ThreadError => e + :ok if /can't create Thread/ =~ e.message +end } -assert_equal %q{5000}, %q{ - 5000.times{|e| +assert_equal %q{ok}, %q{ +begin + :ok if 5000 == 5000.times{|e| (1..2).map{ Thread.new{ } @@ -28,9 +45,13 @@ assert_equal %q{5000}, %q{ e.join() } } +rescue ThreadError => e + /can't create Thread/ =~ e.message ? :ok : e.message +end } -assert_equal %q{5000}, %q{ - 5000.times{|e| +assert_equal %q{ok}, %q{ +begin + :ok if 5000 == 5000.times{|e| (1..2).map{ Thread.new{ } @@ -38,14 +59,21 @@ assert_equal %q{5000}, %q{ e.join(1000000000) } } +rescue ThreadError => e + /can't create Thread/ =~ e.message ? :ok : e.message +end } -assert_equal %q{5000}, %q{ - 5000.times{ +assert_equal %q{ok}, %q{ +begin + :ok if 5000 == 5000.times{ t = Thread.new{} while t.alive? Thread.pass end } +rescue NoMemoryError + :ok +end } assert_equal %q{100}, %q{ 100.times{ @@ -75,7 +103,7 @@ assert_equal %q{ok}, %q{ ans = :ok end } - Thread.pass + Thread.pass until t.stop? t.kill t.join ans @@ -160,14 +188,21 @@ assert_equal %q{[1, 1]}, %q{ sleep 0.1 [thg.list.size, ThreadGroup::Default.list.size] } +assert_equal %q{true}, %q{ + thg = ThreadGroup.new + + t = Thread.new{sleep 5} + thg.add t + thg.list.include?(t) +} assert_equal %q{[true, nil, true]}, %q{ /a/ =~ 'a' $a = $~ Thread.new{ $b = $~ - /a/ =~ 'a' + /b/ =~ 'b' $c = $~ - } + }.join $d = $~ [$a == $d, $b, $c != $d] } @@ -179,17 +214,298 @@ assert_equal %q{11}, %q{ Thread.current[:a] }.value + Thread.current[:a] } -assert_equal %q{100}, %q{ -begin - 100.times do |i| - begin - Thread.start(Thread.current) {|u| u.raise } - raise - rescue - ensure +assert_normal_exit %q{ + begin + 100.times do |i| + begin + th = Thread.start(Thread.current) {|u| u.raise } + raise + rescue + ensure + th.join + end end + rescue end -rescue - 100 -end }, '[ruby-dev:31371]' + +assert_equal 'true', %{ + t = Thread.new { loop {} } + begin + pid = fork { + exit t.status != "run" + } + Process.wait pid + $?.success? + rescue NotImplementedError + true + end +} + +assert_equal 'true', %{ + Thread.new{}.join + begin + Process.waitpid2 fork{ + Thread.new{ + sleep 0.1 + }.join + } + true + rescue NotImplementedError + true + end +} + +assert_equal 'ok', %{ + File.write("zzz_t1.rb", <<-END) + begin + Thread.new { fork { GC.start } }.join + pid, status = Process.wait2 + $result = status.success? ? :ok : :ng + rescue NotImplementedError + $result = :ok + end + END + require "./zzz_t1.rb" + $result +} + +assert_finish 3, %{ + th = Thread.new {sleep 0.2} + th.join(0.1) + th.join +} + +assert_finish 3, %{ + require 'timeout' + th = Thread.new {sleep 0.2} + begin + Timeout.timeout(0.1) {th.join} + rescue Timeout::Error + end + th.join +} + +assert_normal_exit %q{ + STDERR.reopen(STDOUT) + exec "/" +} + +assert_normal_exit %q{ + (0..10).map { + Thread.new { + 10000.times { + Object.new.to_s + } + } + }.each {|t| + t.join + } +} + +assert_equal 'ok', %q{ + def m + t = Thread.new { while true; // =~ "" end } + sleep 0.01 + 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{ + 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{ + Thread.new("foo", &Object.method(:class_eval)).join +}, '[ruby-dev:34128]' + +assert_equal 'ok', %q{ + begin + Thread.new { Thread.stop } + Thread.stop + :ng + rescue Exception + :ok + end +} + +assert_equal 'ok', %q{ + begin + m1, m2 = Thread::Mutex.new, Thread::Mutex.new + f1 = f2 = false + Thread.new { m1.lock; f2 = true; sleep 0.001 until f1; m2.lock } + m2.lock; f1 = true; sleep 0.001 until f2; m1.lock + :ng + rescue Exception + :ok + end +} + +assert_equal 'ok', %q{ + m = Thread::Mutex.new + Thread.new { m.lock }; sleep 0.1; m.lock + :ok +} + +assert_equal 'ok', %q{ + m = Thread::Mutex.new + Thread.new { m.lock }; m.lock + :ok +} + +assert_equal 'ok', %q{ + m = Thread::Mutex.new + Thread.new { m.lock }.join; m.lock + :ok +} + +assert_equal 'ok', %q{ + m = Thread::Mutex.new + Thread.new { m.lock; sleep 0.2 } + sleep 0.1; m.lock + :ok +} + +assert_equal 'ok', %q{ + m = Thread::Mutex.new + Thread.new { m.lock; sleep 0.2; m.unlock } + sleep 0.1; m.lock + :ok +} + +assert_equal 'ok', %q{ + t = Thread.new {`echo`} + t.join + $? ? :ng : :ok +}, '[ruby-dev:35414]' + +assert_equal 'ok', %q{ + begin + 100.times{ + (1..100).map{ Thread.new(true) {|x| x == false } }.each{|th| th.join} + } + rescue NoMemoryError, StandardError + end + :ok +} + +assert_equal 'ok', %{ + File.write("zzz_t2.rb", <<-'end;') # do + begin + m = Thread::Mutex.new + parent = Thread.current + th1 = Thread.new { m.lock; sleep } + sleep 0.01 until th1.stop? + Thread.new do + sleep 0.01 until parent.stop? + begin + fork { GC.start } + rescue Exception + parent.raise $! + end + th1.run + end + m.lock + pid, status = Process.wait2 + $result = status.success? ? :ok : :ng + rescue NotImplementedError + $result = :ok + end + end; + require "./zzz_t2.rb" + $result +} + +assert_finish 3, %q{ + require 'thread' + + lock = Thread::Mutex.new + cond = Thread::ConditionVariable.new + t = Thread.new do + lock.synchronize do + cond.wait(lock) + end + end + + 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 + end +}, '[ruby-core:23572]' + +assert_equal 'ok', %q{ + begin + Process.waitpid2(fork {})[1].success? ? 'ok' : 'ng' + rescue NotImplementedError + 'ok' + end +} + +assert_equal 'foo', %q{ + i = 0 + Thread.start {sleep 1; exit!} + f = proc {|s, c| /#{c.call; s}/o } + th2 = Thread.new { + sleep 0.01 until i == 1 + i = 2 + f.call("bar", proc {sleep 2}); + nil + } + th1 = Thread.new { + f.call("foo", proc {i = 1; sleep 0.01 until i == 2; sleep 0.01}) + nil + } + [th1, th2].each {|t| t.join } + GC.start + f.call.source +} + +assert_normal_exit %q{ + class C + def inspect + sleep 0.5 + 'C!!' + end + end + Thread.new{ + loop{ + p C.new + } + } + sleep 0.1 +}, timeout: 5 |