summaryrefslogtreecommitdiff
path: root/test/socket/test_socket.rb
diff options
context:
space:
mode:
Diffstat (limited to 'test/socket/test_socket.rb')
-rw-r--r--test/socket/test_socket.rb584
1 files changed, 532 insertions, 52 deletions
diff --git a/test/socket/test_socket.rb b/test/socket/test_socket.rb
index 0628f94b00..c42527f370 100644
--- a/test/socket/test_socket.rb
+++ b/test/socket/test_socket.rb
@@ -1,7 +1,10 @@
+# frozen_string_literal: true
+
begin
require "socket"
require "tmpdir"
require "fcntl"
+ require "etc"
require "test/unit"
rescue LoadError
end
@@ -70,22 +73,40 @@ class TestSocket < Test::Unit::TestCase
}
end
+ def test_bind
+ Socket.open(Socket::AF_INET, Socket::SOCK_STREAM, 0) {|bound|
+ bound.bind(Socket.sockaddr_in(0, "127.0.0.1"))
+ addr = bound.getsockname
+ port, = Socket.unpack_sockaddr_in(addr)
+
+ Socket.open(Socket::AF_INET, Socket::SOCK_STREAM, 0) {|s|
+ e = assert_raise(Errno::EADDRINUSE) do
+ s.bind(Socket.sockaddr_in(port, "127.0.0.1"))
+ end
+
+ assert_match "bind(2) for 127.0.0.1:#{port}", e.message
+ }
+ }
+ end
+
def test_getaddrinfo
# This should not send a DNS query because AF_UNIX.
- assert_raise(SocketError) { Socket.getaddrinfo("www.kame.net", 80, "AF_UNIX") }
+ assert_raise(Socket::ResolutionError) { Socket.getaddrinfo("www.kame.net", 80, "AF_UNIX") }
end
def test_getaddrinfo_raises_no_errors_on_port_argument_of_0 # [ruby-core:29427]
assert_nothing_raised('[ruby-core:29427]'){ Socket.getaddrinfo('localhost', 0, Socket::AF_INET, Socket::SOCK_STREAM, nil, Socket::AI_CANONNAME) }
assert_nothing_raised('[ruby-core:29427]'){ Socket.getaddrinfo('localhost', '0', Socket::AF_INET, Socket::SOCK_STREAM, nil, Socket::AI_CANONNAME) }
assert_nothing_raised('[ruby-core:29427]'){ Socket.getaddrinfo('localhost', '00', Socket::AF_INET, Socket::SOCK_STREAM, nil, Socket::AI_CANONNAME) }
- assert_raise(SocketError, '[ruby-core:29427]'){ Socket.getaddrinfo(nil, nil, Socket::AF_INET, Socket::SOCK_STREAM, nil, Socket::AI_CANONNAME) }
+ assert_raise(Socket::ResolutionError, '[ruby-core:29427]'){ Socket.getaddrinfo(nil, nil, Socket::AF_INET, Socket::SOCK_STREAM, nil, Socket::AI_CANONNAME) }
assert_nothing_raised('[ruby-core:29427]'){ TCPServer.open('localhost', 0) {} }
end
def test_getnameinfo
- assert_raise(SocketError) { Socket.getnameinfo(["AF_UNIX", 80, "0.0.0.0"]) }
+ assert_raise(Socket::ResolutionError) { Socket.getnameinfo(["AF_UNIX", 80, "0.0.0.0"]) }
+ assert_raise(ArgumentError) {Socket.getnameinfo(["AF_INET", "http\0", "example.net"])}
+ assert_raise(ArgumentError) {Socket.getnameinfo(["AF_INET", "http", "example.net\0"])}
end
def test_ip_address_list
@@ -100,6 +121,15 @@ class TestSocket < Test::Unit::TestCase
}
end
+ def test_ip_address_list_include_localhost
+ begin
+ list = Socket.ip_address_list
+ rescue NotImplementedError
+ return
+ end
+ assert_includes list.map(&:ip_address), Addrinfo.tcp("localhost", 0).ip_address
+ end
+
def test_tcp
TCPServer.open(0) {|serv|
addr = serv.connect_address
@@ -133,11 +163,22 @@ class TestSocket < Test::Unit::TestCase
def random_port
# IANA suggests dynamic port for 49152 to 65535
# http://www.iana.org/assignments/port-numbers
- 49152 + rand(65535-49152+1)
+ case RUBY_PLATFORM
+ when /mingw|mswin/
+ rand(50000..65535)
+ else
+ rand(49152..65535)
+ end
end
def errors_addrinuse
- [Errno::EADDRINUSE]
+ errs = [Errno::EADDRINUSE]
+ # Windows can fail with "Errno::EACCES: Permission denied - bind(2) for 0.0.0.0:49721"
+ # or "Test::Unit::ProxyError: Permission denied - bind(2) for 0.0.0.0:55333"
+ if /mswin|mingw/ =~ RUBY_PLATFORM
+ errs += [Errno::EACCES, Test::Unit::ProxyError]
+ end
+ errs
end
def test_tcp_server_sockets
@@ -221,9 +262,12 @@ class TestSocket < Test::Unit::TestCase
unix_server = Socket.unix_server_socket("#{tmpdir}/sock")
tcp_servers.each {|s|
addr = s.connect_address
- assert_nothing_raised("connect to #{addr.inspect}") {
+ begin
clients << addr.connect
- }
+ rescue
+ # allow failure if the address is IPv6
+ raise unless addr.ipv6?
+ end
}
addr = unix_server.connect_address
assert_nothing_raised("connect to #{addr.inspect}") {
@@ -299,10 +343,14 @@ class TestSocket < Test::Unit::TestCase
end
def test_udp_server
+ # http://rubyci.s3.amazonaws.com/rhel_zlinux/ruby-master/log/20230312T023302Z.fail.html.gz
+ # Errno::EHOSTUNREACH: No route to host - recvmsg(2)
+ omit if 'rhel_zlinux' == ENV['RUBYCI_NICKNAME']
+
begin
- ip_addrs = Socket.ip_address_list
+ ifaddrs = Socket.getifaddrs
rescue NotImplementedError
- skip "Socket.ip_address_list not implemented"
+ omit "Socket.getifaddrs not implemented"
end
ifconfig = nil
@@ -310,26 +358,29 @@ class TestSocket < Test::Unit::TestCase
famlies = {}
sockets.each {|s| famlies[s.local_address.afamily] = s }
nd6 = {}
- ip_addrs.reject! {|ai|
+ ifaddrs.reject! {|ifa|
+ ai = ifa.addr
+ next true unless ai
s = famlies[ai.afamily]
next true unless s
+ next true if ai.ipv6_linklocal? # IPv6 link-local address is too troublesome in this test.
case RUBY_PLATFORM
when /linux/
if ai.ip_address.include?('%') and
- (`uname -r`[/[0-9.]+/].split('.').map(&:to_i) <=> [2,6,18]) <= 0
+ (Etc.uname[:release][/[0-9.]+/].split('.').map(&:to_i) <=> [2,6,18]) <= 0
# Cent OS 5.6 (2.6.18-238.19.1.el5xen) doesn't correctly work
# sendmsg with pktinfo for link-local ipv6 addresses
next true
end
when /freebsd/
- if ifr_name = ai.ip_address[/%(.*)/, 1]
+ if ifa.addr.ipv6_linklocal?
# FreeBSD 9.0 with default setting (ipv6_activate_all_interfaces
# is not YES) sets IFDISABLED to interfaces which don't have
# global IPv6 address.
# Link-local IPv6 addresses on those interfaces don't work.
ulSIOCGIFINFO_IN6 = 3225971052
ulND6_IFF_IFDISABLED = 8
- in6_ondireq = ifr_name
+ in6_ondireq = ifa.name
s.ioctl(ulSIOCGIFINFO_IN6, in6_ondireq)
flag = in6_ondireq.unpack('A16L6').last
next true if flag & ulND6_IFF_IFDISABLED != 0
@@ -343,7 +394,6 @@ class TestSocket < Test::Unit::TestCase
# Mac OS X may sets IFDISABLED as FreeBSD does
ulSIOCGIFFLAGS = 3223349521
ulSIOCGIFINFO_IN6 = 3224398156
- ulSIOCGIFAFLAG_IN6 = 3240126793
ulIFF_POINTOPOINT = 0x10
ulND6_IFF_IFDISABLED = 8
in6_ondireq = ifr_name
@@ -354,11 +404,10 @@ class TestSocket < Test::Unit::TestCase
in6_ifreq = [ifr_name,ai.to_sockaddr].pack('a16A*')
s.ioctl(ulSIOCGIFFLAGS, in6_ifreq)
next true if in6_ifreq.unpack('A16L1').last & ulIFF_POINTOPOINT != 0
- else
- ifconfig ||= `/sbin/ifconfig`
- next true if ifconfig.scan(/^(\w+):(.*(?:\n\t.*)*)/).find do|ifname, value|
- value.include?(ai.ip_address) && value.include?('POINTOPOINT')
- end
+ end
+ ifconfig ||= `/sbin/ifconfig`
+ next true if ifconfig.scan(/^(\w+):(.*(?:\n\t.*)*)/).find do |_ifname, value|
+ value.include?(ai.ip_address) && value.include?('POINTOPOINT')
end
end
false
@@ -377,33 +426,36 @@ class TestSocket < Test::Unit::TestCase
}
}
- ip_addrs.each {|ai|
+ ifaddrs.each {|ifa|
+ ai = ifa.addr
Addrinfo.udp(ai.ip_address, port).connect {|s|
ping_p = false
msg1 = "<<<#{ai.inspect}>>>"
s.sendmsg msg1
unless IO.select([s], nil, nil, 10)
nd6options = nd6.key?(ai) ? "nd6=%x " % nd6[ai] : ''
- raise "no response from #{ai.inspect} #{nd6options}ping=#{ping_p}"
+ raise "no response from #{ifa.inspect} #{nd6options}ping=#{ping_p}"
end
msg2, addr = s.recvmsg
- msg2, remote_address, local_address = Marshal.load(msg2)
+ msg2, _, _ = Marshal.load(msg2)
assert_equal(msg1, msg2)
assert_equal(ai.ip_address, addr.ip_address)
}
}
rescue NotImplementedError, Errno::ENOSYS
skipped = true
- skip "need sendmsg and recvmsg"
+ omit "need sendmsg and recvmsg: #{$!}"
+ rescue RuntimeError
+ skipped = true
+ omit "UDP server is no response: #{$!}"
ensure
if th
- if skipped
- Thread.kill th unless th.join(10)
- else
+ unless skipped
Addrinfo.udp("127.0.0.1", port).connect {|s| s.sendmsg "exit" }
- unless th.join(10)
- Thread.kill th
- th.join(10)
+ end
+ unless th.join(10)
+ th.kill.join(10)
+ unless skipped
raise "thread killed"
end
end
@@ -429,25 +481,52 @@ class TestSocket < Test::Unit::TestCase
}
end
+ def timestamp_retry_rw(s1, s2, t1, type)
+ IO.pipe do |r,w|
+ # UDP may not be reliable, keep sending until recvmsg returns:
+ th = Thread.new do
+ n = 0
+ begin
+ s2.send("a", 0, s1.local_address)
+ n += 1
+ end while IO.select([r], nil, nil, 0.1).nil?
+ n
+ end
+ timeout = 30
+ assert_equal([[s1],[],[]], IO.select([s1], nil, nil, timeout))
+ msg, _, _, stamp = s1.recvmsg
+ assert_equal("a", msg)
+ assert(stamp.cmsg_is?(:SOCKET, type))
+ w.close # stop th
+ n = th.value
+ th = nil
+ n > 1 and
+ warn "UDP packet loss for #{type} over loopback, #{n} tries needed"
+ t2 = Time.now.strftime("%Y-%m-%d")
+ pat = Regexp.union([t1, t2].uniq)
+ assert_match(pat, stamp.inspect)
+ t = stamp.timestamp
+ assert_match(pat, t.strftime("%Y-%m-%d"))
+ stamp
+ ensure
+ if th and !th.join(10)
+ th.kill.join(10)
+ end
+ end
+ end
+
def test_timestamp
- return if /linux|freebsd|netbsd|openbsd|solaris|darwin/ !~ RUBY_PLATFORM
- return if !defined?(Socket::AncillaryData)
+ return if /linux|freebsd|netbsd|openbsd|darwin/ !~ RUBY_PLATFORM
+ return if !defined?(Socket::AncillaryData) || !defined?(Socket::SO_TIMESTAMP)
t1 = Time.now.strftime("%Y-%m-%d")
stamp = nil
Addrinfo.udp("127.0.0.1", 0).bind {|s1|
Addrinfo.udp("127.0.0.1", 0).bind {|s2|
s1.setsockopt(:SOCKET, :TIMESTAMP, true)
- s2.send "a", 0, s1.local_address
- msg, addr, rflags, stamp = s1.recvmsg
- assert_equal("a", msg)
- assert(stamp.cmsg_is?(:SOCKET, :TIMESTAMP))
+ stamp = timestamp_retry_rw(s1, s2, t1, :TIMESTAMP)
}
}
- t2 = Time.now.strftime("%Y-%m-%d")
- pat = Regexp.union([t1, t2].uniq)
- assert_match(pat, stamp.inspect)
t = stamp.timestamp
- assert_match(pat, t.strftime("%Y-%m-%d"))
pat = /\.#{"%06d" % t.usec}/
assert_match(pat, stamp.inspect)
end
@@ -464,17 +543,10 @@ class TestSocket < Test::Unit::TestCase
# SO_TIMESTAMPNS is available since Linux 2.6.22
return
end
- s2.send "a", 0, s1.local_address
- msg, addr, rflags, stamp = s1.recvmsg
- assert_equal("a", msg)
- assert(stamp.cmsg_is?(:SOCKET, :TIMESTAMPNS))
+ stamp = timestamp_retry_rw(s1, s2, t1, :TIMESTAMPNS)
}
}
- t2 = Time.now.strftime("%Y-%m-%d")
- pat = Regexp.union([t1, t2].uniq)
- assert_match(pat, stamp.inspect)
t = stamp.timestamp
- assert_match(pat, t.strftime("%Y-%m-%d"))
pat = /\.#{"%09d" % t.nsec}/
assert_match(pat, stamp.inspect)
end
@@ -487,7 +559,7 @@ class TestSocket < Test::Unit::TestCase
Addrinfo.udp("127.0.0.1", 0).bind {|s2|
s1.setsockopt(:SOCKET, :BINTIME, true)
s2.send "a", 0, s1.local_address
- msg, addr, rflags, stamp = s1.recvmsg
+ msg, _, _, stamp = s1.recvmsg
assert_equal("a", msg)
assert(stamp.cmsg_is?(:SOCKET, :BINTIME))
}
@@ -509,17 +581,20 @@ class TestSocket < Test::Unit::TestCase
begin sleep(0.1) end until serv_thread.stop?
sock = TCPSocket.new("localhost", server.addr[1])
client_thread = Thread.new do
- sock.readline
+ assert_raise(IOError, bug4390) {
+ sock.readline
+ }
end
begin sleep(0.1) end until client_thread.stop?
Timeout.timeout(1) do
sock.close
sock = nil
- assert_raise(IOError, bug4390) {client_thread.join}
+ client_thread.join
end
ensure
+ serv_thread.value.close
server.close
- end
+ end unless RUBY_PLATFORM.include?("freebsd")
def test_connect_timeout
host = "127.0.0.1"
@@ -535,7 +610,7 @@ class TestSocket < Test::Unit::TestCase
# some platforms may not timeout when the listener queue overflows,
# but we know Linux does with the default listen backlog of SOMAXCONN for
# TCPServer.
- assert_raises(Errno::ETIMEDOUT) do
+ assert_raise(Errno::ETIMEDOUT) do
(Socket::SOMAXCONN*2).times do |i|
sock = Socket.tcp(host, port, :connect_timeout => 0)
assert_equal sock, IO.select(nil, [ sock ])[1][0],
@@ -549,6 +624,17 @@ class TestSocket < Test::Unit::TestCase
sock.close if sock && ! sock.closed?
end
+ def test_getifaddrs
+ begin
+ list = Socket.getifaddrs
+ rescue NotImplementedError
+ return
+ end
+ list.each {|ifaddr|
+ assert_instance_of(Socket::Ifaddr, ifaddr)
+ }
+ end
+
def test_connect_in_rescue
serv = Addrinfo.tcp(nil, 0).listen
addr = serv.connect_address
@@ -619,4 +705,398 @@ class TestSocket < Test::Unit::TestCase
end
end
+ def test_recvmsg_udp_no_arg
+ n = 4097
+ s1 = Addrinfo.udp("127.0.0.1", 0).bind
+ s2 = s1.connect_address.connect
+ s2.send("a" * n, 0)
+ ret = s1.recvmsg
+ assert_equal n, ret[0].bytesize, '[ruby-core:71517] [Bug #11701]'
+
+ s2.send("a" * n, 0)
+ IO.select([s1])
+ ret = s1.recvmsg_nonblock
+ assert_equal n, ret[0].bytesize, 'non-blocking should also grow'
+ ensure
+ s1.close
+ s2.close
+ end
+
+ def test_udp_read_truncation
+ s1 = Addrinfo.udp("127.0.0.1", 0).bind
+ s2 = s1.connect_address.connect
+ s2.send("a" * 100, 0)
+ ret = s1.read(10)
+ assert_equal "a" * 10, ret
+ s2.send("b" * 100, 0)
+ ret = s1.read(10)
+ assert_equal "b" * 10, ret
+ ensure
+ s1.close
+ s2.close
+ end
+
+ def test_udp_recv_truncation
+ s1 = Addrinfo.udp("127.0.0.1", 0).bind
+ s2 = s1.connect_address.connect
+ s2.send("a" * 100, 0)
+ ret = s1.recv(10, Socket::MSG_PEEK)
+ assert_equal "a" * 10, ret
+ ret = s1.recv(10, 0)
+ assert_equal "a" * 10, ret
+ s2.send("b" * 100, 0)
+ ret = s1.recv(10, 0)
+ assert_equal "b" * 10, ret
+ ensure
+ s1.close
+ s2.close
+ end
+
+ def test_udp_recvmsg_truncation
+ s1 = Addrinfo.udp("127.0.0.1", 0).bind
+ s2 = s1.connect_address.connect
+ s2.send("a" * 100, 0)
+ ret, addr, rflags = s1.recvmsg(10, Socket::MSG_PEEK)
+ assert_equal "a" * 10, ret
+ # AIX does not set MSG_TRUNC for a message partially read with MSG_PEEK.
+ assert_equal Socket::MSG_TRUNC, rflags & Socket::MSG_TRUNC if !rflags.nil? && /aix/ !~ RUBY_PLATFORM
+ ret, addr, rflags = s1.recvmsg(10, 0)
+ assert_equal "a" * 10, ret
+ assert_equal Socket::MSG_TRUNC, rflags & Socket::MSG_TRUNC if !rflags.nil?
+ s2.send("b" * 100, 0)
+ ret, addr, rflags = s1.recvmsg(10, 0)
+ assert_equal "b" * 10, ret
+ assert_equal Socket::MSG_TRUNC, rflags & Socket::MSG_TRUNC if !rflags.nil?
+ addr
+ ensure
+ s1.close
+ s2.close
+ end
+
+ def test_resolurion_error_error_code
+ begin
+ Socket.getaddrinfo("example.com", 80, "AF_UNIX")
+ rescue => e
+ assert_include([Socket::EAI_FAMILY, Socket::EAI_FAIL], e.error_code)
+ end
+ end
+
+ def test_tcp_socket_v6_hostname_resolved_earlier
+ opts = %w[-rsocket -W1]
+ assert_separately opts, <<~RUBY
+ begin
+ begin
+ # Verify that "localhost" can be resolved to an IPv6 address
+ Socket.getaddrinfo("localhost", 0, Socket::AF_INET6)
+ server = TCPServer.new("::1", 0)
+ rescue Socket::ResolutionError, Errno::EADDRNOTAVAIL # IPv6 is not supported
+ return
+ end
+
+ _, port, = server.addr
+ server_thread = Thread.new { server.accept }
+
+ Addrinfo.define_singleton_method(:getaddrinfo) do |_, _, family, *_|
+ case family
+ when Socket::AF_INET6 then [Addrinfo.tcp("::1", port)]
+ when Socket::AF_INET then sleep(10); [Addrinfo.tcp("127.0.0.1", port)]
+ end
+ end
+
+ socket = Socket.tcp("localhost", port)
+ assert_true(socket.remote_address.ipv6?)
+ ensure
+ server_thread&.value&.close
+ server&.close
+ socket&.close
+ end
+ RUBY
+ end
+
+ def test_tcp_socket_v4_hostname_resolved_earlier
+ opts = %w[-rsocket -W1]
+ assert_separately opts, <<~RUBY
+ begin
+ server = TCPServer.new("127.0.0.1", 0)
+ _, port, = server.addr
+ server_thread = Thread.new { server.accept }
+
+ Addrinfo.define_singleton_method(:getaddrinfo) do |_, _, family, *_|
+ case family
+ when Socket::AF_INET6 then sleep(10); [Addrinfo.tcp("::1", port)]
+ when Socket::AF_INET then [Addrinfo.tcp("127.0.0.1", port)]
+ end
+ end
+
+ socket = Socket.tcp("localhost", port)
+ assert_true(socket.remote_address.ipv4?)
+ ensure
+ server_thread&.value&.close
+ server&.close
+ socket&.close
+ end
+ RUBY
+ end
+
+ def test_tcp_socket_v6_hostname_resolved_in_resolution_delay
+ opts = %w[-rsocket -W1]
+ assert_separately opts, <<~RUBY
+ begin
+ begin
+ # Verify that "localhost" can be resolved to an IPv6 address
+ Socket.getaddrinfo("localhost", 0, Socket::AF_INET6)
+ server = TCPServer.new("::1", 0)
+ rescue Socket::ResolutionError, Errno::EADDRNOTAVAIL # IPv6 is not supported
+ return
+ end
+
+ _, port, = server.addr
+ server_thread = Thread.new { server.accept }
+
+ delay_time = 0.025 # Socket::RESOLUTION_DELAY (private) is 0.05
+
+ Addrinfo.define_singleton_method(:getaddrinfo) do |_, _, family, *_|
+ case family
+ when Socket::AF_INET6 then sleep(delay_time); [Addrinfo.tcp("::1", port)]
+ when Socket::AF_INET then [Addrinfo.tcp("127.0.0.1", port)]
+ end
+ end
+
+ socket = Socket.tcp("localhost", port)
+ assert_true(socket.remote_address.ipv6?)
+ ensure
+ server_thread&.value&.close
+ server&.close
+ socket&.close
+ end
+ RUBY
+ end
+
+ def test_tcp_socket_v6_hostname_resolved_earlier_and_v6_server_is_not_listening
+ opts = %w[-rsocket -W1]
+ assert_separately opts, <<~RUBY
+ begin
+ ipv4_address = "127.0.0.1"
+ server = Socket.new(Socket::AF_INET, :STREAM)
+ server.bind(Socket.pack_sockaddr_in(0, ipv4_address))
+ port = server.connect_address.ip_port
+ server_thread = Thread.new { server.listen(1); server.accept }
+
+ Addrinfo.define_singleton_method(:getaddrinfo) do |_, _, family, *_|
+ case family
+ when Socket::AF_INET6 then [Addrinfo.tcp("::1", port)]
+ when Socket::AF_INET then sleep(0.001); [Addrinfo.tcp(ipv4_address, port)]
+ end
+ end
+
+ socket = Socket.tcp("localhost", port)
+ assert_equal(ipv4_address, socket.remote_address.ip_address)
+ ensure
+ accepted, _ = server_thread&.value
+ accepted&.close
+ server&.close
+ socket&.close
+ end
+ RUBY
+ end
+
+ def test_tcp_socket_resolv_timeout
+ opts = %w[-rsocket -W1]
+ assert_separately opts, <<~RUBY
+ begin
+ server = TCPServer.new("localhost", 0)
+ _, port, = server.addr
+
+ Addrinfo.define_singleton_method(:getaddrinfo) { |*_| sleep }
+
+ assert_raise(IO::TimeoutError) do
+ Socket.tcp("localhost", port, resolv_timeout: 0.01)
+ end
+ ensure
+ server&.close
+ end
+ RUBY
+ end
+
+ def test_tcp_socket_resolv_timeout_with_connection_failure
+ opts = %w[-rsocket -W1]
+ assert_separately opts, <<~RUBY
+ server = TCPServer.new("127.0.0.1", 12345)
+ _, port, = server.addr
+
+ Addrinfo.define_singleton_method(:getaddrinfo) do |_, _, family, *_|
+ if family == Socket::AF_INET6
+ sleep
+ else
+ [Addrinfo.tcp("127.0.0.1", port)]
+ end
+ end
+
+ server.close
+
+ assert_raise(IO::TimeoutError) do
+ Socket.tcp("localhost", port, resolv_timeout: 0.01)
+ end
+ RUBY
+ end
+
+ def test_tcp_socket_open_timeout
+ opts = %w[-rsocket -W1]
+ assert_separately opts, <<~RUBY
+ Addrinfo.define_singleton_method(:getaddrinfo) do |_, _, family, *_|
+ if family == Socket::AF_INET6
+ sleep
+ else
+ [Addrinfo.tcp("127.0.0.1", 12345)]
+ end
+ end
+
+ assert_raise(IO::TimeoutError) do
+ Socket.tcp("localhost", 12345, open_timeout: 0.01)
+ end
+ RUBY
+ end
+
+ def test_tcp_socket_open_timeout_with_other_timeouts
+ opts = %w[-rsocket -W1]
+ assert_separately opts, <<~RUBY
+ assert_raise(ArgumentError) do
+ Socket.tcp("localhost", 12345, open_timeout: 0.01, resolv_timout: 0.01)
+ end
+ RUBY
+ end
+
+ def test_tcp_socket_one_hostname_resolution_succeeded_at_least
+ opts = %w[-rsocket -W1]
+ assert_separately opts, <<~RUBY
+ begin
+ begin
+ # Verify that "localhost" can be resolved to an IPv6 address
+ Socket.getaddrinfo("localhost", 0, Socket::AF_INET6)
+ server = TCPServer.new("::1", 0)
+ rescue Socket::ResolutionError, Errno::EADDRNOTAVAIL # IPv6 is not supported
+ return
+ end
+
+ _, port, = server.addr
+ server_thread = Thread.new { server.accept }
+
+ Addrinfo.define_singleton_method(:getaddrinfo) do |_, _, family, *_|
+ case family
+ when Socket::AF_INET6 then [Addrinfo.tcp("::1", port)]
+ when Socket::AF_INET then sleep(0.001); raise SocketError
+ end
+ end
+
+ socket = nil
+
+ assert_nothing_raised do
+ socket = Socket.tcp("localhost", port)
+ end
+ ensure
+ server_thread&.value&.close
+ server&.close
+ socket&.close
+ end
+ RUBY
+ end
+
+ def test_tcp_socket_all_hostname_resolution_failed
+ opts = %w[-rsocket -W1]
+ assert_separately opts, <<~RUBY
+ begin
+ server = TCPServer.new("localhost", 0)
+ _, port, = server.addr
+
+ Addrinfo.define_singleton_method(:getaddrinfo) do |_, _, family, *_|
+ case family
+ when Socket::AF_INET6 then raise SocketError
+ when Socket::AF_INET then sleep(0.01); raise SocketError, "Last hostname resolution error"
+ end
+ end
+
+ assert_raise_with_message(SocketError, "Last hostname resolution error") do
+ Socket.tcp("localhost", port)
+ end
+ ensure
+ server&.close
+ end
+ RUBY
+ end
+
+ def test_tcp_socket_hostname_resolution_failed_after_connection_failure
+ opts = %w[-rsocket -W1]
+ assert_separately opts, <<~RUBY
+ server = TCPServer.new("127.0.0.1", 0)
+ port = server.connect_address.ip_port
+
+ Addrinfo.define_singleton_method(:getaddrinfo) do |_, _, family, *_|
+ case family
+ when Socket::AF_INET6 then sleep(0.1); raise Socket::ResolutionError
+ when Socket::AF_INET then [Addrinfo.tcp("127.0.0.1", port)]
+ end
+ end
+
+ server.close
+
+ # SystemCallError is a workaround for Windows environment
+ assert_raise(Errno::ECONNREFUSED, SystemCallError) do
+ Socket.tcp("localhost", port)
+ end
+ RUBY
+ end
+
+ def test_tcp_socket_v6_address_passed
+ opts = %w[-rsocket -W1]
+ assert_separately opts, <<~RUBY
+ begin
+ begin
+ # Verify that "localhost" can be resolved to an IPv6 address
+ Socket.getaddrinfo("localhost", 0, Socket::AF_INET6)
+ server = TCPServer.new("::1", 0)
+ rescue Socket::ResolutionError, Errno::EADDRNOTAVAIL # IPv6 is not supported
+ return
+ end
+
+ _, port, = server.addr
+ server_thread = Thread.new { server.accept }
+
+ Addrinfo.define_singleton_method(:getaddrinfo) do |*_|
+ [Addrinfo.tcp("::1", port)]
+ end
+
+ socket = Socket.tcp("::1", port)
+ assert_true(socket.remote_address.ipv6?)
+ ensure
+ server_thread&.value&.close
+ server&.close
+ socket&.close
+ end
+ RUBY
+ end
+
+ def test_tcp_socket_fast_fallback_is_false
+ server = TCPServer.new("127.0.0.1", 0)
+ _, port, = server.addr
+ server_thread = Thread.new { server.accept }
+ socket = Socket.tcp("127.0.0.1", port, fast_fallback: false)
+ assert_true(socket.remote_address.ipv4?)
+ ensure
+ server_thread&.value&.close
+ server&.close
+ socket&.close
+ end
+
+ def test_tcp_fast_fallback
+ opts = %w[-rsocket -W1]
+ assert_separately opts, <<~RUBY
+ assert_true(Socket.tcp_fast_fallback)
+
+ Socket.tcp_fast_fallback = false
+ assert_false(Socket.tcp_fast_fallback)
+
+ Socket.tcp_fast_fallback = true
+ assert_true(Socket.tcp_fast_fallback)
+ RUBY
+ end
end if defined?(Socket)
generated by cgit v1.2.3 (git 2.25.1) at 2026-01-20 02:49:54 +0000