fluentd 1.14.4-x64-mingw-ucrt

data/test/plugin/test_parser_csv.rb

@@ -0,0 +1,200 @@
+require_relative '../helper'
+require 'fluent/test/driver/parser'
+require 'fluent/plugin/parser_csv'
+
+class CSVParserTest < ::Test::Unit::TestCase
+  def setup
+    Fluent::Test.setup
+  end
+
+  def create_driver(conf={})
+    Fluent::Test::Driver::Parser.new(Fluent::Plugin::CSVParser).configure(conf)
+  end
+
+  data('array param' => '["time","c","d"]', 'string param' => 'time,c,d')
+  def test_parse(param)
+    d = create_driver('keys' => param, 'time_key' => 'time')
+    d.instance.parse("2013/02/28 12:00:00,192.168.0.1,111") { |time, record|
+      assert_equal(event_time('2013/02/28 12:00:00', format: '%Y/%m/%d %H:%M:%S'), time)
+      assert_equal({
+                     'c' => '192.168.0.1',
+                     'd' => '111',
+                   }, record)
+    }
+  end
+
+  data('array param' => '["c","d"]', 'string param' => 'c,d')
+  def test_parse_without_time(param)
+    time_at_start = Time.now.to_i
+
+    d = create_driver('keys' => param)
+    d.instance.parse("192.168.0.1,111") { |time, record|
+      assert time && time >= time_at_start, "parser puts current time without time input"
+      assert_equal({
+                     'c' => '192.168.0.1',
+                     'd' => '111',
+                   }, record)
+    }
+
+    d = Fluent::Test::Driver::Parser.new(Fluent::Plugin::CSVParser)
+    d.configure('keys' => param, 'estimate_current_event' => 'no')
+    d.instance.parse("192.168.0.1,111") { |time, record|
+      assert_equal({
+                     'c' => '192.168.0.1',
+                     'd' => '111',
+                   }, record)
+      assert_nil time, "parser returns nil w/o time and if configured so"
+    }
+  end
+
+  def test_parse_with_keep_time_key
+    d = create_driver(
+                     'keys'=>'time',
+                     'time_key'=>'time',
+                     'time_format'=>"%d/%b/%Y:%H:%M:%S %z",
+                     'keep_time_key'=>'true',
+                     )
+    text = '28/Feb/2013:12:00:00 +0900'
+    d.instance.parse(text) do |time, record|
+      assert_equal text, record['time']
+    end
+  end
+
+  data('array param' => '["a","b","c","d","e","f"]', 'string param' => 'a,b,c,d,e,f')
+  def test_parse_with_null_value_pattern(param)
+    d = create_driver(
+                     'keys'=>param,
+                     'null_value_pattern'=>'^(-|null|NULL)$'
+                     )
+    d.instance.parse("-,null,NULL,,--,nuLL") do |time, record|
+      assert_nil record['a']
+      assert_nil record['b']
+      assert_nil record['c']
+      assert_nil record['d']
+      assert_equal record['e'], '--'
+      assert_equal record['f'], 'nuLL'
+    end
+  end
+
+  data('array param' => '["a","b"]', 'string param' => 'a,b')
+  def test_parse_with_null_empty_string(param)
+    d = create_driver(
+                     'keys'=>param,
+                     'null_empty_string'=>true
+                     )
+    d.instance.parse(", ") do |time, record|
+      assert_nil record['a']
+      assert_equal record['b'], ' '
+    end
+  end
+
+  data('array param' => '["a","b","c"]', 'string param' => 'a,b,c')
+  def test_parse_with_option_delimiter(param)
+    d = create_driver(
+                     'keys'=>param,
+                     'delimiter'=>' ',
+                     )
+    d.instance.parse("123 456 789") do |time, record|
+      assert_equal record['a'], '123'
+      assert_equal record['b'], '456'
+      assert_equal record['c'], '789'
+    end
+  end
+
+  sub_test_case 'parser' do
+    data('normal' => 'normal',
+         'fast' => 'fast')
+    def test_compatibility_between_normal_and_fast_parser(param)
+      d = create_driver(
+        'keys' => 'time,key1,key2,key3,key4,key5',
+        'time_key' => 'time',
+        'time_format' => "%d/%b/%Y:%H:%M:%S %z",
+        'keep_time_key' => 'false',
+        'parser_type' => param
+      )
+
+      # non quoted
+      text = '28/Feb/2013:12:00:00 +0900,value1,value2,value3,value4,value5'
+      expected = {'key1' => 'value1', 'key2' => 'value2', 'key3' => "value3",
+                  'key4' => 'value4', 'key5' => "value5"}
+      d.instance.parse(text) do |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
+
+      # quoted
+      text = '28/Feb/2013:12:00:00 +0900,"value1","val,ue2","va,lu,e3","val ue4",""'
+      expected = {'key1' => 'value1', 'key2' => 'val,ue2', 'key3' => "va,lu,e3",
+                  'key4' => 'val ue4', 'key5' => ""}
+      d.instance.parse(text) do |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
+
+      # mixed
+      text = '28/Feb/2013:12:00:00 +0900,message,"mes,sage","me,ssa,ge",mess age,""'
+      expected = {'key1' => 'message', 'key2' => 'mes,sage', 'key3' => "me,ssa,ge",
+                  'key4' => 'mess age', 'key5' => ""}
+      d.instance.parse(text) do |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
+
+      # escaped
+      text = '28/Feb/2013:12:00:00 +0900,"message","mes""sage","""message""",,""""""'
+      expected = {'key1' => 'message', 'key2' => 'mes"sage', 'key3' => '"message"',
+                  'key4' => nil, 'key5' => '""'}
+      d.instance.parse(text) do |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
+    end
+
+    def test_incompatibility_between_normal_and_fast_parser
+      normal = create_driver(
+        'keys' => 'key1,key2',
+        'parser_type' => 'normal'
+      )
+      fast = create_driver(
+        'keys' => 'key1,key2',
+        'parser_type' => 'fast'
+      )
+
+      # unexpected quote position
+      text = 'a"b,"a"""c"'
+      assert_raise(CSV::MalformedCSVError) {
+        normal.instance.parse(text) { |t, r| }
+      } 
+      assert_nothing_raised {
+        # generate broken record
+        fast.instance.parse(text) { |t, r| }
+      }
+
+      # incorrect the number of column
+      text = 'a,b,c'
+      expected = {"key1" => 'a', "key2" => 'b'}
+      normal.instance.parse(text) { |t, r|
+        assert_equal expected, r
+      }
+      fast.instance.parse(text) { |t, r|
+        assert_not_equal expected, r
+      }
+
+      # And more...
+    end
+  end
+
+  # "parser_type" config shouldn't hide Fluent::Plugin::Parser#plugin_type
+  # https://github.com/fluent/fluentd/issues/3296
+  data('normal' => :normal, 'fast' => :fast)
+  def test_parser_type_method(engine)
+    d = create_driver('keys' => '["time"]','time_key' => 'time', 'parser_type' => engine.to_s)
+    assert_equal(:text_per_line, d.instance.parser_type)
+  end
+
+  data('normal' => :normal, 'fast' => :fast)
+  def test_parser_engine(engine)
+    d = create_driver('keys' => '["time"]', 'time_key' => 'time', 'parser_engine' => engine.to_s)
+    assert_equal(engine, d.instance.parser_engine)
+  end
+end

data/test/plugin/test_parser_json.rb

@@ -0,0 +1,138 @@
+require_relative '../helper'
+require 'fluent/test/driver/parser'
+require 'fluent/plugin/parser'
+
+class JsonParserTest < ::Test::Unit::TestCase
+  def setup
+    Fluent::Test.setup
+    @parser = Fluent::Test::Driver::Parser.new(Fluent::Plugin::JSONParser)
+  end
+
+  data('oj' => 'oj', 'yajl' => 'yajl')
+  def test_parse(data)
+    @parser.configure('json_parser' => data)
+    @parser.instance.parse('{"time":1362020400,"host":"192.168.0.1","size":777,"method":"PUT"}') { |time, record|
+      assert_equal(event_time('2013-02-28 12:00:00 +0900').to_i, time)
+      assert_equal({
+                     'host'   => '192.168.0.1',
+                     'size'   => 777,
+                     'method' => 'PUT',
+                   }, record)
+    }
+  end
+
+  data('oj' => 'oj', 'yajl' => 'yajl')
+  def test_parse_with_large_float(data)
+    @parser.configure('json_parser' => data)
+    @parser.instance.parse('{"num":999999999999999999999999999999.99999}') { |time, record|
+      assert_equal(Float, record['num'].class)
+    }
+  end
+
+  data('oj' => 'oj', 'yajl' => 'yajl')
+  def test_parse_without_time(data)
+    time_at_start = Time.now.to_i
+
+    @parser.configure('json_parser' => data)
+    @parser.instance.parse('{"host":"192.168.0.1","size":777,"method":"PUT"}') { |time, record|
+      assert time && time >= time_at_start, "parser puts current time without time input"
+      assert_equal({
+                     'host'   => '192.168.0.1',
+                     'size'   => 777,
+                     'method' => 'PUT',
+                   }, record)
+    }
+
+    parser = Fluent::Test::Driver::Parser.new(Fluent::Plugin::JSONParser)
+    parser.configure('json_parser' => data, 'estimate_current_event' => 'false')
+    parser.instance.parse('{"host":"192.168.0.1","size":777,"method":"PUT"}') { |time, record|
+      assert_equal({
+                     'host'   => '192.168.0.1',
+                     'size'   => 777,
+                     'method' => 'PUT',
+                   }, record)
+      assert_nil time, "parser return nil w/o time and if specified so"
+    }
+  end
+
+  data('oj' => 'oj', 'yajl' => 'yajl')
+  def test_parse_with_colon_string(data)
+    @parser.configure('json_parser' => data)
+    @parser.instance.parse('{"time":1362020400,"log":":message"}') { |time, record|
+      assert_equal(record['log'], ':message')
+    }
+  end
+
+  data('oj' => 'oj', 'yajl' => 'yajl')
+  def test_parse_with_invalid_time(data)
+    @parser.configure('json_parser' => data)
+    assert_raise Fluent::ParserError do
+      @parser.instance.parse('{"time":[],"k":"v"}') { |time, record| }
+    end
+  end
+
+  data('oj' => 'oj', 'yajl' => 'yajl')
+  def test_parse_float_time(data)
+    parser = Fluent::Test::Driver::Parser.new(Fluent::Plugin::JSONParser)
+    parser.configure('json_parser' => data)
+    text = "100.1"
+    parser.instance.parse("{\"time\":\"#{text}\"}") do |time, record|
+      assert_equal 100, time.sec
+      assert_equal 100_000_000, time.nsec
+    end
+  end
+
+  data('oj' => 'oj', 'yajl' => 'yajl')
+  def test_parse_with_keep_time_key(data)
+    parser = Fluent::Test::Driver::Parser.new(Fluent::Plugin::JSONParser)
+    format = "%d/%b/%Y:%H:%M:%S %z"
+    parser.configure(
+                     'time_format' => format,
+                     'keep_time_key' => 'true',
+                     'json_parser' => data
+                     )
+    text = "28/Feb/2013:12:00:00 +0900"
+    parser.instance.parse("{\"time\":\"#{text}\"}") do |time, record|
+      assert_equal Time.strptime(text, format).to_i, time.sec
+      assert_equal text, record['time']
+    end
+  end
+
+  data('oj' => 'oj', 'yajl' => 'yajl')
+  def test_parse_with_keep_time_key_without_time_format(data)
+    parser = Fluent::Test::Driver::Parser.new(Fluent::Plugin::JSONParser)
+    parser.configure(
+                     'keep_time_key' => 'true',
+                     'json_parser' => data
+                     )
+    text = "100"
+    parser.instance.parse("{\"time\":\"#{text}\"}") do |time, record|
+      assert_equal text.to_i, time.sec
+      assert_equal text, record['time']
+    end
+  end
+
+  def test_yajl_parse_io_with_buffer_smaller_than_input
+    parser = Fluent::Test::Driver::Parser.new(Fluent::Plugin::JSONParser)
+    parser.configure(
+                     'keep_time_key' => 'true',
+                     'json_parser' => 'yajl',
+                     'stream_buffer_size' => 1,
+                     )
+    text = "100"
+
+    waiting(5) do
+      rd, wr = IO.pipe
+      wr.write "{\"time\":\"#{text}\"}"
+
+      parser.instance.parse_io(rd) do |time, record|
+        assert_equal text.to_i, time.sec
+        assert_equal text, record['time']
+
+        # Once a record has been received the 'write' end of the pipe must be
+        # closed, otherwise the test will block waiting for more input.
+        wr.close
+      end
+    end
+  end
+end

data/test/plugin/test_parser_labeled_tsv.rb

@@ -0,0 +1,160 @@
+require_relative '../helper'
+require 'fluent/test/driver/parser'
+require 'fluent/plugin/parser'
+
+class LabeledTSVParserTest < ::Test::Unit::TestCase
+  def setup
+    Fluent::Test.setup
+  end
+
+  def test_config_params
+    parser = Fluent::Test::Driver::Parser.new(Fluent::TextParser::LabeledTSVParser)
+
+    assert_equal "\t", parser.instance.delimiter
+    assert_equal  ":", parser.instance.label_delimiter
+
+    parser.configure(
+                     'delimiter'       => ',',
+                     'label_delimiter' => '=',
+                     )
+
+    assert_equal ",", parser.instance.delimiter
+    assert_equal "=", parser.instance.label_delimiter
+  end
+
+  def test_parse
+    parser = Fluent::Test::Driver::Parser.new(Fluent::TextParser::LabeledTSVParser)
+    parser.configure({})
+    parser.instance.parse("time:2013/02/28 12:00:00\thost:192.168.0.1\treq_id:111") { |time, record|
+      assert_equal(event_time('2013/02/28 12:00:00', format: '%Y/%m/%d %H:%M:%S'), time)
+      assert_equal({
+                     'host'   => '192.168.0.1',
+                     'req_id' => '111',
+                   }, record)
+    }
+  end
+
+  def test_parse_with_customized_delimiter
+    parser = Fluent::Test::Driver::Parser.new(Fluent::TextParser::LabeledTSVParser)
+    parser.configure(
+                     'delimiter'       => ',',
+                     'label_delimiter' => '=',
+                     )
+    parser.instance.parse('time=2013/02/28 12:00:00,host=192.168.0.1,req_id=111') { |time, record|
+      assert_equal(event_time('2013/02/28 12:00:00', format: '%Y/%m/%d %H:%M:%S'), time)
+      assert_equal({
+                     'host'   => '192.168.0.1',
+                     'req_id' => '111',
+                   }, record)
+    }
+  end
+
+  def test_parse_with_customized_time_format
+    parser = Fluent::Test::Driver::Parser.new(Fluent::TextParser::LabeledTSVParser)
+    parser.configure(
+                     'time_key'    => 'mytime',
+                     'time_format' => '%d/%b/%Y:%H:%M:%S %z',
+                     )
+    parser.instance.parse("mytime:28/Feb/2013:12:00:00 +0900\thost:192.168.0.1\treq_id:111") { |time, record|
+      assert_equal(event_time('28/Feb/2013:12:00:00 +0900', format: '%d/%b/%Y:%H:%M:%S %z'), time)
+      assert_equal({
+                     'host'   => '192.168.0.1',
+                     'req_id' => '111',
+                   }, record)
+    }
+  end
+
+  def test_parse_without_time
+    time_at_start = Time.now.to_i
+
+    parser = Fluent::Test::Driver::Parser.new(Fluent::Plugin::LabeledTSVParser)
+    parser.configure({})
+    parser.instance.parse("host:192.168.0.1\treq_id:111") { |time, record|
+      assert time && time >= time_at_start, "parser puts current time without time input"
+      assert_equal({
+                     'host'   => '192.168.0.1',
+                     'req_id' => '111',
+                   }, record)
+    }
+
+    parser = Fluent::Test::Driver::Parser.new(Fluent::Plugin::LabeledTSVParser)
+    parser.configure({'estimate_current_event' => 'no'})
+    parser.instance.parse("host:192.168.0.1\treq_id:111") { |time, record|
+      assert_equal({
+                     'host'   => '192.168.0.1',
+                     'req_id' => '111',
+                   }, record)
+      assert_nil time, "parser returns nil w/o time and if configured so"
+    }
+  end
+
+  def test_parse_with_keep_time_key
+    parser = Fluent::Test::Driver::Parser.new(Fluent::Plugin::LabeledTSVParser)
+    parser.configure(
+                     'time_format'=>"%d/%b/%Y:%H:%M:%S %z",
+                     'keep_time_key'=>'true',
+                     )
+    text = '28/Feb/2013:12:00:00 +0900'
+    parser.instance.parse("time:#{text}") do |time, record|
+      assert_equal text, record['time']
+    end
+  end
+
+  def test_parse_and_reject_invalid_kv_pairs
+    parser = Fluent::Test::Driver::Parser.new(Fluent::Plugin::LabeledTSVParser)
+    parser.configure(
+                     'delimiter'       => ' ',
+                     'label_delimiter' => '=',
+                     )
+    text = 'A leading portion that is not LTSV    :  foo=bar baz=derp and a trailing portion'
+
+    expected = {'foo' => 'bar', 'baz' => 'derp'}
+    parser.instance.parse(text) do |time, record|
+      assert_equal expected, record
+    end
+
+  end
+
+  def test_parse_with_null_value_pattern
+    parser = Fluent::Test::Driver::Parser.new(Fluent::Plugin::LabeledTSVParser)
+    parser.configure(
+                     'null_value_pattern'=>'^(-|null|NULL)$'
+                     )
+    parser.instance.parse("a:-\tb:null\tc:NULL\td:\te:--\tf:nuLL") do |time, record|
+      assert_nil record['a']
+      assert_nil record['b']
+      assert_nil record['c']
+      assert_equal record['d'], ''
+      assert_equal record['e'], '--'
+      assert_equal record['f'], 'nuLL'
+    end
+  end
+
+  def test_parse_with_null_empty_string
+    parser = Fluent::Test::Driver::Parser.new(Fluent::Plugin::LabeledTSVParser)
+    parser.configure(
+                     'null_empty_string'=>true
+                     )
+    parser.instance.parse("a:\tb: ") do |time, record|
+      assert_nil record['a']
+      assert_equal record['b'], ' '
+    end
+  end
+
+  data("single space" => ["k1=v1 k2=v2", { "k1" => "v1", "k2" => "v2" }],
+       "multiple space" => ["k1=v1    k2=v2", { "k1" => "v1", "k2" => "v2" }],
+       "reverse" => ["k2=v2 k1=v1", { "k1" => "v1", "k2" => "v2" }],
+       "tab" => ["k2=v2\tk1=v1", { "k1" => "v1", "k2" => "v2" }],
+       "tab and space" => ["k2=v2\t k1=v1", { "k1" => "v1", "k2" => "v2" }])
+  def test_parse_with_delimiter_pattern(data)
+    text, expected = data
+    parser = Fluent::Test::Driver::Parser.new(Fluent::Plugin::LabeledTSVParser)
+    parser.configure(
+                     'delimiter_pattern' => '/\s+/',
+                     'label_delimiter' => '='
+                    )
+    parser.instance.parse(text) do |_time, record|
+      assert_equal(expected, record)
+    end
+  end
+end

data/test/plugin/test_parser_multiline.rb

@@ -0,0 +1,111 @@
+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