From 839214e1e635d3af9049fa637e484b3b8b9c0dfb Mon Sep 17 00:00:00 2001 From: akr Date: Mon, 12 Jan 2009 08:52:37 +0000 Subject: add test for AddrInfo. git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/trunk@21450 b2dd03c8-39d4-4d8f-98ff-823fe69b080e --- test/socket/test_addrinfo.rb | 300 +++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 300 insertions(+) create mode 100644 test/socket/test_addrinfo.rb (limited to 'test/socket') diff --git a/test/socket/test_addrinfo.rb b/test/socket/test_addrinfo.rb new file mode 100644 index 0000000000..88e08d55d0 --- /dev/null +++ b/test/socket/test_addrinfo.rb @@ -0,0 +1,300 @@ +begin + require "socket" +rescue LoadError +end + +require "test/unit" +require "tempfile" + +class TestSocketAddrInfo < Test::Unit::TestCase + def test_addrinfo_tcp + ai = AddrInfo.tcp("127.0.0.1", 80) + assert_equal([80, "127.0.0.1"], Socket.unpack_sockaddr_in(ai)) + assert_equal(Socket::AF_INET, ai.afamily) + assert_equal(Socket::PF_INET, ai.pfamily) + assert_equal(Socket::SOCK_STREAM, ai.socktype) + assert_includes([0, Socket::IPPROTO_TCP], ai.protocol) + end + + def test_addrinfo_udp + ai = AddrInfo.udp("127.0.0.1", 80) + assert_equal([80, "127.0.0.1"], Socket.unpack_sockaddr_in(ai)) + assert_equal(Socket::AF_INET, ai.afamily) + assert_equal(Socket::PF_INET, ai.pfamily) + assert_equal(Socket::SOCK_DGRAM, ai.socktype) + assert_includes([0, Socket::IPPROTO_UDP], ai.protocol) + end + + def test_addrinfo_new_inet + ai = AddrInfo.new(["AF_INET", 46102, "localhost.localdomain", "127.0.0.2"]) + assert_equal([46102, "127.0.0.2"], Socket.unpack_sockaddr_in(ai)) + assert_equal(Socket::AF_INET, ai.afamily) + assert_equal(Socket::PF_INET, ai.pfamily) + assert_equal(0, ai.socktype) + assert_equal(0, ai.protocol) + end + + def test_addrinfo_predicates + ipv4_ai = AddrInfo.new(Socket.sockaddr_in(80, "192.168.0.1")) + assert(ipv4_ai.ip?) + assert(ipv4_ai.ipv4?) + assert(!ipv4_ai.ipv6?) + assert(!ipv4_ai.unix?) + end + + def test_basicsocket_send + s1 = Socket.new(:INET, :DGRAM, 0) + s1.bind(Socket.sockaddr_in(0, "127.0.0.1")) + sa = s1.getsockname + ai = AddrInfo.new(sa) + s2 = Socket.new(:INET, :DGRAM, 0) + s2.send("test-basicsocket-send", 0, ai) + assert_equal("test-basicsocket-send", s1.recv(100)) + ensure + s1.close if s1 && !s1.closed? + s2.close if s2 && !s2.closed? + end + + def test_udpsocket_send + s1 = UDPSocket.new + s1.bind("127.0.0.1", 0) + ai = AddrInfo.new(s1.getsockname) + s2 = UDPSocket.new + s2.send("test-udp-send", 0, ai) + assert_equal("test-udp-send", s1.recv(100)) + ensure + s1.close if s1 && !s1.closed? + s2.close if s2 && !s2.closed? + end + + def test_socket_bind + s1 = Socket.new(:INET, :DGRAM, 0) + sa = Socket.sockaddr_in(0, "127.0.0.1") + ai = AddrInfo.new(sa) + s1.bind(ai) + s2 = UDPSocket.new + s2.send("test-socket-bind", 0, s1.getsockname) + assert_equal("test-socket-bind", s1.recv(100)) + ensure + s1.close if s1 && !s1.closed? + s2.close if s2 && !s2.closed? + end + + def test_socket_connect + s1 = Socket.new(:INET, :STREAM, 0) + s1.bind(Socket.sockaddr_in(0, "127.0.0.1")) + s1.listen(5) + ai = AddrInfo.new(s1.getsockname) + s2 = Socket.new(:INET, :STREAM, 0) + s2.connect(ai) + s3, sender_addr = s1.accept + s2.send("test-socket-connect", 0) + assert_equal("test-socket-connect", s3.recv(100)) + ensure + s1.close if s1 && !s1.closed? + s2.close if s2 && !s2.closed? + s3.close if s3 && !s3.closed? + end + + def test_socket_connect_nonblock + s1 = Socket.new(:INET, :STREAM, 0) + s1.bind(Socket.sockaddr_in(0, "127.0.0.1")) + s1.listen(5) + ai = AddrInfo.new(s1.getsockname) + s2 = Socket.new(:INET, :STREAM, 0) + begin + s2.connect_nonblock(ai) + rescue Errno::EINPROGRESS + IO.select(nil, [s2]) + begin + s2.connect_nonblock(ai) + rescue Errno::EISCONN + end + end + s3, sender_addr = s1.accept + s2.send("test-socket-connect-nonblock", 0) + assert_equal("test-socket-connect-nonblock", s3.recv(100)) + ensure + s1.close if s1 && !s1.closed? + s2.close if s2 && !s2.closed? + s3.close if s3 && !s3.closed? + end + + def test_basicsocket_local_address + s1 = Socket.new(:INET, :DGRAM, 0) + s1.bind(Socket.sockaddr_in(0, "127.0.0.1")) + e = Socket.unpack_sockaddr_in(s1.getsockname) + a = Socket.unpack_sockaddr_in(s1.local_address.to_sockaddr) + assert_equal(e, a) + assert_equal(Socket::AF_INET, s1.local_address.afamily) + assert_equal(Socket::PF_INET, s1.local_address.pfamily) + assert_equal(Socket::SOCK_DGRAM, s1.local_address.socktype) + ensure + s1.close if s1 && !s1.closed? + end + + def test_basicsocket_remote_address + s1 = TCPServer.new("127.0.0.1", 0) + s2 = Socket.new(:INET, :STREAM, 0) + s2.connect(s1.getsockname) + s3, _ = s1.accept + e = Socket.unpack_sockaddr_in(s2.getsockname) + a = Socket.unpack_sockaddr_in(s3.remote_address.to_sockaddr) + assert_equal(e, a) + assert_equal(Socket::AF_INET, s3.remote_address.afamily) + assert_equal(Socket::PF_INET, s3.remote_address.pfamily) + assert_equal(Socket::SOCK_STREAM, s3.remote_address.socktype) + ensure + s1.close if s1 && !s1.closed? + s2.close if s2 && !s2.closed? + s3.close if s3 && !s3.closed? + end + + def test_socket_accept + serv = Socket.new(:INET, :STREAM, 0) + serv.bind(Socket.sockaddr_in(0, "127.0.0.1")) + serv.listen(5) + c = Socket.new(:INET, :STREAM, 0) + c.connect(serv.local_address) + ret = serv.accept + s, ai = ret + assert_kind_of(Array, ret) + assert_equal(2, ret.length) + assert_kind_of(AddrInfo, ai) + e = Socket.unpack_sockaddr_in(c.getsockname) + a = Socket.unpack_sockaddr_in(ai.to_sockaddr) + assert_equal(e, a) + ensure + serv.close if serv && !serv.closed? + s.close if s && !s.closed? + c.close if c && !c.closed? + end + + def test_socket_accept_nonblock + serv = Socket.new(:INET, :STREAM, 0) + serv.bind(Socket.sockaddr_in(0, "127.0.0.1")) + serv.listen(5) + c = Socket.new(:INET, :STREAM, 0) + c.connect(serv.local_address) + begin + ret = serv.accept_nonblock + rescue Errno::EAGAIN, Errno::EWOULDBLOCK, Errno::ECONNABORTED, Errno::EPROTO, Errno::EINTR + IO.select([serv]) + retry + end + s, ai = ret + assert_kind_of(Array, ret) + assert_equal(2, ret.length) + assert_kind_of(AddrInfo, ai) + e = Socket.unpack_sockaddr_in(c.getsockname) + a = Socket.unpack_sockaddr_in(ai.to_sockaddr) + assert_equal(e, a) + ensure + serv.close if serv && !serv.closed? + s.close if s && !s.closed? + c.close if c && !c.closed? + end + + def test_socket_sysaccept + serv = Socket.new(:INET, :STREAM, 0) + serv.bind(Socket.sockaddr_in(0, "127.0.0.1")) + serv.listen(5) + c = Socket.new(:INET, :STREAM, 0) + c.connect(serv.local_address) + ret = serv.sysaccept + fd, ai = ret + s = IO.new(fd) + assert_kind_of(Array, ret) + assert_equal(2, ret.length) + assert_kind_of(AddrInfo, ai) + e = Socket.unpack_sockaddr_in(c.getsockname) + a = Socket.unpack_sockaddr_in(ai.to_sockaddr) + assert_equal(e, a) + ensure + serv.close if serv && !serv.closed? + s.close if s && !s.closed? + c.close if c && !c.closed? + end + + def test_socket_recvfrom + s1 = Socket.new(:INET, :DGRAM, 0) + s1.bind(Socket.sockaddr_in(0, "127.0.0.1")) + s2 = Socket.new(:INET, :DGRAM, 0) + s2.bind(Socket.sockaddr_in(0, "127.0.0.1")) + s2.send("test-socket-recvfrom", 0, s1.getsockname) + data, ai = s1.recvfrom(100) + assert_equal("test-socket-recvfrom", data) + assert_kind_of(AddrInfo, ai) + e = Socket.unpack_sockaddr_in(s2.getsockname) + a = Socket.unpack_sockaddr_in(ai.to_sockaddr) + assert_equal(e, a) + ensure + s1.close if s1 && !s1.closed? + s2.close if s2 && !s2.closed? + end + + def test_socket_recvfrom_nonblock + s1 = Socket.new(:INET, :DGRAM, 0) + s1.bind(Socket.sockaddr_in(0, "127.0.0.1")) + s2 = Socket.new(:INET, :DGRAM, 0) + s2.bind(Socket.sockaddr_in(0, "127.0.0.1")) + s2.send("test-socket-recvfrom", 0, s1.getsockname) + begin + data, ai = s1.recvfrom_nonblock(100) + rescue Errno::EWOULDBLOCK + IO.select([s1]) + retry + end + assert_equal("test-socket-recvfrom", data) + assert_kind_of(AddrInfo, ai) + e = Socket.unpack_sockaddr_in(s2.getsockname) + a = Socket.unpack_sockaddr_in(ai.to_sockaddr) + assert_equal(e, a) + ensure + s1.close if s1 && !s1.closed? + s2.close if s2 && !s2.closed? + end + + if Socket.const_defined?("AF_INET6") + + def test_addrinfo_new_inet6 + ai = AddrInfo.new(["AF_INET6", 42304, "ip6-localhost", "::1"]) + assert_equal([42304, "::1"], Socket.unpack_sockaddr_in(ai)) + assert_equal(Socket::AF_INET6, ai.afamily) + assert_equal(Socket::PF_INET6, ai.pfamily) + assert_equal(0, ai.socktype) + assert_equal(0, ai.protocol) + end + + end + + if defined?(UNIXSocket) && /cygwin/ !~ RUBY_PLATFORM + + def test_addrinfo_unix + ai = AddrInfo.unix("/tmp/sock") + assert_equal("/tmp/sock", Socket.unpack_sockaddr_un(ai)) + assert_equal(Socket::AF_UNIX, ai.afamily) + assert_equal(Socket::PF_UNIX, ai.pfamily) + assert_equal(Socket::SOCK_STREAM, ai.socktype) + assert_equal(0, ai.protocol) + end + + def test_addrinfo_new_unix + ai = AddrInfo.new(["AF_UNIX", "/tmp/sock"]) + assert_equal("/tmp/sock", Socket.unpack_sockaddr_un(ai)) + assert_equal(Socket::AF_UNIX, ai.afamily) + assert_equal(Socket::PF_UNIX, ai.pfamily) + assert_equal(Socket::SOCK_STREAM, ai.socktype) # UNIXSocket/UNIXServer is SOCK_STREAM only. + assert_equal(0, ai.protocol) + end + + def test_addrinfo_predicates_unix + unix_ai = AddrInfo.new(Socket.sockaddr_un("/tmp/sososo")) + assert(!unix_ai.ip?) + assert(!unix_ai.ipv4?) + assert(!unix_ai.ipv6?) + assert(unix_ai.unix?) + end + + end +end -- cgit v1.2.3