fluentd 1.17.0-x64-mingw-ucrt → 1.17.1-x64-mingw-ucrt

data/test/plugin/test_parser_msgpack.rb

@@ -1,127 +0,0 @@
-require_relative '../helper'
-require 'fluent/test/driver/parser'
-require 'fluent/plugin/parser_msgpack'
-
-class MessagePackParserTest < ::Test::Unit::TestCase
-  def setup
-    Fluent::Test.setup
-  end
-
-  def create_driver(conf)
-    Fluent::Test::Driver::Parser.new(Fluent::Plugin::MessagePackParser).configure(conf)
-  end
-
-  sub_test_case "simple setting" do
-    data(
-      "Normal Hash",
-      {
-        input: "\x82\xA7message\xADHello msgpack\xA3numd",
-        expected: [{"message" => "Hello msgpack", "num" => 100}]
-      },
-      keep: true
-    )
-    data(
-      "Array of multiple Hash",
-      {
-        input: "\x92\x81\xA7message\xA3foo\x81\xA7message\xA3bar",
-        expected: [{"message"=>"foo"}, {"message"=>"bar"}]
-      },
-      keep: true
-    )
-    data(
-      "String",
-      {
-        # "Hello msgpack".to_msgpack
-        input: "\xADHello msgpack",
-        expected: [nil]
-      },
-      keep: true
-    )
-    data(
-      "Array of String",
-      {
-        # ["foo", "bar"].to_msgpack
-        input: "\x92\xA3foo\xA3bar",
-        expected: [nil, nil]
-      },
-      keep: true
-    )
-    data(
-      "Array of String and Hash",
-      {
-        # ["foo", {message: "bar"}].to_msgpack
-        input: "\x92\xA3foo\x81\xA7message\xA3bar",
-        expected: [nil, {"message"=>"bar"}]
-      },
-      keep: true
-    )
-
-    def test_parse(data)
-      parsed_records = []
-      create_driver("").instance.parse(data[:input]) do |time, record|
-        parsed_records.append(record)
-      end
-      assert_equal(data[:expected], parsed_records)
-    end
-
-    def test_parse_io(data)
-      parsed_records = []
-      StringIO.open(data[:input]) do |io|
-        create_driver("").instance.parse_io(io) do |time, record|
-          parsed_records.append(record)
-        end
-      end
-      assert_equal(data[:expected], parsed_records)
-    end
-  end
-
-  # This becomes NoMethodError if a non-Hash object is passed to convert_values.
-  # https://github.com/fluent/fluentd/issues/4100
-  sub_test_case "execute_convert_values with null_empty_string" do
-    data(
-      "Normal hash",
-      {
-        # {message: "foo", empty: ""}.to_msgpack
-        input: "\x82\xA7message\xA3foo\xA5empty\xA0",
-        expected: [{"message" => "foo", "empty" => nil}]
-      },
-      keep: true
-    )
-    data(
-      "Array of multiple Hash",
-      {
-        # [{message: "foo", empty: ""}, {message: "bar", empty: ""}].to_msgpack
-        input: "\x92\x82\xA7message\xA3foo\xA5empty\xA0\x82\xA7message\xA3bar\xA5empty\xA0",
-        expected: [{"message"=>"foo", "empty" => nil}, {"message"=>"bar", "empty" => nil}]
-      },
-      keep: true
-    )
-    data(
-      "String",
-      {
-        # "Hello msgpack".to_msgpack
-        input: "\xADHello msgpack",
-        expected: [nil]
-      },
-      keep: true
-    )
-
-    def test_parse(data)
-      parsed_records = []
-      create_driver("null_empty_string").instance.parse(data[:input]) do |time, record|
-        parsed_records.append(record)
-      end
-      assert_equal(data[:expected], parsed_records)
-    end
-
-    def test_parse_io(data)
-      parsed_records = []
-      StringIO.open(data[:input]) do |io|
-        create_driver("null_empty_string").instance.parse_io(io) do |time, record|
-          parsed_records.append(record)
-        end
-      end
-      assert_equal(data[:expected], parsed_records)
-    end
-  end
-end

data/test/plugin/test_parser_multiline.rb

@@ -1,111 +0,0 @@
-require_relative '../helper'
-require 'fluent/test/driver/parser'
-require 'fluent/plugin/parser'
-
-class MultilineParserTest < ::Test::Unit::TestCase
-  def setup
-    Fluent::Test.setup
-  end
-
-  def create_parser(conf)
-    parser = Fluent::Test::Driver::Parser.new(Fluent::Plugin::MultilineParser).configure(conf)
-    parser
-  end
-
-  def test_configure_with_invalid_params
-    [{'format100' => '/(?<msg>.*)/'}, {'format1' => '/(?<msg>.*)/', 'format3' => '/(?<msg>.*)/'}, 'format1' => '/(?<msg>.*)'].each { |config|
-      assert_raise(Fluent::ConfigError) {
-        create_parser(config)
-      }
-    }
-  end
-
-  def test_parse
-    parser = create_parser('format1' => '/^(?<time>\d{4}-\d{1,2}-\d{1,2} \d{1,2}:\d{1,2}:\d{1,2}) \[(?<thread>.*)\] (?<level>[^\s]+)(?<message>.*)/')
-    parser.instance.parse(<<EOS.chomp) { |time, record|
-2013-3-03 14:27:33 [main] ERROR Main - Exception
-javax.management.RuntimeErrorException: null
-\tat Main.main(Main.java:16) ~[bin/:na]
-EOS
-
-      assert_equal(event_time('2013-3-03 14:27:33').to_i, time)
-      assert_equal({
-                     "thread"  => "main",
-                     "level"   => "ERROR",
-                     "message" => " Main - Exception\njavax.management.RuntimeErrorException: null\n\tat Main.main(Main.java:16) ~[bin/:na]"
-                   }, record)
-    }
-  end
-
-  def test_parse_with_firstline
-    parser = create_parser('format_firstline' => '/----/', 'format1' => '/time=(?<time>\d{4}-\d{1,2}-\d{1,2} \d{1,2}:\d{1,2}:\d{1,2}).*message=(?<message>.*)/')
-    parser.instance.parse(<<EOS.chomp) { |time, record|
-----
-time=2013-3-03 14:27:33
-message=test1
-EOS
-
-      assert(parser.instance.firstline?('----'))
-      assert_equal(event_time('2013-3-03 14:27:33').to_i, time)
-      assert_equal({"message" => "test1"}, record)
-    }
-  end
-
-  def test_parse_with_multiple_formats
-    parser = create_parser('format_firstline' => '/^Started/',
-                           'format1' => '/Started (?<method>[^ ]+) "(?<path>[^"]+)" for (?<host>[^ ]+) at (?<time>[^ ]+ [^ ]+ [^ ]+)\n/',
-                           'format2' => '/Processing by (?<controller>[^\u0023]+)\u0023(?<controller_method>[^ ]+) as (?<format>[^ ]+?)\n/',
-                           'format3' => '/(  Parameters: (?<parameters>[^ ]+)\n)?/',
-                           'format4' => '/  Rendered (?<template>[^ ]+) within (?<layout>.+) \([\d\.]+ms\)\n/',
-                           'format5' => '/Completed (?<code>[^ ]+) [^ ]+ in (?<runtime>[\d\.]+)ms \(Views: (?<view_runtime>[\d\.]+)ms \| ActiveRecord: (?<ar_runtime>[\d\.]+)ms\)/'
-                           )
-    parser.instance.parse(<<EOS.chomp) { |time, record|
-Started GET "/users/123/" for 127.0.0.1 at 2013-06-14 12:00:11 +0900
-Processing by UsersController#show as HTML
-  Parameters: {"user_id"=>"123"}
-  Rendered users/show.html.erb within layouts/application (0.3ms)
-Completed 200 OK in 4ms (Views: 3.2ms | ActiveRecord: 0.0ms)
-EOS
-
-      assert(parser.instance.firstline?('Started GET "/users/123/" for 127.0.0.1...'))
-      assert_equal(event_time('2013-06-14 12:00:11 +0900').to_i, time)
-      assert_equal({
-                     "method" => "GET",
-                     "path" => "/users/123/",
-                     "host" => "127.0.0.1",
-                     "controller" => "UsersController",
-                     "controller_method" => "show",
-                     "format" => "HTML",
-                     "parameters" => "{\"user_id\"=>\"123\"}",
-                     "template" => "users/show.html.erb",
-                     "layout" => "layouts/application",
-                     "code" => "200",
-                     "runtime" => "4",
-                     "view_runtime" => "3.2",
-                     "ar_runtime" => "0.0"
-                   }, record)
-    }
-  end
-
-  def test_parse_with_keep_time_key
-    parser = Fluent::Test::Driver::Parser.new(Fluent::Plugin::MultilineParser).configure(
-      'format1' => '/^(?<time>\d{4}-\d{1,2}-\d{1,2} \d{1,2}:\d{1,2}:\d{1,2})/',
-      'keep_time_key' => 'true'
-    )
-    text = '2013-3-03 14:27:33'
-    parser.instance.parse(text) { |time, record|
-      assert_equal text, record['time']
-    }
-  end
-
-  def test_parse_unmatched_lines
-    parser = Fluent::Test::Driver::Parser.new(Fluent::Plugin::MultilineParser).configure(
-      'format1' => '/^message (?<message_id>\d)/',
-      'unmatched_lines' => true,
-    )
-    text = "message 1\nmessage a"
-    r = []
-    parser.instance.parse(text) { |_, record| r << record }
-    assert_equal [{ 'message_id' => '1' }, { 'unmatched_line' => 'message a'}], r
-  end
-end

data/test/plugin/test_parser_nginx.rb

@@ -1,88 +0,0 @@
-require_relative '../helper'
-require 'fluent/test/driver/parser'
-require 'fluent/plugin/parser_nginx'
-
-class NginxParserTest < ::Test::Unit::TestCase
-  def setup
-    Fluent::Test.setup
-    @expected = {
-      'remote'  => '127.0.0.1',
-      'host'    => '192.168.0.1',
-      'user'    => '-',
-      'method'  => 'GET',
-      'path'    => '/',
-      'code'    => '200',
-      'size'    => '777',
-      'referer' => '-',
-      'agent'   => 'Opera/12.0'
-    }
-    @expected_extended = {
-      'remote'               => '127.0.0.1',
-      'host'                 => '192.168.0.1',
-      'user'                 => '-',
-      'method'               => 'GET',
-      'path'                 => '/',
-      'code'                 => '200',
-      'size'                 => '777',
-      'referer'              => '-',
-      'agent'                => 'Opera/12.0',
-      'http_x_forwarded_for' => '-'
-    }
-    @expected_extended_multiple_ip = {
-      'remote'               => '127.0.0.1',
-      'host'                 => '192.168.0.1',
-      'user'                 => '-',
-      'method'               => 'GET',
-      'path'                 => '/',
-      'code'                 => '200',
-      'size'                 => '777',
-      'referer'              => '-',
-      'agent'                => 'Opera/12.0',
-      'http_x_forwarded_for' => '127.0.0.1, 192.168.0.1'
-    }
-  end
-
-  def create_driver
-    Fluent::Test::Driver::Parser.new(Fluent::Plugin::NginxParser.new).configure({})
-  end
-
-  def test_parse
-    d = create_driver
-    d.instance.parse('127.0.0.1 192.168.0.1 - [28/Feb/2013:12:00:00 +0900] "GET / HTTP/1.1" 200 777 "-" "Opera/12.0"') { |time, record|
-      assert_equal(event_time('28/Feb/2013:12:00:00 +0900', format: '%d/%b/%Y:%H:%M:%S %z'), time)
-      assert_equal(@expected, record)
-    }
-  end
-
-  def test_parse_with_empty_included_path
-    d = create_driver
-    d.instance.parse('127.0.0.1 192.168.0.1 - [28/Feb/2013:12:00:00 +0900] "GET /a[ ]b HTTP/1.1" 200 777 "-" "Opera/12.0"') { |time, record|
-      assert_equal(event_time('28/Feb/2013:12:00:00 +0900', format: '%d/%b/%Y:%H:%M:%S %z'), time)
-      assert_equal(@expected.merge('path' => '/a[ ]b'), record)
-    }
-  end
-
-  def test_parse_without_http_version
-    d = create_driver
-    d.instance.parse('127.0.0.1 192.168.0.1 - [28/Feb/2013:12:00:00 +0900] "GET /" 200 777 "-" "Opera/12.0"') { |time, record|
-      assert_equal(event_time('28/Feb/2013:12:00:00 +0900', format: '%d/%b/%Y:%H:%M:%S %z'), time)
-      assert_equal(@expected, record)
-    }
-  end
-
-  def test_parse_with_http_x_forwarded_for
-    d = create_driver
-    d.instance.parse('127.0.0.1 192.168.0.1 - [28/Feb/2013:12:00:00 +0900] "GET / HTTP/1.1" 200 777 "-" "Opera/12.0" -') { |time, record|
-      assert_equal(event_time('28/Feb/2013:12:00:00 +0900', format: '%d/%b/%Y:%H:%M:%S %z'), time)
-      assert_equal(@expected_extended, record)
-    }
-  end
-
-  def test_parse_with_http_x_forwarded_for_multiple_ip
-    d = create_driver
-    d.instance.parse('127.0.0.1 192.168.0.1 - [28/Feb/2013:12:00:00 +0900] "GET / HTTP/1.1" 200 777 "-" "Opera/12.0" "127.0.0.1, 192.168.0.1"') { |time, record|
-      assert_equal(event_time('28/Feb/2013:12:00:00 +0900', format: '%d/%b/%Y:%H:%M:%S %z'), time)
-      assert_equal(@expected_extended_multiple_ip, record)
-    }
-  end
-end

data/test/plugin/test_parser_none.rb

@@ -1,52 +0,0 @@
-require_relative '../helper'
-require 'fluent/test/driver/parser'
-require 'fluent/plugin/parser'
-
-class NoneParserTest < ::Test::Unit::TestCase
-  def setup
-    Fluent::Test.setup
-  end
-
-  def test_config_params
-    parser = Fluent::Test::Driver::Parser.new(Fluent::TextParser::NoneParser)
-    parser.configure({})
-    assert_equal "message", parser.instance.message_key
-
-    parser.configure('message_key' => 'foobar')
-    assert_equal "foobar", parser.instance.message_key
-  end
-
-  def test_parse
-    parser = Fluent::Test::Driver::Parser.new(Fluent::Plugin.new_parser('none'))
-    parser.configure({})
-    parser.instance.parse('log message!') { |time, record|
-      assert_equal({'message' => 'log message!'}, record)
-    }
-  end
-
-  def test_parse_with_message_key
-    parser = Fluent::Test::Driver::Parser.new(Fluent::TextParser::NoneParser)
-    parser.configure('message_key' => 'foobar')
-    parser.instance.parse('log message!') { |time, record|
-      assert_equal({'foobar' => 'log message!'}, record)
-    }
-  end
-
-  def test_parse_without_default_time
-    time_at_start = Time.now.to_i
-
-    parser = Fluent::Test::Driver::Parser.new(Fluent::Plugin.new_parser('none'))
-    parser.configure({})
-    parser.instance.parse('log message!') { |time, record|
-      assert time && time >= time_at_start, "parser puts current time without time input"
-      assert_equal({'message' => 'log message!'}, record)
-    }
-
-    parser = Fluent::Test::Driver::Parser.new(Fluent::Plugin.new_parser('none'))
-    parser.configure({'estimate_current_event' => 'false'})
-    parser.instance.parse('log message!') { |time, record|
-      assert_equal({'message' => 'log message!'}, record)
-      assert_nil time, "parser returns nil w/o time if configured so"
-    }
-  end
-end

data/test/plugin/test_parser_regexp.rb

@@ -1,284 +0,0 @@
-require_relative '../helper'
-require 'fluent/test/driver/parser'
-require 'fluent/plugin/parser'
-
-class RegexpParserTest < ::Test::Unit::TestCase
-  def setup
-    Fluent::Test.setup
-  end
-
-  def internal_test_case(parser)
-    text = '192.168.0.1 - - [28/Feb/2013:12:00:00 +0900] [14/Feb/2013:12:00:00 +0900] "true /,/user HTTP/1.1" 200 777'
-    parser.parse(text) { |time, record|
-      assert_equal(event_time('28/Feb/2013:12:00:00 +0900', format: '%d/%b/%Y:%H:%M:%S %z'), time)
-      assert_equal({
-                     'user' => '-',
-                     'flag' => true,
-                     'code' => 200.0,
-                     'size' => 777,
-                     'date' => event_time('14/Feb/2013:12:00:00 +0900', format: '%d/%b/%Y:%H:%M:%S %z'),
-                     'host' => '192.168.0.1',
-                     'path' => ['/', '/user']
-                   }, record)
-    }
-  end
-
-  sub_test_case "Fluent::Compat::TextParser::RegexpParser" do
-    def create_driver(regexp, conf = {}, initialize_conf: false)
-      if initialize_conf
-        Fluent::Test::Driver::Parser.new(Fluent::Compat::TextParser::RegexpParser.new(regexp, conf))
-      else
-        Fluent::Test::Driver::Parser.new(Fluent::Compat::TextParser::RegexpParser.new(regexp)).configure(conf)
-      end
-    end
-
-    def test_parse_with_typed
-      # Use Regexp.new instead of // literal to avoid different parser behaviour in 1.9 and 2.0
-      regexp = Regexp.new(%q!^(?<host>[^ ]*) [^ ]* (?<user>[^ ]*) \[(?<time>[^\]]*)\] \[(?<date>[^\]]*)\] "(?<flag>\S+)(?: +(?<path>[^ ]*) +\S*)?" (?<code>[^ ]*) (?<size>[^ ]*)$!)
-      conf = {
-        'time_format' => "%d/%b/%Y:%H:%M:%S %z",
-        'types' => 'user:string,date:time:%d/%b/%Y:%H:%M:%S %z,flag:bool,path:array,code:float,size:integer'
-      }
-      d = create_driver(regexp, conf, initialize_conf: true)
-      internal_test_case(d.instance)
-    end
-
-    def test_parse_with_configure
-      # Specify conf by configure method instead of initializer
-      regexp = Regexp.new(%q!^(?<host>[^ ]*) [^ ]* (?<user>[^ ]*) \[(?<time>[^\]]*)\] \[(?<date>[^\]]*)\] "(?<flag>\S+)(?: +(?<path>[^ ]*) +\S*)?" (?<code>[^ ]*) (?<size>[^ ]*)$!)
-      conf = {
-        'time_format' => "%d/%b/%Y:%H:%M:%S %z",
-        'types' => 'user:string,date:time:%d/%b/%Y:%H:%M:%S %z,flag:bool,path:array,code:float,size:integer'
-      }
-      d = create_driver(regexp, conf)
-      internal_test_case(d.instance)
-      assert_equal(regexp, d.instance.patterns['format'])
-      assert_equal("%d/%b/%Y:%H:%M:%S %z", d.instance.patterns['time_format'])
-    end
-
-    def test_parse_with_typed_and_name_separator
-      regexp = Regexp.new(%q!^(?<host>[^ ]*) [^ ]* (?<user>[^ ]*) \[(?<time>[^\]]*)\] \[(?<date>[^\]]*)\] "(?<flag>\S+)(?: +(?<path>[^ ]*) +\S*)?" (?<code>[^ ]*) (?<size>[^ ]*)$!)
-      conf = {
-        'time_format' => "%d/%b/%Y:%H:%M:%S %z",
-        'types' => 'user|string,date|time|%d/%b/%Y:%H:%M:%S %z,flag|bool,path|array,code|float,size|integer',
-        'types_label_delimiter' => '|'
-      }
-      d = create_driver(regexp, conf)
-      internal_test_case(d.instance)
-    end
-
-    def test_parse_with_time_key
-      conf = {
-        'time_format' => "%Y-%m-%d %H:%M:%S %z",
-        'time_key' => 'logtime'
-      }
-      d = create_driver(/(?<logtime>[^\]]*)/, conf)
-      text = '2013-02-28 12:00:00 +0900'
-      d.instance.parse(text) do |time, _record|
-        assert_equal Fluent::EventTime.parse(text), time
-      end
-    end
-
-    def test_parse_without_time
-      time_at_start = Time.now.to_i
-      text = "tagomori_satoshi tagomoris 34\n"
-
-      regexp = Regexp.new(%q!^(?<name>[^ ]*) (?<user>[^ ]*) (?<age>\d*)$!)
-      conf = {
-        'types' => 'name:string,user:string,age:integer'
-      }
-      d = create_driver(regexp, conf)
-
-      d.instance.parse(text) { |time, record|
-        assert time && time >= time_at_start, "parser puts current time without time input"
-        assert_equal "tagomori_satoshi", record["name"]
-        assert_equal "tagomoris", record["user"]
-        assert_equal 34, record["age"]
-      }
-    end
-
-    def test_parse_without_time_estimate_curent_event_false
-      text = "tagomori_satoshi tagomoris 34\n"
-      regexp = Regexp.new(%q!^(?<name>[^ ]*) (?<user>[^ ]*) (?<age>\d*)$!)
-      conf = {
-        'types' => 'name:string,user:string,age:integer'
-      }
-      d = create_driver(regexp, conf)
-      d.instance.estimate_current_event = false
-      d.instance.parse(text) { |time, record|
-        assert_equal "tagomori_satoshi", record["name"]
-        assert_equal "tagomoris", record["user"]
-        assert_equal 34, record["age"]
-
-        assert_nil time, "parser returns nil if configured so"
-      }
-    end
-
-    def test_parse_with_keep_time_key
-      regexp = Regexp.new(%q!(?<time>.*)!)
-      conf = {
-        'time_format' => "%d/%b/%Y:%H:%M:%S %z",
-        'keep_time_key' => 'true',
-      }
-      d = create_driver(regexp, conf)
-      text = '28/Feb/2013:12:00:00 +0900'
-      d.instance.parse(text) do |_time, record|
-        assert_equal text, record['time']
-      end
-    end
-
-    def test_parse_with_keep_time_key_with_typecast
-      regexp = Regexp.new(%q!(?<time>.*)!)
-      conf = {
-        'time_format' => "%d/%b/%Y:%H:%M:%S %z",
-        'keep_time_key' => 'true',
-        'types' => 'time:time:%d/%b/%Y:%H:%M:%S %z',
-      }
-      d = create_driver(regexp, conf)
-      text = '28/Feb/2013:12:00:00 +0900'
-      d.instance.parse(text) do |_time, record|
-        assert_equal 1362020400, record['time']
-      end
-    end
-  end
-
-  sub_test_case "Fluent::Plugin::RegexpParser" do
-    def create_driver(conf)
-      Fluent::Test::Driver::Parser.new(Fluent::Plugin::RegexpParser.new).configure(conf)
-    end
-
-    sub_test_case "configure" do
-      def test_bad_expression
-        conf = {
-          'expression' => %q!/.*/!,
-        }
-        assert_raise Fluent::ConfigError do
-          create_driver(conf)
-        end
-      end
-
-      def test_default_options
-        conf = {
-          'expression' => %q!/^(?<host>[^ ]*) [^ ]* (?<user>[^ ]*) \[(?<time>[^\]]*)\] \[(?<date>[^\]]*)\] "(?<flag>\S+)(?: +(?<path>[^ ]*) +\S*)?" (?<code>[^ ]*) (?<size>[^ ]*)$/!,
-          'time_format' => "%d/%b/%Y:%H:%M:%S %z",
-          'types' => 'user:string,date:time:%d/%b/%Y:%H:%M:%S %z,flag:bool,path:array,code:float,size:integer'
-        }
-        d = create_driver(conf)
-        regexp = d.instance.expression
-        assert_equal(0, regexp.options)
-      end
-
-      data(
-        ignorecase: ["i", Regexp::IGNORECASE],
-        multiline: ["m", Regexp::MULTILINE],
-        ignorecase_multiline: ["im", Regexp::IGNORECASE | Regexp::MULTILINE],
-      )
-      def test_options(data)
-        regexp_option, expected = data
-        conf = {
-          'expression' => %Q!/^(?<host>[^ ]*) [^ ]* (?<user>[^ ]*) \[(?<time>[^\]]*)\] \[(?<date>[^\]]*)\] "(?<flag>\S+)(?: +(?<path>[^ ]*) +\S*)?" (?<code>[^ ]*) (?<size>[^ ]*)$/#{regexp_option}!,
-          'time_format' => "%d/%b/%Y:%H:%M:%S %z",
-          'types' => 'user:string,date:time:%d/%b/%Y:%H:%M:%S %z,flag:bool,path:array,code:float,size:integer'
-        }
-        d = create_driver(conf)
-        regexp = d.instance.expression
-        assert_equal(expected, regexp.options)
-      end
-    end
-
-    def test_parse_with_typed
-      conf = {
-        'expression' => %q!/^(?<host>[^ ]*) [^ ]* (?<user>[^ ]*) \[(?<time>[^\]]*)\] \[(?<date>[^\]]*)\] "(?<flag>\S+)(?: +(?<path>[^ ]*) +\S*)?" (?<code>[^ ]*) (?<size>[^ ]*)$/!,
-        'time_format' => "%d/%b/%Y:%H:%M:%S %z",
-        'types' => 'user:string,date:time:%d/%b/%Y:%H:%M:%S %z,flag:bool,path:array,code:float,size:integer'
-      }
-      d = create_driver(conf)
-      internal_test_case(d.instance)
-    end
-
-    def test_parse_with_typed_by_json_hash
-      conf = {
-        'expression' => %q!/^(?<host>[^ ]*) [^ ]* (?<user>[^ ]*) \[(?<time>[^\]]*)\] \[(?<date>[^\]]*)\] "(?<flag>\S+)(?: +(?<path>[^ ]*) +\S*)?" (?<code>[^ ]*) (?<size>[^ ]*)$/!,
-        'time_format' => "%d/%b/%Y:%H:%M:%S %z",
-        'types' => '{"user":"string","date":"time:%d/%b/%Y:%H:%M:%S %z","flag":"bool","path":"array","code":"float","size":"integer"}',
-      }
-      d = create_driver(conf)
-      internal_test_case(d.instance)
-    end
-
-    def test_parse_with_time_key
-      conf = {
-        'expression' => %q!/(?<logtime>[^\]]*)/!,
-        'time_format' => "%Y-%m-%d %H:%M:%S %z",
-        'time_key' => 'logtime'
-      }
-      d = create_driver(conf)
-      text = '2013-02-28 12:00:00 +0900'
-      d.instance.parse(text) do |time, _record|
-        assert_equal Fluent::EventTime.parse(text), time
-      end
-    end
-
-    def test_parse_without_time
-      time_at_start = Time.now.to_i
-      text = "tagomori_satoshi tagomoris 34\n"
-
-      conf = {
-        'expression' => %q!/^(?<name>[^ ]*) (?<user>[^ ]*) (?<age>\d*)$/!,
-        'types' => 'name:string,user:string,age:integer'
-      }
-      d = create_driver(conf)
-
-      d.instance.parse(text) { |time, record|
-        assert time && time >= time_at_start, "parser puts current time without time input"
-        assert_equal "tagomori_satoshi", record["name"]
-        assert_equal "tagomoris", record["user"]
-        assert_equal 34, record["age"]
-      }
-    end
-
-    def test_parse_without_time_estimate_curent_event_false
-      text = "tagomori_satoshi tagomoris 34\n"
-      conf = {
-        'expression' => %q!/^(?<name>[^ ]*) (?<user>[^ ]*) (?<age>\d*)$/!,
-        'types' => 'name:string,user:string,age:integer'
-      }
-      d = create_driver(conf)
-      d.instance.estimate_current_event = false
-      d.instance.parse(text) { |time, record|
-        assert_equal "tagomori_satoshi", record["name"]
-        assert_equal "tagomoris", record["user"]
-        assert_equal 34, record["age"]
-
-        assert_nil time, "parser returns nil if configured so"
-      }
-    end
-
-    def test_parse_with_keep_time_key
-      conf = {
-        'expression' => %q!/(?<time>.*)/!,
-        'time_format' => "%d/%b/%Y:%H:%M:%S %z",
-        'keep_time_key' => 'true',
-      }
-      d = create_driver(conf)
-      text = '28/Feb/2013:12:00:00 +0900'
-      d.instance.parse(text) do |_time, record|
-        assert_equal text, record['time']
-      end
-    end
-
-    def test_parse_with_keep_time_key_with_typecast
-      conf = {
-        'expression' => %q!/(?<time>.*)/!,
-        'time_format' => "%d/%b/%Y:%H:%M:%S %z",
-        'keep_time_key' => 'true',
-        'types' => 'time:time:%d/%b/%Y:%H:%M:%S %z',
-      }
-      d = create_driver(conf)
-      text = '28/Feb/2013:12:00:00 +0900'
-      d.instance.parse(text) do |_time, record|
-        assert_equal 1362020400, record['time']
-      end
-    end
-  end
-end