fluentd 0.14.4-x64-mingw32

data/test/plugin/test_parser_syslog.rb

@@ -0,0 +1,66 @@
+require_relative '../helper'
+require 'fluent/test/driver/parser'
+require 'fluent/plugin/parser'
+
+class SyslogParserTest < ::Test::Unit::TestCase
+  def setup
+    Fluent::Test.setup
+    @parser = Fluent::Test::Driver::Parser.new(Fluent::Plugin::SyslogParser)
+    @expected = {
+      'host'    => '192.168.0.1',
+      'ident'   => 'fluentd',
+      'pid'     => '11111',
+      'message' => '[error] Syslog test'
+    }
+  end
+
+  def test_parse
+    @parser.configure({})
+    @parser.instance.parse('Feb 28 12:00:00 192.168.0.1 fluentd[11111]: [error] Syslog test') { |time, record|
+      assert_equal(event_time('Feb 28 12:00:00', format: '%b %d %H:%M:%S'), time)
+      assert_equal(@expected, record)
+    }
+    assert_equal(Fluent::Plugin::SyslogParser::REGEXP, @parser.instance.patterns['format'])
+    assert_equal("%b %d %H:%M:%S", @parser.instance.patterns['time_format'])
+  end
+
+  def test_parse_with_time_format
+    @parser.configure('time_format' => '%b %d %M:%S:%H')
+    @parser.instance.parse('Feb 28 00:00:12 192.168.0.1 fluentd[11111]: [error] Syslog test') { |time, record|
+      assert_equal(event_time('Feb 28 12:00:00', format: '%b %d %H:%M:%S'), time)
+      assert_equal(@expected, record)
+    }
+    assert_equal('%b %d %M:%S:%H', @parser.instance.patterns['time_format'])
+  end
+
+  def test_parse_with_priority
+    @parser.configure('with_priority' => true)
+    @parser.instance.parse('<6>Feb 28 12:00:00 192.168.0.1 fluentd[11111]: [error] Syslog test') { |time, record|
+      assert_equal(event_time('Feb 28 12:00:00', format: '%b %d %H:%M:%S'), time)
+      assert_equal(@expected.merge('pri' => 6), record)
+    }
+    assert_equal(Fluent::Plugin::SyslogParser::REGEXP_WITH_PRI, @parser.instance.patterns['format'])
+    assert_equal("%b %d %H:%M:%S", @parser.instance.patterns['time_format'])
+  end
+
+  def test_parse_without_colon
+    @parser.configure({})
+    @parser.instance.parse('Feb 28 12:00:00 192.168.0.1 fluentd[11111] [error] Syslog test') { |time, record|
+      assert_equal(event_time('Feb 28 12:00:00', format: '%b %d %H:%M:%S'), time)
+      assert_equal(@expected, record)
+    }
+    assert_equal(Fluent::Plugin::SyslogParser::REGEXP, @parser.instance.patterns['format'])
+    assert_equal("%b %d %H:%M:%S", @parser.instance.patterns['time_format'])
+  end
+
+  def test_parse_with_keep_time_key
+    @parser.configure(
+                      'time_format' => '%b %d %M:%S:%H',
+                      'keep_time_key'=>'true',
+                      )
+    text = 'Feb 28 00:00:12 192.168.0.1 fluentd[11111]: [error] Syslog test'
+    @parser.instance.parse(text) do |time, record|
+      assert_equal "Feb 28 00:00:12", record['time']
+    end
+  end
+end

data/test/plugin/test_parser_time.rb

@@ -0,0 +1,46 @@
+require_relative '../helper'
+require 'fluent/test/driver/parser'
+require 'fluent/plugin/parser'
+
+class TimeParserTest < ::Test::Unit::TestCase
+  def setup
+    Fluent::Test.setup
+  end
+
+  def test_call_with_parse
+    parser = Fluent::Test::Driver::Parser.new(Fluent::Plugin::Parser::TimeParser.new(nil))
+
+    assert(parser.instance.parse('2013-09-18 12:00:00 +0900').is_a?(Fluent::EventTime))
+
+    time = event_time('2013-09-18 12:00:00 +0900')
+    assert_equal(time, parser.instance.parse('2013-09-18 12:00:00 +0900'))
+  end
+
+  def test_parse_with_strptime
+    parser = Fluent::Test::Driver::Parser.new(Fluent::Plugin::Parser::TimeParser.new('%d/%b/%Y:%H:%M:%S %z'))
+
+    assert(parser.instance.parse('28/Feb/2013:12:00:00 +0900').is_a?(Fluent::EventTime))
+
+    time = event_time('28/Feb/2013:12:00:00 +0900', format: '%d/%b/%Y:%H:%M:%S %z')
+    assert_equal(time, parser.instance.parse('28/Feb/2013:12:00:00 +0900'))
+  end
+
+  def test_parse_nsec_with_strptime
+    parser = Fluent::Test::Driver::Parser.new(Fluent::Plugin::Parser::TimeParser.new('%d/%b/%Y:%H:%M:%S:%N %z'))
+
+    assert(parser.instance.parse('28/Feb/2013:12:00:00:123456789 +0900').is_a?(Fluent::EventTime))
+
+    time = event_time('28/Feb/2013:12:00:00:123456789 +0900', format: '%d/%b/%Y:%H:%M:%S:%N %z')
+    assert_equal_event_time(time, parser.instance.parse('28/Feb/2013:12:00:00:123456789 +0900'))
+  end
+
+  def test_parse_with_invalid_argument
+    parser = Fluent::Test::Driver::Parser.new(Fluent::Plugin::Parser::TimeParser.new(nil))
+
+    [[], {}, nil, true, 10000, //, ->{}, '', :symbol].each { |v|
+      assert_raise Fluent::ParserError do
+        parser.instance.parse(v)
+      end
+    }
+  end
+end

data/test/plugin/test_parser_tsv.rb

@@ -0,0 +1,121 @@
+require_relative '../helper'
+require 'fluent/test/driver/parser'
+require 'fluent/plugin/parser_tsv'
+
+class TSVParserTest < ::Test::Unit::TestCase
+  def setup
+    Fluent::Test.setup
+  end
+
+  def create_driver(conf={})
+    Fluent::Test::Driver::Parser.new(Fluent::TextParser::TSVParser).configure(conf)
+  end
+
+  data('array param' => '["a","b"]', 'string param' => 'a,b')
+  def test_config_params(param)
+    d = create_driver
+
+    assert_equal "\t", d.instance.delimiter
+
+    d = create_driver(
+      'keys' => param,
+      'delimiter' => ',',
+    )
+
+    assert_equal ['a', 'b'], d.instance.keys
+    assert_equal ",", d.instance.delimiter
+  end
+
+  data('array param' => '["time","a","b"]', 'string param' => 'time,a,b')
+  def test_parse(param)
+    d = create_driver('keys' => param, 'time_key' => 'time')
+    d.instance.parse("2013/02/28 12:00:00\t192.168.0.1\t111") { |time, record|
+      assert_equal(event_time('2013/02/28 12:00:00', format: '%Y/%m/%d %H:%M:%S'), time)
+      assert_equal({
+          'a' => '192.168.0.1',
+          'b' => '111',
+        }, record)
+    }
+  end
+
+  def test_parse_with_time
+    time_at_start = Time.now.to_i
+
+    d = create_driver('keys' => 'a,b')
+    d.instance.parse("192.168.0.1\t111") { |time, record|
+      assert time && time >= time_at_start, "parser puts current time without time input"
+      assert_equal({
+          'a' => '192.168.0.1',
+          'b' => '111',
+        }, record)
+    }
+
+    d = Fluent::Test::Driver::Parser.new(Fluent::Plugin::TSVParser)
+    d.instance.estimate_current_event = false
+    d.configure('keys' => 'a,b', 'time_key' => 'time')
+    d.instance.parse("192.168.0.1\t111") { |time, record|
+      assert_equal({
+                     'a' => '192.168.0.1',
+                     'b' => '111',
+                   }, record)
+      assert_nil time, "parser returns nil w/o time and if configured so"
+    }
+  end
+
+  data(
+    'left blank column' => ["\t@\t@", {"1" => "","2" => "@","3" => "@"}],
+    'center blank column' => ["@\t\t@", {"1" => "@","2" => "","3" => "@"}],
+    'right blank column' => ["@\t@\t", {"1" => "@","2" => "@","3" => ""}],
+    '2 right blank columns' => ["@\t\t", {"1" => "@","2" => "","3" => ""}],
+    'left blank columns' => ["\t\t@", {"1" => "","2" => "","3" => "@"}],
+    'all blank columns' => ["\t\t", {"1" => "","2" => "","3" => ""}])
+  def test_black_column(data)
+    line, expected = data
+
+    d = create_driver('keys' => '1,2,3')
+    d.instance.parse(line) { |time, record|
+      assert_equal(expected, record)
+    }
+  end
+
+  def test_parse_with_keep_time_key
+    d = create_driver(
+      'keys'=>'time',
+      'time_key'=>'time',
+      'time_format'=>"%d/%b/%Y:%H:%M:%S %z",
+      'keep_time_key'=>'true',
+    )
+    text = '28/Feb/2013:12:00:00 +0900'
+    d.instance.parse(text) do |time, record|
+      assert_equal text, record['time']
+    end
+  end
+
+  data('array param' => '["a","b","c","d","e","f"]', 'string param' => 'a,b,c,d,e,f')
+  def test_parse_with_null_value_pattern(param)
+    d = create_driver(
+      'keys'=>param,
+      'null_value_pattern'=>'^(-|null|NULL)$'
+    )
+    d.instance.parse("-\tnull\tNULL\t\t--\tnuLL") do |time, record|
+      assert_nil record['a']
+      assert_nil record['b']
+      assert_nil record['c']
+      assert_equal record['d'], ''
+      assert_equal record['e'], '--'
+      assert_equal record['f'], 'nuLL'
+    end
+  end
+
+  data('array param' => '["a","b"]', 'string param' => 'a,b')
+  def test_parse_with_null_empty_string(param)
+    d = create_driver(
+      'keys'=>param,
+      'null_empty_string'=>true
+    )
+    d.instance.parse("\t ") do |time, record|
+      assert_nil record['a']
+      assert_equal record['b'], ' '
+    end
+  end
+end

data/test/plugin/test_storage.rb

@@ -0,0 +1,167 @@
+require_relative '../helper'
+require 'fluent/plugin/storage'
+require 'fluent/plugin/base'
+
+class DummyPlugin < Fluent::Plugin::TestBase
+end
+
+class BareStorage < Fluent::Plugin::Storage
+  Fluent::Plugin.register_storage('bare', self)
+end
+
+class BasicStorage < Fluent::Plugin::Storage
+  Fluent::Plugin.register_storage('example', self)
+
+  attr_reader :data, :saved
+
+  def initialize
+    super
+    @data = @saved = nil
+  end
+  def load
+    @data = {}
+  end
+  def save
+    @saved = @data.dup
+  end
+  def get(key)
+    @data[key]
+  end
+  def fetch(key, defval)
+    @data.fetch(key, defval)
+  end
+  def put(key, value)
+    @data[key] = value
+  end
+  def delete(key)
+    @data.delete(key)
+  end
+  def update(key, &block)
+    @data[key] = block.call(@data[key])
+  end
+  def close
+    @data = {}
+    super
+  end
+  def terminate
+    @saved = {}
+    super
+  end
+end
+
+class StorageTest < Test::Unit::TestCase
+  sub_test_case 'BareStorage' do
+    setup do
+      plugin = DummyPlugin.new
+      @s = BareStorage.new
+      @s.configure(config_element())
+      @s.owner = plugin
+    end
+
+    test 'is configured with plugin information and system config' do
+      plugin = DummyPlugin.new
+      plugin.system_config_override({'process_name' => 'mytest'})
+      plugin.configure(config_element('ROOT', '', {'@id' => '1'}))
+      s = BareStorage.new
+      s.configure(config_element())
+      s.owner = plugin
+
+      assert_equal 'mytest', s.owner.system_config.process_name
+      assert_equal '1', s.instance_eval{ @_plugin_id }
+      assert_equal true, s.instance_eval{ @_plugin_id_configured }
+    end
+
+    test 'does NOT have features for high-performance/high-consistent storages' do
+      assert_equal false, @s.persistent_always?
+      assert_equal false, @s.synchronized?
+    end
+
+    test 'does have default values which is conservative for almost all users' do
+      assert_equal false, @s.persistent
+      assert_equal true, @s.autosave
+      assert_equal 10,   @s.autosave_interval
+      assert_equal true, @s.save_at_shutdown
+    end
+
+    test 'load/save doesn NOT anything: just as memory storage' do
+      assert_nothing_raised{ @s.load }
+      assert_nothing_raised{ @s.save }
+    end
+
+    test 'all operations are not defined yet' do
+      assert_raise NotImplementedError do
+        @s.get('key')
+      end
+      assert_raise NotImplementedError do
+        @s.fetch('key', 'value')
+      end
+      assert_raise NotImplementedError do
+        @s.put('key', 'value')
+      end
+      assert_raise NotImplementedError do
+        @s.delete('key')
+      end
+      assert_raise NotImplementedError do
+        @s.update('key'){ |v| v + '2' }
+      end
+    end
+  end
+
+  sub_test_case 'ExampleStorage' do
+    setup do
+      plugin = DummyPlugin.new
+      plugin.configure(config_element('ROOT', '', {'@id' => '1'}))
+      @s = BasicStorage.new
+      @s.configure(config_element())
+      @s.owner = plugin
+    end
+
+    test 'load/save works well as plugin internal state operations' do
+      plugin = DummyPlugin.new
+      plugin.configure(config_element('ROOT', '', {'@id' => '0'}))
+      s = BasicStorage.new
+      s.owner = plugin
+
+      assert_nothing_raised{ s.load }
+      assert s.data
+      assert_nil s.saved
+
+      assert_nothing_raised{ s.save }
+      assert s.saved
+      assert{ s.data == s.saved }
+      assert{ s.data.object_id != s.saved.object_id }
+    end
+
+    test 'all operations work well' do
+      @s.load
+
+      assert_nil @s.get('key')
+      assert_equal 'value', @s.fetch('key', 'value')
+      assert_nil @s.get('key')
+
+      assert_equal 'value', @s.put('key', 'value')
+      assert_equal 'value', @s.get('key')
+
+      assert_equal 'valuevalue', @s.update('key'){|v| v * 2 }
+
+      assert_equal 'valuevalue', @s.delete('key')
+    end
+
+    test 'close and terminate work to operate internal states' do
+      @s.load
+      @s.put('k1', 'v1')
+      @s.put('k2', 'v2')
+      assert_equal 2, @s.data.size
+      @s.save
+      assert_equal @s.data.size, @s.saved.size
+
+      assert_nothing_raised{ @s.close }
+      assert @s.data.empty?
+      assert !@s.saved.empty?
+
+      assert_nothing_raised{ @s.terminate }
+      assert @s.data.empty?
+      assert @s.saved.empty?
+    end
+  end
+end

data/test/plugin/test_storage_local.rb

@@ -0,0 +1,8 @@
+require_relative '../helper'
+require 'fluent/plugin/storage_local'
+
+class LocalStorageTest < Test::Unit::TestCase
+  test 'syntax' do
+    assert true
+  end
+end

data/test/plugin/test_string_util.rb

@@ -0,0 +1,26 @@
+require_relative '../helper'
+require 'fluent/plugin/string_util'
+
+class StringUtilTest < Test::Unit::TestCase
+  def setup
+    @null_value_pattern = Regexp.new("^(-|null|NULL)$")
+  end
+
+  sub_test_case 'valid string' do
+    test 'null string' do
+      assert_equal Fluent::StringUtil.match_regexp(@null_value_pattern, "null").to_s, "null"
+      assert_equal Fluent::StringUtil.match_regexp(@null_value_pattern, "NULL").to_s, "NULL"
+      assert_equal Fluent::StringUtil.match_regexp(@null_value_pattern, "-").to_s, "-"
+    end
+
+    test 'normal string' do
+      assert_equal Fluent::StringUtil.match_regexp(@null_value_pattern, "fluentd"), nil
+    end
+  end
+
+  sub_test_case 'invalid string' do
+    test 'normal string' do
+      assert_equal Fluent::StringUtil.match_regexp(@null_value_pattern, "\xff"), nil
+    end
+  end
+end

data/test/plugin_helper/test_child_process.rb

@@ -0,0 +1,608 @@
+require_relative '../helper'
+require 'fluent/plugin_helper/child_process'
+require 'fluent/plugin/base'
+require 'timeout'
+
+class ChildProcessTest < Test::Unit::TestCase
+  TEST_DEADLOCK_TIMEOUT = 30
+  TEST_WAIT_INTERVAL_FOR_BLOCK_RUNNING = 0.1 # This may be shorter than ruby's threading timer, but work well
+  # @nalsh says that ruby's cpu assignments for threads are almost 200ms or so.
+  # Loop interval (expected that it work as specified) should be longer than it.
+  TEST_WAIT_INTERVAL_FOR_LOOP = 0.5
+
+  setup do
+    @d = Dummy.new
+    @d.configure(config_element())
+    @d.start
+  end
+
+  teardown do
+    if @d
+      @d.stop      unless @d.stopped?
+      @d.shutdown  unless @d.shutdown?
+      @d.close     unless @d.closed?
+      @d.terminate unless @d.terminated?
+    end
+  end
+
+  class Dummy < Fluent::Plugin::TestBase
+    helpers :child_process
+    def configure(conf)
+      super
+      @_child_process_kill_timeout = 1
+    end
+  end
+
+  test 'can be instantiated' do
+    d1 = Dummy.new
+    assert d1.respond_to?(:_child_process_processes)
+  end
+
+  test 'can be configured and started' do
+    d1 = Dummy.new
+    assert_nothing_raised do
+      d1.configure(config_element())
+    end
+    assert d1.plugin_id
+    assert d1.log
+
+    d1.start
+  end
+
+  test 'can execute external command asyncronously' do
+    m = Mutex.new
+    m.lock
+    ary = []
+    Timeout.timeout(TEST_DEADLOCK_TIMEOUT) do
+      ran = false
+      @d.child_process_execute(:t0, 'echo', arguments: ['foo', 'bar'], mode: [:read]) do |io|
+        m.lock
+        ran = true
+        io.read # discard
+        ary << 2
+        m.unlock
+      end
+      ary << 1
+      m.unlock
+      sleep TEST_WAIT_INTERVAL_FOR_BLOCK_RUNNING until m.locked? || ran
+      m.lock
+      m.unlock
+    end
+    assert_equal [1,2], ary
+  end
+
+  test 'can execute external command at just once, which finishes immediately' do
+    m = Mutex.new
+    t1 = Time.now
+    ary = []
+    Timeout.timeout(TEST_DEADLOCK_TIMEOUT) do
+      ran = false
+      @d.child_process_execute(:t1, 'echo', arguments: ['foo', 'bar'], mode: [:read]) do |io|
+        m.lock
+        ran = true
+        ary << io.read
+        m.unlock
+      end
+      sleep TEST_WAIT_INTERVAL_FOR_BLOCK_RUNNING until m.locked? || ran
+      m.lock
+      m.unlock
+    end
+    assert{ Time.now - t1 < 4.0 }
+  end
+
+  test 'can execute external command at just once, which can handle both of read and write' do
+    m = Mutex.new
+    ary = []
+    Timeout.timeout(TEST_DEADLOCK_TIMEOUT) do
+      ran = false
+      cmd = "ruby -e 'while !STDIN.eof? && line = STDIN.readline; puts line.chomp; STDOUT.flush rescue nil; end'"
+      @d.child_process_execute(:t2, cmd, mode: [:write, :read]) do |writeio, readio|
+        m.lock
+        ran = true
+
+        [[1,2],[3,4],[5,6]].each do |i,j|
+          writeio.write "my data#{i}\n"
+          writeio.write "my data#{j}\n"
+          writeio.flush
+        end
+        writeio.close
+
+        while line = readio.readline
+          ary << line
+        end
+        m.unlock
+      end
+      sleep TEST_WAIT_INTERVAL_FOR_BLOCK_RUNNING until m.locked? || ran
+      m.lock
+      m.unlock
+    end
+
+    assert_equal [], @d.log.out.logs
+    expected = (1..6).map{|i| "my data#{i}\n" }
+    assert_equal expected, ary
+  end
+
+  test 'can execute external command at just once, which can handle all of read, write and stderr' do
+    m = Mutex.new
+    ary1 = []
+    ary2 = []
+    Timeout.timeout(TEST_DEADLOCK_TIMEOUT) do
+      ran = false
+      cmd = "ruby -e 'while !STDIN.eof? && line = STDIN.readline; puts line.chomp; STDOUT.flush rescue nil; STDERR.puts line.chomp; STDERR.flush rescue nil; end'"
+      @d.child_process_execute(:t2a, cmd, mode: [:write, :read, :stderr]) do |writeio, readio, stderrio|
+        m.lock
+        ran = true
+
+        [[1,2],[3,4],[5,6]].each do |i,j|
+          writeio.write "my data#{i}\n"
+          writeio.write "my data#{j}\n"
+          writeio.flush
+        end
+        writeio.close
+
+        while (line1 = readio.readline) && (line2 = stderrio.readline)
+          ary1 << line1
+          ary2 << line2
+        end
+
+        m.unlock
+      end
+      sleep TEST_WAIT_INTERVAL_FOR_BLOCK_RUNNING until m.locked? || ran
+      m.lock
+      m.unlock
+    end
+
+    assert_equal [], @d.log.out.logs
+    expected = (1..6).map{|i| "my data#{i}\n" }
+    assert_equal expected, ary1
+    assert_equal expected, ary2
+  end
+
+  test 'can execute external command at just once, which can handle both of write and read (with stderr)' do
+    m = Mutex.new
+    ary = []
+    Timeout.timeout(TEST_DEADLOCK_TIMEOUT) do
+      ran = false
+      cmd = "ruby"
+      args = ['-e', 'while !STDIN.eof? && line = STDIN.readline; puts "[s]" + line.chomp; STDOUT.flush rescue nil; STDERR.puts "[e]" + line.chomp; STDERR.flush rescue nil; end']
+      @d.child_process_execute(:t2b, cmd, arguments: args, mode: [:write, :read_with_stderr]) do |writeio, readio|
+        m.lock
+        ran = true
+
+        [[1,2],[3,4],[5,6]].each do |i,j|
+          writeio.write "my data#{i}\n"
+          writeio.write "my data#{j}\n"
+          writeio.flush
+        end
+        writeio.close
+
+        while line = readio.readline
+          ary << line
+        end
+
+        m.unlock
+      end
+      sleep TEST_WAIT_INTERVAL_FOR_BLOCK_RUNNING until m.locked? || ran
+      m.lock
+      m.unlock
+    end
+
+    assert_equal [], @d.log.out.logs
+    expected = (1..6).map{|i| ["[s]my data#{i}\n", "[e]my data#{i}\n"] }.flatten
+    assert_equal expected, ary
+  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"]
+      @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
+            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
+      @d.stop # nothing occures
+      @d.shutdown
+
+      assert{ ary.size > 5 }
+
+      @d.close
+
+      @d.terminate
+      assert @d._child_process_processes.empty?
+    end
+  end
+
+  unless Fluent.windows?
+    # In windows environment, child_process try KILL at first (because there's no SIGTERM)
+    test 'can execute external command just once, and can terminate it forcedly when shutdown/terminate even if it ignore SIGTERM' do
+      m = Mutex.new
+      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|
+          m.lock
+          ran = true
+          begin
+            while line = io.readline
+              ary << line
+            end
+          rescue
+            # ignore
+          ensure
+            m.unlock
+          end
+        end
+        sleep TEST_WAIT_INTERVAL_FOR_BLOCK_RUNNING until m.locked? || ran
+
+        assert_equal [], @d.log.out.logs
+
+        @d.stop # nothing occures
+        sleep TEST_WAIT_INTERVAL_FOR_LOOP * 5
+        lines1 = ary.size
+        assert{ lines1 > 1 }
+
+        pid = @d._child_process_processes.keys.first
+
+        @d.shutdown
+        sleep TEST_WAIT_INTERVAL_FOR_LOOP * 5
+        lines2 = ary.size
+        assert{ lines2 > lines1 }
+
+        @d.close
+
+        assert_nil((Process.waitpid(pid, Process::WNOHANG) rescue nil))
+
+        @d.terminate
+        assert @d._child_process_processes.empty?
+        begin
+          Process.waitpid(pid)
+        rescue Errno::ECHILD
+        end
+        # Process successfully KILLed if test reaches here
+        assert true
+      end
+    end
+  end
+
+  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
+    Timeout.timeout(TEST_DEADLOCK_TIMEOUT) do
+      @d.child_process_execute(:t5, "ruby", arguments: arguments, interval: 5, mode: [:read]) do |io|
+        ary << io.read.split("\n").map(&:chomp).join
+      end
+      sleep 13 # 5sec * 2 + 3sec
+      assert_equal [], @d.log.out.logs
+      @d.stop
+      assert_equal [], @d.log.out.logs
+      @d.shutdown; @d.close; @d.terminate
+      assert_equal 2, ary.size
+    end
+  end
+
+  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} }"]
+    Timeout.timeout(TEST_DEADLOCK_TIMEOUT) do
+      @d.child_process_execute(:t6, "ruby", arguments: arguments, interval: 5, 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
+      @d.stop; @d.shutdown; @d.close; @d.terminate
+      assert_equal 2, ary.size
+      assert_equal [], @d.log.out.logs
+    end
+  end
+
+  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
+    Timeout.timeout(TEST_DEADLOCK_TIMEOUT) do
+      assert_equal [], @d.log.out.logs
+      @d.log.out.singleton_class.module_eval do
+        define_method(:write){|message|
+          raise "boo" if message.include?('test: {"test":"test"}') || message.include?('test: {"test"=>"test"}')
+          @logs.push message
+        }
+      end
+
+      @d.child_process_execute(:t7, "ruby", arguments: arguments, interval: 2, immediate: true, mode: [:read]) do |io|
+        ary << io.read.split("\n").map(&:chomp).join
+      end
+      sleep 4
+      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"
+      logs = @d.log.out.logs
+      assert{ logs.first.end_with?(warn_msg) }
+      assert{ logs.all?{|line| line.end_with?(warn_msg) } }
+      @d.shutdown; @d.close; @d.terminate
+      assert_equal [], @d.log.out.logs
+    end
+  end
+
+  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
+    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
+      processes = @d._child_process_processes.size
+      assert{ processes >= 3 && processes <= 5 }
+      @d.stop; @d.shutdown; @d.close; @d.terminate
+      assert_equal [], @d.log.out.logs
+    end
+  end
+
+  test 'execute external processes only for writing' do
+    m = Mutex.new
+    unreadable = false
+    Timeout.timeout(TEST_DEADLOCK_TIMEOUT) do
+      ran = false
+      @d.child_process_execute(:t9, "ruby", arguments: ['-e', 'a=""; while b=STDIN.readline; a+=b; end'], mode: [:write]) do |io|
+        m.lock
+        ran = true
+        begin
+          io.read
+        rescue IOError
+          unreadable = true
+        end
+        50.times do
+          io.write "hahaha\n"
+        end
+        m.unlock
+      end
+      sleep TEST_WAIT_INTERVAL_FOR_BLOCK_RUNNING until m.locked? || ran
+      m.lock
+      m.unlock
+      assert unreadable
+      @d.stop; @d.shutdown; @d.close; @d.terminate
+      assert_equal [], @d.log.out.logs
+    end
+  end
+
+  test 'execute external processes only for reading' do
+    m = Mutex.new
+    unwritable = false
+    Timeout.timeout(TEST_DEADLOCK_TIMEOUT) do
+      ran = false
+      @d.child_process_execute(:t10, "ruby", arguments: ["-e", "while sleep #{TEST_WAIT_INTERVAL_FOR_LOOP}; puts 1; STDOUT.flush rescue nil; end"], mode: [:read]) do |io|
+        m.lock
+        ran = true
+        begin
+          io.write "foobar"
+        rescue IOError
+          unwritable = true
+        end
+        _data = io.readline
+        m.unlock
+      end
+      sleep TEST_WAIT_INTERVAL_FOR_BLOCK_RUNNING until m.locked? || ran
+      m.lock
+      m.unlock
+      @d.stop; @d.shutdown; @d.close; @d.terminate
+      assert unwritable
+      assert_equal [], @d.log.out.logs
+    end
+  end
+
+  test 'can control external encodings' do
+    m = Mutex.new
+    encodings = []
+    Timeout.timeout(TEST_DEADLOCK_TIMEOUT) do
+      ran = false
+      @d.child_process_execute(:t11, "ruby -e 'sleep 10'", external_encoding: 'ascii-8bit') do |r, w|
+        m.lock
+        ran = true
+        encodings << r.external_encoding
+        encodings << w.external_encoding
+        m.unlock
+      end
+      sleep TEST_WAIT_INTERVAL_FOR_BLOCK_RUNNING until m.locked? || ran
+      m.lock
+      assert_equal Encoding::ASCII_8BIT, encodings[0]
+      assert_equal Encoding::ASCII_8BIT, encodings[1]
+      @d.stop; @d.shutdown; @d.close; @d.terminate
+    end
+  end
+
+  test 'can control internal encodings' do
+    m = Mutex.new
+    encodings = []
+    Timeout.timeout(TEST_DEADLOCK_TIMEOUT) do
+      ran = false
+      @d.child_process_execute(:t12, "ruby -e 'sleep 10'", external_encoding: 'utf-8', internal_encoding: 'ascii-8bit') do |r, w|
+        m.lock
+        ran = true
+        encodings << r.internal_encoding
+        encodings << w.internal_encoding
+        m.unlock
+      end
+      sleep TEST_WAIT_INTERVAL_FOR_BLOCK_RUNNING until m.locked? || ran
+      m.lock
+      assert_equal Encoding::ASCII_8BIT, encodings[0]
+      assert_equal Encoding::ASCII_8BIT, encodings[1]
+      @d.stop; @d.shutdown; @d.close; @d.terminate
+    end
+  end
+
+  test 'can convert encodings from ascii-8bit to utf-8' do
+    m = Mutex.new
+    str = nil
+    Timeout.timeout(TEST_DEADLOCK_TIMEOUT) do
+      ran = false
+      args = ['-e', 'STDOUT.set_encoding("ascii-8bit"); STDOUT.write "\xA4\xB5\xA4\xC8\xA4\xB7"']
+      @d.child_process_execute(:t13, "ruby", arguments: args, external_encoding: 'euc-jp', internal_encoding: 'windows-31j', mode: [:read]) do |io|
+        m.lock
+        ran = true
+        str = io.read
+        m.unlock
+      end
+      sleep TEST_WAIT_INTERVAL_FOR_BLOCK_RUNNING until m.locked? || ran
+      m.lock
+      assert_equal Encoding.find('windows-31j'), str.encoding
+      expected = "さとし".encode('windows-31j')
+      assert_equal expected, str
+      @d.stop; @d.shutdown; @d.close; @d.terminate
+    end
+  end
+
+  test 'can scrub characters without exceptions' do
+    m = Mutex.new
+    str = nil
+    Timeout.timeout(TEST_DEADLOCK_TIMEOUT) do
+      ran = false
+      args = ['-e', 'STDOUT.set_encoding("ascii-8bit"); STDOUT.write "\xFF\xFF\x00\xF0\xF0"']
+      @d.child_process_execute(:t13a, "ruby", arguments: args, mode: [:read]) do |io|
+        m.lock
+        ran = true
+        str = io.read
+        m.unlock
+      end
+      sleep TEST_WAIT_INTERVAL_FOR_BLOCK_RUNNING until m.locked? || ran
+      m.lock
+      assert_equal Encoding.find('utf-8'), str.encoding
+      expected = "\xEF\xBF\xBD\xEF\xBF\xBD\x00\xEF\xBF\xBD\xEF\xBF\xBD".force_encoding("utf-8")
+      assert_equal expected, str
+      @d.stop; @d.shutdown; @d.close; @d.terminate
+    end
+  end
+
+  test 'can scrub characters without exceptions and replace specified chars' do
+    m = Mutex.new
+    str = nil
+    Timeout.timeout(TEST_DEADLOCK_TIMEOUT) do
+      ran = false
+      args = ['-e', 'STDOUT.set_encoding("ascii-8bit"); STDOUT.write "\xFF\xFF\x00\xF0\xF0"']
+      @d.child_process_execute(:t13b, "ruby", arguments: args, mode: [:read], scrub: true, replace_string: '?') do |io|
+        m.lock
+        ran = true
+        str = io.read
+        m.unlock
+      end
+      sleep TEST_WAIT_INTERVAL_FOR_BLOCK_RUNNING until m.locked? || ran
+      m.lock
+      assert_equal Encoding.find('utf-8'), str.encoding
+      expected = "??\x00??".force_encoding("utf-8")
+      assert_equal expected, str
+      @d.stop; @d.shutdown; @d.close; @d.terminate
+    end
+  end
+
+  unless Fluent.windows?
+    test 'can specify subprocess name' do
+      io = IO.popen([["cat", "caaaaaaaaaaat"], '-'])
+      process_naming_enabled = (open("|ps"){|_io| _io.readlines }.select{|line| line.include?("caaaaaaaaaaat") }.size > 0)
+      Process.kill(:TERM, io.pid) rescue nil
+      io.close rescue nil
+
+      # Does TravisCI prohibit process renaming?
+      # This test will be passed in such environment
+      pend unless process_naming_enabled
+
+      m = Mutex.new
+      pids = []
+      proc_lines = []
+      Timeout.timeout(TEST_DEADLOCK_TIMEOUT) do
+        ran = false
+        @d.child_process_execute(:t14, "ruby", arguments:['-e', 'sleep 10; puts "hello"'], subprocess_name: "sleeeeeeeeeper", mode: [:read]) do |readio|
+          m.lock
+          ran = true
+          pids << @d.child_process_id
+          proc_lines += open("|ps"){|_io| _io.readlines }
+          m.unlock
+          readio.read
+        end
+        sleep TEST_WAIT_INTERVAL_FOR_BLOCK_RUNNING until m.locked? || ran
+        m.lock
+        pid = pids.first
+        # 51358 ttys001    0:00.00 sleeper -e sleep 10
+        assert{ proc_lines.select{|line| line =~ /^\s*#{pid}\s/ }.first.strip.split(/\s+/)[3] == "sleeeeeeeeeper" }
+        @d.stop; @d.shutdown; @d.close; @d.terminate
+      end
+    end
+  end
+
+  test 'can set ENV variables' do
+    m = Mutex.new
+    str = nil
+    Timeout.timeout(TEST_DEADLOCK_TIMEOUT) do
+      ran = false
+      args = ['-e', 'puts ENV["testing_child_process"]']
+      @d.child_process_execute(:t15a, "ruby", arguments: args, mode: [:read], env: {'testing_child_process' => 'Yes! True!'}) do |io|
+        m.lock
+        ran = true
+        str = io.read
+        m.unlock
+      end
+      sleep TEST_WAIT_INTERVAL_FOR_BLOCK_RUNNING until m.locked? || ran
+      m.lock
+      expected = "Yes! True!\n"
+      assert_equal expected, str
+      @d.stop; @d.shutdown; @d.close; @d.terminate
+    end
+  end
+
+  test 'can unset ENV variables of Fluentd process' do
+    m = Mutex.new
+    str = nil
+    Timeout.timeout(TEST_DEADLOCK_TIMEOUT) do
+      current_env_path = ENV['PATH']
+      ran = false
+      args = ['-e', 'puts ENV["testing_child_process1"].to_s + ENV["testing_child_process2"].to_s']
+      ENV['testing_child_process1'] = "No! False!"
+      @d.child_process_execute(:t15b, "ruby", arguments: args, mode: [:read], unsetenv: true, env: {'testing_child_process2' => 'Yes! True!', 'PATH' => current_env_path}) do |io|
+        m.lock
+        ran = true
+        str = io.read
+        m.unlock
+      end
+      sleep TEST_WAIT_INTERVAL_FOR_BLOCK_RUNNING until m.locked? || ran
+      m.lock
+      expected = "Yes! True!\n"
+      assert_equal expected, str
+      @d.stop; @d.shutdown; @d.close; @d.terminate
+    end
+  end
+
+  unless Fluent.windows?
+    test 'can change working directory' do
+      # check my real /tmp directory (for mac)
+      cmd = %[|ruby -e 'Dir.chdir("/tmp"); puts Dir.pwd']
+      mytmpdir = open(cmd){|io| io.read.chomp }
+
+      m = Mutex.new
+      str = nil
+      Timeout.timeout(TEST_DEADLOCK_TIMEOUT) do
+        ran = false
+        args = ['-e', 'puts Dir.pwd']
+        @d.child_process_execute(:t16, "ruby", arguments: args, mode: [:read], chdir: "/tmp") do |io|
+          m.lock
+          ran = true
+          str = io.read.chomp
+          m.unlock
+        end
+        sleep TEST_WAIT_INTERVAL_FOR_BLOCK_RUNNING until m.locked? || ran
+        m.lock
+        assert_equal mytmpdir, str
+        @d.stop; @d.shutdown; @d.close; @d.terminate
+      end
+    end
+  end
+end