1begin 2 require "socket" 3rescue LoadError 4end 5 6require "test/unit" 7 8class TestSocketAddrinfo < Test::Unit::TestCase 9 HAS_UNIXSOCKET = defined?(UNIXSocket) && /cygwin/ !~ RUBY_PLATFORM 10 11 def tcp_unspecified_to_loopback(addrinfo) 12 if addrinfo.ipv4? && addrinfo.ip_address == "0.0.0.0" 13 Addrinfo.tcp("127.0.0.1", addrinfo.ip_port) 14 elsif addrinfo.ipv6? && addrinfo.ipv6_unspecified? 15 Addrinfo.tcp("::1", addrinfo.ip_port) 16 elsif addrinfo.ipv6? && (ai = addrinfo.ipv6_to_ipv4) && ai.ip_address == "0.0.0.0" 17 Addrinfo.tcp("127.0.0.1", addrinfo.ip_port) 18 else 19 addrinfo 20 end 21 end 22 23 def test_addrinfo_ip 24 ai = Addrinfo.ip("127.0.0.1") 25 assert_equal([0, "127.0.0.1"], Socket.unpack_sockaddr_in(ai)) 26 assert_equal(Socket::AF_INET, ai.afamily) 27 assert_equal(Socket::PF_INET, ai.pfamily) 28 assert_equal(0, ai.socktype) 29 assert_equal(0, ai.protocol) 30 end 31 32 def test_addrinfo_tcp 33 ai = Addrinfo.tcp("127.0.0.1", 80) 34 assert_equal([80, "127.0.0.1"], Socket.unpack_sockaddr_in(ai)) 35 assert_equal(Socket::AF_INET, ai.afamily) 36 assert_equal(Socket::PF_INET, ai.pfamily) 37 assert_equal(Socket::SOCK_STREAM, ai.socktype) 38 assert_include([0, Socket::IPPROTO_TCP], ai.protocol) 39 end 40 41 def test_addrinfo_udp 42 ai = Addrinfo.udp("127.0.0.1", 80) 43 assert_equal([80, "127.0.0.1"], Socket.unpack_sockaddr_in(ai)) 44 assert_equal(Socket::AF_INET, ai.afamily) 45 assert_equal(Socket::PF_INET, ai.pfamily) 46 assert_equal(Socket::SOCK_DGRAM, ai.socktype) 47 assert_include([0, Socket::IPPROTO_UDP], ai.protocol) 48 end 49 50 def test_addrinfo_ip_unpack 51 ai = Addrinfo.tcp("127.0.0.1", 80) 52 assert_equal(["127.0.0.1", 80], ai.ip_unpack) 53 assert_equal("127.0.0.1", ai.ip_address) 54 assert_equal(80, ai.ip_port) 55 end 56 57 def test_addrinfo_inspect_sockaddr 58 ai = Addrinfo.tcp("127.0.0.1", 80) 59 assert_equal("127.0.0.1:80", ai.inspect_sockaddr) 60 end 61 62 def test_addrinfo_new_inet 63 ai = Addrinfo.new(["AF_INET", 46102, "localhost.localdomain", "127.0.0.2"]) 64 assert_equal([46102, "127.0.0.2"], Socket.unpack_sockaddr_in(ai)) 65 assert_equal(Socket::AF_INET, ai.afamily) 66 assert_equal(Socket::PF_INET, ai.pfamily) 67 assert_equal(0, ai.socktype) 68 assert_equal(0, ai.protocol) 69 end 70 71 def test_addrinfo_predicates 72 ipv4_ai = Addrinfo.new(Socket.sockaddr_in(80, "192.168.0.1")) 73 assert(ipv4_ai.ip?) 74 assert(ipv4_ai.ipv4?) 75 assert(!ipv4_ai.ipv6?) 76 assert(!ipv4_ai.unix?) 77 end 78 79 def test_ipv4_address_predicates 80 list = [ 81 [:ipv4_private?, "10.0.0.0", "10.255.255.255", 82 "172.16.0.0", "172.31.255.255", 83 "192.168.0.0", "192.168.255.255"], 84 [:ipv4_loopback?, "127.0.0.1", "127.0.0.0", "127.255.255.255"], 85 [:ipv4_multicast?, "224.0.0.0", "224.255.255.255"] 86 ] 87 list.each {|meth, *addrs| 88 addrs.each {|addr| 89 assert(Addrinfo.ip(addr).send(meth), "Addrinfo.ip(#{addr.inspect}).#{meth}") 90 list.each {|meth2,| 91 next if meth == meth2 92 assert(!Addrinfo.ip(addr).send(meth2), "!Addrinfo.ip(#{addr.inspect}).#{meth2}") 93 } 94 } 95 } 96 end 97 98 def test_basicsocket_send 99 s1 = Socket.new(:INET, :DGRAM, 0) 100 s1.bind(Socket.sockaddr_in(0, "127.0.0.1")) 101 sa = s1.getsockname 102 ai = Addrinfo.new(sa) 103 s2 = Socket.new(:INET, :DGRAM, 0) 104 s2.send("test-basicsocket-send", 0, ai) 105 assert_equal("test-basicsocket-send", s1.recv(100)) 106 ensure 107 s1.close if s1 && !s1.closed? 108 s2.close if s2 && !s2.closed? 109 end 110 111 def test_udpsocket_send 112 s1 = UDPSocket.new 113 s1.bind("127.0.0.1", 0) 114 ai = Addrinfo.new(s1.getsockname) 115 s2 = UDPSocket.new 116 s2.send("test-udp-send", 0, ai) 117 assert_equal("test-udp-send", s1.recv(100)) 118 ensure 119 s1.close if s1 && !s1.closed? 120 s2.close if s2 && !s2.closed? 121 end 122 123 def test_socket_bind 124 s1 = Socket.new(:INET, :DGRAM, 0) 125 sa = Socket.sockaddr_in(0, "127.0.0.1") 126 ai = Addrinfo.new(sa) 127 s1.bind(ai) 128 s2 = UDPSocket.new 129 s2.send("test-socket-bind", 0, s1.getsockname) 130 assert_equal("test-socket-bind", s1.recv(100)) 131 ensure 132 s1.close if s1 && !s1.closed? 133 s2.close if s2 && !s2.closed? 134 end 135 136 def test_socket_connect 137 s1 = Socket.new(:INET, :STREAM, 0) 138 s1.bind(Socket.sockaddr_in(0, "127.0.0.1")) 139 s1.listen(5) 140 ai = Addrinfo.new(s1.getsockname) 141 s2 = Socket.new(:INET, :STREAM, 0) 142 s2.connect(ai) 143 s3, sender_addr = s1.accept 144 s2.send("test-socket-connect", 0) 145 assert_equal("test-socket-connect", s3.recv(100)) 146 ensure 147 s1.close if s1 && !s1.closed? 148 s2.close if s2 && !s2.closed? 149 s3.close if s3 && !s3.closed? 150 end 151 152 def test_socket_connect_nonblock 153 s1 = Socket.new(:INET, :STREAM, 0) 154 s1.bind(Socket.sockaddr_in(0, "127.0.0.1")) 155 s1.listen(5) 156 ai = Addrinfo.new(s1.getsockname) 157 s2 = Socket.new(:INET, :STREAM, 0) 158 begin 159 s2.connect_nonblock(ai) 160 rescue IO::WaitWritable 161 IO.select(nil, [s2]) 162 r = s2.getsockopt(Socket::SOL_SOCKET, Socket::SO_ERROR) 163 assert_equal(0, r.int, "NOERROR is expected but #{r.inspect}") 164 begin 165 s2.connect_nonblock(ai) 166 rescue Errno::EISCONN 167 end 168 end 169 s3, sender_addr = s1.accept 170 s2.send("test-socket-connect-nonblock", 0) 171 assert_equal("test-socket-connect-nonblock", s3.recv(100)) 172 ensure 173 s1.close if s1 && !s1.closed? 174 s2.close if s2 && !s2.closed? 175 s3.close if s3 && !s3.closed? 176 end 177 178 def test_socket_getnameinfo 179 ai = Addrinfo.udp("127.0.0.1", 8888) 180 assert_equal(["127.0.0.1", "8888"], Socket.getnameinfo(ai, Socket::NI_NUMERICHOST|Socket::NI_NUMERICSERV)) 181 end 182 183 def test_basicsocket_local_address 184 s1 = Socket.new(:INET, :DGRAM, 0) 185 s1.bind(Socket.sockaddr_in(0, "127.0.0.1")) 186 e = Socket.unpack_sockaddr_in(s1.getsockname) 187 a = Socket.unpack_sockaddr_in(s1.local_address.to_sockaddr) 188 assert_equal(e, a) 189 assert_equal(Socket::AF_INET, s1.local_address.afamily) 190 assert_equal(Socket::PF_INET, s1.local_address.pfamily) 191 assert_equal(Socket::SOCK_DGRAM, s1.local_address.socktype) 192 ensure 193 s1.close if s1 && !s1.closed? 194 end 195 196 def test_basicsocket_remote_address 197 s1 = TCPServer.new("127.0.0.1", 0) 198 s2 = Socket.new(:INET, :STREAM, 0) 199 s2.connect(s1.getsockname) 200 s3, _ = s1.accept 201 e = Socket.unpack_sockaddr_in(s2.getsockname) 202 a = Socket.unpack_sockaddr_in(s3.remote_address.to_sockaddr) 203 assert_equal(e, a) 204 assert_equal(Socket::AF_INET, s3.remote_address.afamily) 205 assert_equal(Socket::PF_INET, s3.remote_address.pfamily) 206 assert_equal(Socket::SOCK_STREAM, s3.remote_address.socktype) 207 ensure 208 s1.close if s1 && !s1.closed? 209 s2.close if s2 && !s2.closed? 210 s3.close if s3 && !s3.closed? 211 end 212 213 def test_socket_accept 214 serv = Socket.new(:INET, :STREAM, 0) 215 serv.bind(Socket.sockaddr_in(0, "127.0.0.1")) 216 serv.listen(5) 217 c = Socket.new(:INET, :STREAM, 0) 218 c.connect(serv.local_address) 219 ret = serv.accept 220 s, ai = ret 221 assert_kind_of(Array, ret) 222 assert_equal(2, ret.length) 223 assert_kind_of(Addrinfo, ai) 224 e = Socket.unpack_sockaddr_in(c.getsockname) 225 a = Socket.unpack_sockaddr_in(ai.to_sockaddr) 226 assert_equal(e, a) 227 ensure 228 serv.close if serv && !serv.closed? 229 s.close if s && !s.closed? 230 c.close if c && !c.closed? 231 end 232 233 def test_socket_accept_nonblock 234 serv = Socket.new(:INET, :STREAM, 0) 235 serv.bind(Socket.sockaddr_in(0, "127.0.0.1")) 236 serv.listen(5) 237 c = Socket.new(:INET, :STREAM, 0) 238 c.connect(serv.local_address) 239 begin 240 ret = serv.accept_nonblock 241 rescue IO::WaitReadable, Errno::EINTR 242 IO.select([serv]) 243 retry 244 end 245 s, ai = ret 246 assert_kind_of(Array, ret) 247 assert_equal(2, ret.length) 248 assert_kind_of(Addrinfo, ai) 249 e = Socket.unpack_sockaddr_in(c.getsockname) 250 a = Socket.unpack_sockaddr_in(ai.to_sockaddr) 251 assert_equal(e, a) 252 ensure 253 serv.close if serv && !serv.closed? 254 s.close if s && !s.closed? 255 c.close if c && !c.closed? 256 end 257 258 def test_socket_sysaccept 259 serv = Socket.new(:INET, :STREAM, 0) 260 serv.bind(Socket.sockaddr_in(0, "127.0.0.1")) 261 serv.listen(5) 262 c = Socket.new(:INET, :STREAM, 0) 263 c.connect(serv.local_address) 264 ret = serv.sysaccept 265 fd, ai = ret 266 s = IO.new(fd) 267 assert_kind_of(Array, ret) 268 assert_equal(2, ret.length) 269 assert_kind_of(Addrinfo, ai) 270 e = Socket.unpack_sockaddr_in(c.getsockname) 271 a = Socket.unpack_sockaddr_in(ai.to_sockaddr) 272 assert_equal(e, a) 273 ensure 274 serv.close if serv && !serv.closed? 275 s.close if s && !s.closed? 276 c.close if c && !c.closed? 277 end 278 279 def test_socket_recvfrom 280 s1 = Socket.new(:INET, :DGRAM, 0) 281 s1.bind(Socket.sockaddr_in(0, "127.0.0.1")) 282 s2 = Socket.new(:INET, :DGRAM, 0) 283 s2.bind(Socket.sockaddr_in(0, "127.0.0.1")) 284 s2.send("test-socket-recvfrom", 0, s1.getsockname) 285 data, ai = s1.recvfrom(100) 286 assert_equal("test-socket-recvfrom", data) 287 assert_kind_of(Addrinfo, ai) 288 e = Socket.unpack_sockaddr_in(s2.getsockname) 289 a = Socket.unpack_sockaddr_in(ai.to_sockaddr) 290 assert_equal(e, a) 291 ensure 292 s1.close if s1 && !s1.closed? 293 s2.close if s2 && !s2.closed? 294 end 295 296 def test_socket_recvfrom_nonblock 297 s1 = Socket.new(:INET, :DGRAM, 0) 298 s1.bind(Socket.sockaddr_in(0, "127.0.0.1")) 299 s2 = Socket.new(:INET, :DGRAM, 0) 300 s2.bind(Socket.sockaddr_in(0, "127.0.0.1")) 301 s2.send("test-socket-recvfrom", 0, s1.getsockname) 302 begin 303 data, ai = s1.recvfrom_nonblock(100) 304 rescue IO::WaitReadable 305 IO.select([s1]) 306 retry 307 end 308 assert_equal("test-socket-recvfrom", data) 309 assert_kind_of(Addrinfo, ai) 310 e = Socket.unpack_sockaddr_in(s2.getsockname) 311 a = Socket.unpack_sockaddr_in(ai.to_sockaddr) 312 assert_equal(e, a) 313 ensure 314 s1.close if s1 && !s1.closed? 315 s2.close if s2 && !s2.closed? 316 end 317 318 def test_family_addrinfo 319 ai = Addrinfo.tcp("0.0.0.0", 4649).family_addrinfo("127.0.0.1", 80) 320 assert_equal(["127.0.0.1", 80], ai.ip_unpack) 321 assert_equal(Socket::SOCK_STREAM, ai.socktype) 322 return unless Addrinfo.respond_to?(:unix) 323 ai = Addrinfo.unix("/testdir/sock").family_addrinfo("/testdir/sock2") 324 assert_equal("/testdir/sock2", ai.unix_path) 325 assert_equal(Socket::SOCK_STREAM, ai.socktype) 326 assert_raise(SocketError) { Addrinfo.tcp("0.0.0.0", 4649).family_addrinfo("::1", 80) } 327 end 328 329 def random_port 330 # IANA suggests dynamic port for 49152 to 65535 331 # http://www.iana.org/assignments/port-numbers 332 49152 + rand(65535-49152+1) 333 end 334 335 def errors_addrinuse 336 [Errno::EADDRINUSE] 337 end 338 339 def test_connect_from 340 TCPServer.open("0.0.0.0", 0) {|serv| 341 serv_ai = Addrinfo.new(serv.getsockname, :INET, :STREAM) 342 serv_ai = tcp_unspecified_to_loopback(serv_ai) 343 port = random_port 344 begin 345 serv_ai.connect_from("0.0.0.0", port) {|s1| 346 s2 = serv.accept 347 begin 348 assert_equal(port, s2.remote_address.ip_port) 349 ensure 350 s2.close 351 end 352 } 353 rescue *errors_addrinuse 354 # not test failure 355 end 356 } 357 358 TCPServer.open("0.0.0.0", 0) {|serv| 359 serv_ai = Addrinfo.new(serv.getsockname, :INET, :STREAM) 360 serv_ai = tcp_unspecified_to_loopback(serv_ai) 361 port = random_port 362 begin 363 serv_ai.connect_from(Addrinfo.tcp("0.0.0.0", port)) {|s1| 364 s2 = serv.accept 365 begin 366 assert_equal(port, s2.remote_address.ip_port) 367 ensure 368 s2.close 369 end 370 } 371 rescue *errors_addrinuse 372 # not test failure 373 end 374 } 375 end 376 377 def test_connect_to 378 TCPServer.open("0.0.0.0", 0) {|serv| 379 serv_ai = Addrinfo.new(serv.getsockname, :INET, :STREAM) 380 serv_ai = tcp_unspecified_to_loopback(serv_ai) 381 port = random_port 382 client_ai = Addrinfo.tcp("0.0.0.0", port) 383 begin 384 client_ai.connect_to(*serv_ai.ip_unpack) {|s1| 385 s2 = serv.accept 386 begin 387 assert_equal(port, s2.remote_address.ip_port) 388 ensure 389 s2.close 390 end 391 } 392 rescue *errors_addrinuse 393 # not test failure 394 end 395 } 396 end 397 398 def test_connect 399 TCPServer.open("0.0.0.0", 0) {|serv| 400 serv_ai = Addrinfo.new(serv.getsockname, :INET, :STREAM) 401 serv_ai = tcp_unspecified_to_loopback(serv_ai) 402 begin 403 serv_ai.connect {|s1| 404 s2 = serv.accept 405 begin 406 assert_equal(s1.local_address.ip_unpack, s2.remote_address.ip_unpack) 407 assert_equal(s2.local_address.ip_unpack, s1.remote_address.ip_unpack) 408 ensure 409 s2.close 410 end 411 } 412 rescue *errors_addrinuse 413 # not test failure 414 end 415 } 416 end 417 418 def test_bind 419 port = random_port 420 client_ai = Addrinfo.tcp("0.0.0.0", port) 421 begin 422 client_ai.bind {|s| 423 assert_equal(port, s.local_address.ip_port) 424 } 425 rescue *errors_addrinuse 426 # not test failure 427 end 428 end 429 430 def test_listen 431 port = random_port 432 client_ai = Addrinfo.tcp("0.0.0.0", port) 433 begin 434 client_ai.listen {|serv| 435 assert_equal(port, serv.local_address.ip_port) 436 serv_addr, serv_port = serv.local_address.ip_unpack 437 case serv_addr 438 when "0.0.0.0" then serv_addr = "127.0.0.1" 439 end 440 TCPSocket.open(serv_addr, serv_port) {|s1| 441 s2, addr = serv.accept 442 begin 443 assert_equal(s1.local_address.ip_unpack, addr.ip_unpack) 444 ensure 445 s2.close 446 end 447 } 448 } 449 rescue *errors_addrinuse 450 # not test failure 451 end 452 end 453 454 def test_s_foreach 455 Addrinfo.foreach(nil, 80, nil, :STREAM) {|ai| 456 assert_kind_of(Addrinfo, ai) 457 } 458 end 459 460 def test_marshal 461 ai1 = Addrinfo.tcp("127.0.0.1", 80) 462 ai2 = Marshal.load(Marshal.dump(ai1)) 463 assert_equal(ai1.afamily, ai2.afamily) 464 assert_equal(ai1.ip_unpack, ai2.ip_unpack) 465 assert_equal(ai1.pfamily, ai2.pfamily) 466 assert_equal(ai1.socktype, ai2.socktype) 467 assert_equal(ai1.protocol, ai2.protocol) 468 assert_equal(ai1.canonname, ai2.canonname) 469 end 470 471 if Socket.const_defined?("AF_INET6") && Socket::AF_INET6.is_a?(Integer) 472 473 def test_addrinfo_new_inet6 474 ai = Addrinfo.new(["AF_INET6", 42304, "ip6-localhost", "::1"]) 475 assert_equal([42304, "::1"], Socket.unpack_sockaddr_in(ai)) 476 assert_equal(Socket::AF_INET6, ai.afamily) 477 assert_equal(Socket::PF_INET6, ai.pfamily) 478 assert_equal(0, ai.socktype) 479 assert_equal(0, ai.protocol) 480 end 481 482 def test_addrinfo_ip_unpack_inet6 483 ai = Addrinfo.tcp("::1", 80) 484 assert_equal(["::1", 80], ai.ip_unpack) 485 assert_equal("::1", ai.ip_address) 486 assert_equal(80, ai.ip_port) 487 end 488 489 def test_addrinfo_inspect_sockaddr_inet6 490 ai = Addrinfo.tcp("::1", 80) 491 assert_equal("[::1]:80", ai.inspect_sockaddr) 492 end 493 494 def test_marshal_inet6 495 ai1 = Addrinfo.tcp("::1", 80) 496 ai2 = Marshal.load(Marshal.dump(ai1)) 497 assert_equal(ai1.afamily, ai2.afamily) 498 assert_equal(ai1.ip_unpack, ai2.ip_unpack) 499 assert_equal(ai1.pfamily, ai2.pfamily) 500 assert_equal(ai1.socktype, ai2.socktype) 501 assert_equal(ai1.protocol, ai2.protocol) 502 assert_equal(ai1.canonname, ai2.canonname) 503 end 504 505 def ipv6(str) 506 Addrinfo.getaddrinfo(str, nil, :INET6, :DGRAM).fetch(0) 507 end 508 509 def test_ipv6_address_predicates 510 list = [ 511 [:ipv6_unspecified?, "::"], 512 [:ipv6_loopback?, "::1"], 513 [:ipv6_v4compat?, "::0.0.0.2", "::255.255.255.255"], 514 [:ipv6_v4mapped?, "::ffff:0.0.0.0", "::ffff:255.255.255.255"], 515 [:ipv6_linklocal?, "fe80::", "febf::"], 516 [:ipv6_sitelocal?, "fec0::", "feef::"], 517 [:ipv6_multicast?, "ff00::", "ffff::"], 518 [:ipv6_unique_local?, "fc00::", "fd00::"], 519 ] 520 mlist = [ 521 [:ipv6_mc_nodelocal?, "ff01::", "ff11::"], 522 [:ipv6_mc_linklocal?, "ff02::", "ff12::"], 523 [:ipv6_mc_sitelocal?, "ff05::", "ff15::"], 524 [:ipv6_mc_orglocal?, "ff08::", "ff18::"], 525 [:ipv6_mc_global?, "ff0e::", "ff1e::"] 526 ] 527 list.each {|meth, *addrs| 528 addrs.each {|addr| 529 addr_exp = "Addrinfo.getaddrinfo(#{addr.inspect}, nil, :INET6, :DGRAM).fetch(0)" 530 if meth == :ipv6_v4compat? || meth == :ipv6_v4mapped? 531 # MacOS X returns IPv4 address for ::ffff:1.2.3.4 and ::1.2.3.4. 532 # Solaris returns IPv4 address for ::ffff:1.2.3.4. 533 ai = ipv6(addr) 534 assert(ai.ipv4? || ai.send(meth), "ai=#{addr_exp}; ai.ipv4? || .#{meth}") 535 else 536 assert(ipv6(addr).send(meth), "#{addr_exp}.#{meth}") 537 assert_equal(addr, ipv6(addr).ip_address) 538 end 539 list.each {|meth2,| 540 next if meth == meth2 541 assert(!ipv6(addr).send(meth2), "!#{addr_exp}.#{meth2}") 542 } 543 } 544 } 545 mlist.each {|meth, *addrs| 546 addrs.each {|addr| 547 addr_exp = "Addrinfo.getaddrinfo(#{addr.inspect}, nil, :INET6, :DGRAM).fetch(0)" 548 assert(ipv6(addr).send(meth), "#{addr_exp}.#{meth}") 549 assert(ipv6(addr).ipv6_multicast?, "#{addr_exp}.ipv6_multicast?") 550 mlist.each {|meth2,| 551 next if meth == meth2 552 assert(!ipv6(addr).send(meth2), "!#{addr_exp}.#{meth2}") 553 } 554 list.each {|meth2,| 555 next if :ipv6_multicast? == meth2 556 assert(!ipv6(addr).send(meth2), "!#{addr_exp}.#{meth2}") 557 } 558 } 559 } 560 end 561 562 def test_ipv6_to_ipv4 563 ai = Addrinfo.ip("::192.0.2.3") 564 ai = ai.ipv6_to_ipv4 if !ai.ipv4? 565 assert(ai.ipv4?) 566 assert_equal("192.0.2.3", ai.ip_address) 567 568 ai = Addrinfo.ip("::ffff:192.0.2.3") 569 ai = ai.ipv6_to_ipv4 if !ai.ipv4? 570 assert(ai.ipv4?) 571 assert_equal("192.0.2.3", ai.ip_address) 572 573 assert_nil(Addrinfo.ip("::1").ipv6_to_ipv4) 574 assert_nil(Addrinfo.ip("192.0.2.3").ipv6_to_ipv4) 575 if HAS_UNIXSOCKET 576 assert_nil(Addrinfo.unix("/testdir/sock").ipv6_to_ipv4) 577 end 578 end 579 end 580 581 if HAS_UNIXSOCKET 582 583 def test_addrinfo_unix 584 ai = Addrinfo.unix("/testdir/sock") 585 assert_equal("/testdir/sock", Socket.unpack_sockaddr_un(ai)) 586 assert_equal(Socket::AF_UNIX, ai.afamily) 587 assert_equal(Socket::PF_UNIX, ai.pfamily) 588 assert_equal(Socket::SOCK_STREAM, ai.socktype) 589 assert_equal(0, ai.protocol) 590 end 591 592 def test_addrinfo_unix_dgram 593 ai = Addrinfo.unix("/testdir/sock", :DGRAM) 594 assert_equal("/testdir/sock", Socket.unpack_sockaddr_un(ai)) 595 assert_equal(Socket::AF_UNIX, ai.afamily) 596 assert_equal(Socket::PF_UNIX, ai.pfamily) 597 assert_equal(Socket::SOCK_DGRAM, ai.socktype) 598 assert_equal(0, ai.protocol) 599 end 600 601 def test_addrinfo_unix_path 602 ai = Addrinfo.unix("/testdir/sock1") 603 assert_equal("/testdir/sock1", ai.unix_path) 604 end 605 606 def test_addrinfo_inspect_sockaddr_unix 607 ai = Addrinfo.unix("/testdir/test_addrinfo_inspect_sockaddr_unix") 608 assert_equal("/testdir/test_addrinfo_inspect_sockaddr_unix", ai.inspect_sockaddr) 609 end 610 611 def test_addrinfo_new_unix 612 ai = Addrinfo.new(["AF_UNIX", "/testdir/sock"]) 613 assert_equal("/testdir/sock", Socket.unpack_sockaddr_un(ai)) 614 assert_equal(Socket::AF_UNIX, ai.afamily) 615 assert_equal(Socket::PF_UNIX, ai.pfamily) 616 assert_equal(Socket::SOCK_STREAM, ai.socktype) # UNIXSocket/UNIXServer is SOCK_STREAM only. 617 assert_equal(0, ai.protocol) 618 end 619 620 def test_addrinfo_predicates_unix 621 unix_ai = Addrinfo.new(Socket.sockaddr_un("/testdir/sososo")) 622 assert(!unix_ai.ip?) 623 assert(!unix_ai.ipv4?) 624 assert(!unix_ai.ipv6?) 625 assert(unix_ai.unix?) 626 end 627 628 def test_marshal_unix 629 ai1 = Addrinfo.unix("/testdir/sock") 630 ai2 = Marshal.load(Marshal.dump(ai1)) 631 assert_equal(ai1.afamily, ai2.afamily) 632 assert_equal(ai1.unix_path, ai2.unix_path) 633 assert_equal(ai1.pfamily, ai2.pfamily) 634 assert_equal(ai1.socktype, ai2.socktype) 635 assert_equal(ai1.protocol, ai2.protocol) 636 assert_equal(ai1.canonname, ai2.canonname) 637 end 638 639 end 640end 641