fluentd 0.12.0.pre.1 → 0.12.0.pre.2

data/lib/fluent/plugin/buf_zfile.rb

@@ -1,75 +0,0 @@
-#
-# Fluentd
-#
-#    Licensed under the Apache License, Version 2.0 (the "License");
-#    you may not use this file except in compliance with the License.
-#    You may obtain a copy of the License at
-#
-#        http://www.apache.org/licenses/LICENSE-2.0
-#
-#    Unless required by applicable law or agreed to in writing, software
-#    distributed under the License is distributed on an "AS IS" BASIS,
-#    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-#    See the License for the specific language governing permissions and
-#    limitations under the License.
-#
-
-module Fluent
-  class ZFileBufferChunk < FileBufferChunk
-    def initialize(path)
-      super(path)
-      @z = Zlib::Deflate.new
-    end
-
-    def <<(data)
-      zdata = @z.deflate(data, Z_NO_FLUSH)
-      unless zdata.empty?
-        super(zdata)
-      end
-    end
-
-    def close_write
-      zdata = @z.flush
-      unless zdata.empty?
-        @file.write(zdata)
-        @size += zdata.bytesize
-      end
-      super
-    end
-
-    def close
-      @z.close
-      super
-    end
-
-    def purge
-      @z.close
-      super
-    end
-
-    #def open(&block)
-    #end
-  end
-
-  class ZFileBuffer < FileBuffer
-    #Plugin.register_buffer('zfile', self)
-
-    def initialize
-      require 'zlib'
-      super
-    end
-
-    def resume_queue
-      queue = resume_queue_paths.map {|path|
-        ZFileBufferChunk.new(path)
-      }
-      top = new_chunk
-      return queue, top
-    end
-
-    def new_chunk
-      path = new_chunk_path
-      ZFileBufferChunk.new(path)
-    end
-  end
-end

data/spec/config/config_parser_spec.rb

@@ -1,314 +0,0 @@
-require "json"
-require "config/helper"
-require "fluent/config/error"
-require "fluent/config/basic_parser"
-require "fluent/config/literal_parser"
-require "fluent/config/v1_parser"
-
-describe Fluent::Config::V1Parser do
-  include_context 'config_helper'
-
-  def read_config(path)
-    path = File.expand_path(path)
-    data = File.read(path)
-    Fluent::Config::V1Parser.parse(data, File.basename(path), File.dirname(path))
-  end
-
-  def parse_text(text)
-    basepath = File.expand_path(File.dirname(__FILE__) + '/../../')
-    Fluent::Config::V1Parser.parse(text, '(test)', basepath, nil)
-  end
-
-  def root(*elements)
-    if elements.first.is_a?(Fluent::Config::Element)
-      attrs = {}
-    else
-      attrs = elements.shift || {}
-    end
-    Fluent::Config::Element.new('ROOT', '', attrs, elements)
-  end
-
-  def e(name, arg='', attrs={}, elements=[])
-    Fluent::Config::Element.new(name, arg, attrs, elements)
-  end
-
-  describe 'attribute parsing' do
-    it "parses attributes" do
-      expect(%[
-        k1 v1
-        k2 v2
-      ]).to be_parsed_as(e('ROOT', '', {"k1"=>"v1", "k2"=>"v2"}))
-    end
-
-    it "allows attribute without value" do
-      expect(%[
-        k1
-        k2 v2
-      ]).to be_parsed_as(e('ROOT', '', {"k1"=>"", "k2"=>"v2"}))
-    end
-
-    it "parses attribute key always string" do
-      expect("1 1").to be_parsed_as(e('ROOT', '', {"1" => "1"}))
-    end
-
-    [
-      "_.%$!,",
-      "/=~-~@\`:?",
-      "()*{}.[]",
-    ].each do |v|
-      it "parses a value with symbol #{v.inspect}" do
-        expect("k #{v}").to be_parsed_as(e('ROOT', '', {"k" => v}))
-      end
-    end
-
-    it "ignores spacing around value" do
-      expect("  k1     a    ").to be_parsed_as(e('ROOT', '', {"k1" => "a"}))
-    end
-
-    it "allows spaces in value" do
-      expect("k1 a  b  c").to be_parsed_as(e('ROOT', '', {"k1" => "a  b  c"}))
-    end
-
-    it "ignores comments after value" do
-      expect("  k1 a#comment").to be_parsed_as(e('ROOT', '', {"k1" => "a"}))
-    end
-
-    it "allows # in value if quoted" do
-      expect('  k1 "a#comment"').to be_parsed_as(e('ROOT', '', {"k1" => "a#comment"}))
-    end
-
-    it "rejects characters after quoted string" do
-      expect('  k1 "a" 1').to be_parse_error
-    end
-
-    it "rejects @ prefix in parameter name" do
-      expect('  @k v').to be_parse_error
-    end
-  end
-
-  describe 'element parsing' do
-    it do
-      expect("").to be_parsed_as(root)
-    end
-
-    it "accepts empty element" do
-      expect(%[
-        <test>
-        </test>
-      ]).to be_parsed_as(
-        root(
-          e("test")
-        )
-      )
-    end
-
-    it "accepts argument and attributes" do
-      expect(%[
-        <test var>
-          key val
-        </test>
-      ]).to be_parsed_as(root(
-          e("test", 'var', {'key'=>"val"})
-        ))
-    end
-
-    it "accepts nested elements" do
-      expect(%[
-        <test var>
-          key 1
-          <nested1>
-          </nested1>
-          <nested2>
-          </nested2>
-        </test>
-      ]).to be_parsed_as(root(
-          e("test", 'var', {'key'=>'1'}, [
-            e('nested1'),
-            e('nested2')
-          ])
-        ))
-    end
-
-    it "accepts multiline json values" do
-      expect(%[
-        <test var>
-          key ["a",
-"b", "c",
-"d"]
-        </test>
-      ]).to be_parsed_as(root(
-          e("test", 'var', {'key'=>"[\"a\",\"b\",\"c\",\"d\"]"})
-      ))
-    end
-
-    [
-      "**",
-      "*.*",
-      "1",
-      "_.%$!",
-      "/",
-      "()*{}.[]",
-    ].each do |arg|
-      it "parses element argument #{arg.inspect}" do
-        expect(%[
-          <test #{arg}>
-          </test>
-        ]).to be_parsed_as(root(
-            e("test", arg)
-          ))
-      end
-    end
-
-    it "parses empty element argument to nil" do
-      expect(%[
-        <test >
-        </test>
-      ]).to be_parsed_as(root(
-          e("test", '')
-        ))
-    end
-
-    it "ignores spacing around element argument" do
-      expect(%[
-        <test    a    >
-        </test>
-      ]).to be_parsed_as(root(
-          e("test", "a")
-        ))
-    end
-
-    it "considers comments in element argument" do
-      expect(%[
-        <test #a>
-        </test>
-      ]).to be_parse_error
-    end
-
-    it "requires line_end after begin tag" do
-      expect(%[
-        <test></test>
-      ]).to be_parse_error
-    end
-
-    it "requires line_end after end tag" do
-      expect(%[
-        <test>
-        </test><test>
-        </test>
-      ]).to be_parse_error
-    end
-  end
-
-  # port from test_config.rb
-  describe '@include parsing' do
-    TMP_DIR = File.dirname(__FILE__) + "/tmp/v1_config#{ENV['TEST_ENV_NUMBER']}"
-
-    def write_config(path, data)
-      FileUtils.mkdir_p(File.dirname(path))
-      File.open(path, "w") { |f| f.write data }
-    end
-
-    def prepare_config
-      write_config "#{TMP_DIR}/config_test_1.conf", %[
-        k1 root_config
-        include dir/config_test_2.conf  #
-        @include #{TMP_DIR}/config_test_4.conf
-        include file://#{TMP_DIR}/config_test_5.conf
-        @include config.d/*.conf
-      ]
-      write_config "#{TMP_DIR}/dir/config_test_2.conf", %[
-        k2 relative_path_include
-        @include ../config_test_3.conf
-      ]
-      write_config "#{TMP_DIR}/config_test_3.conf", %[
-        k3 relative_include_in_included_file
-      ]
-      write_config "#{TMP_DIR}/config_test_4.conf", %[
-        k4 absolute_path_include
-      ]
-      write_config "#{TMP_DIR}/config_test_5.conf", %[
-        k5 uri_include
-      ]
-      write_config "#{TMP_DIR}/config.d/config_test_6.conf", %[
-        k6 wildcard_include_1
-        <elem1 name>
-          include normal_parameter
-        </elem1>
-      ]
-      write_config "#{TMP_DIR}/config.d/config_test_7.conf", %[
-        k7 wildcard_include_2
-      ]
-      write_config "#{TMP_DIR}/config.d/config_test_8.conf", %[
-        <elem2 name>
-          @include ../dir/config_test_9.conf
-        </elem2>
-      ]
-      write_config "#{TMP_DIR}/dir/config_test_9.conf", %[
-        k9 embeded
-        <elem3 name>
-          nested nested_value
-          include hoge
-        </elem3>
-      ]
-      write_config "#{TMP_DIR}/config.d/00_config_test_8.conf", %[
-        k8 wildcard_include_3
-        <elem4 name>
-          include normal_parameter
-        </elem4>
-      ]
-    end
-
-    it 'parses @include / include correctly' do
-      prepare_config
-      c = read_config("#{TMP_DIR}/config_test_1.conf")
-      expect(c['k1']).to eq('root_config')
-      expect(c['k2']).to eq('relative_path_include')
-      expect(c['k3']).to eq('relative_include_in_included_file')
-      expect(c['k4']).to eq('absolute_path_include')
-      expect(c['k5']).to eq('uri_include')
-      expect(c['k6']).to eq('wildcard_include_1')
-      expect(c['k7']).to eq('wildcard_include_2')
-      expect(c['k8']).to eq('wildcard_include_3')
-      expect(c.keys).to eq([
-        'k1',
-        'k2',
-        'k3',
-        'k4',
-        'k5',
-        'k8', # Because of the file name this comes first.
-        'k6',
-        'k7',
-      ])
-
-      elem1 = c.elements.find { |e| e.name == 'elem1' }
-      expect(elem1).to be
-      expect(elem1.arg).to eq('name')
-      expect(elem1['include']).to eq('normal_parameter')
-
-      elem2 = c.elements.find { |e| e.name == 'elem2' }
-      expect(elem2).to be
-      expect(elem2.arg).to eq('name')
-      expect(elem2['k9']).to eq('embeded')
-      expect(elem2.has_key?('include')).to be(false)
-
-      elem3 = elem2.elements.find { |e| e.name == 'elem3' }
-      expect(elem3).to be
-      expect(elem3['nested']).to eq('nested_value')
-      expect(elem3['include']).to eq('hoge')
-    end
-
-    # TODO: Add uri based include spec
-  end
-
-  describe 'unescape parameter' do
-    it 'parses dumpped configuration' do
-      original = %q!a\\\\\n\r\f\b\\'\\"z!
-      expected = %!a\\\n\r\f\b'"z!
-
-      conf = parse_text(%[k1 #{original}])
-      expect(conf['k1']).to eq(expected) # escape check
-      conf2 = parse_text(conf.to_s) # use dumpped configuration to check unescape
-      expect(conf2.elements.first['k1']).to eq(expected)
-    end
-  end
-end

data/spec/config/configurable_spec.rb

@@ -1,524 +0,0 @@
-require 'fluent/configurable'
-require 'fluent/config/element'
-require 'fluent/config/section'
-
-module ConfigurableSpec
-  class Base1
-    include Fluent::Configurable
-
-    config_param :node, :string, :default => "node"
-    config_param :flag1, :bool, :default => false
-    config_param :flag2, :bool, :default => true
-
-    config_param :name1, :string
-    config_param :name2, :string
-    config_param :name3, :string, :default => "base1"
-    config_param :name4, :string, :default => "base1"
-
-    def get_all
-      [@node, @flag1, @flag2, @name1, @name2, @name3, @name4]
-    end
-  end
-
-  class Base2 < Base1
-    config_set_default :name2, "base2"
-    config_set_default :name4, "base2"
-    config_param :name5, :string
-    config_param :name6, :string, :default => "base2"
-
-    def get_all
-      ary = super
-      ary + [@name5, @name6]
-    end
-  end
-
-  class Base3 < Base2
-    config_section :node do
-      config_param :name, :string, :default => "node"
-      config_param :type, :string
-    end
-    config_section :branch, required: true, multi: true do
-      config_argument :name, :string
-      config_param :size, :integer, default: 10
-      config_section :leaf, required: false, multi: true do
-        config_param :weight, :integer
-        config_section :worm, param_name: 'worms', multi: true do
-          config_param :type, :string, default: 'ladybird'
-        end
-      end
-    end
-
-    def get_all
-      ary = super
-      ary + [@branch]
-    end
-  end
-
-  class Base4 < Base2
-    config_section :node, param_name: :nodes do
-      config_argument :num, :integer
-      config_param :name, :string, :default => "node"
-      config_param :type, :string, :default => "b4"
-    end
-    config_section :description1, required: false, multi: false do
-      config_argument :note, :string, default: "desc1"
-      config_param :text, :string
-    end
-    config_section :description2, required: true, multi: false do
-      config_argument :note, :string, default: "desc2"
-      config_param :text, :string
-    end
-    config_section :description3, required: true, multi: true do
-      config_argument :note, default: "desc3" do |val|
-        "desc3: #{val}"
-      end
-      config_param :text, :string
-    end
-
-    def get_all
-      ary = super
-      ary + [@nodes, @description1, @description2, @description3]
-    end
-  end
-
-  class Example0
-    include Fluent::Configurable
-
-    config_param :stringvalue, :string
-    config_param :boolvalue, :bool
-    config_param :integervalue, :integer
-    config_param :sizevalue, :size
-    config_param :timevalue, :time
-    config_param :floatvalue, :float
-    config_param :hashvalue, :hash
-    config_param :arrayvalue, :array
-  end
-
-  class Example1
-    include Fluent::Configurable
-
-    config_param :name, :string, alias: :fullname
-    config_param :bool, :bool, alias: :flag
-    config_section :detail, required: true, multi: false, alias: "information" do
-      config_param :address, :string
-    end
-
-    def get_all
-      [@name, @detail]
-    end
-  end
-end
-
-describe Fluent::Configurable do
-  context 'class defined without config_section' do
-    describe '#initialize' do
-      it 'create instance methods and default values by config_param and config_set_default' do
-        obj1 = ConfigurableSpec::Base1.new
-        expect(obj1.node).to eql("node")
-        expect(obj1.flag1).to eq(false)
-        expect(obj1.flag2).to eq(true)
-        expect(obj1.name1).to be_nil
-        expect(obj1.name2).to be_nil
-        expect(obj1.name3).to eql("base1")
-        expect(obj1.name4).to eql("base1")
-      end
-
-      it 'create instance methods and default values overwritten by sub class definition' do
-        obj2 = ConfigurableSpec::Base2.new
-        expect(obj2.node).to eql("node")
-        expect(obj2.flag1).to eq(false)
-        expect(obj2.flag2).to eq(true)
-        expect(obj2.name1).to be_nil
-        expect(obj2.name2).to eql("base2")
-        expect(obj2.name3).to eql("base1")
-        expect(obj2.name4).to eql("base2")
-        expect(obj2.name5).to be_nil
-        expect(obj2.name6).to eql("base2")
-      end
-    end
-
-    describe '#configure' do
-      it 'returns configurable object itself' do
-        b2 = ConfigurableSpec::Base2.new
-        expect(b2.configure({"name1" => "t1", "name5" => "t5"})).to be_a(ConfigurableSpec::Base2)
-      end
-
-      it 'raise errors without any specifications for param without defaults' do
-        b2 = ConfigurableSpec::Base2.new
-        expect{ b2.configure({}) }.to raise_error(Fluent::ConfigError)
-        expect{ b2.configure({"name1" => "t1"}) }.to raise_error(Fluent::ConfigError)
-        expect{ b2.configure({"name5" => "t5"}) }.to raise_error(Fluent::ConfigError)
-        expect{ b2.configure({"name1" => "t1", "name5" => "t5"}) }.not_to raise_error()
-
-        expect(b2.get_all).to eql(["node", false, true, "t1", "base2", "base1", "base2", "t5", "base2"])
-      end
-
-      it 'can configure bool values' do
-        b2a = ConfigurableSpec::Base2.new
-        expect{ b2a.configure({"flag1" => "true", "flag2" => "yes", "name1" => "t1", "name5" => "t5"}) }.not_to raise_error()
-        expect(b2a.flag1).to eq(true)
-        expect(b2a.flag2).to eq(true)
-
-        b2b = ConfigurableSpec::Base2.new
-        expect{ b2b.configure({"flag1" => false, "flag2" => "no", "name1" => "t1", "name5" => "t5"}) }.not_to raise_error()
-        expect(b2b.flag1).to eq(false)
-        expect(b2b.flag2).to eq(false)
-      end
-
-      it 'overwrites values of defaults' do
-        b2 = ConfigurableSpec::Base2.new
-        b2.configure({"name1" => "t1", "name2" => "t2", "name3" => "t3", "name4" => "t4", "name5" => "t5"})
-        expect(b2.name1).to eql("t1")
-        expect(b2.name2).to eql("t2")
-        expect(b2.name3).to eql("t3")
-        expect(b2.name4).to eql("t4")
-        expect(b2.name5).to eql("t5")
-        expect(b2.name6).to eql("base2")
-
-        expect(b2.get_all).to eql(["node", false, true, "t1", "t2", "t3", "t4", "t5", "base2"])
-      end
-    end
-  end
-
-  context 'class defined with config_section' do
-    describe '#initialize' do
-      it 'create instance methods and default values as nil for params from config_section specified as non-multi' do
-        b4 = ConfigurableSpec::Base4.new
-        expect(b4.description1).to be_nil
-        expect(b4.description2).to be_nil
-      end
-
-      it 'create instance methods and default values as [] for params from config_section specified as multi' do
-        b4 = ConfigurableSpec::Base4.new
-        expect(b4.description3).to eql([])
-      end
-
-      it 'overwrite base class definition by config_section of sub class definition' do
-        b3 = ConfigurableSpec::Base3.new
-        expect(b3.node).to eql([])
-      end
-
-      it 'create instance methods and default values by param_name' do
-        b4 = ConfigurableSpec::Base4.new
-        expect(b4.nodes).to eql([])
-        expect(b4.node).to eql("node")
-      end
-
-      it 'create non-required and multi without any specifications' do
-        b3 = ConfigurableSpec::Base3.new
-        expect(b3.class.merged_configure_proxy.sections[:node].required?).to be false
-        expect(b3.class.merged_configure_proxy.sections[:node].multi?).to be true
-      end
-    end
-
-    describe '#configure' do
-      def e(name, arg = '', attrs = {}, elements = [])
-        attrs_str_keys = {}
-        attrs.each{|key, value| attrs_str_keys[key.to_s] = value }
-        Fluent::Config::Element.new(name, arg, attrs_str_keys, elements)
-      end
-
-      BASE_ATTRS = {
-        "name1" => "1", "name2" => "2", "name3" => "3",
-        "name4" => "4", "name5" => "5", "name6" => "6",
-      }
-      it 'checks required subsections' do
-        b3 = ConfigurableSpec::Base3.new
-        # branch sections required
-        expect{ b3.configure(e('ROOT', '', BASE_ATTRS, [])) }.to raise_error(Fluent::ConfigError)
-
-        # branch argument required
-        msg = "'<branch ARG>' section requires argument, in section branch"
-        expect{ b3.configure(e('ROOT', '', BASE_ATTRS, [e('branch', '')])) }.to raise_error(Fluent::ConfigError, msg)
-
-        # leaf is not required
-        expect{ b3.configure(e('ROOT', '', BASE_ATTRS, [e('branch', 'branch_name')])) }.not_to raise_error()
-
-        # leaf weight required
-        msg = "'weight' parameter is required, in section branch > leaf"
-        branch1 = e('branch', 'branch_name', {size: 1}, [e('leaf', '10', {weight: 1})])
-        expect{ b3.configure(e('ROOT', '', BASE_ATTRS, [branch1])) }.not_to raise_error()
-        branch2 = e('branch', 'branch_name', {size: 1}, [e('leaf', '20')])
-        expect{ b3.configure(e('ROOT', '', BASE_ATTRS, [branch1, branch2])) }.to raise_error(Fluent::ConfigError, msg)
-        branch3 = e('branch', 'branch_name', {size: 1}, [e('leaf', '10', {weight: 3}), e('leaf', '20')])
-        expect{ b3.configure(e('ROOT', '', BASE_ATTRS, [branch3])) }.to raise_error(Fluent::ConfigError, msg)
-
-        ### worm not required
-
-        b4 = ConfigurableSpec::Base4.new
-
-        d1 = e('description1', '', {text:"d1"})
-        d2 = e('description2', '', {text:"d2"})
-        d3 = e('description3', '', {text:"d3"})
-        expect{ b4.configure(e('ROOT', '', BASE_ATTRS, [d1.dup, d2.dup, d3.dup])) }.not_to raise_error()
-
-        # description1 cannot be specified 2 or more
-        msg = "'<description1>' section cannot be written twice or more"
-        expect{ b4.configure(e('ROOT', '', BASE_ATTRS, [d1.dup, d2.dup, d1.dup, d3.dup])) }.to raise_error(Fluent::ConfigError, msg)
-
-        # description2 cannot be specified 2 or more
-        msg = "'<description2>' section cannot be written twice or more"
-        expect{ b4.configure(e('ROOT', '', BASE_ATTRS, [d1.dup, d2.dup, d3.dup, d2.dup])) }.to raise_error(Fluent::ConfigError, msg)
-
-        # description3 can be specified 2 or more
-        expect{ b4.configure(e('ROOT', '', BASE_ATTRS, [d1.dup, d2.dup, d3.dup, d3.dup])) }.not_to raise_error()
-      end
-
-      it 'constructs confuguration object tree for Base3' do
-        conf = e(
-          'ROOT',
-          '',
-          BASE_ATTRS,
-          [
-            e('node', '', {type:"1"}), e('node', '', {name:"node2",type:"2"}),
-            e('branch', 'b1.*', {}, []),
-            e('branch',
-              'b2.*',
-              {size: 5},
-              [
-                e('leaf', 'THIS IS IGNORED', {weight: 55}, []),
-                e('leaf', 'THIS IS IGNORED', {weight: 50}, [ e('worm', '', {}) ]),
-                e('leaf', 'THIS IS IGNORED', {weight: 50}, [ e('worm', '', {type:"w1"}), e('worm', '', {type:"w2"}) ]),
-              ]
-            ),
-            e('branch',
-              'b3.*',
-              {size: "503"},
-              [
-                e('leaf', 'THIS IS IGNORED', {weight: 55}, []),
-              ]
-            )
-          ],
-        )
-        b3 = ConfigurableSpec::Base3.new.configure(conf)
-
-        expect(b3.node).not_to eql("node") # overwritten
-
-        expect(b3.name1).to eql("1")
-        expect(b3.name2).to eql("2")
-        expect(b3.name3).to eql("3")
-        expect(b3.name4).to eql("4")
-        expect(b3.name5).to eql("5")
-        expect(b3.name6).to eql("6")
-
-        expect(b3.node).to be_a(Array)
-        expect(b3.node.size).to eql(2)
-
-        expect(b3.node[0].name).to eql("node")
-        expect(b3.node[0].type).to eql("1")
-        expect(b3.node[0][:type]).to eq(b3.node[0].type)
-        expect(b3.node[1].name).to eql("node2")
-        expect(b3.node[1].type).to eql("2")
-        expect(b3.node[1][:type]).to eq(b3.node[1].type)
-
-        expect(b3.branch).to be_a(Array)
-        expect(b3.branch.size).to eql(3)
-
-        expect(b3.branch[0].name).to eql('b1.*')
-        expect(b3.branch[0].size).to eql(10)
-        expect(b3.branch[0].leaf).to eql([])
-
-        expect(b3.branch[1].name).to eql('b2.*')
-        expect(b3.branch[1].size).to eql(5)
-        expect(b3.branch[1].leaf.size).to eql(3)
-        expect(b3.branch[1][:leaf]).to eq(b3.branch[1].leaf)
-
-        expect(b3.branch[1].leaf[0].weight).to eql(55)
-        expect(b3.branch[1].leaf[0].worms.size).to eql(0)
-
-        expect(b3.branch[1].leaf[1].weight).to eql(50)
-        expect(b3.branch[1].leaf[1].worms.size).to eql(1)
-        expect(b3.branch[1].leaf[1].worms[0].type).to eql("ladybird")
-
-        expect(b3.branch[1].leaf[2].weight).to eql(50)
-        expect(b3.branch[1].leaf[2].worms.size).to eql(2)
-        expect(b3.branch[1].leaf[2].worms[0].type).to eql("w1")
-        expect(b3.branch[1].leaf[2].worms[1].type).to eql("w2")
-
-        expect(b3.branch[2].name).to eql('b3.*')
-        expect(b3.branch[2].size).to eql(503)
-        expect(b3.branch[2].leaf.size).to eql(1)
-        expect(b3.branch[2].leaf[0].weight).to eql(55)
-      end
-
-      it 'constructs confuguration object tree for Base4' do
-        conf = e(
-          'ROOT',
-          '',
-          BASE_ATTRS,
-          [
-            e('node', '1', {type:"1"}), e('node', '2', {name:"node2"}),
-            e('description3', '', {text:"dddd3-1"}),
-            e('description2', 'd-2', {text:"dddd2"}),
-            e('description1', '', {text:"dddd1"}),
-            e('description3', 'd-3', {text:"dddd3-2"}),
-            e('description3', 'd-3a', {text:"dddd3-3"}),
-            e('node', '4', {type:"four"}),
-          ],
-        )
-        b4 = ConfigurableSpec::Base4.new.configure(conf)
-
-        expect(b4.node).to eql("node")
-
-        expect(b4.name1).to eql("1")
-        expect(b4.name2).to eql("2")
-        expect(b4.name3).to eql("3")
-        expect(b4.name4).to eql("4")
-        expect(b4.name5).to eql("5")
-        expect(b4.name6).to eql("6")
-
-        expect(b4.nodes).to be_a(Array)
-        expect(b4.nodes.size).to eql(3)
-        expect(b4.nodes[0].num).to eql(1)
-        expect(b4.nodes[0].name).to eql("node")
-        expect(b4.nodes[0].type).to eql("1")
-        expect(b4.nodes[1].num).to eql(2)
-        expect(b4.nodes[1].name).to eql("node2")
-        expect(b4.nodes[1].type).to eql("b4")
-        expect(b4.nodes[2].num).to eql(4)
-        expect(b4.nodes[2].name).to eql("node")
-        expect(b4.nodes[2].type).to eql("four")
-
-            # e('description3', '', {text:"dddd3-1"}),
-            # e('description3', 'd-3', {text:"dddd3-2"}),
-            # e('description3', 'd-3a', {text:"dddd3-3"}),
-
-        expect(b4.description1).to be_a(Fluent::Config::Section)
-        expect(b4.description1.note).to eql("desc1")
-        expect(b4.description1.text).to eql("dddd1")
-
-        expect(b4.description2).to be_a(Fluent::Config::Section)
-        expect(b4.description2.note).to eql("d-2")
-        expect(b4.description2.text).to eql("dddd2")
-
-        expect(b4.description3).to be_a(Array)
-        expect(b4.description3.size).to eql(3)
-        expect(b4.description3[0].note).to eql('desc3')
-        expect(b4.description3[0].text).to eql('dddd3-1')
-        expect(b4.description3[1].note).to eql('desc3: d-3')
-        expect(b4.description3[1].text).to eql('dddd3-2')
-        expect(b4.description3[2].note).to eql('desc3: d-3a')
-        expect(b4.description3[2].text).to eql('dddd3-3')
-      end
-
-      it 'checks missing of specifications' do
-        conf0 = e('ROOT', '', {}, [])
-        ex01 = ConfigurableSpec::Example0.new
-        expect { ex01.configure(conf0) }.to raise_error(Fluent::ConfigError)
-
-        complete = {
-          "stringvalue" => "s1", "boolvalue" => "yes", "integervalue" => "10",
-          "sizevalue" => "10m", "timevalue" => "100s", "floatvalue" => "1.001",
-          "hashvalue" => '{"foo":1, "bar":2}',
-          "arrayvalue" => '[1,"ichi"]',
-        }
-
-        checker = lambda {|conf| ConfigurableSpec::Example0.new.configure(conf) }
-
-        expect { checker.call(complete) }.not_to raise_error()
-        expect { checker.call(complete.reject{|k,v| k == "stringvalue" }) }.to raise_error(Fluent::ConfigError)
-        expect { checker.call(complete.reject{|k,v| k == "boolvalue"   }) }.to raise_error(Fluent::ConfigError)
-        expect { checker.call(complete.reject{|k,v| k == "integervalue"}) }.to raise_error(Fluent::ConfigError)
-        expect { checker.call(complete.reject{|k,v| k == "sizevalue"   }) }.to raise_error(Fluent::ConfigError)
-        expect { checker.call(complete.reject{|k,v| k == "timevalue"   }) }.to raise_error(Fluent::ConfigError)
-        expect { checker.call(complete.reject{|k,v| k == "floatvalue"  }) }.to raise_error(Fluent::ConfigError)
-        expect { checker.call(complete.reject{|k,v| k == "hashvalue"   }) }.to raise_error(Fluent::ConfigError)
-        expect { checker.call(complete.reject{|k,v| k == "arrayvalue"  }) }.to raise_error(Fluent::ConfigError)
-      end
-
-      it 'accepts configuration values as string representation' do
-        conf = {
-          "stringvalue" => "s1", "boolvalue" => "yes", "integervalue" => "10",
-          "sizevalue" => "10m", "timevalue" => "10m", "floatvalue" => "1.001",
-          "hashvalue" => '{"foo":1, "bar":2}',
-          "arrayvalue" => '[1,"ichi"]',
-        }
-        ex = ConfigurableSpec::Example0.new.configure(conf)
-        expect(ex.stringvalue).to eq("s1")
-        expect(ex.boolvalue).to equal(true)
-        expect(ex.integervalue).to eq(10)
-        expect(ex.sizevalue).to eq(10 * 1024 * 1024)
-        expect(ex.timevalue).to eq(10 * 60)
-        expect(ex.floatvalue).to eq(1.001)
-        expect(ex.hashvalue).to eq({"foo" => 1, "bar" => 2})
-        expect(ex.arrayvalue).to eq([1, "ichi"])
-      end
-
-      it 'accepts configuration values as ruby value representation (especially for DSL)' do
-        conf = {
-          "stringvalue" => "s1", "boolvalue" => true, "integervalue" => 10,
-          "sizevalue" => 10 * 1024 * 1024, "timevalue" => 10 * 60, "floatvalue" => 1.001,
-          "hashvalue" => {"foo" => 1, "bar" => 2},
-          "arrayvalue" => [1,"ichi"],
-        }
-        ex = ConfigurableSpec::Example0.new.configure(conf)
-        expect(ex.stringvalue).to eq("s1")
-        expect(ex.boolvalue).to equal(true)
-        expect(ex.integervalue).to eq(10)
-        expect(ex.sizevalue).to eq(10 * 1024 * 1024)
-        expect(ex.timevalue).to eq(10 * 60)
-        expect(ex.floatvalue).to eq(1.001)
-        expect(ex.hashvalue).to eq({"foo" => 1, "bar" => 2})
-        expect(ex.arrayvalue).to eq([1, "ichi"])
-      end
-
-      it 'gets both of true(yes) and false(no) for bool value parameter' do
-        conf = {
-          "stringvalue" => "s1", "integervalue" => 10,
-          "sizevalue" => 10 * 1024 * 1024, "timevalue" => 10 * 60, "floatvalue" => 1.001,
-          "hashvalue" => {"foo" => 1, "bar" => 2},
-          "arrayvalue" => [1,"ichi"],
-        }
-        ex0 = ConfigurableSpec::Example0.new.configure(conf.merge({"boolvalue" => "true"}))
-        expect(ex0.boolvalue).to equal(true)
-
-        ex1 = ConfigurableSpec::Example0.new.configure(conf.merge({"boolvalue" => "yes"}))
-        expect(ex1.boolvalue).to equal(true)
-
-        ex2 = ConfigurableSpec::Example0.new.configure(conf.merge({"boolvalue" => true}))
-        expect(ex2.boolvalue).to equal(true)
-
-        ex3 = ConfigurableSpec::Example0.new.configure(conf.merge({"boolvalue" => "false"}))
-        expect(ex3.boolvalue).to equal(false)
-
-        ex4 = ConfigurableSpec::Example0.new.configure(conf.merge({"boolvalue" => "no"}))
-        expect(ex4.boolvalue).to equal(false)
-
-        ex5 = ConfigurableSpec::Example0.new.configure(conf.merge({"boolvalue" => false}))
-        expect(ex5.boolvalue).to equal(false)
-      end
-    end
-  end
-
-  context 'class defined with config_param/config_section having :alias' do
-    describe '#initialize' do
-      it 'does not create methods for alias' do
-        ex1 = ConfigurableSpec::Example1.new
-        expect { ex1.name }.not_to raise_error()
-        expect { ex1.fullname }.to raise_error(NoMethodError)
-        expect { ex1.bool }.not_to raise_error()
-        expect { ex1.flag }.to raise_error(NoMethodError)
-        expect { ex1.detail }.not_to raise_error()
-        expect { ex1.information}.to raise_error(NoMethodError)
-      end
-    end
-
-    describe '#configure' do
-      def e(name, arg = '', attrs = {}, elements = [])
-        attrs_str_keys = {}
-        attrs.each{|key, value| attrs_str_keys[key.to_s] = value }
-        Fluent::Config::Element.new(name, arg, attrs_str_keys, elements)
-      end
-
-      it 'provides accessible data for alias attribute keys' do
-        ex1 = ConfigurableSpec::Example1.new
-        ex1.configure(e('ROOT', '', {"fullname" => "foo bar", "bool" => false}, [e('information', '', {"address" => "Mountain View 0"})]))
-        expect(ex1.name).to eql("foo bar")
-        expect(ex1.bool).not_to be_nil
-        expect(ex1.bool).to be_falsy
-        expect(ex1.detail).not_to be_nil
-        expect(ex1.detail.address).to eql("Mountain View 0")
-      end
-    end
-  end
-end