fluentd 1.8.1-x64-mingw32 → 1.9.0-x64-mingw32

data/test/plugin/test_in_object_space.rb

@@ -27,7 +27,7 @@ class ObjectSpaceInputTest < Test::Unit::TestCase
   end
 
   TESTCONFIG = %[
-    emit_interval 1
+    emit_interval 0.2
     tag t1
     top 2
   ]
@@ -38,7 +38,7 @@ class ObjectSpaceInputTest < Test::Unit::TestCase
 
   def test_configure
     d = create_driver
-    assert_equal 1, d.instance.emit_interval
+    assert_equal 0.2, d.instance.emit_interval
     assert_equal "t1", d.instance.tag
     assert_equal 2, d.instance.top
   end
@@ -46,11 +46,7 @@ class ObjectSpaceInputTest < Test::Unit::TestCase
   def test_emit
     d = create_driver
 
-    d.run do
-      waiting(10, d.instance) do
-        sleep 0.5 until d.events.size > 3
-      end
-    end
+    d.run(expect_emits: 3)
 
     emits = d.events
     assert{ emits.length > 0 }

data/test/plugin/test_out_exec_filter.rb

@@ -460,7 +460,7 @@ class ExecFilterOutputTest < Test::Unit::TestCase
 
   CONFIG_ROUND_ROBIN = %[
     command ruby -e 'STDOUT.sync = true; STDIN.each_line{|line| puts line.chomp + "\t" + Process.pid.to_s }'
-    num_children 3
+    num_children 2
     <inject>
       tag_key     tag
       time_key    time_in
@@ -489,7 +489,7 @@ class ExecFilterOutputTest < Test::Unit::TestCase
     out_time_key time_out
     time_format %Y-%m-%d %H:%M:%S
     localtime
-    num_children 3
+    num_children 2
   ]
 
   data(
@@ -498,53 +498,38 @@ class ExecFilterOutputTest < Test::Unit::TestCase
   )
   test 'using child processes by round robin' do |conf|
     d = create_driver(conf)
-    time = event_time("2011-01-02 13:14:15")
+    time = event_time('2011-01-02 13:14:15')
 
-    d.run(default_tag: 'test', expect_emits: 1, timeout: 10, start: true,  shutdown: false){ d.feed(time, {"k1"=>1}) }
-    d.run(default_tag: 'test', expect_emits: 1, timeout: 10, start: false, shutdown: false){ d.feed(time, {"k1"=>2}) }
-    d.run(default_tag: 'test', expect_emits: 1, timeout: 10, start: false, shutdown: false){ d.feed(time, {"k1"=>3}) }
-    d.run(default_tag: 'test', expect_emits: 1, timeout: 10, start: false, shutdown: false){ d.feed(time, {"k1"=>4}) }
-    d.run(default_tag: 'test', expect_emits: 1, timeout: 10, start: false, shutdown: false){ d.feed(time, {"k1"=>5}) }
-    d.run(default_tag: 'test', expect_emits: 1, timeout: 10, start: false, shutdown: false){ d.feed(time, {"k1"=>6}) }
-    d.run(default_tag: 'test', expect_emits: 1, timeout: 10, start: false, shutdown: false){ d.feed(time, {"k1"=>7}) }
-    d.run(default_tag: 'test', expect_emits: 1, timeout: 10, start: false, shutdown: false){ d.feed(time, {"k1"=>8}) }
-    d.run(default_tag: 'test', expect_emits: 1, timeout: 10, start: false, shutdown: true ){ d.feed(time, {"k1"=>9}) }
+    d.run(default_tag: 'test', expect_emits: 1, timeout: 10, start: true,  shutdown: false){ d.feed(time, {"k1" => 0}) }
+    d.run(default_tag: 'test', expect_emits: 1, timeout: 10, start: false, shutdown: false){ d.feed(time, {"k1" => 1}) }
+    d.run(default_tag: 'test', expect_emits: 1, timeout: 10, start: false, shutdown: false){ d.feed(time, {"k1" => 2}) }
+    d.run(default_tag: 'test', expect_emits: 1, timeout: 10, start: false, shutdown: false){ d.feed(time, {"k1" => 3}) }
 
-    assert_equal "2011-01-02 13:14:15\ttest\t1\n", d.formatted[0]
-    assert_equal "2011-01-02 13:14:15\ttest\t2\n", d.formatted[1]
-    assert_equal "2011-01-02 13:14:15\ttest\t3\n", d.formatted[2]
-    assert_equal "2011-01-02 13:14:15\ttest\t4\n", d.formatted[3]
-    assert_equal "2011-01-02 13:14:15\ttest\t5\n", d.formatted[4]
-    assert_equal "2011-01-02 13:14:15\ttest\t6\n", d.formatted[5]
-    assert_equal "2011-01-02 13:14:15\ttest\t7\n", d.formatted[6]
-    assert_equal "2011-01-02 13:14:15\ttest\t8\n", d.formatted[7]
-    assert_equal "2011-01-02 13:14:15\ttest\t9\n", d.formatted[8]
+    assert_equal "2011-01-02 13:14:15\ttest\t0\n", d.formatted[0]
+    assert_equal "2011-01-02 13:14:15\ttest\t1\n", d.formatted[1]
+    assert_equal "2011-01-02 13:14:15\ttest\t2\n", d.formatted[2]
+    assert_equal "2011-01-02 13:14:15\ttest\t3\n", d.formatted[3]
 
     events = d.events
-    assert_equal 9, events.length
+    assert_equal 4, events.length
 
     pid_list = []
     events.each do |event|
       pid = event[2]['child_pid']
       pid_list << pid unless pid_list.include?(pid)
     end
-    assert_equal 3, pid_list.size, "the number of pids should be same with number of child processes: #{pid_list.inspect}"
+    assert_equal 2, pid_list.size, "the number of pids should be same with number of child processes: #{pid_list.inspect}"
 
     assert_equal pid_list[0], events[0][2]['child_pid']
     assert_equal pid_list[1], events[1][2]['child_pid']
-    assert_equal pid_list[2], events[2][2]['child_pid']
-    assert_equal pid_list[0], events[3][2]['child_pid']
-    assert_equal pid_list[1], events[4][2]['child_pid']
-    assert_equal pid_list[2], events[5][2]['child_pid']
-    assert_equal pid_list[0], events[6][2]['child_pid']
-    assert_equal pid_list[1], events[7][2]['child_pid']
-    assert_equal pid_list[2], events[8][2]['child_pid']
+    assert_equal pid_list[0], events[2][2]['child_pid']
+    assert_equal pid_list[1], events[3][2]['child_pid']
   end
 
   # child process exits per 3 lines
   CONFIG_RESPAWN = %[
     command ruby -e 'STDOUT.sync = true; proc = ->(){line = STDIN.readline.chomp; puts line + "\t" + Process.pid.to_s}; proc.call; proc.call; proc.call'
-    num_children 4
+    num_children 2
     child_respawn -1
     <inject>
       tag_key   tag
@@ -566,7 +551,7 @@ class ExecFilterOutputTest < Test::Unit::TestCase
 
   CONFIG_RESPAWN_COMPAT = %[
     command ruby -e 'STDOUT.sync = true; proc = ->(){line = STDIN.readline.chomp; puts line + "\t" + Process.pid.to_s}; proc.call; proc.call; proc.call'
-    num_children 4
+    num_children 2
     child_respawn -1
     in_keys time_in,tag,k1
     out_keys time_out,tag,k2,child_pid
@@ -584,35 +569,33 @@ class ExecFilterOutputTest < Test::Unit::TestCase
   test 'emit events via child processes which exits sometimes' do |conf|
     d = create_driver(conf)
     time = event_time("2011-01-02 13:14:15")
-
     countup = 0
 
     d.run(start: true, shutdown: false)
+    assert_equal 2, d.instance.instance_eval{ @_child_process_processes.size }
 
-    assert_equal 4, d.instance.instance_eval{ @_child_process_processes.size }
-
-    20.times do
-      d.run(default_tag: 'test', expect_emits: 1, timeout: 10, force_flush_retry: true, start: false, shutdown: false) do
-        d.feed(time, {"k1"=>countup}); countup += 1
-        d.feed(time, {"k1"=>countup}); countup += 1
-        d.feed(time, {"k1"=>countup}); countup += 1
+    2.times do
+      d.run(default_tag: 'test', expect_emits: 3, timeout: 3, force_flush_retry: true, start: false, shutdown: false) do
+        d.feed(time, { "k1" => countup }); countup += 1
+        d.feed(time, { "k1" => countup }); countup += 1
+        d.feed(time, { "k1" => countup }); countup += 1
       end
     end
 
     events = d.events
-    assert_equal 60, events.length
+    assert_equal 6, events.length
 
     pid_list = []
     events.each do |event|
       pid = event[2]['child_pid']
       pid_list << pid unless pid_list.include?(pid)
     end
-    # the number of pids should be same with number of child processes
-    assert{ pid_list.size >= 18 }
 
+    # the number of pids should be same with number of child processes
+    assert_equal 2, pid_list.size
     logs = d.instance.log.out.logs
-    assert{ logs.select{|l| l.include?("child process exits with error code") }.size >= 18 } # 20
-    assert{ logs.select{|l| l.include?("respawning child process") }.size >= 18 } # 20
+    assert_equal 2, logs.select { |l| l.include?('child process exits with error code') }.size
+    assert_equal 2, logs.select { |l| l.include?('respawning child process') }.size
 
     d.run(start: false, shutdown: true)
   end

data/test/plugin/test_out_forward.rb

@@ -671,7 +671,7 @@ EOL
 
     @d = d = create_driver(CONFIG + %[
       require_ack_response true
-      ack_response_timeout 5s
+      ack_response_timeout 1s
       <buffer tag>
         flush_mode immediate
         retry_type periodic
@@ -699,7 +699,7 @@ EOL
       end
     end
 
-    assert_equal (5 + 2), delayed_commit_timeout_value
+    assert_equal (1 + 2), delayed_commit_timeout_value
 
     events = target_input_driver.events
     assert_equal ['test', time, records[0]], events[0]

data/test/plugin/test_out_http.rb

@@ -117,7 +117,7 @@ class HTTPOutputTest < Test::Unit::TestCase
     Fluent::Test.setup
     FileUtils.rm_rf(TMP_DIR)
 
-    @@result = Result.new(nil, nil, {}, nil)    
+    @@result = Result.new(nil, nil, {}, nil)
     @@http_server_thread ||= Thread.new do
       run_http_server
     end
@@ -230,6 +230,9 @@ class HTTPOutputTest < Test::Unit::TestCase
   end
 
   def test_write_with_retryable_response
+    old_report_on_exception = Thread.report_on_exception
+    Thread.report_on_exception = false # thread finished as invalid state since RetryableResponse raises.
+
     d = create_driver("endpoint #{base_endpoint}/503")
     assert_raise(Fluent::Plugin::HTTPOutput::RetryableResponse) do
       d.run(default_tag: 'test.http', shutdown: false) do
@@ -238,7 +241,10 @@ class HTTPOutputTest < Test::Unit::TestCase
         }
       end
     end
-    d.instance_shutdown
+
+    d.instance_shutdown(log: $log)
+  ensure
+    Thread.report_on_exception = old_report_on_exception
   end
 
   def test_write_with_disabled_unrecoverable

data/test/plugin/test_output.rb

@@ -855,7 +855,7 @@ class OutputTest < Test::Unit::TestCase
     sub_test_case 'configure secondary' do
       test "Warn if primary type is different from secondary type and either primary or secondary has custom_format" do
         o = create_output(:buffered)
-        mock(o.log).warn("secondary type should be same with primary one",
+        mock(o.log).warn("Use different plugin for secondary. Check the plugin works with primary like secondary_file",
                          { primary: o.class.to_s, secondary: "Fluent::Plugin::TestOutput" })
 
         o.configure(config_element('ROOT','',{},[config_element('secondary','',{'@type'=>'test', 'name' => "cool"})]))
@@ -864,7 +864,7 @@ class OutputTest < Test::Unit::TestCase
 
       test "don't warn if primary type is the same as secondary type" do
         o = Fluent::Plugin::TestOutput.new
-        mock(o.log).warn("secondary type should be same with primary one",
+        mock(o.log).warn("Use different plugin for secondary. Check the plugin works with primary like secondary_file",
                          { primary: o.class.to_s, secondary: "Fluent::Plugin::TestOutput" }).never
 
         o.configure(config_element('ROOT','',{'name' => "cool2"},
@@ -876,7 +876,7 @@ class OutputTest < Test::Unit::TestCase
 
       test "don't warn if primary type is different from secondary type and both don't have custom_format" do
         o = create_output(:standard)
-        mock(o.log).warn("secondary type should be same with primary one",
+        mock(o.log).warn("Use different plugin for secondary. Check the plugin works with primary like secondary_file",
                          { primary: o.class.to_s, secondary: "Fluent::Plugin::TestOutput" }).never
 
         o.configure(config_element('ROOT','',{},[config_element('secondary','',{'@type'=>'test', 'name' => "cool"})]))

data/test/plugin/test_output_as_buffered.rb

@@ -699,7 +699,7 @@ class BufferedOutputTest < Test::Unit::TestCase
         r["key#{i}"] = "value #{i}"
       end
 
-      3.times do |i|
+      2.times do |i|
         rand_records = rand(1..4)
         es = Fluent::ArrayEventStream.new([ [t, r] ] * rand_records)
         assert_equal rand_records, es.size

data/test/plugin/test_output_as_buffered_overflow.rb

@@ -141,7 +141,7 @@ class BufferedOutputOverflowTest < Test::Unit::TestCase
       assert !@i.buffer.storable?
 
       Thread.new do
-        sleep 3
+        sleep 1
         failing = false
       end
 

data/test/plugin/test_output_as_buffered_secondary.rb

@@ -153,7 +153,7 @@ class BufferedOutputSecondaryTest < Test::Unit::TestCase
       i = create_output()
       i.configure(config_element('ROOT','',{},[priconf,secconf]))
       logs = i.log.out.logs
-      assert{ logs.any?{|l| l.include?("secondary type should be same with primary one") } }
+      assert{ logs.any?{|l| l.include?("Use different plugin for secondary. Check the plugin works with primary like secondary_file") } }
     end
 
     test 'secondary plugin lifecycle is kicked by primary' do
@@ -162,7 +162,7 @@ class BufferedOutputSecondaryTest < Test::Unit::TestCase
       i = create_output()
       i.configure(config_element('ROOT','',{},[priconf,secconf]))
       logs = i.log.out.logs
-      assert{ logs.any?{|l| l.include?("secondary type should be same with primary one") } }
+      assert{ logs.any?{|l| l.include?("Use different plugin for secondary. Check the plugin works with primary like secondary_file") } }
 
       assert i.secondary.configured?
 

data/test/plugin_helper/test_child_process.rb

@@ -232,30 +232,26 @@ class ChildProcessTest < Test::Unit::TestCase
   end
 
   test 'can execute external command at just once, which runs forever' do
-    m = Mutex.new
     ary = []
     Timeout.timeout(TEST_DEADLOCK_TIMEOUT) do
       ran = false
-      args = ["-e", "while sleep #{TEST_WAIT_INTERVAL_FOR_LOOP}; puts 1; STDOUT.flush; end"]
+      args = ["-e", "while sleep 0.1; puts 1; STDOUT.flush; end"]
       @d.child_process_execute(:t3, "ruby", arguments: args, mode: [:read]) do |io|
-        m.lock
-        ran = true
         begin
           while @d.child_process_running? && line = io.readline
+            ran ||= true
             ary << line
           end
         rescue
           # ignore
-        ensure
-          m.unlock
         end
       end
-      sleep TEST_WAIT_INTERVAL_FOR_BLOCK_RUNNING until m.locked? || ran
-      sleep TEST_WAIT_INTERVAL_FOR_LOOP * 10
+      sleep TEST_WAIT_INTERVAL_FOR_BLOCK_RUNNING until ran
+      sleep 1
+
       @d.stop # nothing occurs
       @d.shutdown
-
-      assert{ ary.size > 5 }
+      assert { ary.size >= 4 }
 
       @d.close
 
@@ -272,7 +268,7 @@ class ChildProcessTest < Test::Unit::TestCase
     ary = []
     Timeout.timeout(TEST_DEADLOCK_TIMEOUT) do
       ran = false
-      @d.child_process_execute(:t4, "ruby -e 'Signal.trap(:TERM, nil); while sleep #{TEST_WAIT_INTERVAL_FOR_LOOP}; puts 1; STDOUT.flush rescue nil; end'", mode: [:read]) do |io|
+      @d.child_process_execute(:t4, "ruby -e 'Signal.trap(:TERM, nil); while sleep 0.1; puts 1; STDOUT.flush rescue nil; end'", mode: [:read]) do |io|
         m.lock
         ran = true
         begin
@@ -290,17 +286,17 @@ class ChildProcessTest < Test::Unit::TestCase
       assert_equal [], @d.log.out.logs
 
       @d.stop # nothing occurs
-      sleep TEST_WAIT_INTERVAL_FOR_LOOP * 5
+      sleep TEST_WAIT_INTERVAL_FOR_LOOP
       lines1 = ary.size
       assert{ lines1 > 1 }
 
       pid = @d._child_process_processes.keys.first
-
+      # default value 10 is too long for test
+      @d.instance_eval { @_child_process_exit_timeout = 1 }
       @d.shutdown
-      sleep TEST_WAIT_INTERVAL_FOR_LOOP * 5
+      sleep TEST_WAIT_INTERVAL_FOR_LOOP
       lines2 = ary.size
-      assert{ lines2 > lines1 }
-
+      assert { lines2 > lines1 }
       @d.close
 
       assert_nil((Process.waitpid(pid, Process::WNOHANG) rescue nil))
@@ -318,12 +314,12 @@ class ChildProcessTest < Test::Unit::TestCase
 
   test 'can execute external command many times, which finishes immediately' do
     ary = []
-    arguments = ["-e", "3.times{ puts 'okay'; STDOUT.flush rescue nil; sleep #{TEST_WAIT_INTERVAL_FOR_LOOP} }"] # 0.5 * 3
+    arguments = ["-e", "puts 'okay'; STDOUT.flush rescue nil"]
     Timeout.timeout(TEST_DEADLOCK_TIMEOUT) do
-      @d.child_process_execute(:t5, "ruby", arguments: arguments, interval: 5, mode: [:read]) do |io|
+      @d.child_process_execute(:t5, "ruby", arguments: arguments, interval: 1, mode: [:read]) do |io|
         ary << io.read.split("\n").map(&:chomp).join
       end
-      sleep 13 # 5sec * 2 + 3sec
+      sleep 2.5 # 2sec(second invocation) + 0.5sec
       assert_equal [], @d.log.out.logs
       @d.stop
       assert_equal [], @d.log.out.logs
@@ -334,13 +330,12 @@ class ChildProcessTest < Test::Unit::TestCase
 
   test 'can execute external command many times, with leading once executed immediately' do
     ary = []
-    arguments = ["-e", "3.times{ puts 'okay'; STDOUT.flush rescue nil; sleep #{TEST_WAIT_INTERVAL_FOR_LOOP} }"]
+    arguments = ["-e", "puts 'okay'; STDOUT.flush rescue nil"]
     Timeout.timeout(TEST_DEADLOCK_TIMEOUT) do
-      @d.child_process_execute(:t6, "ruby", arguments: arguments, interval: 5, immediate: true, mode: [:read]) do |io|
+      @d.child_process_execute(:t6, "ruby", arguments: arguments, interval: 1, immediate: true, mode: [:read]) do |io|
         ary << io.read.split("\n").map(&:chomp).join
       end
-      sleep 8 # 5sec * 1 + 3sec
-              # but expected lines are same with test above
+      sleep 1.5 # 2sec(second invocation) + 0.5sec
       @d.stop; @d.shutdown; @d.close; @d.terminate
       assert_equal 2, ary.size
       assert_equal [], @d.log.out.logs
@@ -349,7 +344,7 @@ class ChildProcessTest < Test::Unit::TestCase
 
   test 'does not execute long running external command in parallel in default' do
     ary = []
-    arguments = ["-e", "10.times{ puts 'okay'; STDOUT.flush rescue nil; sleep #{TEST_WAIT_INTERVAL_FOR_LOOP} }"] # 0.5 * 10
+    arguments = ["-e", "10.times{ sleep #{TEST_WAIT_INTERVAL_FOR_LOOP} }"] # 5 sec
     Timeout.timeout(TEST_DEADLOCK_TIMEOUT) do
       assert_equal [], @d.log.out.logs
       @d.log.out.singleton_class.module_eval do
@@ -359,13 +354,13 @@ class ChildProcessTest < Test::Unit::TestCase
         }
       end
 
-      @d.child_process_execute(:t7, "ruby", arguments: arguments, interval: 2, immediate: true, mode: [:read]) do |io|
+      @d.child_process_execute(:t7, "ruby", arguments: arguments, interval: 1, immediate: true, mode: [:read]) do |io|
         ary << io.read.split("\n").map(&:chomp).join
       end
-      sleep 4
+      sleep 2
       assert_equal 1, @d._child_process_processes.size
       @d.stop
-      warn_msg = '[warn]: previous child process is still running. skipped. title=:t7 command="ruby" arguments=["-e", "10.times{ puts \'okay\'; STDOUT.flush rescue nil; sleep 0.5 }"] interval=2 parallel=false' + "\n"
+      warn_msg = '[warn]: previous child process is still running. skipped. title=:t7 command="ruby" arguments=["-e", "10.times{ sleep 0.5 }"] interval=1 parallel=false' + "\n"
       logs = @d.log.out.logs
       assert{ logs.first.end_with?(warn_msg) }
       assert{ logs.all?{|line| line.end_with?(warn_msg) } }
@@ -376,14 +371,14 @@ class ChildProcessTest < Test::Unit::TestCase
 
   test 'can execute long running external command in parallel if specified' do
     ary = []
-    arguments = ["-e", "10.times{ puts 'okay'; STDOUT.flush rescue nil; sleep #{TEST_WAIT_INTERVAL_FOR_LOOP} }"] # 0.5 * 10 sec
+    arguments = ["-e", "10.times{  puts 'okay'; STDOUT.flush rescue nil; sleep #{TEST_WAIT_INTERVAL_FOR_LOOP} }"] # 5 sec
     Timeout.timeout(TEST_DEADLOCK_TIMEOUT) do
       @d.child_process_execute(:t8, "ruby", arguments: arguments, interval: 1, immediate: true, parallel: true, mode: [:read]) do |io|
         ary << io.read.split("\n").map(&:chomp).join
       end
-      sleep 4
+      sleep 2
       processes = @d._child_process_processes.size
-      assert{ processes >= 3 && processes <= 5 }
+      assert { processes >= 2 && processes <= 4 }
       @d.stop; @d.shutdown; @d.close; @d.terminate
       assert_equal [], @d.log.out.logs
     end
@@ -662,14 +657,14 @@ class ChildProcessTest < Test::Unit::TestCase
       block_exits = false
       callback_called = false
       exit_status = nil
-      args = ['-e', 'sleep ARGV[0].to_i; puts "yay"; File.unlink ARGV[1]', '1', @temp_path]
+      args = ['-e', 'puts "yay"; File.unlink ARGV[0]', @temp_path]
       cb = ->(status){ exit_status = status; callback_called = true }
 
       str = nil
-
       pid = nil
       @d.child_process_execute(:st1, "ruby", arguments: args, mode: [:read], on_exit_callback: cb) do |readio|
-        pid = @d.instance_eval{ child_process_id }
+        assert !callback_called # ensure yet to be called
+        pid = @d.instance_eval { child_process_id }
         str = readio.read.chomp
         block_exits = true
       end
@@ -697,16 +692,11 @@ class ChildProcessTest < Test::Unit::TestCase
       cb = ->(status){ exit_status = status; callback_called = true }
 
       str = nil
-
       pid = nil
       @d.child_process_execute(:st1, "ruby", arguments: args, mode: [:read], on_exit_callback: cb) do |readio|
-        pid = @d.instance_eval{ child_process_id }
-        sleep 10 # to run child process correctly
-        Process.kill(:QUIT, pid)
+        pid = @d.instance_eval { child_process_id }
         sleep 1
-        Process.kill(:QUIT, pid) rescue nil # once more to send kill
-        sleep 1
-        Process.kill(:QUIT, pid) rescue nil # just like sync
+        Process.kill(:QUIT, pid)
         str = readio.read.chomp rescue nil # empty string before EOF
         block_exits = true
       end
@@ -717,29 +707,28 @@ class ChildProcessTest < Test::Unit::TestCase
       assert callback_called
       assert exit_status
 
-      # This test sometimes fails on TravisCI
-      #    with [nil, 11] # SIGSEGV
-      # or with [1, nil]  # ???
-      assert_equal [nil, 3, true, ""], [exit_status.exitstatus, exit_status.termsig, File.exist?(@temp_path), str] # SIGQUIT
-      # SIGSEGV looks a kind of BUG of ruby...
+      assert_equal nil, exit_status.exitstatus
+      assert_equal 3, exit_status.termsig
+      assert File.exist?(@temp_path)
+      assert_equal '', str
     end
 
     test 'calls on_exit_callback for each process exits for interval call using on_exit_callback' do
       read_data_list = []
       exit_status_list = []
 
-      args = ['-e', 'puts "yay"', '1']
+      args = ['-e', 'puts "yay"']
       cb = ->(status){ exit_status_list << status }
 
       Timeout.timeout(TEST_DEADLOCK_TIMEOUT) do
-        @d.child_process_execute(:st1, "ruby", arguments: args, immediate: true, interval: 2, mode: [:read], on_exit_callback: cb) do |readio|
+        @d.child_process_execute(:st1, "ruby", arguments: args, immediate: true, interval: 1, mode: [:read], on_exit_callback: cb) do |readio|
           read_data_list << readio.read.chomp
         end
-        sleep 10
+        sleep 2
       end
 
-      assert{ read_data_list.size >= 3 }
-      assert{ exit_status_list.size >= 3 }
+      assert { read_data_list.size >= 2 }
+      assert { exit_status_list.size >= 2 }
     end
 
     test 'waits lasting child process until wait_timeout if block is not specified' do
@@ -747,11 +736,11 @@ class ChildProcessTest < Test::Unit::TestCase
 
       callback_called = false
       exit_status = nil
-      args = ['-e', 'sleep ARGV[0].to_i; File.unlink ARGV[1]', '1', @temp_path]
+      args = ['-e', 'File.unlink ARGV[0]', @temp_path]
       cb = ->(status){ exit_status = status; callback_called = true }
 
       Timeout.timeout(TEST_DEADLOCK_TIMEOUT) do
-        @d.child_process_execute(:t17, "ruby", arguments: args, on_exit_callback: cb, wait_timeout: 5)
+        @d.child_process_execute(:t17, "ruby", arguments: args, on_exit_callback: cb, wait_timeout: 2)
         sleep TEST_WAIT_INTERVAL_FOR_BLOCK_RUNNING until callback_called
       end
 
@@ -766,7 +755,7 @@ class ChildProcessTest < Test::Unit::TestCase
 
       callback_called = false
       exit_status = nil
-      args = ['-e', 'sleep ARGV[0].to_i; File.unlink ARGV[1]', '3', @temp_path]
+      args = ['-e', 'File.unlink ARGV[0]', @temp_path]
       cb = ->(status){ exit_status = status; callback_called = true }
 
       Timeout.timeout(TEST_DEADLOCK_TIMEOUT) do
@@ -791,7 +780,7 @@ class ChildProcessTest < Test::Unit::TestCase
       cb = ->(status){ exit_status = status; callback_called = true }
 
       Timeout.timeout(TEST_DEADLOCK_TIMEOUT) do
-        @d.child_process_execute(:t17, "ruby", arguments: args, on_exit_callback: cb, wait_timeout: 3)
+        @d.child_process_execute(:t17, "ruby", arguments: args, on_exit_callback: cb, wait_timeout: 1)
         sleep TEST_WAIT_INTERVAL_FOR_BLOCK_RUNNING until callback_called
       end
 
@@ -813,8 +802,8 @@ class ChildProcessTest < Test::Unit::TestCase
       cb = ->(status){ exit_status = status; callback_called = true }
 
       Timeout.timeout(TEST_DEADLOCK_TIMEOUT) do
-        @d.child_process_execute(:t17, "ruby", arguments: args, mode: nil, on_exit_callback: cb, wait_timeout: 3) do
-          sleep 3
+        @d.child_process_execute(:t17, "ruby", arguments: args, mode: nil, on_exit_callback: cb, wait_timeout: 1) do
+          sleep 1
         end
         sleep TEST_WAIT_INTERVAL_FOR_BLOCK_RUNNING until callback_called
       end