fluentd 1.10.4-x86-mingw32 → 1.11.4-x86-mingw32

data/test/plugin/test_in_tail.rb

@@ -1403,6 +1403,9 @@ class TailInputTest < Test::Unit::TestCase
     end
 
     def test_tail_path_with_multiline_with_multiple_paths
+      if ENV["APPVEYOR"] && Fluent.windows?
+        omit "This testcase is unstable on AppVeyor."
+      end
       files = ["#{TMP_DIR}/tail1.txt", "#{TMP_DIR}/tail2.txt"]
       files.each { |file| File.open(file, "wb") { |f| } }
 

data/test/plugin/test_in_unix.rb

@@ -1,125 +1,181 @@
 require_relative '../helper'
-require 'fluent/test'
+require 'fluent/test/driver/input'
 require 'fluent/plugin/in_unix'
 
-module StreamInputTest
+class UnixInputTest < Test::Unit::TestCase
   def setup
     Fluent::Test.setup
+    @d = nil
   end
 
-  def test_time
-    d = create_driver
+  def teardown
+    @d.instance_shutdown if @d
+  end
 
-    time = Fluent::EventTime.parse("2011-01-02 13:14:15 UTC")
+  TMP_DIR = File.dirname(__FILE__) + "/../tmp/in_unix#{ENV['TEST_ENV_NUMBER']}"
+  CONFIG = %[
+    path #{TMP_DIR}/unix
+    backlog 1000
+  ]
+
+  def create_driver(conf = CONFIG)
+    Fluent::Test::Driver::Input.new(Fluent::Plugin::UnixInput).configure(conf)
+  end
 
-    d.expect_emit "tag1", time, {"a"=>1}
-    d.expect_emit "tag2", time, {"a"=>2}
+  def packer(*args)
+    Fluent::MessagePackFactory.msgpack_packer(*args)
+  end
 
-    d.run do
-      d.expected_emits.each {|tag,_time,record|
-        send_data Fluent::MessagePackFactory.msgpack_packer.write([tag, _time, record]).to_s
+  def unpacker
+    Fluent::MessagePackFactory.msgpack_unpacker
+  end
+
+  def send_data(data)
+    io = UNIXSocket.new("#{TMP_DIR}/unix")
+    begin
+      io.write data
+    ensure
+      io.close
+    end
+  end
+
+  def test_configure
+    @d = create_driver
+    assert_equal "#{TMP_DIR}/unix", @d.instance.path
+    assert_equal 1000, @d.instance.backlog
+  end
+
+  def test_time
+    @d = create_driver
+
+    time = Fluent::EventTime.now
+    records = [
+      ["tag1", 0, {"a" => 1}],
+      ["tag2", nil, {"a" => 2}],
+    ]
+
+    @d.run(expect_records: records.length, timeout: 5) do
+      records.each {|tag, _time, record|
+        send_data packer.write([tag, _time, record]).to_s
       }
     end
+
+    @d.events.each_with_index { |e, i|
+      orig = records[i]
+      assert_equal(orig[0], e[0])
+      assert_true(time <= e[1])
+      assert_equal(orig[2], e[2])
+    }
   end
 
   def test_message
-    d = create_driver
+    @d = create_driver
 
-    time = Fluent::EventTime.parse("2011-01-02 13:14:15 UTC")
-
-    d.expect_emit "tag1", time, {"a"=>1}
-    d.expect_emit "tag2", time, {"a"=>2}
+    time = Fluent::EventTime.now
+    records = [
+      ["tag1", time, {"a" => 1}],
+      ["tag2", time, {"a" => 2}],
+    ]
 
-    d.run do
-      d.expected_emits.each {|tag,_time,record|
-        send_data Fluent::MessagePackFactory.msgpack_packer.write([tag, _time, record]).to_s
+    @d.run(expect_records: records.length, timeout: 5) do
+      records.each {|tag, _time, record|
+        send_data packer.write([tag, _time, record]).to_s
       }
     end
+
+    assert_equal(records, @d.events)
   end
 
   def test_forward
-    d = create_driver
+    @d = create_driver
 
     time = Fluent::EventTime.parse("2011-01-02 13:14:15 UTC")
+    records = [
+      ["tag1", time, {"a" => 1}],
+      ["tag1", time, {"a" => 2}]
+    ]
 
-    d.expect_emit "tag1", time, {"a"=>1}
-    d.expect_emit "tag1", time, {"a"=>2}
-
-    d.run do
+    @d.run(expect_records: records.length, timeout: 20) do
       entries = []
-      d.expected_emits.each {|tag,_time,record|
+      records.each {|tag, _time, record|
         entries << [_time, record]
       }
-      send_data Fluent::MessagePackFactory.msgpack_packer.write(["tag1", entries]).to_s
+      send_data packer.write(["tag1", entries]).to_s
     end
+    assert_equal(records, @d.events)
   end
 
   def test_packed_forward
-    d = create_driver
+    @d = create_driver
 
-    time = Fluent::EventTime.parse("2011-01-02 13:14:15 UTC")
-
-    d.expect_emit "tag1", time, {"a"=>1}
-    d.expect_emit "tag1", time, {"a"=>2}
+    time = Fluent::EventTime.now
+    records = [
+      ["tag1", time, {"a" => 1}],
+      ["tag1", time, {"a" => 2}],
+    ]
 
-    d.run do
+    @d.run(expect_records: records.length, timeout: 20) do
       entries = ''
-      d.expected_emits.each {|tag,_time,record|
-        Fluent::MessagePackFactory.msgpack_packer(entries).write([_time, record]).flush
+      records.each {|_tag, _time, record|
+        packer(entries).write([_time, record]).flush
       }
-      send_data Fluent::MessagePackFactory.msgpack_packer.write(["tag1", entries]).to_s
+      send_data packer.write(["tag1", entries]).to_s
     end
+    assert_equal(records, @d.events)
   end
 
   def test_message_json
-    d = create_driver
+    @d = create_driver
+
+    time = Fluent::EventTime.now
+    records = [
+      ["tag1", time, {"a" => 1}],
+      ["tag2", time, {"a" => 2}],
+    ]
+
+    @d.run(expect_records: records.length, timeout: 5) do
+      tag, _time, record = records[0]
+      send_data [tag, _time.to_i, record].to_json
+      tag, _time, record = records[1]
+      send_data [tag, _time.to_f, record].to_json
+    end
 
-    time = Time.parse("2011-01-02 13:14:15 UTC").to_i
+    assert_equal(records, @d.events)
+  end
+
+  def test_message_with_tag
+    @d = create_driver(CONFIG + "tag new_tag")
 
-    d.expect_emit "tag1", time, {"a"=>1}
-    d.expect_emit "tag2", time, {"a"=>2}
+    time = Fluent::EventTime.now
+    records = [
+      ["tag1", time, {"a" => 1}],
+      ["tag2", time, {"a" => 2}],
+    ]
 
-    d.run do
-      d.expected_emits.each {|tag,_time,record|
-        send_data [tag, time, record].to_json
+    @d.run(expect_records: records.length, timeout: 5) do
+      records.each {|tag, _time, record|
+        send_data packer.write([tag, _time, record]).to_s
       }
     end
-  end
 
-  def create_driver(klass, conf)
-    Fluent::Test::InputTestDriver.new(klass).configure(conf)
+    @d.events.each { |event|
+      assert_equal("new_tag", event[0])
+    }
   end
 
-  def send_data(data)
-    io = connect
-    begin
-      io.write data
-    ensure
-      io.close
+  data('string chunk' => 'broken string',
+       'integer chunk' => 10)
+  def test_broken_message(data)
+    @d = create_driver
+    @d.run(shutdown: false, timeout: 5) do
+      @d.instance.__send__(:on_message, data)
     end
-  end
-end
-
-class UnixInputTest < Test::Unit::TestCase
-  include StreamInputTest
-
-  TMP_DIR = File.dirname(__FILE__) + "/../tmp/in_unix#{ENV['TEST_ENV_NUMBER']}"
-  CONFIG = %[
-    path #{TMP_DIR}/unix
-    backlog 1000
-  ]
 
-  def create_driver(conf=CONFIG)
-    super(Fluent::UnixInput, conf)
-  end
-
-  def test_configure
-    d = create_driver
-    assert_equal "#{TMP_DIR}/unix", d.instance.path
-    assert_equal 1000, d.instance.backlog
-  end
+    assert_equal 0, @d.events.size
 
-  def connect
-    UNIXSocket.new("#{TMP_DIR}/unix")
+    logs = @d.instance.log.logs
+    assert_equal 1, logs.select { |line|
+      line =~ / \[warn\]: incoming data is broken: msg=#{data.inspect}/
+    }.size, "should not accept broken chunk"
   end
 end unless Fluent.windows?

data/test/plugin/test_output.rb

@@ -378,6 +378,18 @@ class OutputTest < Test::Unit::TestCase
       assert { logs.any? { |log| log.include?("${chunk_id} is not allowed in this plugin") } }
     end
 
+    test '#extract_placeholders does not log for ${chunk_id} placeholder' do
+      @i.configure(config_element('ROOT', '', {}, [config_element('buffer', '')]))
+      tmpl = "/mypath/${chunk_id}/tail"
+      t = event_time('2016-04-11 20:30:00 +0900')
+      v = {key1: "value1", key2: "value2"}
+      c = create_chunk(timekey: t, tag: 'fluentd.test.output', variables: v)
+      @i.log.out.logs.clear
+      @i.extract_placeholders(tmpl, c)
+      logs = @i.log.out.logs
+      assert { logs.none? { |log| log.include?("${chunk_id}") } }
+    end
+
     test '#extract_placeholders logs warn message with not replaced key' do
       @i.configure(config_element('ROOT', '', {}, [config_element('buffer', '')]))
       tmpl = "/mypath/${key1}/test"

data/test/plugin/test_parser_syslog.rb

@@ -35,8 +35,9 @@ class SyslogParserTest < ::Test::Unit::TestCase
     assert_equal('%b %d %M:%S:%H', @parser.instance.patterns['time_format'])
   end
 
-  def test_parse_with_time_format2
-    @parser.configure('time_format' => '%Y-%m-%dT%H:%M:%SZ')
+  data('regexp' => 'regexp', 'string' => 'string')
+  def test_parse_with_time_format2(param)
+    @parser.configure('time_format' => '%Y-%m-%dT%H:%M:%SZ', 'parser_type' => param)
     @parser.instance.parse('2020-03-03T10:14:29Z 192.168.0.1 fluentd[11111]: [error] Syslog test') { |time, record|
       assert_equal(event_time('Mar 03 10:14:29', format: '%b %d %H:%M:%S'), time)
       assert_equal(@expected, record)
@@ -198,11 +199,13 @@ class SyslogParserTest < ::Test::Unit::TestCase
   end
 
   class TestRFC5424Regexp < self
-    def test_parse_with_rfc5424_message
+    data('regexp' => 'regexp', 'string' => 'string')
+    def test_parse_with_rfc5424_message(param)
       @parser.configure(
                         'time_format' => '%Y-%m-%dT%H:%M:%S.%L%z',
                         'message_format' => 'rfc5424',
                         'with_priority' => true,
+                        'parser_type' => param
                         )
       text = '<16>1 2017-02-06T13:14:15.003Z 192.168.0.1 fluentd - - - Hi, from Fluentd!'
       @parser.instance.parse(text) do |time, record|
@@ -215,11 +218,13 @@ class SyslogParserTest < ::Test::Unit::TestCase
       assert_equal(Fluent::Plugin::SyslogParser::RFC5424_WITHOUT_TIME_AND_PRI_REGEXP, @parser.instance.patterns['format'])
     end
 
-    def test_parse_with_rfc5424_message_trailing_eol
+    data('regexp' => 'regexp', 'string' => 'string')
+    def test_parse_with_rfc5424_message_trailing_eol(param)
       @parser.configure(
                         'time_format' => '%Y-%m-%dT%H:%M:%S.%L%z',
                         'message_format' => 'rfc5424',
                         'with_priority' => true,
+                        'parser_type' => param
                         )
       text = "<16>1 2017-02-06T13:14:15.003Z 192.168.0.1 fluentd - - - Hi, from Fluentd!\n"
       @parser.instance.parse(text) do |time, record|
@@ -232,11 +237,13 @@ class SyslogParserTest < ::Test::Unit::TestCase
       assert_equal(Fluent::Plugin::SyslogParser::RFC5424_WITHOUT_TIME_AND_PRI_REGEXP, @parser.instance.patterns['format'])
     end
 
-    def test_parse_with_rfc5424_multiline_message
+    data('regexp' => 'regexp', 'string' => 'string')
+    def test_parse_with_rfc5424_multiline_message(param)
       @parser.configure(
                         'time_format' => '%Y-%m-%dT%H:%M:%S.%L%z',
                         'message_format' => 'rfc5424',
                         'with_priority' => true,
+                        'parser_type' => param
                         )
       text = "<16>1 2017-02-06T13:14:15.003Z 192.168.0.1 fluentd - - - Hi,\nfrom\nFluentd!"
       @parser.instance.parse(text) do |time, record|
@@ -249,10 +256,12 @@ class SyslogParserTest < ::Test::Unit::TestCase
       assert_equal(Fluent::Plugin::SyslogParser::RFC5424_WITHOUT_TIME_AND_PRI_REGEXP, @parser.instance.patterns['format'])
     end
 
-    def test_parse_with_rfc5424_message_and_without_priority
+    data('regexp' => 'regexp', 'string' => 'string')
+    def test_parse_with_rfc5424_message_and_without_priority(param)
       @parser.configure(
                         'time_format' => '%Y-%m-%dT%H:%M:%S.%L%z',
                         'message_format' => 'rfc5424',
+                        'parser_type' => param
                         )
       text = '2017-02-06T13:14:15.003Z 192.168.0.1 fluentd - - - Hi, from Fluentd!'
       @parser.instance.parse(text) do |time, record|
@@ -265,10 +274,12 @@ class SyslogParserTest < ::Test::Unit::TestCase
       assert_equal(Fluent::Plugin::SyslogParser::RFC5424_WITHOUT_TIME_AND_PRI_REGEXP, @parser.instance.patterns['format'])
     end
 
-    def test_parse_with_rfc5424_empty_message_and_without_priority
+    data('regexp' => 'regexp', 'string' => 'string')
+    def test_parse_with_rfc5424_empty_message_and_without_priority(param)
       @parser.configure(
                         'time_format' => '%Y-%m-%dT%H:%M:%S.%L%z',
                         'message_format' => 'rfc5424',
+                        'parser_type' => param
                         )
       text = '2017-02-06T13:14:15.003Z 192.168.0.1 fluentd - - -'
       @parser.instance.parse(text) do |time, record|
@@ -281,10 +292,12 @@ class SyslogParserTest < ::Test::Unit::TestCase
       assert_equal(Fluent::Plugin::SyslogParser::RFC5424_WITHOUT_TIME_AND_PRI_REGEXP, @parser.instance.patterns['format'])
     end
 
-    def test_parse_with_rfc5424_message_without_time_format
+    data('regexp' => 'regexp', 'string' => 'string')
+    def test_parse_with_rfc5424_message_without_time_format(param)
       @parser.configure(
                         'message_format' => 'rfc5424',
                         'with_priority' => true,
+                        'parser_type' => param
                         )
       text = '<16>1 2017-02-06T13:14:15.003Z 192.168.0.1 fluentd - - - Hi, from Fluentd!'
       @parser.instance.parse(text) do |time, record|
@@ -296,10 +309,12 @@ class SyslogParserTest < ::Test::Unit::TestCase
       end
     end
 
-    def test_parse_with_rfc5424_message_with_priority_and_pid
+    data('regexp' => 'regexp', 'string' => 'string')
+    def test_parse_with_rfc5424_message_with_priority_and_pid(param)
       @parser.configure(
                         'message_format' => 'rfc5424',
                         'with_priority' => true,
+                        'parser_type' => param
                         )
       text = '<28>1 2018-09-26T15:54:26.620412+09:00 machine minissdpd 1298 - -  peer 192.168.0.5:50123 is not from a LAN'
       @parser.instance.parse(text) do |time, record|
@@ -311,11 +326,13 @@ class SyslogParserTest < ::Test::Unit::TestCase
       end
     end
 
-    def test_parse_with_rfc5424_structured_message
+    data('regexp' => 'regexp', 'string' => 'string')
+    def test_parse_with_rfc5424_structured_message(param)
       @parser.configure(
                         'time_format' => '%Y-%m-%dT%H:%M:%S.%L%z',
                         'message_format' => 'rfc5424',
                         'with_priority' => true,
+                        'parser_type' => param
                         )
       text = '<16>1 2017-02-06T13:14:15.003Z 192.168.0.1 fluentd 11111 ID24224 [exampleSDID@20224 iut="3" eventSource="Application" eventID="11211"] [Hi] from Fluentd!'
       @parser.instance.parse(text) do |time, record|
@@ -328,11 +345,13 @@ class SyslogParserTest < ::Test::Unit::TestCase
       end
     end
 
-    def test_parse_with_rfc5424_multiple_structured_message
+    data('regexp' => 'regexp', 'string' => 'string')
+    def test_parse_with_rfc5424_multiple_structured_message(param)
       @parser.configure(
                         'time_format' => '%Y-%m-%dT%H:%M:%S.%L%z',
                         'message_format' => 'rfc5424',
                         'with_priority' => true,
+                        'parser_type' => param
                         )
       text = '<16>1 2017-02-06T13:14:15.003Z 192.168.0.1 fluentd 11111 ID24224 [exampleSDID@20224 iut="3" eventSource="Application" eventID="11211"][exampleSDID@20224 class="high"] Hi, from Fluentd!'
       @parser.instance.parse(text) do |time, record|
@@ -345,11 +364,13 @@ class SyslogParserTest < ::Test::Unit::TestCase
       end
     end
 
-    def test_parse_with_rfc5424_message_includes_right_bracket
+    data('regexp' => 'regexp', 'string' => 'string')
+    def test_parse_with_rfc5424_message_includes_right_bracket(param)
       @parser.configure(
                         'time_format' => '%Y-%m-%dT%H:%M:%S.%L%z',
                         'message_format' => 'rfc5424',
                         'with_priority' => true,
+                        'parser_type' => param
                         )
       text = '<16>1 2017-02-06T13:14:15.003Z 192.168.0.1 fluentd 11111 ID24224 [exampleSDID@20224 iut="3" eventSource="Application" eventID="11211"] [Hi] from Fluentd]!'
       @parser.instance.parse(text) do |time, record|
@@ -362,11 +383,13 @@ class SyslogParserTest < ::Test::Unit::TestCase
       end
     end
 
-    def test_parse_with_rfc5424_empty_message
+    data('regexp' => 'regexp', 'string' => 'string')
+    def test_parse_with_rfc5424_empty_message(param)
       @parser.configure(
                         'time_format' => '%Y-%m-%dT%H:%M:%S.%L%z',
                         'message_format' => 'rfc5424',
                         'with_priority' => true,
+                        'parser_type' => param
                         )
       text = '<16>1 2017-02-06T13:14:15.003Z 192.168.0.1 fluentd 11111 ID24224 [exampleSDID@20224 iut="3" eventSource="Application" eventID="11211"]'
       @parser.instance.parse(text) do |time, record|
@@ -379,10 +402,35 @@ class SyslogParserTest < ::Test::Unit::TestCase
       end
     end
 
-    def test_parse_with_rfc5424_message_without_subseconds
+    data('regexp' => 'regexp', 'string' => 'string')
+    def test_parse_with_rfc5424_space_empty_message(param)
+      @parser.configure(
+                        'message_format' => 'rfc5424',
+                        'with_priority' => true,
+                        'parser_type' => param
+                        )
+      text = '<16>1 2017-02-06T13:14:15.003Z 192.168.0.1 fluentd 11111 ID24224 [exampleSDID@20224 iut="3" eventSource="Application" eventID="11211"] '
+      @parser.instance.parse(text) do |time, record|
+        if param == 'string'
+          assert_equal(event_time("2017-02-06T13:14:15.003Z", format: '%Y-%m-%dT%H:%M:%S.%L%z'), time)
+          assert_equal "11111", record["pid"]
+          assert_equal "ID24224", record["msgid"]
+          assert_equal "[exampleSDID@20224 iut=\"3\" eventSource=\"Application\" eventID=\"11211\"]",
+                       record["extradata"]
+          assert_equal '', record["message"]
+        else
+          assert_nil time
+          assert_nil record
+        end
+      end
+    end
+
+    data('regexp' => 'regexp', 'string' => 'string')
+    def test_parse_with_rfc5424_message_without_subseconds(param)
       @parser.configure(
                         'message_format' => 'rfc5424',
                         'with_priority' => true,
+                        'parser_type' => param
                         )
       text = '<16>1 2017-02-06T13:14:15Z 192.168.0.1 fluentd - - - Hi, from Fluentd!'
       @parser.instance.parse(text) do |time, record|
@@ -394,10 +442,12 @@ class SyslogParserTest < ::Test::Unit::TestCase
       end
     end
 
-    def test_parse_with_rfc5424_message_both_timestamp
+    data('regexp' => 'regexp', 'string' => 'string')
+    def test_parse_with_rfc5424_message_both_timestamp(param)
       @parser.configure(
                         'message_format' => 'rfc5424',
                         'with_priority' => true,
+                        'parser_type' => param
                         )
       text = '<16>1 2017-02-06T13:14:15Z 192.168.0.1 fluentd - - - Hi, from Fluentd!'
       @parser.instance.parse(text) do |time, record|
@@ -431,7 +481,6 @@ class SyslogParserTest < ::Test::Unit::TestCase
         assert_equal(event_time("Feb 28 00:00:12", format: '%b %d %M:%S:%H'), time)
         assert_equal(@expected, record)
       end
-      assert_equal(Fluent::Plugin::SyslogParser::RFC3164_WITHOUT_TIME_AND_PRI_REGEXP, @parser.instance.patterns['format'])
     end
 
     data('regexp' => 'regexp', 'string' => 'string')
@@ -447,7 +496,6 @@ class SyslogParserTest < ::Test::Unit::TestCase
         assert_equal(event_time("Feb 28 12:00:00", format: '%b %d %M:%S:%H'), time)
         assert_equal(@expected.merge('pri' => 6), record)
       end
-      assert_equal(Fluent::Plugin::SyslogParser::RFC3164_WITHOUT_TIME_AND_PRI_REGEXP, @parser.instance.patterns['format'])
     end
 
     data('regexp' => 'regexp', 'string' => 'string')
@@ -467,7 +515,6 @@ class SyslogParserTest < ::Test::Unit::TestCase
         assert_equal 16, record["pri"]
         assert_equal "Hi, from Fluentd!", record["message"]
       end
-      assert_equal(Fluent::Plugin::SyslogParser::RFC5424_WITHOUT_TIME_AND_PRI_REGEXP, @parser.instance.patterns['format'])
     end
 
     data('regexp' => 'regexp', 'string' => 'string')
@@ -487,7 +534,7 @@ class SyslogParserTest < ::Test::Unit::TestCase
                      record["extradata"]
         assert_equal "Hi, from Fluentd!", record["message"]
       end
-      assert_equal(Fluent::Plugin::SyslogParser::RFC5424_WITHOUT_TIME_AND_PRI_REGEXP, @parser.instance.patterns['format'])end
+    end
 
     data('regexp' => 'regexp', 'string' => 'string')
     def test_parse_with_both_message_type(param)
@@ -503,7 +550,6 @@ class SyslogParserTest < ::Test::Unit::TestCase
         assert_equal(event_time("Feb 28 12:00:00", format: '%b %d %M:%S:%H'), time)
         assert_equal(@expected.merge('pri' => 1), record)
       end
-      assert_equal(Fluent::Plugin::SyslogParser::RFC3164_WITHOUT_TIME_AND_PRI_REGEXP, @parser.instance.patterns['format'])
 
       text = '<16>1 2017-02-06T13:14:15.003Z 192.168.0.1 fluentd 11111 ID24224 [exampleSDID@20224 iut="3" eventSource="Application" eventID="11211"] Hi, from Fluentd!'
       @parser.instance.parse(text) do |time, record|
@@ -514,21 +560,18 @@ class SyslogParserTest < ::Test::Unit::TestCase
                      record["extradata"]
         assert_equal "Hi, from Fluentd!", record["message"]
       end
-      assert_equal(Fluent::Plugin::SyslogParser::RFC5424_WITHOUT_TIME_AND_PRI_REGEXP, @parser.instance.patterns['format'])
 
       text = '<1>Feb 28 12:00:02 192.168.0.1 fluentd[11111]: [error] Syslog test 2>1'
       @parser.instance.parse(text) do |time, record|
         assert_equal(event_time("Feb 28 12:00:02", format: '%b %d %M:%S:%H'), time)
         assert_equal(@expected.merge('pri' => 1, 'message'=> '[error] Syslog test 2>1'), record)
       end
-      assert_equal(Fluent::Plugin::SyslogParser::RFC3164_WITHOUT_TIME_AND_PRI_REGEXP, @parser.instance.patterns['format'])
 
       text = '<1>Feb 28 12:00:02 192.168.0.1 fluentd[11111]: [error] Syslog test'
       @parser.instance.parse(text) do |time, record|
         assert_equal(event_time("Feb 28 12:00:02", format: '%b %d %M:%S:%H'), time)
         assert_equal(@expected.merge('pri' => 1), record)
       end
-      assert_equal(Fluent::Plugin::SyslogParser::RFC3164_WITHOUT_TIME_AND_PRI_REGEXP, @parser.instance.patterns['format'])
 
       text = '<16>1 2017-02-06T13:14:15.003Z 192.168.0.1 fluentd - - - Hi, from Fluentd!'
       @parser.instance.parse(text) do |time, record|
@@ -538,7 +581,6 @@ class SyslogParserTest < ::Test::Unit::TestCase
         assert_equal "-", record["extradata"]
         assert_equal "Hi, from Fluentd!", record["message"]
       end
-      assert_equal(Fluent::Plugin::SyslogParser::RFC5424_WITHOUT_TIME_AND_PRI_REGEXP, @parser.instance.patterns['format'])
     end
 
     data('regexp' => 'regexp', 'string' => 'string')
@@ -555,7 +597,6 @@ class SyslogParserTest < ::Test::Unit::TestCase
         assert_equal(event_time("Feb 28 12:00:00", format: '%b %d %M:%S:%H'), time)
         assert_equal(@expected.merge('pri' => 6), record)
       end
-      assert_equal(Fluent::Plugin::SyslogParser::RFC3164_WITHOUT_TIME_AND_PRI_REGEXP, @parser.instance.patterns['format'])
 
       text = '<16>1 2017-02-06T13:14:15.003Z 192.168.0.1 fluentd 11111 ID24224 [exampleSDID@20224 iut="3" eventSource="Application" eventID="11211"] Hi, from Fluentd!'
       @parser.instance.parse(text) do |time, record|
@@ -566,14 +607,12 @@ class SyslogParserTest < ::Test::Unit::TestCase
                      record["extradata"]
         assert_equal "Hi, from Fluentd!", record["message"]
       end
-      assert_equal(Fluent::Plugin::SyslogParser::RFC5424_WITHOUT_TIME_AND_PRI_REGEXP, @parser.instance.patterns['format'])
 
       text = '<16>Feb 28 12:00:02 192.168.0.1 fluentd[11111]: [error] Syslog test'
       @parser.instance.parse(text) do |time, record|
         assert_equal(event_time("Feb 28 12:00:02", format: '%b %d %M:%S:%H'), time)
         assert_equal(@expected.merge('pri' => 16), record)
       end
-      assert_equal(Fluent::Plugin::SyslogParser::RFC3164_WITHOUT_TIME_AND_PRI_REGEXP, @parser.instance.patterns['format'])
 
       text = '<16>1 2017-02-06T13:14:15.003Z 192.168.0.1 fluentd - - - Hi, from Fluentd!'
       @parser.instance.parse(text) do |time, record|
@@ -583,7 +622,6 @@ class SyslogParserTest < ::Test::Unit::TestCase
         assert_equal "-", record["extradata"]
         assert_equal "Hi, from Fluentd!", record["message"]
       end
-      assert_equal(Fluent::Plugin::SyslogParser::RFC5424_WITHOUT_TIME_AND_PRI_REGEXP, @parser.instance.patterns['format'])
 
       text = '<16>1 2017-02-06T13:14:15Z 192.168.0.1 fluentd - - - Hi, from Fluentd without subseconds!'
       @parser.instance.parse(text) do |time, record|
@@ -593,7 +631,6 @@ class SyslogParserTest < ::Test::Unit::TestCase
         assert_equal "-", record["extradata"]
         assert_equal "Hi, from Fluentd without subseconds!", record["message"]
       end
-      assert_equal(Fluent::Plugin::SyslogParser::RFC5424_WITHOUT_TIME_AND_PRI_REGEXP, @parser.instance.patterns['format'])
     end
   end
 end