fluentd 0.10.53 → 0.10.54

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b76b903de67ead21383835723d9b289f437de46e
-  data.tar.gz: b1b787a0cc37983a878136b9731d5ad83eea40cc
+  metadata.gz: a362e48a2716bb0892c742fd3e1a3ba78c943c80
+  data.tar.gz: 4bebdc013320b9e06be09fa93b52e83e95ee814f
 SHA512:
-  metadata.gz: 05b4ab5c735e1d6d01c059dde695faa7513180f1520b56f7078eedf9b1491fb00b9fd29aaec0f87f28784750a5c5aa210c5aaff2f5c9fe7740fad857c92b30ee
-  data.tar.gz: 075c930dd72a40427330313e11bf4e3fe5d4399ea91a44df072cbe6fb2605b584549b9075ae55234a999fd737ff805b24f0285969574cca485f360a9b9b6ffa8
+  metadata.gz: a67253d1567eb3f934d2740271c3e1355a1df08b0638809e5add6b9e739f1f99aee1fa27896f9aac798c659f5dc7ce38f943654c5299a8af63ca679c3158f260
+  data.tar.gz: f32dd1c438f4a6f0598182d0a26d712f05cd1782a3eeebad4d32026529668e8212b4cf0269361646c440b1b3cae8e0e5b46b89cff8e2ba4e7334e42a819953af

data/.gitignore

@@ -17,5 +17,5 @@ fluent-gem
 fluentd
 pkg/*
 test/tmp/*
-spec/config/tmp/*
+test/config/tmp/*
 make_dist.sh

data/ChangeLog

@@ -1,3 +1,13 @@
+Release 0.10.54 - 2014/10/17
+
+* config: Change v1's non-quoted string literal behaviour to v0's behaviour
+* config: Add --use-v0-config for keeping old configuration
+* config: Add single quoted literal in v1 configuration
+* config: Improve error message of Array / Hash parse error
+* input: Reduce shutdown time in some network related plugins when use Cool.io 1.2
+* parser: Use ParserError instead of general exception classes
+* Remove unused zfile buffer plugin
+
 Release 0.10.53 - 2014/08/21
 
 * in_tail: Fix forget to detach Closer timer object

data/Rakefile

@@ -4,10 +4,8 @@ require "bundler/gem_tasks"
 require 'fileutils'
 require 'rake/testtask'
 require 'rake/clean'
-require 'rspec/core'
-require 'rspec/core/rake_task'
 
-task :test => [:base_test, :spec]
+task :test => [:base_test]
 
 desc 'Run test_unit based test'
 Rake::TestTask.new(:base_test) do |t|
@@ -15,7 +13,7 @@ Rake::TestTask.new(:base_test) do |t|
   #  $ bundle exec rake base_test TEST=test/test_specified_path.rb
   #  $ bundle exec rake base_test TEST=test/test_*.rb
   t.libs << "test"
-  t.test_files = (Dir["test/test_*.rb"] + Dir["test/plugin/test_*.rb"] - ["helper.rb"]).sort
+  t.test_files = Dir["test/**/test_*.rb"].sort
   t.verbose = true
   #t.warning = true
 end
@@ -26,14 +24,7 @@ task :parallel_test do
   FileUtils.rm_rf('./test/tmp')
 end
 
-desc 'Run rspec based test'
-RSpec::Core::RakeTask.new(:spec) do |t|
-  t.rspec_opts = %w[-c -f progress -r ./spec/spec_helper.rb]
-  t.pattern = 'spec/**/*_spec.rb'
-  t.verbose = true
-end
-
-desc 'Run rspec with simplecov'
+desc 'Run test with simplecov'
 task :coverage do |t|
   ENV['SIMPLE_COV'] = '1'
   Rake::Task["spec"].invoke

data/example/v1_literal_example.conf

@@ -0,0 +1,36 @@
+<section1>
+  key1  'text'     # text
+  key2  '\''       # ' (1 char)
+  key3  '\\'       # \ (1 char)
+  key4  '\t'       # \t (2 char)
+  key5  '\['       # \[ (2 char)
+  key6  '\\['      # \[ (2 char)
+  key7  '#t'       # #t (2 char)
+  key8  '\#{test}' # \#{test} (8 char)
+  key9  '#{test}'  # #{test} (7 char)
+  key10 '\[(?<time>[^\]]*)\] (?<message>.*)'    # \[(?<time>[^\]]*\] (?<message>.*)
+</section1>
+<section2>
+  key1  "text"     # text
+  key2  "\""       # " (1 char)
+  key3  "\\"       # \ (1 char)
+  key4  "\t"       # TAB (1 char)
+  key5  "\["       # [ (1 char)
+  key6  "\\["      # \[ (2 char)
+  key7  "#t"       # #t (2 char)
+  key8  "\#{test}" # #{test} (7 char)
+  key9  "#{test}"  # replaced by eval('test')
+  key10 "\\[(?<time>[^\\]]*)\\] (?<message>.*)" # \[(?<time>[^\]]*\] (?<message>.*)
+</section2>
+<section3>
+  key1  text     # text
+  key2  \        # \ (1 char)
+  key3  \\       # \\ (2 char)
+  key4  \t       # \t (2 char)
+  key5  \[       # \[ (2 char)
+  key6  \\[      # \\[ (3 char)
+  key7  #t       # #t (2 char)
+  key8  \#{test} # \#{test} (8 char)
+  key9  #{test}  # #{test} (7 char)
+  key10 \[(?<time>[^\]]*)\] (?<message>.*)    # \[(?<time>[^\]]*\] (?<message>.*)
+</section3>

data/fluentd.gemspec

@@ -28,8 +28,8 @@ Gem::Specification.new do |gem|
   gem.add_development_dependency("rake", [">= 0.9.2"])
   gem.add_development_dependency("flexmock")
   gem.add_development_dependency("parallel_tests", [">= 0.15.3"])
-  gem.add_development_dependency("rspec", ["~> 3.0.0"])
   gem.add_development_dependency("simplecov", ["~> 0.6.4"])
   gem.add_development_dependency("rr", [">= 1.0.0"])
   gem.add_development_dependency("timecop", [">= 0.3.0"])
+  gem.add_development_dependency("test-unit", ["~> 3.0.2"])
 end

data/lib/fluent/command/fluentd.rb

@@ -84,6 +84,10 @@ op.on('--use-v1-config', "Use v1 configuration format", TrueClass) {|b|
   opts[:use_v1_config] = b
 }
 
+op.on('--use-v0-config', "Use v0 configuration format (default)", TrueClass) {|b|
+  opts[:use_v1_config] = !b
+}
+
 op.on('-v', '--verbose', "increase verbose level (-v: debug, -vv: trace)", TrueClass) {|b|
   if b
     opts[:log_level] = [opts[:log_level] - 1, Fluent::Log::LEVEL_TRACE].max

data/lib/fluent/config/basic_parser.rb

@@ -26,6 +26,7 @@ module Fluent
 
       LINE_END = /(?:[ \t]*(?:\#.*)?(?:\z|[\r\n]))+/
       SPACING = /(?:[ \t\r\n]|\z|\#.*?(?:\z|[\r\n]))+/
+      SPACING_WITHOUT_COMMENT = /(?:[ \t\r\n]|\z)+/
 
       module ClassMethods
         def symbol(string)
@@ -77,6 +78,10 @@ module Fluent
         skip(SPACING)
       end
 
+      def spacing_without_comment
+        skip(SPACING_WITHOUT_COMMENT)
+      end
+
       def parse_error!(message)
         raise ConfigParseError, "#{message} at #{error_sample}"
       end

data/lib/fluent/config/element.rb

@@ -29,6 +29,7 @@ module Fluent
         "name:#{@name}, arg:#{@arg}, " + attrs + ", " + @elements.inspect
       end
 
+      # This method assumes _o_ is an Element object. Should return false for nil or other object
       def ==(o)
         self.name == o.name && self.arg == o.arg &&
           self.keys.size == o.keys.size &&
@@ -86,11 +87,7 @@ module Fluent
           out << "#{indent}<#{@name} #{@arg}>\n"
         end
         each_pair { |k, v|
-          if @v1_config
-            out << "#{nindent}#{k} #{Element.unescape_parameter(v)}\n"
-          else
-            out << "#{nindent}#{k} #{v}\n"
-          end
+          out << "#{nindent}#{k} #{v}\n"
         }
         @elements.each { |e|
           out << e.to_s(nest + 1)

data/lib/fluent/config/literal_parser.rb

@@ -50,7 +50,7 @@ module Fluent
       end
 
       def parse_literal(string_boundary_charset = LINE_END)
-        spacing
+        spacing_without_comment
 
         value = if skip(/\[/)
                   scan_json(true)
@@ -64,13 +64,15 @@ module Fluent
 
       def scan_string(string_boundary_charset = LINE_END)
         if skip(/\"/)
-          return scan_quoted_string
+          return scan_double_quoted_string
+        elsif skip(/\'/)
+          return scan_single_quoted_string
         else
           return scan_nonquoted_string(string_boundary_charset)
         end
       end
 
-      def scan_quoted_string
+      def scan_double_quoted_string
         string = []
         while true
           if skip(/\"/)
@@ -83,7 +85,24 @@ module Fluent
           elsif s = scan(/./)
             string << s
           else
-            parse_error! "unexpected end of file in a quoted string"
+            parse_error! "unexpected end of file in a double quoted string"
+          end
+        end
+      end
+
+      def scan_single_quoted_string
+        string = []
+        while true
+          if skip(/\'/)
+            return string.join
+          elsif s = scan(/\\'/)
+            string << "'"
+          elsif s = scan(/\\\\/)
+            string << "\\"
+          elsif s = scan(/./)
+            string << s
+          else
+            parse_error! "unexpected end of file in a signle quoted string"
           end
         end
       end
@@ -93,8 +112,8 @@ module Fluent
 
         string = []
         while true
-          if s = scan(/\\./)
-            string << eval_escape_char(s[1,1])
+          if s = scan(/\#/)
+            string << '#'
           elsif s = scan(charset)
             string << s
           else
@@ -213,7 +232,7 @@ module Fluent
         end
 
         unless result
-          parse_error! "got incomplete #{is_array ? 'array' : 'hash'} configuration"
+          parse_error! "got incomplete JSON #{is_array ? 'array' : 'hash'} configuration"
         end
 
         JSON.dump(result)

data/lib/fluent/config/v1_parser.rb

@@ -99,7 +99,7 @@ module Fluent
 
           else
             k = scan_string(SPACING)
-            spacing
+            spacing_without_comment
             if prev_match.include?("\n") # support 'tag_mapped' like "without value" configuration
               attrs[k] = ""
             else

data/lib/fluent/parser.rb

@@ -19,6 +19,9 @@ module Fluent
   require 'fluent/registry'
 
   class TextParser
+    class ParserError < StandardError
+    end
+
     class TimeParser
       def initialize(time_format)
         @cache1_key = nil
@@ -35,7 +38,7 @@ module Fluent
 
       def parse(value)
         unless value.is_a?(String)
-          raise ArgumentError, "Value must be string: #{value}"
+          raise ParserError, "value must be string: #{value}"
         end
 
         if @cache1_key == value
@@ -43,7 +46,11 @@ module Fluent
         elsif @cache2_key == value
           return @cache2_time
         else
-          time = @parser.call(value).to_i
+          begin
+            time = @parser.call(value).to_i
+          rescue => e
+            raise ParserError, "invalid time format: value = #{value}, error_class = #{e.class.name}, error = #{e.message}"
+          end
           @cache1_key = @cache2_key
           @cache1_time = @cache2_time
           @cache2_key = value
@@ -225,7 +232,11 @@ module Fluent
           if @time_format
             time = @mutex.synchronize { @time_parser.parse(value) }
           else
-            time = value.to_i
+            begin
+              time = value.to_i
+            rescue => e
+              raise ParserError, "invalid time value: value = #{value}, error_class = #{e.class.name}, error = #{e.message}"
+            end
           end
         else
           if @estimate_current_event

data/lib/fluent/plugin/in_http.rb

@@ -104,12 +104,20 @@ module Fluent
     end
 
     def run
-      @loop.run
+      if support_blocking_timeout?
+        @loop.run(0.5)
+      else
+        @loop.run
+      end
     rescue
       log.error "unexpected error", :error=>$!.to_s
       log.error_backtrace
     end
 
+    def support_blocking_timeout?
+      @loop.method(:run).arity.nonzero?
+    end
+
     def on_request(path_info, params)
       begin
         path = path_info[1..-1]  # remove /

data/lib/fluent/plugin/in_stream.rb

@@ -43,13 +43,22 @@ module Fluent
     #end
 
     def run
-      @loop.run
+      if support_blocking_timeout?
+        @loop.run(0.5)
+      else
+        @loop.run
+      end
     rescue
       log.error "unexpected error", :error=>$!.to_s
       log.error_backtrace
     end
 
     protected
+
+    def support_blocking_timeout?
+      @loop.method(:run).arity.nonzero?
+    end
+
     # message Entry {
     #   1: long time
     #   2: object record

data/lib/fluent/plugin/in_syslog.rb

@@ -117,13 +117,22 @@ module Fluent
     end
 
     def run
-      @loop.run
+      if support_blocking_timeout?
+        @loop.run(0.5)
+      else
+        @loop.run
+      end
     rescue
       log.error "unexpected error", :error=>$!.to_s
       log.error_backtrace
     end
 
     protected
+
+    def support_blocking_timeout?
+      @loop.method(:run).arity.nonzero?
+    end
+
     def receive_data_parser(data, addr)
       m = SYSLOG_REGEXP.match(data)
       unless m

data/lib/fluent/plugin/socket_util.rb

@@ -106,7 +106,11 @@ module Fluent
       end
 
       def run
-        @loop.run
+        if support_blocking_timeout?
+          @loop.run(0.5)
+        else
+          @loop.run
+        end
       rescue => e
         log.error "unexpected error", :error => e, :error_class => e.class
         log.error_backtrace
@@ -114,6 +118,10 @@ module Fluent
 
       private
 
+      def support_blocking_timeout?
+        @loop.method(:run).arity.nonzero?
+      end
+
       def on_message(msg, addr)
         @parser.parse(msg) { |time, record|
           unless time && record

data/lib/fluent/version.rb

@@ -1,5 +1,5 @@
 module Fluent
 
-  VERSION = '0.10.53'
+  VERSION = '0.10.54'
 
 end

data/test/config/assertions.rb

@@ -0,0 +1,42 @@
+require 'test/unit/assertions'
+
+module Test::Unit::Assertions
+  def assert_text_parsed_as(expected, actual)
+    msg = parse_text(actual).inspect rescue 'failed'
+    msg = "expected that #{actual.inspect} would be a parsed as #{expected.inspect} but got #{msg}"
+    assert_block(msg) {
+      v = parse_text(actual)
+      if expected.is_a?(Float)
+        v.is_a?(Float) && (v == obj || (v.nan? && obj.nan?) || (v - obj).abs < 0.000001)
+      else
+        v == expected
+      end
+    }
+  end
+
+  def assert_text_parsed_as_json(expected, actual)
+    msg = parse_text(actual).inspect rescue 'failed'
+    msg = "expected that #{actual.inspect} would be a parsed as #{expected.inspect} but got #{msg}"
+    assert_block(msg) {
+      v = JSON.parse(parse_text(actual))
+      v == expected
+    }
+  end
+
+  def assert_parse_error(actual)
+    msg = begin
+            parse_text(actual).inspect
+          rescue => e
+            e.inspect
+          end
+    msg = "expected that #{actual.inspect} would cause a parse error but got #{msg}"
+    assert_block(msg) {
+      begin
+        parse_text(actual)
+        false
+      rescue Fluent::ConfigParseError
+        true
+      end
+    }
+  end
+end

data/test/config/test_config_parser.rb

@@ -0,0 +1,354 @@
+require 'helper'
+require "json"
+require "config/assertions"
+require "fluent/config/error"
+require "fluent/config/basic_parser"
+require "fluent/config/literal_parser"
+require "fluent/config/v1_parser"
+
+module Fluent::Config
+  module V1TestHelper
+    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
+  end
+
+  class TestV1Parser < ::Test::Unit::TestCase
+    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
+
+    include V1TestHelper
+    extend V1TestHelper
+
+    sub_test_case 'attribute parsing' do
+      test "parses attributes" do
+        assert_text_parsed_as(e('ROOT', '', {"k1"=>"v1", "k2"=>"v2"}), %[
+          k1 v1
+          k2 v2
+        ])
+      end
+
+      test "allows attribute without value" do
+        assert_text_parsed_as(e('ROOT', '', {"k1"=>"", "k2"=>"v2"}), %[
+          k1
+          k2 v2
+        ])
+      end
+
+      test "parses attribute key always string" do
+        assert_text_parsed_as(e('ROOT', '', {"1" => "1"}), "1 1")
+      end
+
+      data("_.%$!,"     => "_.%$!,",
+           "/=~-~@\`:?" => "/=~-~@\`:?",
+           "()*{}.[]"   => "()*{}.[]")
+      test "parses a value with symbols" do |v|
+        assert_text_parsed_as(e('ROOT', '', {"k" => v}), "k #{v}")
+      end
+
+      test "ignores spacing around value" do
+        assert_text_parsed_as(e('ROOT', '', {"k1" => "a"}), "  k1     a    ")
+      end
+
+      test "allows spaces in value" do
+        assert_text_parsed_as(e('ROOT', '', {"k1" => "a  b  c"}), "k1 a  b  c")
+      end
+
+      sub_test_case 'non-quoted string' do
+        test "remains text starting with '#'" do
+          assert_text_parsed_as(e('ROOT', '', {"k1" => "#not_comment"}), "  k1 #not_comment")
+        end
+
+        test "remains text just after '#'" do
+          assert_text_parsed_as(e('ROOT', '', {"k1" => "a#not_comment"}), "  k1 a#not_comment")
+        end
+
+        test "remove text after ` #` (comment)" do
+          assert_text_parsed_as(e('ROOT', '', {"k1" => "a"}), "  k1 a #comment")
+        end
+
+        test "does not require escaping backslash" do
+          assert_text_parsed_as(e('ROOT', '', {"k1" => "\\\\"}), "  k1 \\\\")
+          assert_text_parsed_as(e('ROOT', '', {"k1" => "\\"}), "  k1 \\")
+        end
+
+        test "remains backslash in front of a normal character" do
+          assert_text_parsed_as(e('ROOT', '', {"k1" => '\['}), "  k1 \\[")
+        end
+
+        test "does not accept escape characters" do
+          assert_text_parsed_as(e('ROOT', '', {"k1" => '\n'}), "  k1 \\n")
+        end
+      end
+
+      sub_test_case 'double quoted string' do
+        test "allows # in value" do
+          assert_text_parsed_as(e('ROOT', '', {"k1" => "a#comment"}), '  k1 "a#comment"')
+        end
+
+        test "rejects characters after double quoted string" do
+          assert_parse_error('  k1 "a" 1')
+        end
+
+        test "requires escaping backslash" do
+          assert_text_parsed_as(e('ROOT', '', {"k1" => "\\"}), '  k1 "\\\\"')
+          assert_parse_error('  k1 "\\"')
+        end
+
+        test "requires escaping double quote" do
+          assert_text_parsed_as(e('ROOT', '', {"k1" => '"'}), '  k1 "\\""')
+          assert_parse_error('  k1 """')
+        end
+
+        test "removes backslash in front of a normal character" do
+          assert_text_parsed_as(e('ROOT', '', {"k1" => '['}), '  k1 "\\["')
+        end
+
+        test "accepts escape characters" do
+          assert_text_parsed_as(e('ROOT', '', {"k1" => "\n"}), '  k1 "\\n"')
+        end
+      end
+
+      sub_test_case 'single quoted string' do
+        test "allows # in value" do
+          assert_text_parsed_as(e('ROOT', '', {"k1" => "a#comment"}), "  k1 'a#comment'")
+        end
+
+        test "rejects characters after single quoted string" do
+          assert_parse_error("  k1 'a' 1")
+        end
+
+        test "requires escaping backslash" do
+          assert_text_parsed_as(e('ROOT', '', {"k1" => "\\"}), "  k1 '\\\\'")
+          assert_parse_error("  k1 '\\'")
+        end
+
+        test "requires escaping single quote" do
+          assert_text_parsed_as(e('ROOT', '', {"k1" => "'"}), "  k1 '\\''")
+          assert_parse_error("  k1 '''")
+        end
+
+        test "remains backslash in front of a normal character" do
+          assert_text_parsed_as(e('ROOT', '', {"k1" => '\\['}), "  k1 '\\['")
+        end
+
+        test "does not accept escape characters" do
+          assert_text_parsed_as(e('ROOT', '', {"k1" => "\\n"}), "  k1 '\\n'")
+        end
+      end
+
+      test "rejects @ prefix in parameter name" do
+        assert_parse_error('  @k v')
+      end
+    end
+
+    sub_test_case 'element parsing' do
+      data(
+        'root' => [root, ""],
+        "accepts empty element" => [root(e("test")), %[
+          <test>
+          </test>
+        ]],
+        "accepts argument and attributes" => [root(e("test", 'var', {'key'=>"val"})), %[
+          <test var>
+            key val
+          </test>
+        ]],
+        "accepts nested elements" => [root(
+          e("test", 'var', {'key'=>'1'}, [
+            e('nested1'),
+            e('nested2')
+          ])), %[
+          <test var>
+            key 1
+            <nested1>
+            </nested1>
+            <nested2>
+            </nested2>
+          </test>
+        ]],
+        "accepts multiline json values" => [root(e("test", 'var', {'key'=>"[\"a\",\"b\",\"c\",\"d\"]"})), %[
+          <test var>
+            key ["a",
+"b", "c",
+"d"]
+          </test>
+        ]],
+        "parses empty element argument to nil" => [root(e("test", '')), %[
+          <test >
+          </test>
+        ]],
+        "ignores spacing around element argument" => [root(e("test", "a")), %[
+          <test    a    >
+          </test>
+        ]])
+      def test_parse_element(data)
+        expected, target = data
+        assert_text_parsed_as(expected, target)
+      end
+
+      [
+        "**",
+        "*.*",
+        "1",
+        "_.%$!",
+        "/",
+        "()*{}.[]",
+      ].each do |arg|
+        test "parses symbol element argument:#{arg}" do
+          assert_text_parsed_as(root(e("test", arg)), %[
+            <test #{arg}>
+            </test>
+          ])
+        end
+      end
+
+      data(
+        "considers comments in element argument" => %[
+          <test #a>
+          </test>
+        ],
+        "requires line_end after begin tag" => %[
+          <test></test>
+        ],
+        "requires line_end after end tag" => %[
+          <test>
+          </test><test>
+          </test>
+        ])
+      def test_parse_error(data)
+        assert_parse_error(data)
+      end
+    end
+
+    # port from test_config.rb
+    sub_test_case '@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
+
+      test 'parses @include / include correctly' do
+        prepare_config
+        c = read_config("#{TMP_DIR}/config_test_1.conf")
+        assert_equal('root_config', c['k1'])
+        assert_equal('relative_path_include', c['k2'])
+        assert_equal('relative_include_in_included_file', c['k3'])
+        assert_equal('absolute_path_include', c['k4'])
+        assert_equal('uri_include', c['k5'])
+        assert_equal('wildcard_include_1', c['k6'])
+        assert_equal('wildcard_include_2', c['k7'])
+        assert_equal('wildcard_include_3', c['k8'])
+        assert_equal([
+            'k1',
+            'k2',
+            'k3',
+            'k4',
+            'k5',
+            'k8', # Because of the file name this comes first.
+            'k6',
+            'k7',
+          ], c.keys)
+
+        elem1 = c.elements.find { |e| e.name == 'elem1' }
+        assert(elem1)
+        assert_equal('name', elem1.arg)
+        assert_equal('normal_parameter', elem1['include'])
+
+        elem2 = c.elements.find { |e| e.name == 'elem2' }
+        assert(elem2)
+        assert_equal('name', elem2.arg)
+        assert_equal('embeded', elem2['k9'])
+        assert_not_include(elem2, 'include')
+
+        elem3 = elem2.elements.find { |e| e.name == 'elem3' }
+        assert(elem3)
+        assert_equal('nested_value', elem3['nested'])
+        assert_equal('hoge', elem3['include'])
+      end
+
+      # TODO: Add uri based include spec
+    end
+
+    sub_test_case '#to_s' do
+      test 'parses dumpped configuration' do
+        original = %q!a\\\n\r\f\b'"z!
+        expected = %q!a\\\n\r\f\b'"z!
+
+        conf = parse_text(%[k1 #{original}])
+        assert_equal(expected, conf['k1']) # escape check
+        conf2 = parse_text(conf.to_s) # use dumpped configuration to check unescape
+        assert_equal(expected, conf2.elements.first['k1'])
+      end
+    end
+  end
+end