fluentd 1.16.5-x64-mingw32 → 1.17.1-x64-mingw32

data/test/config/test_literal_parser.rb

@@ -1,309 +0,0 @@
-require_relative "../helper"
-require_relative 'assertions'
-require "fluent/config/error"
-require "fluent/config/literal_parser"
-require "fluent/config/v1_parser"
-require 'json'
-
-module Fluent::Config
-  class TestLiteralParser < ::Test::Unit::TestCase
-    def parse_text(text)
-      basepath = File.expand_path(File.dirname(__FILE__)+'/../../')
-      ss = StringScanner.new(text)
-      parser = Fluent::Config::V1Parser.new(ss, basepath, "(test)", eval_context)
-      parser.parse_literal
-    end
-
-    TestLiteralParserContext = Struct.new(:v1, :v2, :v3)
-
-    def v1
-      :test
-    end
-
-    def v2
-      true
-    end
-
-    def v3
-      nil
-    end
-
-    def eval_context
-      @eval_context ||= TestLiteralParserContext.new(v1, v2, v3)
-    end
-
-    sub_test_case 'boolean parsing' do
-      def test_true
-        assert_text_parsed_as('true', "true")
-      end
-      def test_false
-        assert_text_parsed_as('false', "false")
-      end
-      def test_trueX
-        assert_text_parsed_as('trueX', "trueX")
-      end
-      def test_falseX
-        assert_text_parsed_as('falseX', "falseX")
-      end
-    end
-
-    sub_test_case 'integer parsing' do
-      test('0') { assert_text_parsed_as('0', "0") }
-      test('1') { assert_text_parsed_as('1', "1") }
-      test('10') { assert_text_parsed_as('10', "10") }
-      test('-1') { assert_text_parsed_as('-1', "-1") }
-      test('-10') { assert_text_parsed_as('-10', "-10") }
-      test('0 ') { assert_text_parsed_as('0', "0 ") }
-      test(' -1 ') { assert_text_parsed_as("-1", ' -1 ') }
-      # string
-      test('01') { assert_text_parsed_as('01', "01") }
-      test('00') { assert_text_parsed_as('00', "00") }
-      test('-01') { assert_text_parsed_as('-01', "-01") }
-      test('-00') { assert_text_parsed_as('-00', "-00") }
-      test('0x61') { assert_text_parsed_as('0x61', "0x61") }
-      test('0s') { assert_text_parsed_as('0s', "0s") }
-    end
-
-    sub_test_case 'float parsing' do
-      test('1.1') { assert_text_parsed_as('1.1', "1.1") }
-      test('0.1') { assert_text_parsed_as('0.1', "0.1") }
-      test('0.0') { assert_text_parsed_as('0.0', "0.0") }
-      test('-1.1') { assert_text_parsed_as('-1.1', "-1.1") }
-      test('-0.1') { assert_text_parsed_as('-0.1', "-0.1") }
-      test('1.10') { assert_text_parsed_as('1.10', "1.10") }
-      # string
-      test('12e8') { assert_text_parsed_as('12e8', "12e8") }
-      test('12.1e7') { assert_text_parsed_as('12.1e7', "12.1e7") }
-      test('-12e8') { assert_text_parsed_as('-12e8', "-12e8") }
-      test('-12.1e7') { assert_text_parsed_as('-12.1e7', "-12.1e7") }
-      test('.0') { assert_text_parsed_as('.0', ".0") }
-      test('.1') { assert_text_parsed_as('.1', ".1") }
-      test('0.') { assert_text_parsed_as('0.', "0.") }
-      test('1.') { assert_text_parsed_as('1.', "1.") }
-      test('.0a') { assert_text_parsed_as('.0a', ".0a") }
-      test('1.a') { assert_text_parsed_as('1.a', "1.a") }
-      test('0@') { assert_text_parsed_as('0@', "0@") }
-    end
-
-    sub_test_case 'float keywords parsing' do
-      test('NaN') { assert_text_parsed_as('NaN', "NaN") }
-      test('Infinity') { assert_text_parsed_as('Infinity', "Infinity") }
-      test('-Infinity') { assert_text_parsed_as('-Infinity', "-Infinity") }
-      test('NaNX') { assert_text_parsed_as('NaNX', "NaNX") }
-      test('InfinityX') { assert_text_parsed_as('InfinityX', "InfinityX") }
-      test('-InfinityX') { assert_text_parsed_as('-InfinityX', "-InfinityX") }
-    end
-
-    sub_test_case 'double quoted string' do
-      test('""') { assert_text_parsed_as("", '""') }
-      test('"text"') { assert_text_parsed_as("text", '"text"') }
-      test('"\\""') { assert_text_parsed_as("\"", '"\\""') }
-      test('"\\t"') { assert_text_parsed_as("\t", '"\\t"') }
-      test('"\\n"') { assert_text_parsed_as("\n", '"\\n"') }
-      test('"\\r\\n"') { assert_text_parsed_as("\r\n", '"\\r\\n"') }
-      test('"\\f\\b"') { assert_text_parsed_as("\f\b", '"\\f\\b"') }
-      test('"\\.t"') { assert_text_parsed_as(".t", '"\\.t"') }
-      test('"\\$t"') { assert_text_parsed_as("$t", '"\\$t"') }
-      test('"\\"') { assert_text_parsed_as("#t", '"\\#t"') }
-      test('"\\0"') { assert_text_parsed_as("\0", '"\\0"') }
-      test('"\\z"') { assert_parse_error('"\\z"') }  # unknown escaped character
-      test('"\\1"') { assert_parse_error('"\\1"') }  # unknown escaped character
-      test('"t') { assert_parse_error('"t') }  # non-terminated quoted character
-      test("\"t\nt\"") { assert_text_parsed_as("t\nt", "\"t\nt\"" ) } # multiline string
-      test("\"t\\\nt\"") { assert_text_parsed_as("tt", "\"t\\\nt\"" ) } # multiline string
-      test('t"') { assert_text_parsed_as('t"', 't"') }
-      test('"."') { assert_text_parsed_as('.', '"."') }
-      test('"*"') { assert_text_parsed_as('*', '"*"') }
-      test('"@"') { assert_text_parsed_as('@', '"@"') }
-      test('"\\#{test}"') { assert_text_parsed_as("\#{test}", '"\\#{test}"') }
-      test('"$"') { assert_text_parsed_as('$', '"$"') }
-      test('"$t"') { assert_text_parsed_as('$t', '"$t"') }
-      test('"$}"') { assert_text_parsed_as('$}', '"$}"') }
-      test('"\\\\"') { assert_text_parsed_as("\\", '"\\\\"') }
-      test('"\\["') { assert_text_parsed_as("[", '"\\["') }
-    end
-
-    sub_test_case 'single quoted string' do
-      test("''") { assert_text_parsed_as("", "''") }
-      test("'text'") { assert_text_parsed_as("text", "'text'") }
-      test("'\\''") { assert_text_parsed_as('\'', "'\\''") }
-      test("'\\t'") { assert_text_parsed_as('\t', "'\\t'") }
-      test("'\\n'") { assert_text_parsed_as('\n', "'\\n'") }
-      test("'\\r\\n'") { assert_text_parsed_as('\r\n', "'\\r\\n'") }
-      test("'\\f\\b'") { assert_text_parsed_as('\f\b', "'\\f\\b'") }
-      test("'\\.t'") { assert_text_parsed_as('\.t', "'\\.t'") }
-      test("'\\$t'") { assert_text_parsed_as('\$t', "'\\$t'") }
-      test("'\\#t'") { assert_text_parsed_as('\#t', "'\\#t'") }
-      test("'\\z'") { assert_text_parsed_as('\z', "'\\z'") }
-      test("'\\0'") { assert_text_parsed_as('\0', "'\\0'") }
-      test("'\\1'") { assert_text_parsed_as('\1', "'\\1'") }
-      test("'t") { assert_parse_error("'t") }  # non-terminated quoted character
-      test("t'") { assert_text_parsed_as("t'", "t'") }
-      test("'.'") { assert_text_parsed_as('.', "'.'") }
-      test("'*'") { assert_text_parsed_as('*', "'*'") }
-      test("'@'") { assert_text_parsed_as('@', "'@'") }
-      test(%q['#{test}']) { assert_text_parsed_as('#{test}', %q['#{test}']) }
-      test("'$'") { assert_text_parsed_as('$', "'$'") }
-      test("'$t'") { assert_text_parsed_as('$t', "'$t'") }
-      test("'$}'") { assert_text_parsed_as('$}', "'$}'") }
-      test("'\\\\'") { assert_text_parsed_as('\\', "'\\\\'") }
-      test("'\\['") { assert_text_parsed_as('\[', "'\\['") }
-    end
-
-    sub_test_case 'nonquoted string parsing' do
-      test("''") { assert_text_parsed_as(nil, '') }
-      test('text') { assert_text_parsed_as('text', 'text') }
-      test('\"') { assert_text_parsed_as('\"', '\"') }
-      test('\t') { assert_text_parsed_as('\t', '\t') }
-      test('\n') { assert_text_parsed_as('\n', '\n') }
-      test('\r\n') { assert_text_parsed_as('\r\n', '\r\n') }
-      test('\f\b') { assert_text_parsed_as('\f\b', '\f\b') }
-      test('\.t') { assert_text_parsed_as('\.t', '\.t') }
-      test('\$t') { assert_text_parsed_as('\$t', '\$t') }
-      test('\#t') { assert_text_parsed_as('\#t', '\#t') }
-      test('\z') { assert_text_parsed_as('\z', '\z') }
-      test('\0') { assert_text_parsed_as('\0', '\0') }
-      test('\1') { assert_text_parsed_as('\1', '\1') }
-      test('.') { assert_text_parsed_as('.', '.') }
-      test('*') { assert_text_parsed_as('*', '*') }
-      test('@') { assert_text_parsed_as('@', '@') }
-      test('#{test}') { assert_text_parsed_as('#{test}', '#{test}') }
-      test('$') { assert_text_parsed_as('$', '$') }
-      test('$t') { assert_text_parsed_as('$t', '$t') }
-      test('$}') { assert_text_parsed_as('$}', '$}') }
-      test('\\\\') { assert_text_parsed_as('\\\\', '\\\\') }
-      test('\[') { assert_text_parsed_as('\[', '\[') }
-      test('#foo') { assert_text_parsed_as('#foo', '#foo') } # not comment out
-      test('foo#bar') { assert_text_parsed_as('foo#bar', 'foo#bar') } # not comment out
-      test(' text') { assert_text_parsed_as('text', ' text') } # remove starting spaces
-      test(' #foo') { assert_text_parsed_as('#foo', ' #foo') } # remove starting spaces
-      test('foo #bar') { assert_text_parsed_as('foo', 'foo #bar') } # comment out
-      test('foo\t#bar') { assert_text_parsed_as('foo', "foo\t#bar") } # comment out
-
-      test('t') { assert_text_parsed_as('t', 't') }
-      test('T') { assert_text_parsed_as('T', 'T') }
-      test('_') { assert_text_parsed_as('_', '_') }
-      test('T1') { assert_text_parsed_as('T1', 'T1') }
-      test('_2') { assert_text_parsed_as('_2', '_2') }
-      test('t0') { assert_text_parsed_as('t0', 't0') }
-      test('t@') { assert_text_parsed_as('t@', 't@') }
-      test('t-') { assert_text_parsed_as('t-', 't-') }
-      test('t.') { assert_text_parsed_as('t.', 't.') }
-      test('t+') { assert_text_parsed_as('t+', 't+') }
-      test('t/') { assert_text_parsed_as('t/', 't/') }
-      test('t=') { assert_text_parsed_as('t=', 't=') }
-      test('t,') { assert_text_parsed_as('t,', 't,') }
-      test('0t') { assert_text_parsed_as('0t', "0t") }
-      test('@1t') { assert_text_parsed_as('@1t', '@1t') }
-      test('-1t') { assert_text_parsed_as('-1t', '-1t') }
-      test('.1t') { assert_text_parsed_as('.1t', '.1t') }
-      test(',1t') { assert_text_parsed_as(',1t', ',1t') }
-      test('.t') { assert_text_parsed_as('.t', '.t') }
-      test('*t') { assert_text_parsed_as('*t', '*t') }
-      test('@t') { assert_text_parsed_as('@t', '@t') }
-      test('{t') { assert_parse_error('{t') }  # '{' begins map
-      test('t{') { assert_text_parsed_as('t{', 't{') }
-      test('}t') { assert_text_parsed_as('}t', '}t') }
-      test('[t') { assert_parse_error('[t') }  # '[' begins array
-      test('t[') { assert_text_parsed_as('t[', 't[') }
-      test(']t') { assert_text_parsed_as(']t', ']t') }
-      test('t:') { assert_text_parsed_as('t:', 't:') }
-      test('t;') { assert_text_parsed_as('t;', 't;') }
-      test('t?') { assert_text_parsed_as('t?', 't?') }
-      test('t^') { assert_text_parsed_as('t^', 't^') }
-      test('t`') { assert_text_parsed_as('t`', 't`') }
-      test('t~') { assert_text_parsed_as('t~', 't~') }
-      test('t|') { assert_text_parsed_as('t|', 't|') }
-      test('t>') { assert_text_parsed_as('t>', 't>') }
-      test('t<') { assert_text_parsed_as('t<', 't<') }
-      test('t(') { assert_text_parsed_as('t(', 't(') }
-    end
-
-    sub_test_case 'embedded ruby code parsing' do
-      test('"#{v1}"') { assert_text_parsed_as("#{v1}", '"#{v1}"') }
-      test('"#{v2}"') { assert_text_parsed_as("#{v2}", '"#{v2}"') }
-      test('"#{v3}"') { assert_text_parsed_as("#{v3}", '"#{v3}"') }
-      test('"#{1+1}"') { assert_text_parsed_as("2", '"#{1+1}"') }
-      test('"#{}"') { assert_text_parsed_as("", '"#{}"') }
-      test('"t#{v1}"') { assert_text_parsed_as("t#{v1}", '"t#{v1}"') }
-      test('"t#{v1}t"') { assert_text_parsed_as("t#{v1}t", '"t#{v1}t"') }
-      test('"#{"}"}"') { assert_text_parsed_as("}", '"#{"}"}"') }
-      test('"#{#}"') { assert_parse_error('"#{#}"') }  # error in embedded ruby code
-      test("\"\#{\n=begin\n}\"") { assert_parse_error("\"\#{\n=begin\n}\"") }  # error in embedded ruby code
-      test('"#{v1}foo#{v2}"') { assert_text_parsed_as("#{v1}foo#{v2}", '"#{v1}foo#{v2}"') }
-      test('"#{1+1}foo#{2+2}bar"') { assert_text_parsed_as("#{1+1}foo#{2+2}bar", '"#{1+1}foo#{2+2}bar"') }
-      test('"foo#{hostname}"') { assert_text_parsed_as("foo#{Socket.gethostname}", '"foo#{hostname}"') }
-      test('"foo#{worker_id}"') {
-        ENV.delete('SERVERENGINE_WORKER_ID')
-        assert_text_parsed_as("foo", '"foo#{worker_id}"')
-        ENV['SERVERENGINE_WORKER_ID'] = '1'
-        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
-      test('[]') { assert_text_parsed_as_json([], '[]') }
-      test('[1]') { assert_text_parsed_as_json([1], '[1]') }
-      test('[1,2]') { assert_text_parsed_as_json([1,2], '[1,2]') }
-      test('[1, 2]') { assert_text_parsed_as_json([1,2], '[1, 2]') }
-      test('[ 1 , 2 ]') { assert_text_parsed_as_json([1,2], '[ 1 , 2 ]') }
-      test('[1,2,]') { assert_parse_error('[1,2,]') } # TODO: Need trailing commas support?
-      test("[\n1\n,\n2\n]") { assert_text_parsed_as_json([1,2], "[\n1\n,\n2\n]") }
-      test('["a"]') { assert_text_parsed_as_json(["a"], '["a"]') }
-      test('["a","b"]') { assert_text_parsed_as_json(["a","b"], '["a","b"]') }
-      test('[ "a" , "b" ]') { assert_text_parsed_as_json(["a","b"], '[ "a" , "b" ]') }
-      test("[\n\"a\"\n,\n\"b\"\n]") { assert_text_parsed_as_json(["a","b"], "[\n\"a\"\n,\n\"b\"\n]") }
-      test('["ab","cd"]') { assert_text_parsed_as_json(["ab","cd"], '["ab","cd"]') }
-      json_array_with_js_comment = <<EOA
-[
- "a", // this is a
- "b", // this is b
- "c"  // this is c
-]
-EOA
-      test(json_array_with_js_comment) { assert_text_parsed_as_json(["a","b","c"], json_array_with_js_comment) }
-      json_array_with_comment = <<EOA
-[
- "a", # this is a
- "b", # this is b
- "c"  # this is c
-]
-EOA
-      test(json_array_with_comment) { assert_text_parsed_as_json(["a","b","c"], json_array_with_comment) }
-      json_array_with_tailing_comma = <<EOA
-[
- "a", # this is a
- "b", # this is b
- "c", # this is c
-]
-EOA
-      test(json_array_with_tailing_comma) { assert_parse_error(json_array_with_tailing_comma) }
-    end
-
-    sub_test_case 'map parsing' do
-      test('{}') { assert_text_parsed_as_json({}, '{}') }
-      test('{"a":1}') { assert_text_parsed_as_json({"a"=>1}, '{"a":1}') }
-      test('{"a":1,"b":2}') { assert_text_parsed_as_json({"a"=>1,"b"=>2}, '{"a":1,"b":2}') }
-      test('{ "a" : 1 , "b" : 2 }') { assert_text_parsed_as_json({"a"=>1,"b"=>2}, '{ "a" : 1 , "b" : 2 }') }
-      test('{"a":1,"b":2,}') { assert_parse_error('{"a":1,"b":2,}') } # TODO: Need trailing commas support?
-      test('{\n\"a\"\n:\n1\n,\n\"b\"\n:\n2\n}') { assert_text_parsed_as_json({"a"=>1,"b"=>2}, "{\n\"a\"\n:\n1\n,\n\"b\"\n:\n2\n}") }
-      test('{"a":"b"}') { assert_text_parsed_as_json({"a"=>"b"}, '{"a":"b"}') }
-      test('{"a":"b","c":"d"}') { assert_text_parsed_as_json({"a"=>"b","c"=>"d"}, '{"a":"b","c":"d"}') }
-      test('{ "a" : "b" , "c" : "d" }') { assert_text_parsed_as_json({"a"=>"b","c"=>"d"}, '{ "a" : "b" , "c" : "d" }') }
-      test('{\n\"a\"\n:\n\"b\"\n,\n\"c\"\n:\n\"d\"\n}') { assert_text_parsed_as_json({"a"=>"b","c"=>"d"}, "{\n\"a\"\n:\n\"b\"\n,\n\"c\"\n:\n\"d\"\n}") }
-      json_hash_with_comment = <<EOH
-{
- "a": 1, # this is a
- "b": 2, # this is b
- "c": 3  # this is c
-}
-EOH
-      test(json_hash_with_comment) { assert_text_parsed_as_json({"a"=>1,"b"=>2,"c"=>3}, json_hash_with_comment) }
-    end
-  end
-end

data/test/config/test_plugin_configuration.rb

@@ -1,56 +0,0 @@
-require_relative '../helper'
-require 'fluent/plugin/input'
-require 'fluent/test/driver/input'
-
-module ConfigurationForPlugins
-  class AllBooleanParams < Fluent::Plugin::Input
-    config_param :flag1, :bool, default: true
-    config_param :flag2, :bool, default: true
-    config_param :flag3, :bool, default: false
-    config_param :flag4, :bool, default: false
-
-    config_section :child, param_name: :children, multi: true, required: true do
-      config_param :flag1, :bool, default: true
-      config_param :flag2, :bool, default: true
-      config_param :flag3, :bool, default: false
-      config_param :flag4, :bool, default: false
-    end
-  end
-
-  class BooleanParamsWithoutValue < ::Test::Unit::TestCase
-    CONFIG = <<CONFIG
-    flag1 
-    flag2 # yaaaaaaaaaay
-    flag3 
-    flag4 # yaaaaaaaaaay
-    <child>
-      flag1
-      flag2 # yaaaaaaaaaay
-      flag3
-      flag4 # yaaaaaaaaaay
-    </child>
-    <child>
-      flag1 # yaaaaaaaaaay
-      flag2
-      flag3 # yaaaaaaaaaay
-      flag4
-    </child>
-    # with following whitespace
-    <child>
-      flag1 
-      flag2 
-      flag3 
-      flag4 
-    </child>
-CONFIG
-
-    test 'create plugin via driver' do
-      d = Fluent::Test::Driver::Input.new(AllBooleanParams)
-      d.configure(CONFIG)
-      assert_equal([true] * 4, [d.instance.flag1, d.instance.flag2, d.instance.flag3, d.instance.flag4])
-      num_of_sections = 3
-      assert_equal num_of_sections, d.instance.children.size
-      assert_equal([true] * (num_of_sections * 4), d.instance.children.map{|c| [c.flag1, c.flag2, c.flag3, c.flag4]}.flatten)
-    end
-  end
-end

data/test/config/test_section.rb

@@ -1,191 +0,0 @@
-require_relative '../helper'
-require 'fluent/config/section'
-require 'pp'
-
-module Fluent::Config
-  class TestSection < ::Test::Unit::TestCase
-    sub_test_case Fluent::Config::Section do
-      sub_test_case 'class' do
-        sub_test_case '.name' do
-          test 'returns its full module name as String' do
-            assert_equal('Fluent::Config::Section', Fluent::Config::Section.name)
-          end
-        end
-      end
-
-      sub_test_case 'instance object' do
-        sub_test_case '#initialize' do
-          test 'creates blank object without argument' do
-            s = Fluent::Config::Section.new
-            assert_equal({}, s.instance_eval{ @params })
-          end
-
-          test 'creates object which contains specified hash object itself' do
-            hash = {
-              name: 'tagomoris',
-              age: 34,
-              send: 'email',
-              klass: 'normal',
-              keys: 5,
-            }
-            s1 = Fluent::Config::Section.new(hash)
-            assert_equal(hash, s1.instance_eval { @params })
-            assert_equal("tagomoris", s1[:name])
-            assert_equal(34, s1[:age])
-            assert_equal("email", s1[:send])
-            assert_equal("normal", s1[:klass])
-            assert_equal(5, s1[:keys])
-
-            assert_equal("tagomoris", s1.name)
-            assert_equal(34, s1.age)
-            assert_equal("email", s1.send)
-            assert_equal("normal", s1.klass)
-            assert_equal(5, s1.keys)
-          end
-
-          test 'creates object which contains specified hash object itself, including fields with at prefix' do
-            hash = {
-              name: 'tagomoris',
-              age: 34,
-              send: 'email',
-              klass: 'normal',
-              keys: 5,
-            }
-            hash['@id'.to_sym] = 'myid'
-
-            s1 = Fluent::Config::Section.new(hash)
-            assert_equal('myid', s1['@id'])
-            assert_equal('myid', s1['@id'.to_sym])
-            assert_equal('myid', s1.__send__('@id'.to_sym))
-          end
-
-          test 'creates object and config element which corresponds to section object itself' do
-            hash = {
-              name: 'tagomoris',
-              age: 34,
-              send: 'email',
-              klass: 'normal',
-              keys: 5,
-            }
-            hash['@id'.to_sym] = 'myid'
-            conf = config_element('section', '', {'name' => 'tagomoris', 'age' => 34, 'send' => 'email', 'klass' => 'normal', 'keys' => 5})
-            s2 = Fluent::Config::Section.new(hash, conf)
-            assert s2.corresponding_config_element.is_a?(Fluent::Config::Element)
-          end
-        end
-
-        sub_test_case '#class' do
-          test 'returns class constant' do
-            assert_equal Fluent::Config::Section, Fluent::Config::Section.new({}).class
-          end
-        end
-
-        sub_test_case '#object_id' do
-          test 'returns its object id' do
-            s1 = Fluent::Config::Section.new({})
-            assert s1.object_id
-            s2 = Fluent::Config::Section.new({})
-            assert s2.object_id
-            assert_not_equal s1.object_id, s2.object_id
-          end
-        end
-
-        sub_test_case '#to_h' do
-          test 'returns internal hash itself' do
-            hash = {
-              name: 'tagomoris',
-              age: 34,
-              send: 'email',
-              klass: 'normal',
-              keys: 5,
-            }
-            s = Fluent::Config::Section.new(hash)
-            assert_equal(hash, s.to_h)
-            assert_instance_of(Hash, s.to_h)
-          end
-        end
-
-        sub_test_case '#instance_of?' do
-          test 'can judge whether it is a Section object or not' do
-            s = Fluent::Config::Section.new
-            assert_true(s.instance_of?(Fluent::Config::Section))
-            assert_false(s.instance_of?(BasicObject))
-          end
-        end
-
-        sub_test_case '#is_a?' do
-          test 'can judge whether it belongs to or not' do
-            s = Fluent::Config::Section.new
-            assert_true(s.is_a?(Fluent::Config::Section))
-            assert_true(s.kind_of?(Fluent::Config::Section))
-            assert_true(s.is_a?(BasicObject))
-          end
-        end
-
-        sub_test_case '#+' do
-          test 'can merge 2 sections: argument side is primary, internal hash is newly created' do
-            h1 = {name: "s1", num: 10, klass: "A"}
-            s1 = Fluent::Config::Section.new(h1)
-
-            h2 = {name: "s2", klass: "A", num2: "5", num3: "8"}
-            s2 = Fluent::Config::Section.new(h2)
-            s = s1 + s2
-
-            assert_not_equal(h1.object_id, s.to_h.object_id)
-            assert_not_equal(h2.object_id, s.to_h.object_id)
-
-            assert_equal("s2", s.name)
-            assert_equal(10, s.num)
-            assert_equal("A", s.klass)
-            assert_equal("5", s.num2)
-            assert_equal("8", s.num3)
-          end
-        end
-
-        sub_test_case '#to_s' do
-          test '#to_s == #inspect' do
-            h1 = {name: "s1", num: 10, klass: "A"}
-            s1 = Fluent::Config::Section.new(h1)
-
-            assert_equal(s1.to_s, s1.inspect)
-          end
-        end
-
-        data("inspect" => [:inspect, true],
-             "nil?" => [:nil?, true],
-             "to_h" => [:to_h, true],
-             "+" =>   [:+, true],
-             "instance_of?" => [:instance_of?, true],
-             "kind_of?" => [:kind_of?, true],
-             "[]" => [:[], true],
-             "respond_to?" => [:respond_to?, true],
-             "respond_to_missing?" => [:respond_to_missing?, true],
-             "!" => [:!, true],
-             "!=" => [:!=, true],
-             "==" => [:==, true],
-             "equal?" => [:equal?, true],
-             "instance_eval" => [:instance_eval, true],
-             "instance_exec" => [:instance_exec, true],
-             "method_missing" => [:method_missing, false],
-             "singleton_method_added" => [:singleton_method_added, false],
-             "singleton_method_removed" => [:singleton_method_removed, false],
-             "singleton_method_undefined" => [:singleton_method_undefined, false],
-             "no_such_method" => [:no_such_method, false])
-        test '#respond_to?' do |data|
-          method, expected = data
-          h1 = {name: "s1", num: 10, klass: "A"}
-          s1 = Fluent::Config::Section.new(h1)
-          assert_equal(expected, s1.respond_to?(method))
-        end
-
-        test '#pretty_print' do
-          q = PP.new
-          h1 = {name: "s1", klass: "A"}
-          s1 = Fluent::Config::Section.new(h1)
-          s1.pretty_print(q)
-          assert_equal s1.inspect, q.output
-        end
-      end
-    end
-  end
-end