summaryrefslogtreecommitdiff
path: root/test/socket
diff options
context:
space:
mode:
Diffstat (limited to 'test/socket')
-rw-r--r--test/socket/test_addrinfo.rb30
-rw-r--r--test/socket/test_basicsocket.rb6
-rw-r--r--test/socket/test_nonblock.rb12
-rw-r--r--test/socket/test_socket.rb399
-rw-r--r--test/socket/test_sockopt.rb2
-rw-r--r--test/socket/test_tcp.rb337
-rw-r--r--test/socket/test_udp.rb2
-rw-r--r--test/socket/test_unix.rb256
8 files changed, 942 insertions, 102 deletions
diff --git a/test/socket/test_addrinfo.rb b/test/socket/test_addrinfo.rb
index a06f3eb451..0c9529090e 100644
--- a/test/socket/test_addrinfo.rb
+++ b/test/socket/test_addrinfo.rb
@@ -103,7 +103,7 @@ class TestSocketAddrinfo < Test::Unit::TestCase
end
def test_error_message
- e = assert_raise_with_message(SocketError, /getaddrinfo:/) do
+ e = assert_raise_with_message(Socket::ResolutionError, /getaddrinfo/) do
Addrinfo.ip("...")
end
m = e.message
@@ -357,17 +357,31 @@ class TestSocketAddrinfo < Test::Unit::TestCase
ai = Addrinfo.unix("/testdir/sock").family_addrinfo("/testdir/sock2")
assert_equal("/testdir/sock2", ai.unix_path)
assert_equal(Socket::SOCK_STREAM, ai.socktype)
- assert_raise(SocketError) { Addrinfo.tcp("0.0.0.0", 4649).family_addrinfo("::1", 80) }
+ assert_raise(Socket::ResolutionError) { Addrinfo.tcp("0.0.0.0", 4649).family_addrinfo("::1", 80) }
+ end
+
+ def test_ractor_shareable
+ assert_ractor(<<~'RUBY', require: 'socket', timeout: 60)
+ Ractor.make_shareable Addrinfo.new "\x10\x02\x14\xE9\xE0\x00\x00\xFB\x00\x00\x00\x00\x00\x00\x00\x00".b
+ RUBY
end
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 fails with "Errno::EACCES: Permission denied - bind(2) for 0.0.0.0:49721"
+ errs << Errno::EACCES if /mingw|mswin/ =~ RUBY_PLATFORM
+ errs
end
def test_connect_from
@@ -578,9 +592,9 @@ class TestSocketAddrinfo < Test::Unit::TestCase
ai = ipv6(addr)
begin
assert(ai.ipv4? || ai.send(meth), "ai=#{addr_exp}; ai.ipv4? || .#{meth}")
- rescue Minitest::Assertion
+ rescue Test::Unit::AssertionFailedError
if /aix/ =~ RUBY_PLATFORM
- skip "Known bug in IN6_IS_ADDR_V4COMPAT and IN6_IS_ADDR_V4MAPPED on AIX"
+ omit "Known bug in IN6_IS_ADDR_V4COMPAT and IN6_IS_ADDR_V4MAPPED on AIX"
end
raise $!
end
@@ -688,5 +702,9 @@ class TestSocketAddrinfo < Test::Unit::TestCase
assert_equal(ai1.canonname, ai2.canonname)
end
+ def test_addrinfo_timeout
+ ai = Addrinfo.getaddrinfo("localhost", "ssh", Socket::PF_INET, Socket::SOCK_STREAM, timeout: 1).fetch(0)
+ assert_equal(22, ai.ip_port)
+ end
end
end
diff --git a/test/socket/test_basicsocket.rb b/test/socket/test_basicsocket.rb
index c8e9b23f83..8c1b434a83 100644
--- a/test/socket/test_basicsocket.rb
+++ b/test/socket/test_basicsocket.rb
@@ -32,10 +32,10 @@ class TestSocket_BasicSocket < Test::Unit::TestCase
n = s.getsockopt(Socket::SOL_SOCKET, Socket::SO_ERROR)
assert_equal([0].pack("i"), n.data)
- rescue Minitest::Assertion
+ rescue Test::Unit::AssertionFailedError
s.close
if /aix/ =~ RUBY_PLATFORM
- skip "Known bug in getsockopt(2) on AIX"
+ omit "Known bug in getsockopt(2) on AIX"
end
raise $!
end
@@ -159,8 +159,6 @@ class TestSocket_BasicSocket < Test::Unit::TestCase
set_nb = true
buf = String.new
if ssock.respond_to?(:nonblock?)
- assert_not_predicate(ssock, :nonblock?)
- assert_not_predicate(csock, :nonblock?)
csock.nonblock = ssock.nonblock = false
# Linux may use MSG_DONTWAIT to avoid setting O_NONBLOCK
diff --git a/test/socket/test_nonblock.rb b/test/socket/test_nonblock.rb
index 5d45593439..5a4688bac3 100644
--- a/test/socket/test_nonblock.rb
+++ b/test/socket/test_nonblock.rb
@@ -279,7 +279,7 @@ class TestSocketNonblock < Test::Unit::TestCase
s1.sendmsg_nonblock("a" * 100000)
}
rescue NotImplementedError, Errno::ENOSYS
- skip "sendmsg not implemented on this platform: #{$!}"
+ omit "sendmsg not implemented on this platform: #{$!}"
rescue Errno::EMSGSIZE
# UDP has 64K limit (if no Jumbograms). No problem.
rescue Errno::EWOULDBLOCK
@@ -307,11 +307,13 @@ class TestSocketNonblock < Test::Unit::TestCase
loop { s1.sendmsg_nonblock(buf) }
end
end
- rescue NotImplementedError, Errno::ENOSYS, Errno::EPROTONOSUPPORT
- skip "UNIXSocket.pair(:SEQPACKET) not implemented on this platform: #{$!}"
+ rescue NotImplementedError, Errno::ENOSYS, Errno::EPROTONOSUPPORT, Errno::EPROTOTYPE
+ omit "UNIXSocket.pair(:SEQPACKET) not implemented on this platform: #{$!}"
end
def test_sendmsg_nonblock_no_exception
+ omit "AF_UNIX + SEQPACKET is not supported on windows" if /mswin|mingw/ =~ RUBY_PLATFORM
+
buf = '*' * 4096
UNIXSocket.pair(:SEQPACKET) do |s1, s2|
n = 0
@@ -329,7 +331,7 @@ class TestSocketNonblock < Test::Unit::TestCase
end
end
rescue NotImplementedError, Errno::ENOSYS, Errno::EPROTONOSUPPORT
- skip "UNIXSocket.pair(:SEQPACKET) not implemented on this platform: #{$!}"
+ omit "UNIXSocket.pair(:SEQPACKET) not implemented on this platform: #{$!}"
end
end
@@ -338,7 +340,7 @@ class TestSocketNonblock < Test::Unit::TestCase
begin
s1.recvmsg_nonblock(4096)
rescue NotImplementedError
- skip "recvmsg not implemented on this platform."
+ omit "recvmsg not implemented on this platform."
rescue Errno::EWOULDBLOCK
assert_kind_of(IO::WaitReadable, $!)
end
diff --git a/test/socket/test_socket.rb b/test/socket/test_socket.rb
index 6cbf3edca8..c42527f370 100644
--- a/test/socket/test_socket.rb
+++ b/test/socket/test_socket.rb
@@ -91,20 +91,20 @@ class TestSocket < Test::Unit::TestCase
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
@@ -121,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
@@ -154,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
@@ -323,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
ifaddrs = Socket.getifaddrs
rescue NotImplementedError
- skip "Socket.getifaddrs not implemented"
+ omit "Socket.getifaddrs not implemented"
end
ifconfig = nil
@@ -380,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
@@ -421,16 +444,18 @@ class TestSocket < Test::Unit::TestCase
}
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
@@ -467,12 +492,14 @@ class TestSocket < Test::Unit::TestCase
end while IO.select([r], nil, nil, 0.1).nil?
n
end
- assert_equal([[s1],[],[]], IO.select([s1], nil, nil, 30))
+ 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")
@@ -481,11 +508,15 @@ class TestSocket < Test::Unit::TestCase
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 /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
@@ -563,7 +594,7 @@ class TestSocket < Test::Unit::TestCase
ensure
serv_thread.value.close
server.close
- end
+ end unless RUBY_PLATFORM.include?("freebsd")
def test_connect_timeout
host = "127.0.0.1"
@@ -742,4 +773,330 @@ class TestSocket < Test::Unit::TestCase
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)
diff --git a/test/socket/test_sockopt.rb b/test/socket/test_sockopt.rb
index f166027d26..7e343e8c36 100644
--- a/test/socket/test_sockopt.rb
+++ b/test/socket/test_sockopt.rb
@@ -34,7 +34,7 @@ class TestSocketOption < Test::Unit::TestCase
}
rescue TypeError
if /aix/ =~ RUBY_PLATFORM
- skip "Known bug in getsockopt(2) on AIX"
+ omit "Known bug in getsockopt(2) on AIX"
end
raise $!
end
diff --git a/test/socket/test_tcp.rb b/test/socket/test_tcp.rb
index 11325fdedb..d689ab2376 100644
--- a/test/socket/test_tcp.rb
+++ b/test/socket/test_tcp.rb
@@ -18,6 +18,12 @@ class TestSocket_TCPSocket < Test::Unit::TestCase
end
def test_initialize_failure
+ assert_raise(Socket::ResolutionError) do
+ t = TCPSocket.open(nil, nil)
+ ensure
+ t&.close
+ end
+
# These addresses are chosen from TEST-NET-1, TEST-NET-2, and TEST-NET-3.
# [RFC 5737]
# They are chosen because probably they are not used as a host address.
@@ -43,16 +49,58 @@ class TestSocket_TCPSocket < Test::Unit::TestCase
server_addr = '127.0.0.1'
server_port = 80
- begin
+ e = assert_raise_kind_of(SystemCallError) do
# Since client_addr is not an IP address of this host,
# bind() in TCPSocket.new should fail as EADDRNOTAVAIL.
t = TCPSocket.new(server_addr, server_port, client_addr, client_port)
- flunk "expected SystemCallError"
- rescue SystemCallError => e
- assert_match "for \"#{client_addr}\" port #{client_port}", e.message
+ ensure
+ t&.close
+ end
+ assert_include e.message, "for \"#{client_addr}\" port #{client_port}"
+ end
+
+ def test_initialize_resolv_timeout
+ TCPServer.open("localhost", 0) do |svr|
+ th = Thread.new {
+ c = svr.accept
+ c.close
+ }
+ addr = svr.addr
+ s = TCPSocket.new(addr[3], addr[1], resolv_timeout: 10)
+ th.join
+ ensure
+ s.close()
+ end
+ end
+
+ def test_tcp_initialize_open_timeout
+ return if RUBY_PLATFORM =~ /mswin|mingw|cygwin/
+
+ server = TCPServer.new("127.0.0.1", 0)
+ port = server.connect_address.ip_port
+ server.close
+
+ assert_raise(IO::TimeoutError) do
+ TCPSocket.new(
+ "localhost",
+ port,
+ open_timeout: 0.01,
+ fast_fallback: true,
+ test_mode_settings: { delay: { ipv4: 1000 } }
+ )
+ end
+ end
+
+ def test_initialize_open_timeout_with_other_timeouts
+ assert_raise(ArgumentError) do
+ TCPSocket.new("localhost", 12345, open_timeout: 0.01, resolv_timeout: 0.01)
+ end
+ end
+
+ def test_initialize_connect_timeout
+ assert_raise(IO::TimeoutError, Errno::ENETUNREACH, Errno::EACCES) do
+ TCPSocket.new("192.0.2.1", 80, connect_timeout: 0)
end
- ensure
- t.close if t && !t.closed?
end
def test_recvfrom
@@ -95,4 +143,281 @@ class TestSocket_TCPSocket < Test::Unit::TestCase
assert_raise(IO::WaitReadable) { svr.accept_nonblock(exception: true) }
}
end
+
+ def test_accept_multithread
+ attempts_count = 5
+ server_threads_count = 3
+ client_threads_count = 3
+
+ attempts_count.times do
+ server_threads = Array.new(server_threads_count) do
+ Thread.new do
+ TCPServer.open("localhost", 0) do |server|
+ accept_threads = Array.new(client_threads_count) do
+ Thread.new { server.accept.close }
+ end
+ client_threads = Array.new(client_threads_count) do
+ Thread.new { TCPSocket.open(server.addr[3], server.addr[1]) {} }
+ end
+ client_threads.each(&:join)
+ accept_threads.each(&:join)
+ end
+ end
+ end
+
+ server_threads.each(&:join)
+ end
+ end
+
+ def test_initialize_v6_hostname_resolved_earlier
+ return if RUBY_PLATFORM =~ /mswin|mingw|cygwin/
+
+ 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
+
+ server_thread = Thread.new { server.accept }
+ port = server.addr[1]
+
+ socket = TCPSocket.new(
+ "localhost",
+ port,
+ fast_fallback: true,
+ test_mode_settings: { delay: { ipv4: 1000 } }
+ )
+ assert_true(socket.remote_address.ipv6?)
+ ensure
+ server_thread&.value&.close
+ server&.close
+ socket&.close
+ end
+
+ def test_initialize_v4_hostname_resolved_earlier
+ return if RUBY_PLATFORM =~ /mswin|mingw|cygwin/
+
+ server = TCPServer.new("127.0.0.1", 0)
+ port = server.addr[1]
+
+ server_thread = Thread.new { server.accept }
+ socket = TCPSocket.new(
+ "localhost",
+ port,
+ fast_fallback: true,
+ test_mode_settings: { delay: { ipv6: 1000 } }
+ )
+ assert_true(socket.remote_address.ipv4?)
+ ensure
+ server_thread&.value&.close
+ server&.close
+ socket&.close
+ end
+
+ def test_initialize_v6_hostname_resolved_in_resolution_delay
+ return if RUBY_PLATFORM =~ /mswin|mingw|cygwin/
+
+ 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[1]
+ delay_time = 25 # Socket::RESOLUTION_DELAY (private) is 50ms
+
+ server_thread = Thread.new { server.accept }
+ socket = TCPSocket.new(
+ "localhost",
+ port,
+ fast_fallback: true,
+ test_mode_settings: { delay: { ipv6: delay_time } }
+ )
+ assert_true(socket.remote_address.ipv6?)
+ ensure
+ server_thread&.value&.close
+ server&.close
+ socket&.close
+ end
+
+ def test_initialize_v6_hostname_resolved_earlier_and_v6_server_is_not_listening
+ return if RUBY_PLATFORM =~ /mswin|mingw|cygwin/
+
+ 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 }
+ socket = TCPSocket.new(
+ "localhost",
+ port,
+ fast_fallback: true,
+ test_mode_settings: { delay: { ipv4: 10 } }
+ )
+ assert_equal(ipv4_address, socket.remote_address.ip_address)
+ ensure
+ accepted, _ = server_thread&.value
+ accepted&.close
+ server&.close
+ socket&.close
+ end
+
+ def test_initialize_v6_hostname_resolved_later_and_v6_server_is_not_listening
+ return if RUBY_PLATFORM =~ /mswin|mingw|cygwin/
+
+ server = Socket.new(Socket::AF_INET, :STREAM)
+ server.bind(Socket.pack_sockaddr_in(0, "127.0.0.1"))
+ port = server.connect_address.ip_port
+
+ server_thread = Thread.new { server.listen(1); server.accept }
+ socket = TCPSocket.new(
+ "localhost",
+ port,
+ fast_fallback: true,
+ test_mode_settings: { delay: { ipv6: 25 } }
+ )
+ assert_true(socket.remote_address.ipv4?)
+ ensure
+ accepted, _ = server_thread&.value
+ accepted&.close
+ server&.close
+ socket&.close
+ end
+
+ def test_initialize_v6_hostname_resolution_failed_and_v4_hostname_resolution_is_success
+ return if RUBY_PLATFORM =~ /mswin|mingw|cygwin/
+
+ server = TCPServer.new("127.0.0.1", 0)
+ port = server.addr[1]
+
+ server_thread = Thread.new { server.accept }
+ socket = TCPSocket.new(
+ "localhost",
+ port,
+ fast_fallback: true,
+ test_mode_settings: { delay: { ipv4: 10 }, error: { ipv6: Socket::EAI_FAIL } }
+ )
+ assert_true(socket.remote_address.ipv4?)
+ ensure
+ server_thread&.value&.close
+ server&.close
+ socket&.close
+ end
+
+ def test_initialize_resolv_timeout_with_connection_failure
+ return if RUBY_PLATFORM =~ /mswin|mingw|cygwin/
+
+ begin
+ server = TCPServer.new("::1", 0)
+ rescue Errno::EADDRNOTAVAIL # IPv6 is not supported
+ return
+ end
+
+ port = server.connect_address.ip_port
+ server.close
+
+ assert_raise(IO::TimeoutError) do
+ TCPSocket.new(
+ "localhost",
+ port,
+ resolv_timeout: 0.01,
+ fast_fallback: true,
+ test_mode_settings: { delay: { ipv4: 1000 } }
+ )
+ end
+ end
+
+ def test_initialize_with_hostname_resolution_failure_after_connection_failure
+ return if RUBY_PLATFORM =~ /mswin|mingw|cygwin/
+
+ begin
+ server = TCPServer.new("::1", 0)
+ rescue Errno::EADDRNOTAVAIL # IPv6 is not supported
+ return
+ end
+
+ port = server.connect_address.ip_port
+ server.close
+
+ assert_raise(Errno::ECONNREFUSED) do
+ TCPSocket.new(
+ "localhost",
+ port,
+ fast_fallback: true,
+ test_mode_settings: { delay: { ipv4: 100 }, error: { ipv4: Socket::EAI_FAIL } }
+ )
+ end
+ end
+
+ def test_initialize_with_connection_failure_after_hostname_resolution_failure
+ return if RUBY_PLATFORM =~ /mswin|mingw|cygwin/
+
+ server = TCPServer.new("127.0.0.1", 0)
+ port = server.connect_address.ip_port
+ server.close
+
+ assert_raise(Errno::ECONNREFUSED) do
+ TCPSocket.new(
+ "localhost",
+ port,
+ fast_fallback: true,
+ test_mode_settings: { delay: { ipv4: 100 }, error: { ipv6: Socket::EAI_FAIL } }
+ )
+ end
+ end
+
+ def test_initialize_v6_connected_socket_with_v6_address
+ return if RUBY_PLATFORM =~ /mswin|mingw|cygwin/
+
+ begin
+ server = TCPServer.new("::1", 0)
+ rescue Errno::EADDRNOTAVAIL # IPv6 is not supported
+ return
+ end
+
+ server_thread = Thread.new { server.accept }
+ port = server.addr[1]
+
+ socket = TCPSocket.new("::1", port)
+ assert_true(socket.remote_address.ipv6?)
+ ensure
+ server_thread&.value&.close
+ server&.close
+ socket&.close
+ end
+
+ def test_initialize_v4_connected_socket_with_v4_address
+ return if RUBY_PLATFORM =~ /mswin|mingw|cygwin/
+
+ server = TCPServer.new("127.0.0.1", 0)
+ server_thread = Thread.new { server.accept }
+ port = server.addr[1]
+
+ socket = TCPSocket.new("127.0.0.1", port)
+ assert_true(socket.remote_address.ipv4?)
+ ensure
+ server_thread&.value&.close
+ server&.close
+ socket&.close
+ end
+
+ def test_initialize_fast_fallback_is_false
+ return if RUBY_PLATFORM =~ /mswin|mingw|cygwin/
+
+ server = TCPServer.new("127.0.0.1", 0)
+ _, port, = server.addr
+ server_thread = Thread.new { server.accept }
+
+ socket = TCPSocket.new("127.0.0.1", port, fast_fallback: false)
+ assert_true(socket.remote_address.ipv4?)
+ ensure
+ server_thread&.value&.close
+ server&.close
+ socket&.close
+ end
end if defined?(TCPSocket)
diff --git a/test/socket/test_udp.rb b/test/socket/test_udp.rb
index f060b65f2c..4b2b7ab976 100644
--- a/test/socket/test_udp.rb
+++ b/test/socket/test_udp.rb
@@ -25,7 +25,7 @@ class TestSocket_UDPSocket < Test::Unit::TestCase
assert_match(/AF_INET6\b/, sock.inspect)
}
rescue Errno::EAFNOSUPPORT
- skip 'AF_INET6 not supported by kernel'
+ omit 'AF_INET6 not supported by kernel'
end
end
end
diff --git a/test/socket/test_unix.rb b/test/socket/test_unix.rb
index 6efb1d60ee..e239e3935b 100644
--- a/test/socket/test_unix.rb
+++ b/test/socket/test_unix.rb
@@ -47,13 +47,21 @@ class TestSocket_UNIXSocket < Test::Unit::TestCase
r.close
s1.send_io(s1)
- # klass = UNIXSocket FIXME: [ruby-core:71860] [Bug #11778]
+ klass = UNIXSocket
+ r = s2.recv_io(klass)
+ assert_instance_of klass, r, 'recv_io with proper klass'
+ assert_not_equal s1.fileno, r.fileno
+ r.close
+
+ s1.send_io(s1)
klass = IO
r = s2.recv_io(klass, 'r+')
- assert_instance_of klass, r, 'recv_io with proper klass'
+ assert_instance_of klass, r, 'recv_io with proper klass and mode'
assert_not_equal s1.fileno, r.fileno
r.close
end
+ rescue NotImplementedError => error
+ omit error.message
end
def test_fd_passing_n
@@ -138,13 +146,14 @@ class TestSocket_UNIXSocket < Test::Unit::TestCase
end
def test_fd_passing_race_condition
+ omit 'randomly crashes on macOS' if RUBY_PLATFORM =~ /darwin/
r1, w = IO.pipe
s1, s2 = UNIXSocket.pair
s1.nonblock = s2.nonblock = true
lock = Thread::Mutex.new
nr = 0
x = 2
- y = 1000
+ y = 400
begin
s1.send_io(nil)
rescue NotImplementedError
@@ -284,14 +293,18 @@ class TestSocket_UNIXSocket < Test::Unit::TestCase
File.unlink path if path && File.socket?(path)
end
- def test_open_nul_byte
- tmpfile = Tempfile.new("s")
- path = tmpfile.path
- tmpfile.close(true)
- assert_raise(ArgumentError) {UNIXServer.open(path+"\0")}
- assert_raise(ArgumentError) {UNIXSocket.open(path+"\0")}
- ensure
- File.unlink path if path && File.socket?(path)
+ def test_open_argument
+ assert_raise(TypeError) {UNIXServer.new(nil)}
+ assert_raise(TypeError) {UNIXServer.new(1)}
+ Tempfile.create("s") do |s|
+ path = s.path
+ s.close
+ File.unlink(path)
+ assert_raise(ArgumentError) {UNIXServer.open(path+"\0")}
+ assert_raise(ArgumentError) {UNIXSocket.open(path+"\0")}
+ arg = Struct.new(:to_path).new(path)
+ assert_equal(path, UNIXServer.open(arg) { |server| server.path })
+ end
end
def test_addr
@@ -328,62 +341,70 @@ class TestSocket_UNIXSocket < Test::Unit::TestCase
end
def test_noname_path
- s1, s2 = UNIXSocket.pair
- assert_equal("", s1.path)
- assert_equal("", s2.path)
- ensure
- s1.close
- s2.close
+ if /mswin|mingw/ =~ RUBY_PLATFORM
+ omit "unnamed pipe is emulated on windows"
+ end
+
+ UNIXSocket.pair do |s1, s2|
+ assert_equal("", s1.path)
+ assert_equal("", s2.path)
+ end
end
def test_noname_addr
- s1, s2 = UNIXSocket.pair
- assert_equal(["AF_UNIX", ""], s1.addr)
- assert_equal(["AF_UNIX", ""], s2.addr)
- ensure
- s1.close
- s2.close
+ if /mswin|mingw/ =~ RUBY_PLATFORM
+ omit "unnamed pipe is emulated on windows"
+ end
+
+ UNIXSocket.pair do |s1, s2|
+ assert_equal(["AF_UNIX", ""], s1.addr)
+ assert_equal(["AF_UNIX", ""], s2.addr)
+ end
end
def test_noname_peeraddr
- s1, s2 = UNIXSocket.pair
- assert_equal(["AF_UNIX", ""], s1.peeraddr)
- assert_equal(["AF_UNIX", ""], s2.peeraddr)
- ensure
- s1.close
- s2.close
+ if /mswin|mingw/ =~ RUBY_PLATFORM
+ omit "unnamed pipe is emulated on windows"
+ end
+
+ UNIXSocket.pair do |s1, s2|
+ assert_equal(["AF_UNIX", ""], s1.peeraddr)
+ assert_equal(["AF_UNIX", ""], s2.peeraddr)
+ end
end
def test_noname_unpack_sockaddr_un
- s1, s2 = UNIXSocket.pair
- n = nil
- assert_equal("", Socket.unpack_sockaddr_un(n)) if (n = s1.getsockname) != ""
- assert_equal("", Socket.unpack_sockaddr_un(n)) if (n = s1.getsockname) != ""
- assert_equal("", Socket.unpack_sockaddr_un(n)) if (n = s2.getsockname) != ""
- assert_equal("", Socket.unpack_sockaddr_un(n)) if (n = s1.getpeername) != ""
- assert_equal("", Socket.unpack_sockaddr_un(n)) if (n = s2.getpeername) != ""
- ensure
- s1.close
- s2.close
+ if /mswin|mingw/ =~ RUBY_PLATFORM
+ omit "unnamed pipe is emulated on windows"
+ end
+
+ UNIXSocket.pair do |s1, s2|
+ n = nil
+ assert_equal("", Socket.unpack_sockaddr_un(n)) if (n = s1.getsockname) != ""
+ assert_equal("", Socket.unpack_sockaddr_un(n)) if (n = s1.getsockname) != ""
+ assert_equal("", Socket.unpack_sockaddr_un(n)) if (n = s2.getsockname) != ""
+ assert_equal("", Socket.unpack_sockaddr_un(n)) if (n = s1.getpeername) != ""
+ assert_equal("", Socket.unpack_sockaddr_un(n)) if (n = s2.getpeername) != ""
+ end
end
def test_noname_recvfrom
- s1, s2 = UNIXSocket.pair
- s2.write("a")
- assert_equal(["a", ["AF_UNIX", ""]], s1.recvfrom(10))
- ensure
- s1.close
- s2.close
+ if /mswin|mingw/ =~ RUBY_PLATFORM
+ omit "unnamed pipe is emulated on windows"
+ end
+
+ UNIXSocket.pair do |s1, s2|
+ s2.write("a")
+ assert_equal(["a", ["AF_UNIX", ""]], s1.recvfrom(10))
+ end
end
def test_noname_recv_nonblock
- s1, s2 = UNIXSocket.pair
- s2.write("a")
- IO.select [s1]
- assert_equal("a", s1.recv_nonblock(10))
- ensure
- s1.close
- s2.close
+ UNIXSocket.pair do |s1, s2|
+ s2.write("a")
+ IO.select [s1]
+ assert_equal("a", s1.recv_nonblock(10))
+ end
end
def test_too_long_path
@@ -404,9 +425,10 @@ class TestSocket_UNIXSocket < Test::Unit::TestCase
s1.recv_nonblock(10)
fail
rescue => e
- assert(IO::EAGAINWaitReadable === e)
- assert(IO::WaitReadable === e)
+ assert_kind_of(IO::EWOULDBLOCKWaitReadable, e)
+ assert_kind_of(IO::WaitReadable, e)
end
+
s2.send("", 0)
s2.send("haha", 0)
s2.send("", 0)
@@ -423,12 +445,79 @@ class TestSocket_UNIXSocket < Test::Unit::TestCase
rv = s1.recv(100, 0, buf)
assert_equal buf.object_id, rv.object_id
assert_equal "BBBBBB", rv
+ rescue Errno::EPROTOTYPE => error
+ omit error.message
+ ensure
+ s1.close if s1
+ s2.close if s2
+ end
+
+ def test_stream_pair
+ s1, s2 = UNIXSocket.pair(Socket::SOCK_STREAM)
+ begin
+ s1.recv_nonblock(10)
+ fail
+ rescue => e
+ assert_kind_of(IO::EWOULDBLOCKWaitReadable, e)
+ assert_kind_of(IO::WaitReadable, e)
+ end
+
+ s2.send("", 0)
+ s2.send("haha", 0)
+ assert_equal("haha", s1.recv(10))
+ assert_raise(IO::EWOULDBLOCKWaitReadable) { s1.recv_nonblock(10) }
+
+ buf = "".dup
+ s2.send("BBBBBB", 0)
+ IO.select([s1])
+ rv = s1.recv(100, 0, buf)
+ assert_equal buf.object_id, rv.object_id
+ assert_equal "BBBBBB", rv
+
+ s2.close
+ assert_nil(s1.recv(10))
+ rescue Errno::EPROTOTYPE => error
+ omit error.message
+ ensure
+ s1.close if s1
+ s2.close if s2
+ end
+
+ def test_seqpacket_pair
+ s1, s2 = UNIXSocket.pair(Socket::SOCK_SEQPACKET)
+ begin
+ s1.recv_nonblock(10)
+ fail
+ rescue => e
+ assert_kind_of(IO::EWOULDBLOCKWaitReadable, e)
+ assert_kind_of(IO::WaitReadable, e)
+ end
+
+ s2.send("haha", 0)
+ assert_equal("haha", s1.recv(10))
+ assert_raise(IO::EWOULDBLOCKWaitReadable) { s1.recv_nonblock(10) }
+
+ buf = "".dup
+ s2.send("BBBBBB", 0)
+ IO.select([s1])
+ rv = s1.recv(100, 0, buf)
+ assert_equal buf.object_id, rv.object_id
+ assert_equal "BBBBBB", rv
+
+ s2.close
+ assert_nil(s1.recv(10))
+ rescue Errno::EPROTOTYPE, Errno::EPROTONOSUPPORT => error
+ omit error.message
ensure
s1.close if s1
s2.close if s2
end
def test_dgram_pair_sendrecvmsg_errno_set
+ if /mswin|mingw/ =~ RUBY_PLATFORM
+ omit("AF_UNIX + SOCK_DGRAM is not supported on windows")
+ end
+
s1, s2 = to_close = UNIXSocket.pair(Socket::SOCK_DGRAM)
pipe = IO.pipe
to_close.concat(pipe)
@@ -451,9 +540,17 @@ class TestSocket_UNIXSocket < Test::Unit::TestCase
end
def test_epipe # [ruby-dev:34619]
+ # This is a good example of why reporting the exact `errno` is a terrible
+ # idea for platform abstractions.
+ if RUBY_PLATFORM =~ /mswin|mingw/
+ error = Errno::ESHUTDOWN
+ else
+ error = Errno::EPIPE
+ end
+
UNIXSocket.pair {|s1, s2|
s1.shutdown(Socket::SHUT_WR)
- assert_raise(Errno::EPIPE) { s1.write "a" }
+ assert_raise(error) { s1.write "a" }
assert_equal(nil, s2.read(1))
s2.write "a"
assert_equal("a", s1.read(1))
@@ -487,6 +584,45 @@ class TestSocket_UNIXSocket < Test::Unit::TestCase
}
end
+ if /mingw|mswin/ =~ RUBY_PLATFORM
+
+ def test_unix_socket_with_encoding
+ Dir.mktmpdir do |tmpdir|
+ path = "#{tmpdir}/sockäöü".encode("cp850")
+ UNIXServer.open(path) do |serv|
+ assert File.socket?(path)
+ assert File.stat(path).socket?
+ assert File.lstat(path).socket?
+ assert_equal path.encode("utf-8"), serv.path
+ UNIXSocket.open(path) do |s1|
+ s2 = serv.accept
+ s2.close
+ end
+ end
+ end
+ end
+
+ def test_windows_unix_socket_pair_with_umlaut
+ otmp = ENV['TMP']
+ ENV['TMP'] = File.join(Dir.tmpdir, "äöü€")
+ FileUtils.mkdir_p ENV['TMP']
+
+ s1, = UNIXSocket.pair
+ assert !s1.path.empty?
+ assert !File.exist?(s1.path)
+ ensure
+ FileUtils.rm_rf ENV['TMP']
+ ENV['TMP'] = otmp
+ end
+
+ def test_windows_unix_socket_pair_paths
+ s1, s2 = UNIXSocket.pair
+ assert !s1.path.empty?
+ assert s2.path.empty?
+ assert !File.exist?(s1.path)
+ end
+ end
+
def test_initialize
Dir.mktmpdir {|d|
Socket.open(Socket::AF_UNIX, Socket::SOCK_STREAM, 0) {|s|
@@ -542,16 +678,20 @@ class TestSocket_UNIXSocket < Test::Unit::TestCase
def test_getcred_xucred
return if /freebsd|darwin/ !~ RUBY_PLATFORM
- Dir.mktmpdir {|d|
+ Dir.mktmpdir do |d|
sockpath = "#{d}/sock"
serv = Socket.unix_server_socket(sockpath)
- Socket.unix(sockpath)
+ u = Socket.unix(sockpath)
s, = serv.accept
cred = s.getsockopt(0, Socket::LOCAL_PEERCRED)
inspect = cred.inspect
assert_match(/ euid=#{Process.euid} /, inspect)
assert_match(/ \(xucred\)/, inspect)
- }
+ ensure
+ s&.close
+ u&.close
+ serv&.close
+ end
end
def test_sendcred_ucred
generated by cgit v1.2.3 (git 2.25.1) at 2026-01-20 07:15:27 +0000