fluentd 1.16.7-x64-mingw32 → 1.17.0-x64-mingw32

data/test/plugin/test_parser_json.rb

@@ -8,37 +8,6 @@ class JsonParserTest < ::Test::Unit::TestCase
     @parser = Fluent::Test::Driver::Parser.new(Fluent::Plugin::JSONParser)
   end
 
-  sub_test_case "configure_json_parser" do
-    data("oj", [:oj, [Oj.method(:load), Oj::ParseError]])
-    data("json", [:json, [JSON.method(:load), JSON::ParserError]])
-    data("yajl", [:yajl, [Yajl.method(:load), Yajl::ParseError]])
-    def test_return_each_loader((input, expected_return))
-      result = @parser.instance.configure_json_parser(input)
-      assert_equal expected_return, result
-    end
-
-    def test_raise_exception_for_unknown_input
-      assert_raise RuntimeError do
-        @parser.instance.configure_json_parser(:unknown)
-      end
-    end
-
-    def test_fall_back_oj_to_yajl_if_oj_not_available
-      stub(Fluent::OjOptions).available? { false }
-
-      result = @parser.instance.configure_json_parser(:oj)
-
-      assert_equal [Yajl.method(:load), Yajl::ParseError], result
-      logs = @parser.logs.collect do |log|
-        log.gsub(/\A\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2} [-+]\d{4} /, "")
-      end
-      assert_equal(
-        ["[info]: Oj is not installed, and failing back to Yajl for json parser\n"],
-        logs
-      )
-    end
-  end
-
   data('oj' => 'oj', 'yajl' => 'yajl')
   def test_parse(data)
     @parser.configure('json_parser' => data)
@@ -166,4 +135,110 @@ class JsonParserTest < ::Test::Unit::TestCase
       end
     end
   end
+
+  sub_test_case "various record pattern" do
+    data("Only string", { record: '"message"', expected: [nil] }, keep: true)
+    data("Only string without quotation", { record: "message", expected: [nil] }, keep: true)
+    data("Only number", { record: "0", expected: [nil] }, keep: true)
+    data(
+      "Array of Hash",
+      {
+        record: '[{"k1": 1}, {"k2": 2}]',
+        expected: [{"k1" => 1}, {"k2" => 2}]
+      },
+      keep: true,
+    )
+    data(
+      "Array of both Hash and invalid",
+      {
+        record: '[{"k1": 1}, "string", {"k2": 2}, 0]',
+        expected: [{"k1" => 1}, nil, {"k2" => 2}, nil]
+      },
+      keep: true,
+    )
+    data(
+      "Array of all invalid",
+      {
+        record: '["string", 0, [{"k": 0}]]',
+        expected: [nil, nil, nil]
+      },
+      keep: true,
+    )
+
+    def test_oj(data)
+      parsed_records = []
+      @parser.configure("json_parser" => "oj")
+      @parser.instance.parse(data[:record]) { |time, record|
+        parsed_records.append(record)
+      }
+      assert_equal(data[:expected], parsed_records)
+    end
+
+    def test_yajl(data)
+      parsed_records = []
+      @parser.configure("json_parser" => "yajl")
+      @parser.instance.parse(data[:record]) { |time, record|
+        parsed_records.append(record)
+      }
+      assert_equal(data[:expected], parsed_records)
+    end
+
+    def test_json(json)
+      parsed_records = []
+      @parser.configure("json_parser" => "json")
+      @parser.instance.parse(data[:record]) { |time, record|
+        parsed_records.append(record)
+      }
+      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("Only string", { record: '"message"', expected: [nil] }, keep: true)
+    data(
+      "Hash",
+      {
+        record: '{"k1": 1, "k2": ""}',
+        expected: [{"k1" => 1, "k2" => nil}]
+      },
+      keep: true,
+    )
+    data(
+      "Array of Hash",
+      {
+        record: '[{"k1": 1}, {"k2": ""}]',
+        expected: [{"k1" => 1}, {"k2" => nil}]
+      },
+      keep: true,
+    )
+
+    def test_oj(data)
+      parsed_records = []
+      @parser.configure("json_parser" => "oj", "null_empty_string" => true)
+      @parser.instance.parse(data[:record]) { |time, record|
+        parsed_records.append(record)
+      }
+      assert_equal(data[:expected], parsed_records)
+    end
+
+    def test_yajl(data)
+      parsed_records = []
+      @parser.configure("json_parser" => "yajl", "null_empty_string" => true)
+      @parser.instance.parse(data[:record]) { |time, record|
+        parsed_records.append(record)
+      }
+      assert_equal(data[:expected], parsed_records)
+    end
+
+    def test_json(json)
+      parsed_records = []
+      @parser.configure("json_parser" => "json", "null_empty_string" => true)
+      @parser.instance.parse(data[:record]) { |time, record|
+        parsed_records.append(record)
+      }
+      assert_equal(data[:expected], parsed_records)
+    end
+  end
 end

data/test/plugin/test_parser_msgpack.rb

@@ -0,0 +1,127 @@
+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_storage.rb

@@ -68,7 +68,6 @@ class StorageTest < Test::Unit::TestCase
 
       assert_equal 'mytest', s.owner.system_config.process_name
       assert_equal '1', s.instance_eval{ @_plugin_id }
-      assert_equal true, s.instance_eval{ @_plugin_id_configured }
     end
 
     test 'does NOT have features for high-performance/high-consistent storages' do

data/test/plugin_helper/test_child_process.rb

@@ -569,7 +569,7 @@ class ChildProcessTest < Test::Unit::TestCase
   unless Fluent.windows?
     test 'can specify subprocess name' do
       io = IO.popen([["cat", "caaaaaaaaaaat"], '-'])
-      process_naming_enabled = (open("|ps opid,cmd"){|_io| _io.readlines }.count{|line| line.include?("caaaaaaaaaaat") } > 0)
+      process_naming_enabled = (IO.popen(["ps", "opid,cmd"]){|_io| _io.readlines }.count{|line| line.include?("caaaaaaaaaaat") } > 0)
       Process.kill(:TERM, io.pid) rescue nil
       io.close rescue nil
 
@@ -586,7 +586,7 @@ class ChildProcessTest < Test::Unit::TestCase
           m.lock
           ran = true
           pids << @d.child_process_id
-          proc_lines += open("|ps opid,cmd"){|_io| _io.readlines }
+          proc_lines += IO.popen(["ps", "opid,cmd"]){|_io| _io.readlines }
           m.unlock
           readio.read
         end
@@ -645,8 +645,8 @@ class ChildProcessTest < Test::Unit::TestCase
   unless Fluent.windows?
     test 'can change working directory' do
       # check my real /tmp directory (for mac)
-      cmd = %[|ruby -e 'Dir.chdir("/tmp"); puts Dir.pwd']
-      mytmpdir = open(cmd){|io| io.read.chomp }
+      cmd = ['ruby', '-e', 'Dir.chdir("/tmp"); puts Dir.pwd']
+      mytmpdir = IO.popen(cmd){|io| io.read.chomp }
 
       m = Mutex.new
       str = nil

data/test/plugin_helper/test_http_server_helper.rb

@@ -14,7 +14,7 @@ class HttpHelperTest < Test::Unit::TestCase
   CERT_CA_DIR = File.expand_path(File.dirname(__FILE__) + '/data/cert/with_ca')
 
   def setup
-    @port = unused_port(protocol: :tcp)
+    @port = unused_port
   end
 
   def teardown

data/test/plugin_helper/test_server.rb

@@ -15,7 +15,7 @@ class ServerPluginHelperTest < Test::Unit::TestCase
   TMP_DIR = File.expand_path(File.dirname(__FILE__) + "/../tmp/plugin_helper_server")
 
   setup do
-    @port = unused_port(protocol: :tcp)
+    @port = unused_port
     if Fluent.windows?
       @socket_manager_server = ServerEngine::SocketManager::Server.open
       @socket_manager_path = @socket_manager_server.path
@@ -233,12 +233,11 @@ class ServerPluginHelperTest < Test::Unit::TestCase
       # 'server_create_connection tcp' => [:server_create_connection, :unix],
     )
     test 'raise error if udp options specified for tcp/tls/unix' do |(m, proto)|
-      port = unused_port(protocol: proto)
       assert_raise ArgumentError do
-        @d.__send__(m, :myserver, port, proto: proto, max_bytes: 128){|x| x }
+        @d.__send__(m, :myserver, @port, proto: proto, max_bytes: 128){|x| x }
       end
       assert_raise ArgumentError do
-        @d.__send__(m, :myserver, port, proto: proto, flags: 1){|x| x }
+        @d.__send__(m, :myserver, @port, proto: proto, flags: 1){|x| x }
       end
     end
 
@@ -246,9 +245,8 @@ class ServerPluginHelperTest < Test::Unit::TestCase
       'server_create udp' => [:server_create, :udp],
     )
     test 'raise error if tcp/tls options specified for udp' do |(m, proto)|
-      port = unused_port(protocol: proto)
       assert_raise(ArgumentError.new("BUG: linger_timeout is available for tcp/tls")) do
-        @d.__send__(m, :myserver, port, proto: proto, linger_timeout: 1, max_bytes: 128){|x| x }
+        @d.__send__(m, :myserver, @port, proto: proto, linger_timeout: 1, max_bytes: 128){|x| x }
       end
     end
 
@@ -256,9 +254,8 @@ class ServerPluginHelperTest < Test::Unit::TestCase
       'server_create udp' => [:server_create, :udp],
     )
     test 'raise error if tcp/tls/unix backlog options specified for udp' do |(m, proto)|
-      port = unused_port(protocol: proto)
       assert_raise(ArgumentError.new("BUG: backlog is available for tcp/tls")) do
-        @d.__send__(m, :myserver, port, proto: proto, backlog: 500){|x| x }
+        @d.__send__(m, :myserver, @port, proto: proto, backlog: 500){|x| x }
       end
     end
 
@@ -266,9 +263,8 @@ class ServerPluginHelperTest < Test::Unit::TestCase
       'server_create udp' => [:server_create, :udp],
     )
     test 'raise error if tcp/tls send_keepalive_packet option is specified for udp' do |(m, proto)|
-      port = unused_port(protocol: proto)
       assert_raise(ArgumentError.new("BUG: send_keepalive_packet is available for tcp/tls")) do
-        @d.__send__(m, :myserver, port, proto: proto, send_keepalive_packet: true){|x| x }
+        @d.__send__(m, :myserver, @port, proto: proto, send_keepalive_packet: true){|x| x }
       end
     end
 
@@ -280,9 +276,8 @@ class ServerPluginHelperTest < Test::Unit::TestCase
       # 'server_create_connection unix' => [:server_create_connection, :unix, {}],
     )
     test 'raise error if tls options specified for tcp/udp/unix' do |(m, proto, kwargs)|
-      port = unused_port(protocol: proto)
       assert_raise(ArgumentError.new("BUG: tls_options is available only for tls")) do
-        @d.__send__(m, :myserver, port, proto: proto, tls_options: {}, **kwargs){|x| x }
+        @d.__send__(m, :myserver, @port, proto: proto, tls_options: {}, **kwargs){|x| x }
       end
     end
 
@@ -294,8 +289,7 @@ class ServerPluginHelperTest < Test::Unit::TestCase
       'server_create_connection tls' => [:server_create_connection, :tls, {tls_options: {insecure: true}}],
     )
     test 'can bind specified IPv4 address' do |(m, proto, kwargs)|
-      port = unused_port(protocol: proto)
-      @d.__send__(m, :myserver, port, proto: proto, bind: "127.0.0.1", **kwargs){|x| x }
+      @d.__send__(m, :myserver, @port, proto: proto, bind: "127.0.0.1", **kwargs){|x| x }
       assert_equal "127.0.0.1", @d._servers.first.bind
       assert_equal "127.0.0.1", @d._servers.first.server.instance_eval{ instance_variable_defined?(:@listen_socket) ? @listen_socket : @_io }.addr[3]
     end
@@ -309,8 +303,7 @@ class ServerPluginHelperTest < Test::Unit::TestCase
     )
     test 'can bind specified IPv6 address' do |(m, proto, kwargs)| # if available
       omit "IPv6 unavailable here" unless ipv6_enabled?
-      port = unused_port(protocol: proto)
-      @d.__send__(m, :myserver, port, proto: proto, bind: "::1", **kwargs){|x| x }
+      @d.__send__(m, :myserver, @port, proto: proto, bind: "::1", **kwargs){|x| x }
       assert_equal "::1", @d._servers.first.bind
       assert_equal "::1", @d._servers.first.server.instance_eval{ instance_variable_defined?(:@listen_socket) ? @listen_socket : @_io }.addr[3]
     end
@@ -327,11 +320,10 @@ class ServerPluginHelperTest < Test::Unit::TestCase
     test 'can create 2 or more servers which share same bind address and port if shared option is true' do |(m, proto, kwargs)|
       begin
         d2 = Dummy.new; d2.start; d2.after_start
-        port = unused_port(protocol: proto)
 
         assert_nothing_raised do
-          @d.__send__(m, :myserver, port, proto: proto, **kwargs){|x| x }
-          d2.__send__(m, :myserver, port, proto: proto, **kwargs){|x| x }
+          @d.__send__(m, :myserver, @port, proto: proto, **kwargs){|x| x }
+          d2.__send__(m, :myserver, @port, proto: proto, **kwargs){|x| x }
         end
       ensure
         d2.stop; d2.before_shutdown; d2.shutdown; d2.after_shutdown; d2.close; d2.terminate
@@ -352,13 +344,12 @@ class ServerPluginHelperTest < Test::Unit::TestCase
     test 'cannot create 2 or more servers using same bind address and port if shared option is false' do |(m, proto, kwargs)|
       begin
         d2 = Dummy.new; d2.start; d2.after_start
-        port = unused_port(protocol: proto)
 
         assert_nothing_raised do
-          @d.__send__(m, :myserver, port, proto: proto, shared: false, **kwargs){|x| x }
+          @d.__send__(m, :myserver, @port, proto: proto, shared: false, **kwargs){|x| x }
         end
         assert_raise(Errno::EADDRINUSE, Errno::EACCES) do
-          d2.__send__(m, :myserver, port, proto: proto, **kwargs){|x| x }
+          d2.__send__(m, :myserver, @port, proto: proto, **kwargs){|x| x }
         end
       ensure
         d2.stop; d2.before_shutdown; d2.shutdown; d2.after_shutdown; d2.close; d2.terminate
@@ -374,18 +365,16 @@ class ServerPluginHelperTest < Test::Unit::TestCase
       # 'unix' => [:unix, {}],
     )
     test 'raise error if block argument is not specified or too many' do |(proto, kwargs)|
-      port = unused_port(protocol: proto)
       assert_raise(ArgumentError.new("BUG: block must have 1 or 2 arguments")) do
-        @d.server_create(:myserver, port, proto: proto, **kwargs){ 1 }
+        @d.server_create(:myserver, @port, proto: proto, **kwargs){ 1 }
       end
       assert_raise(ArgumentError.new("BUG: block must have 1 or 2 arguments")) do
-        @d.server_create(:myserver, port, proto: proto, **kwargs){|sock, conn, what_is_this| 1 }
+        @d.server_create(:myserver, @port, proto: proto, **kwargs){|sock, conn, what_is_this| 1 }
       end
     end
 
     test 'creates udp server if specified in proto' do
-      port = unused_port(protocol: :udp)
-      @d.server_create(:myserver, port, proto: :udp, max_bytes: 512){|x| x }
+      @d.server_create(:myserver, @port, proto: :udp, max_bytes: 512){|x| x }
 
       created_server_info = @d._servers.first
       assert_equal :udp, created_server_info.proto
@@ -598,8 +587,7 @@ class ServerPluginHelperTest < Test::Unit::TestCase
   sub_test_case '#server_create_udp' do
     test 'can accept all keyword arguments valid for udp server' do
       assert_nothing_raised do
-        port = unused_port(protocol: :udp)
-        @d.server_create_udp(:s, port, bind: '127.0.0.1', shared: false, resolve_name: true, max_bytes: 100, flags: 1) do |data, conn|
+        @d.server_create_udp(:s, @port, bind: '127.0.0.1', shared: false, resolve_name: true, max_bytes: 100, flags: 1) do |data, conn|
           # ...
         end
       end
@@ -607,15 +595,14 @@ class ServerPluginHelperTest < Test::Unit::TestCase
 
     test 'creates a udp server just to read data' do
       received = ""
-      port = unused_port(protocol: :udp)
-      @d.server_create_udp(:s, port, max_bytes: 128) do |data|
+      @d.server_create_udp(:s, @port, max_bytes: 128) do |data|
         received << data
       end
       bind_port = unused_port(protocol: :udp, bind: "127.0.0.1")
       3.times do
         sock = UDPSocket.new(Socket::AF_INET)
         sock.bind("127.0.0.1", bind_port)
-        sock.connect("127.0.0.1", port)
+        sock.connect("127.0.0.1", @port)
         sock.puts "yay"
         sock.puts "foo"
         sock.close
@@ -627,17 +614,16 @@ class ServerPluginHelperTest < Test::Unit::TestCase
     test 'creates a udp server to read and write data' do
       received = ""
       responses = []
-      port = unused_port(protocol: :udp)
-      @d.server_create_udp(:s, port, max_bytes: 128) do |data, sock|
+      @d.server_create_udp(:s, @port, max_bytes: 128) do |data, sock|
         received << data
         sock.write "ack\n"
       end
-      bind_port = unused_port(protocol: :udp)
+      bind_port = unused_port
       3.times do
         begin
           sock = UDPSocket.new(Socket::AF_INET)
           sock.bind("127.0.0.1", bind_port)
-          sock.connect("127.0.0.1", port)
+          sock.connect("127.0.0.1", @port)
           th = Thread.new do
             while true
               begin
@@ -668,12 +654,11 @@ class ServerPluginHelperTest < Test::Unit::TestCase
 
       received = ""
       responses = []
-      port = unused_port(protocol: :udp)
-      @d.server_create_udp(:s, port, bind: "::1", max_bytes: 128) do |data, sock|
+      @d.server_create_udp(:s, @port, bind: "::1", max_bytes: 128) do |data, sock|
         received << data
         sock.write "ack\n"
       end
-      bind_port = unused_port(protocol: :udp)
+      bind_port = unused_port
       3.times do
         begin
           sock = UDPSocket.new(Socket::AF_INET6)
@@ -682,7 +667,7 @@ class ServerPluginHelperTest < Test::Unit::TestCase
             responses << sock.recv(16)
             true
           end
-          sock.connect("::1", port)
+          sock.connect("::1", @port)
           sock.write "yay\nfoo\n"
           th.join(5)
         ensure
@@ -697,14 +682,13 @@ class ServerPluginHelperTest < Test::Unit::TestCase
     test 'does not resolve name of client address in default' do
       received = ""
       sources = []
-      port = unused_port(protocol: :udp)
-      @d.server_create_udp(:s, port, max_bytes: 128) do |data, sock|
+      @d.server_create_udp(:s, @port, max_bytes: 128) do |data, sock|
         received << data
         sources << sock.remote_host
       end
       3.times do
         sock = UDPSocket.new(Socket::AF_INET)
-        sock.connect("127.0.0.1", port)
+        sock.connect("127.0.0.1", @port)
         sock.puts "yay"
         sock.close
       end
@@ -718,14 +702,13 @@ class ServerPluginHelperTest < Test::Unit::TestCase
 
       received = ""
       sources = []
-      port = unused_port(protocol: :udp)
-      @d.server_create_udp(:s, port, resolve_name: true, max_bytes: 128) do |data, sock|
+      @d.server_create_udp(:s, @port, resolve_name: true, max_bytes: 128) do |data, sock|
         received << data
         sources << sock.remote_host
       end
       3.times do
         sock = UDPSocket.new(Socket::AF_INET)
-        sock.connect("127.0.0.1", port)
+        sock.connect("127.0.0.1", @port)
         sock.puts "yay"
         sock.close
       end
@@ -737,8 +720,7 @@ class ServerPluginHelperTest < Test::Unit::TestCase
     test 'raises error if plugin registers data callback for connection object from #server_create' do
       received = ""
       errors = []
-      port = unused_port(protocol: :udp)
-      @d.server_create_udp(:s, port, max_bytes: 128) do |data, sock|
+      @d.server_create_udp(:s, @port, max_bytes: 128) do |data, sock|
         received << data
         begin
           sock.data{|d| received << d.upcase }
@@ -747,7 +729,7 @@ class ServerPluginHelperTest < Test::Unit::TestCase
         end
       end
       sock = UDPSocket.new(Socket::AF_INET)
-      sock.connect("127.0.0.1", port)
+      sock.connect("127.0.0.1", @port)
       sock.write "foo\n"
       sock.close
 
@@ -760,8 +742,7 @@ class ServerPluginHelperTest < Test::Unit::TestCase
     test 'raise error if plugin registers write_complete callback for udp' do
       received = ""
       errors = []
-      port = unused_port(protocol: :udp)
-      @d.server_create_udp(:s, port, max_bytes: 128) do |data, sock|
+      @d.server_create_udp(:s, @port, max_bytes: 128) do |data, sock|
         received << data
         begin
           sock.on(:write_complete){|conn| "" }
@@ -770,7 +751,7 @@ class ServerPluginHelperTest < Test::Unit::TestCase
         end
       end
       sock = UDPSocket.new(Socket::AF_INET)
-      sock.connect("127.0.0.1", port)
+      sock.connect("127.0.0.1", @port)
       sock.write "foo\n"
       sock.close
 
@@ -783,8 +764,7 @@ class ServerPluginHelperTest < Test::Unit::TestCase
     test 'raises error if plugin registers close callback for udp' do
       received = ""
       errors = []
-      port = unused_port(protocol: :udp)
-      @d.server_create_udp(:s, port, max_bytes: 128) do |data, sock|
+      @d.server_create_udp(:s, @port, max_bytes: 128) do |data, sock|
         received << data
         begin
           sock.on(:close){|d| "" }
@@ -793,7 +773,7 @@ class ServerPluginHelperTest < Test::Unit::TestCase
         end
       end
       sock = UDPSocket.new(Socket::AF_INET)
-      sock.connect("127.0.0.1", port)
+      sock.connect("127.0.0.1", @port)
       sock.write "foo\n"
       sock.close
 
@@ -806,12 +786,11 @@ class ServerPluginHelperTest < Test::Unit::TestCase
     test 'can bind IPv4 / IPv6 together' do
       omit "IPv6 unavailable here" unless ipv6_enabled?
 
-      port = unused_port(protocol: :udp)
       assert_nothing_raised do
-        @d.server_create_udp(:s_ipv4_udp, port, bind: '0.0.0.0', shared: false, max_bytes: 128) do |data, sock|
+        @d.server_create_udp(:s_ipv4_udp, @port, bind: '0.0.0.0', shared: false, max_bytes: 128) do |data, sock|
           # ...
         end
-        @d.server_create_udp(:s_ipv6_udp, port, bind: '::', shared: false, max_bytes: 128) do |data, sock|
+        @d.server_create_udp(:s_ipv6_udp, @port, bind: '::', shared: false, max_bytes: 128) do |data, sock|
           # ...
         end
       end
@@ -824,12 +803,11 @@ class ServerPluginHelperTest < Test::Unit::TestCase
         max_bytes, records, expected = data.values
 
         actual_records = []
-        port = unused_port(protocol: :udp)
-        @d.server_create_udp(:myserver, port, max_bytes: max_bytes) do |data, sock|
+        @d.server_create_udp(:myserver, @port, max_bytes: max_bytes) do |data, sock|
           actual_records << data
         end
 
-        open_client(:udp, "127.0.0.1", port) do |sock|
+        open_client(:udp, "127.0.0.1", @port) do |sock|
           records.each do |record|
             sock.send(record, 0)
           end
@@ -845,12 +823,11 @@ class ServerPluginHelperTest < Test::Unit::TestCase
         max_bytes, records, expected = data.values
 
         actual_records = []
-        port = unused_port(protocol: :udp)
-        @d.server_create_udp(:myserver, port, max_bytes: max_bytes) do |data|
+        @d.server_create_udp(:myserver, @port, max_bytes: max_bytes) do |data|
           actual_records << data
         end
 
-        open_client(:udp, "127.0.0.1", port) do |sock|
+        open_client(:udp, "127.0.0.1", @port) do |sock|
           records.each do |record|
             sock.send(record, 0)
           end

data/test/plugin_helper/test_socket.rb

@@ -11,7 +11,7 @@ class SocketHelperTest < Test::Unit::TestCase
   CERT_CHAINS_DIR = File.expand_path(File.dirname(__FILE__) + '/data/cert/cert_chains')
 
   def setup
-    @port = unused_port(protocol: :tcp)
+    @port = unused_port
   end
 
   def teardown