fluentd 1.7.4-x64-mingw32 → 1.8.0-x64-mingw32

data/test/config/test_element.rb

@@ -254,6 +254,24 @@ CONF
       assert_not_equal(e.inspect, e.to_s)
       assert_equal(dump, e.to_s)
     end
+
+    test 'dump nil and default for v1' do
+      expected = <<-CONF
+<ROOT>
+  str1 
+  str2 defstring
+</ROOT>
+CONF
+      e = element('ROOT', '', {'str1' => nil, "str2" => :default}, [])
+      type_lookup = ->(type){ Fluent::Configurable.lookup_type(type) }
+      p = Fluent::Config::ConfigureProxy.new("test", type_lookup: type_lookup)
+      p.config_param :str1, :string
+      p.config_param :str2, :string, default: "defstring"
+      e.corresponding_proxies << p
+      e.v1_config = true
+      assert_not_equal(e.inspect, e.to_s)
+      assert_equal(expected, e.to_s)
+    end
   end
 
   sub_test_case '#inspect' do

data/test/config/test_literal_parser.rb

@@ -240,6 +240,10 @@ module Fluent::Config
         assert_text_parsed_as("foo1", '"foo#{worker_id}"')
         ENV.delete('SERVERENGINE_WORKER_ID')
       }
+      test('nil') { assert_text_parsed_as(nil, '"#{raise SetNil}"') }
+      test('default') { assert_text_parsed_as(:default, '"#{raise SetDefault}"') }
+      test('nil helper') { assert_text_parsed_as(nil, '"#{use_nil}"') }
+      test('default helper') { assert_text_parsed_as(:default, '"#{use_default}"') }
     end
 
     sub_test_case 'array parsing' do

data/test/config/test_system_config.rb

@@ -15,20 +15,41 @@ module Fluent::Config
   class FakeSupervisor
     attr_writer :log_level
 
-    def initialize
-      @workers = nil
-      @root_dir = nil
-      @log = FakeLoggerInitializer.new
-      @log_level = Fluent::Log::LEVEL_INFO
-      @suppress_interval = nil
-      @suppress_config_dump = nil
-      @suppress_repeated_stacktrace = nil
-      @log_event_label = nil
-      @log_event_verbose = nil
-      @without_source = nil
-      @emit_error_log_interval = nil
-      @file_permission = nil
-      @dir_permission = nil
+    def initialize(**opt)
+      @system_config = nil
+      @cl_opt = {
+        wokers: nil,
+        root_dir: nil,
+        log: FakeLoggerInitializer.new,
+        log_level: Fluent::Log::LEVEL_INFO,
+        suppress_interval: nil,
+        suppress_config_dump: nil,
+        suppress_repeated_stacktrace: nil,
+        log_event_label: nil,
+        log_event_verbose: nil,
+        without_source: nil,
+        emit_error_log_interval: nil,
+        file_permission: nil,
+        dir_permission: nil,
+      }.merge(opt)
+    end
+
+    def for_system_config
+      opt = {}
+      # this is copy from Supervisor#build_system_config
+      Fluent::SystemConfig::SYSTEM_CONFIG_PARAMETERS.each do |param|
+        if @cl_opt.key?(param) && !@cl_opt[param].nil?
+          if param == :log_level && @cl_opt[:log_level] == Fluent::Log::LEVEL_INFO
+            # info level can't be specified via command line option.
+            # log_level is info here, it is default value and <system>'s log_level should be applied if exists.
+            next
+          end
+
+          opt[param] = @cl_opt[param]
+        end
+      end
+
+      opt
     end
   end
 
@@ -47,26 +68,16 @@ module Fluent::Config
       EOS
       s = FakeSupervisor.new
       sc = Fluent::SystemConfig.new(conf)
-      sc.apply(s)
+      sc.overwrite_variables(s.for_system_config)
       assert_equal(1, sc.workers)
       assert_nil(sc.root_dir)
-      assert_nil(sc.log_level)
+      assert_equal(Fluent::Log::LEVEL_INFO, sc.log_level)
       assert_nil(sc.suppress_repeated_stacktrace)
       assert_nil(sc.emit_error_log_interval)
       assert_nil(sc.suppress_config_dump)
       assert_nil(sc.without_source)
       assert_equal(:text, sc.log.format)
       assert_equal('%Y-%m-%d %H:%M:%S %z', sc.log.time_format)
-      assert_equal(1, s.instance_variable_get(:@workers))
-      assert_nil(s.instance_variable_get(:@root_dir))
-      assert_equal(Fluent::Log::LEVEL_INFO, s.instance_variable_get(:@log_level))
-      assert_nil(s.instance_variable_get(:@suppress_repeated_stacktrace))
-      assert_nil(s.instance_variable_get(:@emit_error_log_interval))
-      assert_nil(s.instance_variable_get(:@suppress_config_dump))
-      assert_nil(s.instance_variable_get(:@log_event_verbose))
-      assert_nil(s.instance_variable_get(:@without_source))
-      assert_nil(s.instance_variable_get(:@file_permission))
-      assert_nil(s.instance_variable_get(:@dir_permission))
     end
 
     data(
@@ -74,10 +85,10 @@ module Fluent::Config
       'root_dir' => ['root_dir', File.join(TMP_DIR, 'root')],
       'log_level' => ['log_level', 'error'],
       'suppress_repeated_stacktrace' => ['suppress_repeated_stacktrace', true],
-      'emit_error_log_interval' => ['emit_error_log_interval', 60],
       'log_event_verbose' => ['log_event_verbose', true],
       'suppress_config_dump' => ['suppress_config_dump', true],
       'without_source' => ['without_source', true],
+      'strict_config_value' => ['strict_config_value', true],
     )
     test "accepts parameters" do |(k, v)|
       conf = parse_text(<<-EOS)
@@ -87,10 +98,12 @@ module Fluent::Config
       EOS
       s = FakeSupervisor.new
       sc = Fluent::SystemConfig.new(conf)
-      sc.apply(s)
-      assert_not_nil(sc.instance_variable_get("@#{k}"))
-      key = (k == 'emit_error_log_interval' ? 'suppress_interval' : k)
-      assert_not_nil(s.instance_variable_get("@#{key}"))
+      sc.overwrite_variables(s.for_system_config)
+      if k == 'log_level'
+        assert_equal(Fluent::Log::LEVEL_ERROR, sc.__send__(k))
+      else
+        assert_equal(v, sc.__send__(k))
+      end
     end
 
     test "log parameters" do
@@ -104,50 +117,11 @@ module Fluent::Config
       EOS
       s = FakeSupervisor.new
       sc = Fluent::SystemConfig.new(conf)
-      sc.apply(s)
+      sc.overwrite_variables(s.for_system_config)
       assert_equal(:json, sc.log.format)
       assert_equal('%Y', sc.log.time_format)
     end
 
-    data(
-      'foo' => ['foo', 'bar'],
-      'hoge' => ['hoge', 'fuga'],
-    )
-    test "should not affect settable parameters with unknown parameters" do |(k, v)|
-      s = FakeSupervisor.new
-      sc = Fluent::SystemConfig.new({k => v})
-      sc.apply(s)
-      assert_equal(1, s.instance_variable_get(:@workers))
-      assert_nil(s.instance_variable_get(:@root_dir))
-      assert_equal(Fluent::Log::LEVEL_INFO, s.instance_variable_get(:@log_level))
-      assert_nil(s.instance_variable_get(:@suppress_repeated_stacktrace))
-      assert_nil(s.instance_variable_get(:@emit_error_log_interval))
-      assert_nil(s.instance_variable_get(:@suppress_config_dump))
-      assert_nil(s.instance_variable_get(:@log_event_verbose))
-      assert_nil(s.instance_variable_get(:@without_source))
-      assert_nil(s.instance_variable_get(:@file_permission))
-      assert_nil(s.instance_variable_get(:@dir_permission))
-    end
-
-    data('trace' => Fluent::Log::LEVEL_TRACE,
-         'debug' => Fluent::Log::LEVEL_DEBUG,
-         'info' => Fluent::Log::LEVEL_INFO,
-         'warn' => Fluent::Log::LEVEL_WARN,
-         'error' => Fluent::Log::LEVEL_ERROR,
-         'fatal' => Fluent::Log::LEVEL_FATAL)
-    test 'log_level is applied when log_level related command line option is not passed' do |level|
-      conf = parse_text(<<-EOS)
-        <system>
-          log_level #{Fluent::Log::LEVEL_TEXT[level]}
-        </system>
-      EOS
-      s = FakeSupervisor.new
-      sc = Fluent::SystemConfig.new(conf)
-      sc.attach(s)
-      sc.apply(s)
-      assert_equal(level, s.instance_variable_get("@log").level)
-    end
-
     # info is removed because info level can't be specified via command line
     data('trace' => Fluent::Log::LEVEL_TRACE,
          'debug' => Fluent::Log::LEVEL_DEBUG,
@@ -160,27 +134,10 @@ module Fluent::Config
           log_level info
         </system>
       EOS
-      s = FakeSupervisor.new
-      s.log_level = level
-      sc = Fluent::SystemConfig.new(conf)
-      sc.attach(s)
-      sc.apply(s)
-      assert_equal(level, s.instance_variable_get("@log").level)
-    end
-
-    test 'process global overridable variables' do
-      conf = parse_text(<<-EOS)
-        <system>
-          file_permission 0655
-          dir_permission 0765
-        </system>
-      EOS
-      s = FakeSupervisor.new
+      s = FakeSupervisor.new(log_level: level)
       sc = Fluent::SystemConfig.new(conf)
-      sc.attach(s)
-      sc.apply(s)
-      assert_equal(0655, s.instance_variable_get(:@file_permission))
-      assert_equal(0765, s.instance_variable_get(:@dir_permission))
+      sc.overwrite_variables(s.for_system_config)
+      assert_equal(level, sc.log_level)
     end
   end
 end

data/test/config/test_types.rb

@@ -5,59 +5,122 @@ class TestConfigTypes < ::Test::Unit::TestCase
   include Fluent
 
   sub_test_case 'Config.size_value' do
-    test 'normal case' do
-      assert_equal(2048, Config.size_value("2k"))
-      assert_equal(2048, Config.size_value("2K"))
-      assert_equal(3145728, Config.size_value("3m"))
-      assert_equal(3145728, Config.size_value("3M"))
-      assert_equal(4294967296, Config.size_value("4g"))
-      assert_equal(4294967296, Config.size_value("4G"))
-      assert_equal(5497558138880, Config.size_value("5t"))
-      assert_equal(5497558138880, Config.size_value("5T"))
-      assert_equal(6, Config.size_value("6"))
-    end
-
-    test 'not assumed case' do
-      assert_equal(6, Config.size_value(6))
-      assert_equal(0, Config.size_value("hoge"))
-      assert_equal(0, Config.size_value(""))
-      assert_equal(0, Config.size_value(nil))
+    data("2k" => [2048, "2k"],
+         "2K" => [2048, "2K"],
+         "3m" => [3145728, "3m"],
+         "3M" => [3145728, "3M"],
+         "4g" => [4294967296, "4g"],
+         "4G" => [4294967296, "4G"],
+         "5t" => [5497558138880, "5t"],
+         "5T" => [5497558138880, "5T"],
+         "6"  => [6, "6"])
+    test 'normal case' do |(expected, val)|
+      assert_equal(expected, Config.size_value(val))
+      assert_equal(expected, Config.size_value(val, { strict: true }))
+    end
+
+    data("integer" => [6, 6],
+         "hoge" => [0, "hoge"],
+         "empty" => [0, ""])
+    test 'not assumed case' do |(expected, val)|
+      assert_equal(expected, Config.size_value(val))
+    end
+
+    test 'nil' do
+      assert_equal(nil, Config.size_value(nil))
+    end
+
+    data("integer" => [6, 6],
+         "hoge" => [Fluent::ConfigError.new('name1: invalid value for Integer(): "hoge"'), "hoge"],
+         "empty" => [Fluent::ConfigError.new('name1: invalid value for Integer(): ""'), ""])
+    test 'not assumed case with strict' do |(expected, val)|
+      if expected.kind_of? Exception
+        assert_raise(expected) do
+          Config.size_value(val, { strict: true }, "name1")
+        end
+      else
+        assert_equal(expected, Config.size_value(val, { strict: true }, "name1"))
+      end
+    end
+
+    test 'nil with strict' do
+      assert_equal(nil, Config.size_value(nil, { strict: true }))
     end
   end
 
   sub_test_case 'Config.time_value' do
-    test 'normal case' do
-      assert_equal(10, Config.time_value("10s"))
-      assert_equal(10, Config.time_value("10sec"))
-      assert_equal(120, Config.time_value("2m"))
-      assert_equal(10800, Config.time_value("3h"))
-      assert_equal(345600, Config.time_value("4d"))
+    data("10s" => [10, "10s"],
+         "10sec" => [10, "10sec"],
+         "2m" => [120, "2m"],
+         "3h" => [10800, "3h"],
+         "4d" => [345600, "4d"])
+    test 'normal case' do |(expected, val)|
+      assert_equal(expected, Config.time_value(val))
+      assert_equal(expected, Config.time_value(val, { strict: true }))
     end
 
-    test 'not assumed case' do
-      assert_equal(4.0, Config.time_value(4))
-      assert_equal(0.4, Config.time_value(0.4))
-      assert_equal(0.0, Config.time_value("hoge"))
-      assert_equal(0.0, Config.time_value(""))
-      assert_equal(0.0, Config.time_value(nil))
+    data("integer" => [4.0, 4],
+         "float" => [0.4, 0.4],
+         "hoge" => [0.0, "hoge"],
+         "empty" => [0.0, ""])
+    test 'not assumed case' do |(expected, val)|
+      assert_equal(expected, Config.time_value(val))
+    end
+
+    test 'nil' do
+      assert_equal(nil, Config.time_value(nil))
+    end
+
+    data("integer" => [6, 6],
+         "hoge" => [Fluent::ConfigError.new('name1: invalid value for Float(): "hoge"'), "hoge"],
+         "empty" => [Fluent::ConfigError.new('name1: invalid value for Float(): ""'), ""])
+    test 'not assumed case with strict' do |(expected, val)|
+      if expected.kind_of? Exception
+        assert_raise(expected) do
+          Config.time_value(val, { strict: true }, "name1")
+        end
+      else
+        assert_equal(expected, Config.time_value(val, { strict: true }, "name1"))
+      end
+    end
+
+    test 'nil with strict' do
+      assert_equal(nil, Config.time_value(nil, { strict: true }))
     end
   end
 
   sub_test_case 'Config.bool_value' do
-    test 'normal case' do
-      assert_true Config.bool_value("true")
-      assert_true Config.bool_value("yes")
-      assert_true Config.bool_value("")
-      assert_false Config.bool_value("false")
-      assert_false Config.bool_value("no")
+    data("true" => [true, "true"],
+         "yes" => [true, "yes"],
+         "empty" => [true, ""],
+         "false" => [false, "false"],
+         "no" => [false, "no"])
+    test 'normal case' do |(expected, val)|
+      assert_equal(expected, Config.bool_value(val))
     end
 
-    test 'not assumed case' do
-      assert_true Config.bool_value(true)
-      assert_false Config.bool_value(false)
-      assert_nil Config.bool_value("hoge")
-      assert_nil Config.bool_value(nil)
-      assert_nil Config.bool_value(10)
+    data("true" =>  [true,  true],
+         "false" => [false, false],
+         "hoge" => [nil, "hoge"],
+         "nil" => [nil, nil],
+         "integer" => [nil, 10])
+    test 'not assumed case' do |(expected, val)|
+      assert_equal(expected, Config.bool_value(val))
+    end
+
+    data("true" =>  [true,  true],
+         "false" => [false, false],
+         "hoge" => [Fluent::ConfigError.new("name1: invalid bool value: hoge"), "hoge"],
+         "nil" => [nil, nil],
+         "integer" => [Fluent::ConfigError.new("name1: invalid bool value: 10"), 10])
+    test 'not assumed case with strict' do |(expected, val)|
+      if expected.kind_of? Exception
+        assert_raise(expected) do
+          Config.bool_value(val, { strict: true }, "name1")
+        end
+      else
+        assert_equal(expected, Config.bool_value(val, { strict: true }, "name1"))
+      end
     end
   end
 
@@ -87,14 +150,23 @@ class TestConfigTypes < ::Test::Unit::TestCase
         Config.regexp_value(str)
       end
     end
+
+    test 'nil' do
+      assert_equal nil, Config.regexp_value(nil)
+    end
   end
 
   sub_test_case 'type converters for config_param definitions' do
-    test 'string' do
-      assert_equal 'test', Config::STRING_TYPE.call('test', {})
-      assert_equal '1', Config::STRING_TYPE.call('1', {})
-      assert_equal '   ', Config::STRING_TYPE.call('   ', {})
-      assert_equal Encoding::UTF_8, Config::STRING_TYPE.call('test', {}).encoding
+    data("test" => ['test', 'test'],
+         "1" =>  ['1',    '1'],
+         "spaces" =>  ['   ',  '   '])
+    test 'string' do |(expected, val)|
+      assert_equal expected, Config::STRING_TYPE.call(val, {})
+      assert_equal Encoding::UTF_8, Config::STRING_TYPE.call(val, {}).encoding
+    end
+
+    test 'string nil' do
+      assert_equal nil, Config::STRING_TYPE.call(nil, {})
     end
 
     data('latin' => 'Märch',
@@ -108,58 +180,133 @@ class TestConfigTypes < ::Test::Unit::TestCase
       assert_equal Encoding::UTF_8, actual.encoding
     end
 
-    test 'enum' do
-      assert_equal :val, Config::ENUM_TYPE.call('val', {list: [:val, :value, :v]})
-      assert_equal :v, Config::ENUM_TYPE.call('v', {list: [:val, :value, :v]})
-      assert_equal :value, Config::ENUM_TYPE.call('value', {list: [:val, :value, :v]})
-      assert_raises(Fluent::ConfigError.new("valid options are val,value,v but got x")){ Config::ENUM_TYPE.call('x', {list: [:val, :value, :v]}) }
-      assert_raises(RuntimeError.new("Plugin BUG: config type 'enum' requires :list of symbols")){ Config::ENUM_TYPE.call('val', {}) }
-      assert_raises(RuntimeError.new("Plugin BUG: config type 'enum' requires :list of symbols")){ Config::ENUM_TYPE.call('val', {list: ["val", "value", "v"]}) }
+    data("val" => [:val, 'val'],
+         "v" => [:v, 'v'],
+         "value" => [:value, 'value'])
+    test 'enum' do |(expected, val, list)|
+      assert_equal expected, Config::ENUM_TYPE.call(val, {list: [:val, :value, :v]})
+    end
+
+    test 'enum: pick unknown choice' do
+      assert_raises(Fluent::ConfigError.new("valid options are val,value,v but got x")) do
+        Config::ENUM_TYPE.call('x', {list: [:val, :value, :v]})
+      end
+    end
+
+    data("empty list"  => {},
+         "string list" => {list: ["val", "value", "v"]})
+    test 'enum: invalid choices' do | list |
+      assert_raises(RuntimeError.new("Plugin BUG: config type 'enum' requires :list of symbols")) do
+        Config::ENUM_TYPE.call('val', list)
+      end
     end
 
-    test 'integer' do
-      assert_equal 1, Config::INTEGER_TYPE.call('1', {})
-      assert_equal 1, Config::INTEGER_TYPE.call('1.0', {})
-      assert_equal 1000, Config::INTEGER_TYPE.call('1_000', {})
-      assert_equal 1, Config::INTEGER_TYPE.call('1x', {})
+    test 'enum: nil' do
+      assert_equal nil, Config::ENUM_TYPE.call(nil)
     end
 
-    test 'float' do
-      assert_equal 1.0, Config::FLOAT_TYPE.call('1', {})
-      assert_equal 1.0, Config::FLOAT_TYPE.call('1.0', {})
-      assert_equal 1.0, Config::FLOAT_TYPE.call('1.00', {})
-      assert_equal 1.0, Config::FLOAT_TYPE.call('1e0', {})
+    data("1" => [1, '1'],
+         "1.0" => [1, '1.0'],
+         "1_000" => [1000, '1_000'],
+         "1x" => [1, '1x'])
+    test 'integer' do |(expected, val)|
+      assert_equal expected, Config::INTEGER_TYPE.call(val, {})
     end
 
-    test 'size' do
-      assert_equal 1000, Config::SIZE_TYPE.call('1000', {})
-      assert_equal 1024, Config::SIZE_TYPE.call('1k', {})
-      assert_equal 1024*1024, Config::SIZE_TYPE.call('1m', {})
+    data("integer" => [6, 6],
+         "hoge" => [0, "hoge"],
+         "empty" => [0, ""])
+    test 'integer: not assumed case' do |(expected, val)|
+      assert_equal expected, Config::INTEGER_TYPE.call(val, {})
     end
 
-    test 'bool' do
-      assert_equal true, Config::BOOL_TYPE.call('true', {})
-      assert_equal true, Config::BOOL_TYPE.call('yes', {})
-      assert_equal false, Config::BOOL_TYPE.call('no', {})
-      assert_equal false, Config::BOOL_TYPE.call('false', {})
+    test 'integer: nil' do
+      assert_equal nil, Config::INTEGER_TYPE.call(nil, {})
+    end
 
-      assert_equal nil, Config::BOOL_TYPE.call('TRUE', {})
-      assert_equal nil, Config::BOOL_TYPE.call('True', {})
-      assert_equal nil, Config::BOOL_TYPE.call('Yes', {})
-      assert_equal nil, Config::BOOL_TYPE.call('No', {})
+    data("integer" => [6, 6],
+         "hoge" => [Fluent::ConfigError.new('name1: invalid value for Integer(): "hoge"'), "hoge"],
+         "empty" => [Fluent::ConfigError.new('name1: invalid value for Integer(): ""'), ""])
+    test 'integer: not assumed case with strict' do |(expected, val)|
+      if expected.kind_of? Exception
+        assert_raise(expected) do
+          Config::INTEGER_TYPE.call(val, { strict: true }, "name1")
+        end
+      else
+        assert_equal expected, Config::INTEGER_TYPE.call(val, { strict: true }, "name1")
+      end
+    end
 
-      assert_equal true, Config::BOOL_TYPE.call('', {})
-      assert_equal nil, Config::BOOL_TYPE.call('unexpected_string', {})
+    test 'integer: nil with strict' do
+      assert_equal nil, Config::INTEGER_TYPE.call(nil, { strict: true })
     end
 
-    test 'time' do
-      assert_equal 0, Config::TIME_TYPE.call('0', {})
-      assert_equal 1.0, Config::TIME_TYPE.call('1', {})
-      assert_equal 1.01, Config::TIME_TYPE.call('1.01', {})
-      assert_equal 1, Config::TIME_TYPE.call('1s', {})
-      assert_equal 60, Config::TIME_TYPE.call('1m', {})
-      assert_equal 3600, Config::TIME_TYPE.call('1h', {})
-      assert_equal 86400, Config::TIME_TYPE.call('1d', {})
+    data("1" => [1.0, '1'],
+         "1.0" => [1.0, '1.0'],
+         "1.00" => [1.0, '1.00'],
+         "1e0" => [1.0, '1e0'])
+    test 'float' do |(expected, val)|
+      assert_equal expected, Config::FLOAT_TYPE.call(val, {})
+    end
+
+    data("integer" => [6, 6],
+         "hoge" => [0, "hoge"],
+         "empty" => [0, ""])
+    test 'float: not assumed case' do |(expected, val)|
+      assert_equal expected, Config::FLOAT_TYPE.call(val, {})
+    end
+
+    test 'float: nil' do
+      assert_equal nil, Config::FLOAT_TYPE.call(nil, {})
+    end
+
+    data("integer" => [6, 6],
+         "hoge" => [Fluent::ConfigError.new('name1: invalid value for Float(): "hoge"'), "hoge"],
+         "empty" => [Fluent::ConfigError.new('name1: invalid value for Float(): ""'), ""])
+    test 'float: not assumed case with strict' do |(expected, val)|
+      if expected.kind_of? Exception
+        assert_raise(expected) do
+          Config::FLOAT_TYPE.call(val, { strict: true }, "name1")
+        end
+      else
+        assert_equal expected, Config::FLOAT_TYPE.call(val, { strict: true }, "name1")
+      end
+    end
+
+    test 'float: nil with strict' do
+      assert_equal nil, Config::FLOAT_TYPE.call(nil, { strict: true })
+    end
+
+    data("1000" => [1000, '1000'],
+         "1k" => [1024, '1k'],
+         "1m" => [1024*1024, '1m'])
+    test 'size' do |(expected, val)|
+      assert_equal expected, Config::SIZE_TYPE.call(val, {})
+    end
+
+    data("true" => [true, 'true'],
+         "yes" => [true, 'yes'],
+         "no" => [false, 'no'],
+         "false" => [false, 'false'],
+         "TRUE" => [nil, 'TRUE'],
+         "True" => [nil, 'True'],
+         "Yes" => [nil, 'Yes'],
+         "No" => [nil, 'No'],
+         "empty" => [true, ''],
+         "unexpected_string" => [nil, 'unexpected_string'])
+    test 'bool' do |(expected, val)|
+      assert_equal expected, Config::BOOL_TYPE.call(val, {})
+    end
+
+    data("0" => [0, '0'],
+         "1" => [1.0, '1'],
+         "1.01" => [1.01,  '1.01'],
+         "1s" => [1, '1s'],
+         "1," => [60, '1m'],
+         "1h" => [3600,  '1h'],
+         "1d" => [86400, '1d'])
+    test 'time' do |(expected, val)|
+      assert_equal expected, Config::TIME_TYPE.call(val, {})
     end
 
     data("empty" => [//, "//"],
@@ -171,24 +318,32 @@ class TestConfigTypes < ::Test::Unit::TestCase
       assert_equal(expected, Config::REGEXP_TYPE.call(str, {}))
     end
 
-    test 'hash' do
-      assert_equal({"x"=>"v","k"=>1}, Config::HASH_TYPE.call('{"x":"v","k":1}', {}))
-      assert_equal({"x"=>"v","k"=>"1"}, Config::HASH_TYPE.call('x:v,k:1', {}))
-      assert_equal({"x"=>"v","k"=>"1"}, Config::HASH_TYPE.call('x:v, k:1', {}))
-      assert_equal({"x"=>"v","k"=>"1"}, Config::HASH_TYPE.call(' x:v, k:1 ', {}))
-      assert_equal({"x"=>"v","k"=>"1"}, Config::HASH_TYPE.call('x:v , k:1 ', {}))
-
-      assert_equal({"x"=>"v:v","k"=>"1"}, Config::HASH_TYPE.call('x:v:v, k:1', {}))
-
-      assert_equal({x: "v", k: 1},   Config::HASH_TYPE.call('{"x":"v","k":1}', {symbolize_keys: true}))
-      assert_equal({x: "v", k: "1"}, Config::HASH_TYPE.call('x:v,k:1',         {symbolize_keys: true, value_type: :string}))
-      assert_equal({x: "v", k: "1"}, Config::HASH_TYPE.call('{"x":"v","k":1}', {symbolize_keys: true, value_type: :string}))
-      assert_equal({x: 0, k: 1},     Config::HASH_TYPE.call('x:0,k:1',         {symbolize_keys: true, value_type: :integer}))
+    data("string and integer" => [{"x"=>"v","k"=>1}, '{"x":"v","k":1}', {}],
+         "strings" => [{"x"=>"v","k"=>"1"}, 'x:v,k:1', {}],
+         "w/ space" => [{"x"=>"v","k"=>"1"}, 'x:v, k:1', {}],
+         "heading space" => [{"x"=>"v","k"=>"1"}, ' x:v, k:1 ', {}],
+         "trailing space" => [{"x"=>"v","k"=>"1"}, 'x:v , k:1 ', {}],
+         "multiple colons" => [{"x"=>"v:v","k"=>"1"}, 'x:v:v, k:1', {}],
+         "symbolize keys" => [{x: "v", k: 1}, '{"x":"v","k":1}', {symbolize_keys: true}],
+         "value_type: :string" => [{x: "v", k: "1"}, 'x:v,k:1', {symbolize_keys: true, value_type: :string}],
+         "value_type: :string 2" => [{x: "v", k: "1"}, '{"x":"v","k":1}', {symbolize_keys: true, value_type: :string}],
+         "value_type: :integer" => [{x: 0, k: 1}, 'x:0,k:1', {symbolize_keys: true, value_type: :integer}],
+         "time 1" => [{"x"=>1,"y"=>60,"z"=>3600}, '{"x":"1s","y":"1m","z":"1h"}', {value_type: :time}],
+         "time 2" => [{"x"=>1,"y"=>60,"z"=>3600}, 'x:1s,y:1m,z:1h', {value_type: :time}])
+    test 'hash' do |(expected, val, opts)|
+      assert_equal(expected, Config::HASH_TYPE.call(val, opts))
+    end
 
-      assert_equal({"x"=>1,"y"=>60,"z"=>3600}, Config::HASH_TYPE.call('{"x":"1s","y":"1m","z":"1h"}', {value_type: :time}))
-      assert_equal({"x"=>1,"y"=>60,"z"=>3600}, Config::HASH_TYPE.call('x:1s,y:1m,z:1h',               {value_type: :time}))
+    test 'hash w/ unknown type' do
+      assert_raise(RuntimeError.new("unknown type in REFORMAT: foo")) do
+        Config::HASH_TYPE.call("x:1,y:2", {value_type: :foo})
+      end
+    end
 
-      assert_raise(RuntimeError.new("unknown type in REFORMAT: foo")){ Config::HASH_TYPE.call("x:1,y:2", {value_type: :foo}) }
+    test 'hash w/ strict option' do
+      assert_raise(Fluent::ConfigError.new('y: invalid value for Integer(): "hoge"')) do
+        Config::HASH_TYPE.call("x:1,y:hoge", {value_type: :integer, strict: true})
+      end
     end
 
     data('latin' => ['3:Märch', {"3"=>"Märch"}],
@@ -199,30 +354,48 @@ class TestConfigTypes < ::Test::Unit::TestCase
       assert_equal(expected, Config::HASH_TYPE.call(target.b, { value_type: :string }))
     end
 
-    test 'array' do
-      assert_equal(["1","2",1], Config::ARRAY_TYPE.call('["1","2",1]', {}))
-      assert_equal(["1","2","1"], Config::ARRAY_TYPE.call('1,2,1', {}))
-
-      assert_equal(["a","b","c"], Config::ARRAY_TYPE.call('["a","b","c"]', {}))
-      assert_equal(["a","b","c"], Config::ARRAY_TYPE.call('a,b,c', {}))
-      assert_equal(["a","b","c"], Config::ARRAY_TYPE.call('a, b, c', {}))
-      assert_equal(["a","b","c"], Config::ARRAY_TYPE.call('a , b , c', {}))
-
-      assert_equal(["a a","b,b"," c "], Config::ARRAY_TYPE.call('["a a","b,b"," c "]', {}))
-
-      assert_equal(["a a","b","c"], Config::ARRAY_TYPE.call('a a,b,c', {}))
+    test 'hash w/ nil' do
+      assert_equal(nil, Config::HASH_TYPE.call(nil))
+    end
 
-      assert_equal([1,2,1], Config::ARRAY_TYPE.call('[1,2,1]', {}))
-      assert_equal([1,2,1], Config::ARRAY_TYPE.call('["1","2","1"]', {value_type: :integer}))
-      assert_equal([1,2,1], Config::ARRAY_TYPE.call('1,2,1', {value_type: :integer}))
+    data("strings and integer" => [["1","2",1],   '["1","2",1]', {}],
+         "number strings" => [["1","2","1"], '1,2,1', {}],
+         "alphabets" => [["a","b","c"], '["a","b","c"]', {}],
+         "alphabets w/o quote" => [["a","b","c"], 'a,b,c', {}],
+         "w/ spaces" => [["a","b","c"], 'a, b, c', {}],
+         "w/ space before comma" => [["a","b","c"], 'a , b , c', {}],
+         "comma or space w/ qupte" => [["a a","b,b"," c "], '["a a","b,b"," c "]', {}],
+         "space in a value w/o qupte" => [["a a","b","c"], 'a a,b,c', {}],
+         "integers" => [[1,2,1], '[1,2,1]', {}],
+         "value_type: :integer w/ quote" => [[1,2,1], '["1","2","1"]', {value_type: :integer}],
+         "value_type: :integer w/o quote" => [[1,2,1], '1,2,1', {value_type: :integer}])
+    test 'array' do |(expected, val, opts)|
+      assert_equal(expected, Config::ARRAY_TYPE.call(val, opts))
+    end
 
+    data('["1","2"]' => [["1","2"], '["1","2"]'],
+         '["3"]' => [["3"], '["3"]'])
+    test 'array w/ default values' do |(expected, val)|
       array_options = {
         default: [],
       }
-      assert_equal(["1","2"], Config::ARRAY_TYPE.call('["1","2"]', array_options))
-      assert_equal(["3"], Config::ARRAY_TYPE.call('["3"]', array_options))
+      assert_equal(expected, Config::ARRAY_TYPE.call(val, array_options))
+    end
+
+    test 'array w/ unknown type' do
+      assert_raise(RuntimeError.new("unknown type in REFORMAT: foo")) do
+        Config::ARRAY_TYPE.call("1,2", {value_type: :foo})
+      end
+    end
+
+    test 'array w/ strict option' do
+      assert_raise(Fluent::ConfigError.new(': invalid value for Integer(): "hoge"')) do
+        Config::ARRAY_TYPE.call("1,hoge", {value_type: :integer, strict: true}, "name1")
+      end
+    end
 
-      assert_raise(RuntimeError.new("unknown type in REFORMAT: foo")){ Config::ARRAY_TYPE.call("1,2", {value_type: :foo}) }
+    test 'array w/ nil' do
+      assert_equal(nil, Config::ARRAY_TYPE.call(nil))
     end
   end
 end