fluentd 0.14.1 → 0.14.2

data/test/plugin/test_parser_regexp.rb

@@ -23,88 +23,255 @@ class RegexpParserTest < ::Test::Unit::TestCase
     }
   end
 
-  def test_parse_with_typed
-    # Use Regexp.new instead of // literal to avoid different parser behaviour in 1.9 and 2.0
-    internal_test_case(Fluent::Plugin::RegexpParser.new(Regexp.new(%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'))
-  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_configure
-    # Specify conf by configure method instaed of intializer
-    regexp = Regexp.new(%q!^(?<host>[^ ]*) [^ ]* (?<user>[^ ]*) \[(?<time>[^\]]*)\] \[(?<date>[^\]]*)\] "(?<flag>\S+)(?: +(?<path>[^ ]*) +\S*)?" (?<code>[^ ]*) (?<size>[^ ]*)$!)
-    parser = Fluent::Test::Driver::Parser.new(Fluent::Plugin::RegexpParser.new(regexp))
-    parser.configure('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')
-    internal_test_case(parser.instance)
-    assert_equal(regexp, parser.instance.patterns['format'])
-    assert_equal("%d/%b/%Y:%H:%M:%S %z", parser.instance.patterns['time_format'])
-  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_typed_and_name_separator
-    internal_test_case(Fluent::Test::Driver::Parser.new(Fluent::Plugin::RegexpParser.new(Regexp.new(%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', 'types_label_delimiter'=>'|')).instance)
-  end
+    def test_parse_with_configure
+      # Specify conf by configure method instaed of intializer
+      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_time_key
-    parser = Fluent::Test::Driver::Parser.new(Fluent::Plugin::RegexpParser.new(/(?<logtime>[^\]]*)/))
-    parser.instance.configure(
-                              'time_format'=>"%Y-%m-%d %H:%M:%S %z",
-                              'time_key'=>'logtime',
-                              )
-    text = '2013-02-28 12:00:00 +0900'
-    parser.instance.parse(text) do |time, record|
-      assert_equal Fluent::EventTime.parse(text), time
+    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
-  end
 
-  def test_parse_without_time
-    time_at_start = Time.now.to_i
-    text = "tagomori_satoshi tagomoris 34\n"
+    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
 
-    parser = Fluent::Plugin::RegexpParser.new(Regexp.new(%q!^(?<name>[^ ]*) (?<user>[^ ]*) (?<age>\d*)$!))
-    parser.configure('types'=>'name:string,user:string,age:integer')
+    def test_parse_without_time
+      time_at_start = Time.now.to_i
+      text = "tagomori_satoshi tagomoris 34\n"
 
-    parser.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"]
-    }
+      regexp = Regexp.new(%q!^(?<name>[^ ]*) (?<user>[^ ]*) (?<age>\d*)$!)
+      conf = {
+        'types' => 'name:string,user:string,age:integer'
+      }
+      d = create_driver(regexp, conf)
 
-    parser2 = Fluent::Test::Driver::Parser.new(Fluent::Plugin::RegexpParser.new(Regexp.new(%q!^(?<name>[^ ]*) (?<user>[^ ]*) (?<age>\d*)$!)))
-    parser2.configure('types'=>'name:string,user:string,age:integer')
-    parser2.instance.estimate_current_event = false
+      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
 
-    parser2.instance.parse(text) { |time, record|
-      assert_equal "tagomori_satoshi", record["name"]
-      assert_equal "tagomoris", record["user"]
-      assert_equal 34, record["age"]
+    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
+        assert_nil time, "parser returns nil if configured so"
+      }
+    end
 
-  def test_parse_with_keep_time_key
-    parser = Fluent::Test::Driver::Parser.new(Fluent::Plugin::RegexpParser.new(
-                                                Regexp.new(%q!(?<time>.*)!),
-                                                'time_format'=>"%d/%b/%Y:%H:%M:%S %z",
-                                                'keep_time_key'=>'true',
-                                                )
-                                              )
-    text = '28/Feb/2013:12:00:00 +0900'
-    parser.instance.parse(text) do |time, record|
-      assert_equal text, record['time']
+    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
 
-  def test_parse_with_keep_time_key_with_typecast
-    parser = Fluent::Test::Driver::Parser.new(Fluent::Plugin::RegexpParser.new(
-                                                Regexp.new(%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',
-                                                )
-                                              )
-    text = '28/Feb/2013:12:00:00 +0900'
-    parser.instance.parse(text) do |time, record|
-      assert_equal 1362020400, record['time']
+  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_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.instance_variable_get(:@regexp)
+        assert_equal(0, regexp.options)
+      end
+
+      data(
+        ignorecase: [{ "ignorecase" => true }, Regexp::IGNORECASE],
+        multiline: [{ "multiline" => true }, Regexp::MULTILINE],
+        ignorecase_multiline: [{ "ignorecase" => true, "multiline" => true }, 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>[^ ]*)$/!,
+          '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'
+        }
+        conf = conf.merge(regexp_option)
+        d = create_driver(conf)
+        regexp = d.instance.instance_variable_get(:@regexp)
+        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_and_name_separator
+      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',
+        'types_label_delimiter' => '|'
+      }
+      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

data/test/plugin/test_parser_tsv.rb

@@ -1,57 +1,59 @@
 require_relative '../helper'
 require 'fluent/test/driver/parser'
-require 'fluent/plugin/parser'
+require 'fluent/plugin/parser_tsv'
 
 class TSVParserTest < ::Test::Unit::TestCase
   def setup
     Fluent::Test.setup
   end
 
+  def create_driver(conf={})
+    Fluent::Test::Driver::Parser.new(Fluent::TextParser::TSVParser).configure(conf)
+  end
+
   data('array param' => '["a","b"]', 'string param' => 'a,b')
   def test_config_params(param)
-    parser = Fluent::Test::Driver::Parser.new(Fluent::TextParser::TSVParser)
+    d = create_driver
 
-    assert_equal "\t", parser.instance.delimiter
+    assert_equal "\t", d.instance.delimiter
 
-    parser.configure(
-                     'keys' => param,
-                     'delimiter' => ',',
-                     )
+    d = create_driver(
+      'keys' => param,
+      'delimiter' => ',',
+    )
 
-    assert_equal ['a', 'b'], parser.instance.keys
-    assert_equal ",", parser.instance.delimiter
+    assert_equal ['a', 'b'], d.instance.keys
+    assert_equal ",", d.instance.delimiter
   end
 
   data('array param' => '["time","a","b"]', 'string param' => 'time,a,b')
   def test_parse(param)
-    parser = Fluent::Test::Driver::Parser.new(Fluent::Plugin::TSVParser)
-    parser.configure('keys' => param, 'time_key' => 'time')
-    parser.instance.parse("2013/02/28 12:00:00\t192.168.0.1\t111") { |time, record|
+    d = create_driver('keys' => param, 'time_key' => 'time')
+    d.instance.parse("2013/02/28 12:00:00\t192.168.0.1\t111") { |time, record|
       assert_equal(event_time('2013/02/28 12:00:00', format: '%Y/%m/%d %H:%M:%S'), time)
       assert_equal({
-                     'a' => '192.168.0.1',
-                     'b' => '111',
-                   }, record)
+          'a' => '192.168.0.1',
+          'b' => '111',
+        }, record)
     }
   end
 
   def test_parse_with_time
     time_at_start = Time.now.to_i
 
-    parser = Fluent::Test::Driver::Parser.new(Fluent::Plugin::TSVParser)
-    parser.configure('keys' => 'a,b')
-    parser.instance.parse("192.168.0.1\t111") { |time, record|
+    d = create_driver('keys' => 'a,b')
+    d.instance.parse("192.168.0.1\t111") { |time, record|
       assert time && time >= time_at_start, "parser puts current time without time input"
       assert_equal({
-                     'a' => '192.168.0.1',
-                     'b' => '111',
-                   }, record)
+          'a' => '192.168.0.1',
+          'b' => '111',
+        }, record)
     }
 
-    parser = Fluent::Test::Driver::Parser.new(Fluent::Plugin::TSVParser)
-    parser.instance.estimate_current_event = false
-    parser.configure('keys' => 'a,b', 'time_key' => 'time')
-    parser.instance.parse("192.168.0.1\t111") { |time, record|
+    d = Fluent::Test::Driver::Parser.new(Fluent::Plugin::TSVParser)
+    d.instance.estimate_current_event = false
+    d.configure('keys' => 'a,b', 'time_key' => 'time')
+    d.instance.parse("192.168.0.1\t111") { |time, record|
       assert_equal({
                      'a' => '192.168.0.1',
                      'b' => '111',
@@ -61,45 +63,41 @@ class TSVParserTest < ::Test::Unit::TestCase
   end
 
   data(
-       'left blank column' => ["\t@\t@", {"1" => "","2" => "@","3" => "@"}],
-       'center blank column' => ["@\t\t@", {"1" => "@","2" => "","3" => "@"}],
-       'right blank column' => ["@\t@\t", {"1" => "@","2" => "@","3" => ""}],
-       '2 right blank columns' => ["@\t\t", {"1" => "@","2" => "","3" => ""}],
-       'left blank columns' => ["\t\t@", {"1" => "","2" => "","3" => "@"}],
-       'all blank columns' => ["\t\t", {"1" => "","2" => "","3" => ""}])
+    'left blank column' => ["\t@\t@", {"1" => "","2" => "@","3" => "@"}],
+    'center blank column' => ["@\t\t@", {"1" => "@","2" => "","3" => "@"}],
+    'right blank column' => ["@\t@\t", {"1" => "@","2" => "@","3" => ""}],
+    '2 right blank columns' => ["@\t\t", {"1" => "@","2" => "","3" => ""}],
+    'left blank columns' => ["\t\t@", {"1" => "","2" => "","3" => "@"}],
+    'all blank columns' => ["\t\t", {"1" => "","2" => "","3" => ""}])
   def test_black_column(data)
     line, expected = data
 
-    parser = Fluent::Test::Driver::Parser.new(Fluent::Plugin::TSVParser)
-    parser.configure('keys' => '1,2,3')
-    parser.instance.parse(line) { |time, record|
+    d = create_driver('keys' => '1,2,3')
+    d.instance.parse(line) { |time, record|
       assert_equal(expected, record)
     }
   end
 
   def test_parse_with_keep_time_key
-    parser = Fluent::Test::Driver::Parser.new(Fluent::Plugin::TSVParser)
-    parser.configure(
-                     'keys'=>'time',
-                     'time_key'=>'time',
-                     'time_format'=>"%d/%b/%Y:%H:%M:%S %z",
-                     'keep_time_key'=>'true',
-                     )
+    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'
-    parser.instance.parse(text) do |time, record|
+    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
-    parser = Fluent::Test::Driver::Parser.new(Fluent::Plugin::TSVParser)
-    parser.configure(
-                     'keys'=>param,
-                     'time_key'=>'time',
-                     'null_value_pattern'=>'^(-|null|NULL)$'
-                     )
-    parser.instance.parse("-\tnull\tNULL\t\t--\tnuLL") do |time, record|
+  def test_parse_with_null_value_pattern(param)
+    d = create_driver(
+      'keys'=>param,
+      'null_value_pattern'=>'^(-|null|NULL)$'
+    )
+    d.instance.parse("-\tnull\tNULL\t\t--\tnuLL") do |time, record|
       assert_nil record['a']
       assert_nil record['b']
       assert_nil record['c']
@@ -110,14 +108,12 @@ class TSVParserTest < ::Test::Unit::TestCase
   end
 
   data('array param' => '["a","b"]', 'string param' => 'a,b')
-  def test_parse_with_null_empty_string
-    parser = Fluent::Test::Driver::Parser.new(Fluent::Plugin::TSVParser)
-    parser.configure(
-                     'keys'=>param,
-                     'time_key'=>'time',
-                     'null_empty_string'=>true
-                     )
-    parser.instance.parse("\t ") do |time, record|
+  def test_parse_with_null_empty_string(param)
+    d = create_driver(
+      'keys'=>param,
+      'null_empty_string'=>true
+    )
+    d.instance.parse("\t ") do |time, record|
       assert_nil record['a']
       assert_equal record['b'], ' '
     end