fluentd 1.8.0.rc3 → 1.8.0

data/lib/fluent/time.rb

@@ -152,9 +152,7 @@ module Fluent
 
       def configure(conf)
         if conf.has_key?('localtime') || conf.has_key?('utc')
-          if conf.has_key?('localtime') && conf.has_key?('utc')
-            raise Fluent::ConfigError, "both of utc and localtime are specified, use only one of them"
-          elsif conf.has_key?('localtime')
+          if conf.has_key?('localtime')
             conf['localtime'] = Fluent::Config.bool_value(conf['localtime'])
           elsif conf.has_key?('utc')
             conf['localtime'] = !(Fluent::Config.bool_value(conf['utc']))
@@ -167,6 +165,10 @@ module Fluent
 
         super
 
+        if conf.has_key?('localtime') && conf.has_key?('utc') && !(@localtime ^ @utc)
+          raise Fluent::ConfigError, "both of utc and localtime are specified, use only one of them"
+        end
+
         Fluent::Timezone.validate!(@timezone) if @timezone
       end
     end

data/lib/fluent/version.rb

@@ -16,6 +16,6 @@
 
 module Fluent
 
-  VERSION = '1.8.0.rc3'
+  VERSION = '1.8.0'
 
 end

data/test/config/test_configurable.rb

@@ -30,6 +30,13 @@ module ConfigurableSpec
     config_set_default :opt1, :baz
   end
 
+  class Base1Nil < Base1
+    config_set_default :name1, nil
+    config_set_default :name2, nil
+    config_set_default :opt1, nil
+    config_param :name5, :string, default: nil
+  end
+
   class Base2 < Base1
     config_set_default :name2, "base2"
     config_set_default :name4, "base2"
@@ -214,6 +221,12 @@ module ConfigurableSpec
     end
   end
 
+  class ExampleWithIntFloat
+    include Fluent::Configurable
+    config_param :int1, :integer
+    config_param :float1, :float
+  end
+
   module Overwrite
     class Base
       include Fluent::Configurable
@@ -602,7 +615,69 @@ module Fluent::Config
             assert_equal([], x6a.obj2)
           end
         end
+
+        test 'strict value type' do
+          default = config_element("", "", {"int1" => "1", "float1" => ""})
+
+          c = ConfigurableSpec::ExampleWithIntFloat.new
+          assert_nothing_raised { c.configure(default) }
+          assert_raise(Fluent::ConfigError) { c.configure(default, true) }
+        end
       end
+
+        test 'set nil for a parameter which has no default value' do
+          obj = ConfigurableSpec::Base2.new
+          conf = config_element("", "", {"name1" => nil, "name5" => "t5", "opt3" => "a"})
+          assert_raise(Fluent::ConfigError.new("'name1' parameter is required but nil is specified")) do
+            obj.configure(conf)
+          end
+        end
+
+        test 'set nil for a parameter which has non-nil default value' do
+          obj = ConfigurableSpec::Base2.new
+          conf = config_element("", "", {"name1" => "t1", "name3" => nil, "name5" => "t5", "opt3" => "a"})
+          assert_raise(Fluent::ConfigError.new("'name3' parameter is required but nil is specified")) do
+            obj.configure(conf)
+          end
+        end
+
+        test 'set nil for a parameter whose default value is nil' do
+          obj = ConfigurableSpec::Base1Nil.new
+          conf = config_element("", "", {"name5" => nil})
+          obj.configure(conf)
+          assert_nil obj.name5
+        end
+
+        test 'set nil for parameters whose default values are overwritten by nil' do
+          obj = ConfigurableSpec::Base1Nil.new
+          conf = config_element("", "", {"name1" => nil, "name2" => nil, "opt1" => nil})
+          obj.configure(conf)
+          assert_nil obj.name1
+          assert_nil obj.name2
+          assert_nil obj.opt1
+        end
+
+        test 'set :default' do
+          obj = ConfigurableSpec::Base2.new
+          conf = config_element("", "", {"name1" => "t1", "name3" => :default, "name5" => "t5", "opt3" => "a"})
+          obj.configure(conf)
+          assert_equal "base1", obj.name3
+        end
+
+        test 'set :default for a parameter which has no default value' do
+          obj = ConfigurableSpec::Base2.new
+          conf = config_element("", "", {"name1" => :default, "name5" => "t5", "opt3" => "a"})
+          assert_raise(Fluent::ConfigError.new("'name1' doesn't have default value")) do
+            obj.configure(conf)
+          end
+        end
+
+        test 'set :default for a parameter which has an overwritten default value' do
+          obj = ConfigurableSpec::Base2.new
+          conf = config_element("", "", {"name1" => "t1", "name3" => "t3", "name4" => :default, "name5" => "t5", "opt3" => "a"})
+          obj.configure(conf)
+          assert_equal "base2", obj.name4
+        end
     end
 
     sub_test_case 'class defined with config_section' do
@@ -1626,5 +1701,84 @@ module Fluent::Config
         assert_equal 'foo', c.subsection.first.param0
       end
     end
+
+    sub_test_case '#config_argument' do
+      test 'with strict_config_value' do
+        class TestClass01
+          include Fluent::Configurable
+          config_section :subsection do
+            config_argument :param1, :integer
+          end
+        end
+
+        c = TestClass01.new
+        subsection = config_element('subsection', "hoge", { })
+        assert_raise(Fluent::ConfigError.new('param1: invalid value for Integer(): "hoge"')) do
+          c.configure(config_element('root', '', {}, [subsection]), true)
+        end
+      end
+
+      test 'with nil' do
+        class TestClass02
+          include Fluent::Configurable
+          config_section :subsection do
+            config_argument :param1, :integer
+          end
+        end
+
+        c = TestClass02.new
+        subsection = config_element('subsection', nil, { })
+        assert_raise(Fluent::ConfigError.new("'<subsection ARG>' section requires argument, in section subsection")) do
+          c.configure(config_element('root', '', {}, [subsection]))
+        end
+      end
+
+      test 'with nil for an argument whose default value is nil' do
+        class TestClass03
+          include Fluent::Configurable
+          config_section :subsection do
+            config_argument :param1, :integer, default: nil
+          end
+        end
+
+        c = TestClass03.new
+        subsection = config_element('subsection', nil, { })
+        c.configure(config_element('root', '', {}, [subsection]))
+
+        assert_equal 1, c.subsection.size
+        assert_equal nil, c.subsection.first.param1
+      end
+
+      test 'with :default' do
+        class TestClass04
+          include Fluent::Configurable
+          config_section :subsection do
+            config_argument :param1, :integer, default: 3
+          end
+        end
+
+        c = TestClass04.new
+        subsection = config_element('subsection', :default, { })
+        c.configure(config_element('root', '', {}, [subsection]))
+
+        assert_equal 1, c.subsection.size
+        assert_equal 3, c.subsection.first.param1
+      end
+
+      test 'with :default for an argument which does not have default value' do
+        class TestClass05
+          include Fluent::Configurable
+          config_section :subsection do
+            config_argument :param1, :integer
+          end
+        end
+
+        c = TestClass05.new
+        subsection = config_element('subsection', :default, { })
+        assert_raise(Fluent::ConfigError.new("'param1' doesn\'t have default value")) do
+          c.configure(config_element('root', '', {}, [subsection]))
+        end
+      end
+    end
   end
 end

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

@@ -71,7 +71,7 @@ module Fluent::Config
       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)
@@ -88,6 +88,7 @@ module Fluent::Config
       '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)

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