← Back to branch summary

~ubuntu-branches/ubuntu/quantal/ruby1.9.1/quantal

« back to all changes in this revision

Viewing changes to test/socket/test_addrinfo.rb

  • Committer: Bazaar Package Importer
  • Author(s): Lucas Nussbaum
  • Date: 2010-07-31 17:08:39 UTC
  • mfrom: (1.1.4 upstream) (8.1.2 sid)
  • Revision ID: james.westby@ubuntu.com-20100731170839-j034dmpdqt1cc4p6
Tags: 1.9.2~svn28788-1
http://bugs.debian.org/580852
http://bugs.debian.org/590002
http://bugs.debian.org/543805
http://bugs.debian.org/542927
* New release based on upstream snapshot from the 1.9.2 branch,
  after 1.9.2 RC2. That branch is (supposed to be) binary-compatible
  with the 1.9.1 branch.
  + Builds fine on i386. Closes: #580852.
* Upgrade to Standards-Version: 3.9.1. No changes needed.
* Updated generated incs.
* Patches that still need work:
  + Unclear status, need more investigation:
   090729_fix_Makefile_deps.dpatch
   090803_exclude_rdoc.dpatch
   203_adjust_base_of_search_path.dpatch
   902_define_YAML_in_yaml_stringio.rb.dpatch
   919_common.mk_tweaks.dpatch
   931_libruby_suffix.dpatch
   940_test_thread_mutex_sync_shorter.dpatch
  + Maybe not needed anymore, keeping but not applying.
   102_skip_test_copy_stream.dpatch (test doesn't block anymore?)
   104_skip_btest_io.dpatch (test doesn't block anymore?)
   201_gem_prelude.dpatch (we don't use that rubygems anyway?)
   202_gem_default_dir.dpatch (we don't use that rubygems anyway?)
   940_test_file_exhaustive_fails_as_root.dpatch
   940_test_priority_fails.dpatch
   100518_load_libc_libm.dpatch
* Add disable-tests.diff: disable some tests that cause failures on FreeBSD.
  Closes: #590002, #543805, #542927.
* However, many new failures on FreeBSD. Since that version is still an
  improvement, add the check that makes test suite failures non-fatal on
  FreeBSD again. That still needs to be investigated.
* Re-add 903_skip_base_ruby_check.dpatch
* Add build-dependency on ruby1.8 and drop all pre-generated files.

Show diffs side-by-side

added added

removed removed

Lines of Context:
test/socket/test_addrinfo.rb
 
1
begin
 
2
  require "socket"
 
3
rescue LoadError
 
4
end
 
5
 
 
6
require "test/unit"
 
7
 
 
8
class 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_includes([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_includes([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
      begin
 
163
        s2.connect_nonblock(ai)
 
164
      rescue Errno::EISCONN
 
165
      end
 
166
    end
 
167
    s3, sender_addr = s1.accept
 
168
    s2.send("test-socket-connect-nonblock", 0)
 
169
    assert_equal("test-socket-connect-nonblock", s3.recv(100))
 
170
  ensure
 
171
    s1.close if s1 && !s1.closed?
 
172
    s2.close if s2 && !s2.closed?
 
173
    s3.close if s3 && !s3.closed?
 
174
  end
 
175
 
 
176
  def test_socket_getnameinfo
 
177
     ai = Addrinfo.udp("127.0.0.1", 8888)
 
178
     assert_equal(["127.0.0.1", "8888"], Socket.getnameinfo(ai, Socket::NI_NUMERICHOST|Socket::NI_NUMERICSERV))
 
179
  end
 
180
 
 
181
  def test_basicsocket_local_address
 
182
    s1 = Socket.new(:INET, :DGRAM, 0)
 
183
    s1.bind(Socket.sockaddr_in(0, "127.0.0.1"))
 
184
    e = Socket.unpack_sockaddr_in(s1.getsockname)
 
185
    a = Socket.unpack_sockaddr_in(s1.local_address.to_sockaddr)
 
186
    assert_equal(e, a)
 
187
    assert_equal(Socket::AF_INET, s1.local_address.afamily)
 
188
    assert_equal(Socket::PF_INET, s1.local_address.pfamily)
 
189
    assert_equal(Socket::SOCK_DGRAM, s1.local_address.socktype)
 
190
  ensure
 
191
    s1.close if s1 && !s1.closed?
 
192
  end
 
193
 
 
194
  def test_basicsocket_remote_address
 
195
    s1 = TCPServer.new("127.0.0.1", 0)
 
196
    s2 = Socket.new(:INET, :STREAM, 0)
 
197
    s2.connect(s1.getsockname)
 
198
    s3, _ = s1.accept
 
199
    e = Socket.unpack_sockaddr_in(s2.getsockname)
 
200
    a = Socket.unpack_sockaddr_in(s3.remote_address.to_sockaddr)
 
201
    assert_equal(e, a)
 
202
    assert_equal(Socket::AF_INET, s3.remote_address.afamily)
 
203
    assert_equal(Socket::PF_INET, s3.remote_address.pfamily)
 
204
    assert_equal(Socket::SOCK_STREAM, s3.remote_address.socktype)
 
205
  ensure
 
206
    s1.close if s1 && !s1.closed?
 
207
    s2.close if s2 && !s2.closed?
 
208
    s3.close if s3 && !s3.closed?
 
209
  end
 
210
 
 
211
  def test_socket_accept
 
212
    serv = Socket.new(:INET, :STREAM, 0)
 
213
    serv.bind(Socket.sockaddr_in(0, "127.0.0.1"))
 
214
    serv.listen(5)
 
215
    c = Socket.new(:INET, :STREAM, 0)
 
216
    c.connect(serv.local_address)
 
217
    ret = serv.accept
 
218
    s, ai = ret
 
219
    assert_kind_of(Array, ret)
 
220
    assert_equal(2, ret.length)
 
221
    assert_kind_of(Addrinfo, ai)
 
222
    e = Socket.unpack_sockaddr_in(c.getsockname)
 
223
    a = Socket.unpack_sockaddr_in(ai.to_sockaddr)
 
224
    assert_equal(e, a)
 
225
  ensure
 
226
    serv.close if serv && !serv.closed?
 
227
    s.close if s && !s.closed?
 
228
    c.close if c && !c.closed?
 
229
  end
 
230
 
 
231
  def test_socket_accept_nonblock
 
232
    serv = Socket.new(:INET, :STREAM, 0)
 
233
    serv.bind(Socket.sockaddr_in(0, "127.0.0.1"))
 
234
    serv.listen(5)
 
235
    c = Socket.new(:INET, :STREAM, 0)
 
236
    c.connect(serv.local_address)
 
237
    begin
 
238
      ret = serv.accept_nonblock
 
239
    rescue IO::WaitReadable, Errno::EINTR
 
240
      IO.select([serv])
 
241
      retry
 
242
    end
 
243
    s, ai = ret
 
244
    assert_kind_of(Array, ret)
 
245
    assert_equal(2, ret.length)
 
246
    assert_kind_of(Addrinfo, ai)
 
247
    e = Socket.unpack_sockaddr_in(c.getsockname)
 
248
    a = Socket.unpack_sockaddr_in(ai.to_sockaddr)
 
249
    assert_equal(e, a)
 
250
  ensure
 
251
    serv.close if serv && !serv.closed?
 
252
    s.close if s && !s.closed?
 
253
    c.close if c && !c.closed?
 
254
  end
 
255
 
 
256
  def test_socket_sysaccept
 
257
    serv = Socket.new(:INET, :STREAM, 0)
 
258
    serv.bind(Socket.sockaddr_in(0, "127.0.0.1"))
 
259
    serv.listen(5)
 
260
    c = Socket.new(:INET, :STREAM, 0)
 
261
    c.connect(serv.local_address)
 
262
    ret = serv.sysaccept
 
263
    fd, ai = ret
 
264
    s = IO.new(fd)
 
265
    assert_kind_of(Array, ret)
 
266
    assert_equal(2, ret.length)
 
267
    assert_kind_of(Addrinfo, ai)
 
268
    e = Socket.unpack_sockaddr_in(c.getsockname)
 
269
    a = Socket.unpack_sockaddr_in(ai.to_sockaddr)
 
270
    assert_equal(e, a)
 
271
  ensure
 
272
    serv.close if serv && !serv.closed?
 
273
    s.close if s && !s.closed?
 
274
    c.close if c && !c.closed?
 
275
  end
 
276
 
 
277
  def test_socket_recvfrom
 
278
    s1 = Socket.new(:INET, :DGRAM, 0)
 
279
    s1.bind(Socket.sockaddr_in(0, "127.0.0.1"))
 
280
    s2 = Socket.new(:INET, :DGRAM, 0)
 
281
    s2.bind(Socket.sockaddr_in(0, "127.0.0.1"))
 
282
    s2.send("test-socket-recvfrom", 0, s1.getsockname)
 
283
    data, ai = s1.recvfrom(100)
 
284
    assert_equal("test-socket-recvfrom", data)
 
285
    assert_kind_of(Addrinfo, ai)
 
286
    e = Socket.unpack_sockaddr_in(s2.getsockname)
 
287
    a = Socket.unpack_sockaddr_in(ai.to_sockaddr)
 
288
    assert_equal(e, a)
 
289
  ensure
 
290
    s1.close if s1 && !s1.closed?
 
291
    s2.close if s2 && !s2.closed?
 
292
  end
 
293
 
 
294
  def test_socket_recvfrom_nonblock
 
295
    s1 = Socket.new(:INET, :DGRAM, 0)
 
296
    s1.bind(Socket.sockaddr_in(0, "127.0.0.1"))
 
297
    s2 = Socket.new(:INET, :DGRAM, 0)
 
298
    s2.bind(Socket.sockaddr_in(0, "127.0.0.1"))
 
299
    s2.send("test-socket-recvfrom", 0, s1.getsockname)
 
300
    begin
 
301
      data, ai = s1.recvfrom_nonblock(100)
 
302
    rescue IO::WaitReadable
 
303
      IO.select([s1])
 
304
      retry
 
305
    end
 
306
    assert_equal("test-socket-recvfrom", data)
 
307
    assert_kind_of(Addrinfo, ai)
 
308
    e = Socket.unpack_sockaddr_in(s2.getsockname)
 
309
    a = Socket.unpack_sockaddr_in(ai.to_sockaddr)
 
310
    assert_equal(e, a)
 
311
  ensure
 
312
    s1.close if s1 && !s1.closed?
 
313
    s2.close if s2 && !s2.closed?
 
314
  end
 
315
 
 
316
  def test_family_addrinfo
 
317
    ai = Addrinfo.tcp("0.0.0.0", 4649).family_addrinfo("127.0.0.1", 80)
 
318
    assert_equal(["127.0.0.1", 80], ai.ip_unpack)
 
319
    assert_equal(Socket::SOCK_STREAM, ai.socktype)
 
320
    return unless Addrinfo.respond_to?(:unix)
 
321
    ai = Addrinfo.unix("/testdir/sock").family_addrinfo("/testdir/sock2")
 
322
    assert_equal("/testdir/sock2", ai.unix_path)
 
323
    assert_equal(Socket::SOCK_STREAM, ai.socktype)
 
324
    assert_raise(SocketError) { Addrinfo.tcp("0.0.0.0", 4649).family_addrinfo("::1", 80) }
 
325
  end
 
326
 
 
327
  def random_port
 
328
    # IANA suggests dynamic port for 49152 to 65535
 
329
    # http://www.iana.org/assignments/port-numbers
 
330
    49152 + rand(65535-49152+1)
 
331
  end
 
332
 
 
333
  def test_connect_from
 
334
    TCPServer.open("0.0.0.0", 0) {|serv|
 
335
      serv_ai = Addrinfo.new(serv.getsockname, :INET, :STREAM)
 
336
      serv_ai = tcp_unspecified_to_loopback(serv_ai)
 
337
      port = random_port
 
338
      begin
 
339
        serv_ai.connect_from("0.0.0.0", port) {|s1|
 
340
          s2 = serv.accept
 
341
          begin
 
342
            assert_equal(port, s2.remote_address.ip_port)
 
343
          ensure
 
344
            s2.close
 
345
          end
 
346
        }
 
347
      rescue Errno::EADDRINUSE
 
348
        # not test failure
 
349
      end
 
350
    }
 
351
  end
 
352
 
 
353
  def test_connect_to
 
354
    TCPServer.open("0.0.0.0", 0) {|serv|
 
355
      serv_ai = Addrinfo.new(serv.getsockname, :INET, :STREAM)
 
356
      serv_ai = tcp_unspecified_to_loopback(serv_ai)
 
357
      port = random_port
 
358
      client_ai = Addrinfo.tcp("0.0.0.0", port)
 
359
      begin
 
360
        client_ai.connect_to(*serv_ai.ip_unpack) {|s1|
 
361
          s2 = serv.accept
 
362
          begin
 
363
            assert_equal(port, s2.remote_address.ip_port)
 
364
          ensure
 
365
            s2.close
 
366
          end
 
367
        }
 
368
      rescue Errno::EADDRINUSE
 
369
        # not test failure
 
370
      end
 
371
    }
 
372
  end
 
373
 
 
374
  def test_connect
 
375
    TCPServer.open("0.0.0.0", 0) {|serv|
 
376
      serv_ai = Addrinfo.new(serv.getsockname, :INET, :STREAM)
 
377
      serv_ai = tcp_unspecified_to_loopback(serv_ai)
 
378
      begin
 
379
        serv_ai.connect {|s1|
 
380
          s2 = serv.accept
 
381
          begin
 
382
            assert_equal(s1.local_address.ip_unpack, s2.remote_address.ip_unpack)
 
383
            assert_equal(s2.local_address.ip_unpack, s1.remote_address.ip_unpack)
 
384
          ensure
 
385
            s2.close
 
386
          end
 
387
        }
 
388
      rescue Errno::EADDRINUSE
 
389
        # not test failure
 
390
      end
 
391
    }
 
392
  end
 
393
 
 
394
  def test_bind
 
395
    port = random_port
 
396
    client_ai = Addrinfo.tcp("0.0.0.0", port)
 
397
    begin
 
398
      client_ai.bind {|s|
 
399
        assert_equal(port, s.local_address.ip_port)
 
400
      }
 
401
    rescue Errno::EADDRINUSE
 
402
      # not test failure
 
403
    end
 
404
  end
 
405
 
 
406
  def test_listen
 
407
    port = random_port
 
408
    client_ai = Addrinfo.tcp("0.0.0.0", port)
 
409
    begin
 
410
      client_ai.listen {|serv|
 
411
        assert_equal(port, serv.local_address.ip_port)
 
412
        serv_addr, serv_port = serv.local_address.ip_unpack
 
413
        case serv_addr
 
414
        when "0.0.0.0" then serv_addr = "127.0.0.1"
 
415
        end
 
416
        TCPSocket.open(serv_addr, serv_port) {|s1|
 
417
          s2, addr = serv.accept
 
418
          begin
 
419
            assert_equal(s1.local_address.ip_unpack, addr.ip_unpack)
 
420
          ensure
 
421
            s2.close
 
422
          end
 
423
        }
 
424
      }
 
425
    rescue Errno::EADDRINUSE
 
426
      # not test failure
 
427
    end
 
428
  end
 
429
 
 
430
  def test_s_foreach
 
431
    Addrinfo.foreach(nil, 80, nil, :STREAM) {|ai|
 
432
      assert_kind_of(Addrinfo, ai)
 
433
    }
 
434
  end
 
435
 
 
436
  def test_marshal
 
437
    ai1 = Addrinfo.tcp("127.0.0.1", 80)
 
438
    ai2 = Marshal.load(Marshal.dump(ai1))
 
439
    assert_equal(ai1.afamily, ai2.afamily)
 
440
    assert_equal(ai1.ip_unpack, ai2.ip_unpack)
 
441
    assert_equal(ai1.pfamily, ai2.pfamily)
 
442
    assert_equal(ai1.socktype, ai2.socktype)
 
443
    assert_equal(ai1.protocol, ai2.protocol)
 
444
    assert_equal(ai1.canonname, ai2.canonname)
 
445
  end
 
446
 
 
447
  if Socket.const_defined?("AF_INET6") && Socket::AF_INET6.is_a?(Integer)
 
448
 
 
449
    def test_addrinfo_new_inet6
 
450
      ai = Addrinfo.new(["AF_INET6", 42304, "ip6-localhost", "::1"])
 
451
      assert_equal([42304, "::1"], Socket.unpack_sockaddr_in(ai))
 
452
      assert_equal(Socket::AF_INET6, ai.afamily)
 
453
      assert_equal(Socket::PF_INET6, ai.pfamily)
 
454
      assert_equal(0, ai.socktype)
 
455
      assert_equal(0, ai.protocol)
 
456
    end
 
457
 
 
458
    def test_addrinfo_ip_unpack_inet6
 
459
      ai = Addrinfo.tcp("::1", 80)
 
460
      assert_equal(["::1", 80], ai.ip_unpack)
 
461
      assert_equal("::1", ai.ip_address)
 
462
      assert_equal(80, ai.ip_port)
 
463
    end
 
464
 
 
465
    def test_addrinfo_inspect_sockaddr_inet6
 
466
      ai = Addrinfo.tcp("::1", 80)
 
467
      assert_equal("[::1]:80", ai.inspect_sockaddr)
 
468
    end
 
469
 
 
470
    def test_marshal_inet6
 
471
      ai1 = Addrinfo.tcp("::1", 80)
 
472
      ai2 = Marshal.load(Marshal.dump(ai1))
 
473
      assert_equal(ai1.afamily, ai2.afamily)
 
474
      assert_equal(ai1.ip_unpack, ai2.ip_unpack)
 
475
      assert_equal(ai1.pfamily, ai2.pfamily)
 
476
      assert_equal(ai1.socktype, ai2.socktype)
 
477
      assert_equal(ai1.protocol, ai2.protocol)
 
478
      assert_equal(ai1.canonname, ai2.canonname)
 
479
    end
 
480
 
 
481
    def ipv6(str)
 
482
      Addrinfo.getaddrinfo(str, nil, :INET6, :DGRAM).fetch(0)
 
483
    end
 
484
 
 
485
    def test_ipv6_address_predicates
 
486
      list = [
 
487
        [:ipv6_unspecified?, "::"],
 
488
        [:ipv6_loopback?, "::1"],
 
489
        [:ipv6_v4compat?, "::0.0.0.2", "::255.255.255.255"],
 
490
        [:ipv6_v4mapped?, "::ffff:0.0.0.0", "::ffff:255.255.255.255"],
 
491
        [:ipv6_linklocal?, "fe80::", "febf::"],
 
492
        [:ipv6_sitelocal?, "fec0::", "feef::"],
 
493
        [:ipv6_multicast?, "ff00::", "ffff::"]
 
494
      ]
 
495
      mlist = [
 
496
        [:ipv6_mc_nodelocal?, "ff01::", "ff11::"],
 
497
        [:ipv6_mc_linklocal?, "ff02::", "ff12::"],
 
498
        [:ipv6_mc_sitelocal?, "ff05::", "ff15::"],
 
499
        [:ipv6_mc_orglocal?, "ff08::", "ff18::"],
 
500
        [:ipv6_mc_global?, "ff0e::", "ff1e::"]
 
501
      ]
 
502
      list.each {|meth, *addrs|
 
503
        addrs.each {|addr|
 
504
          addr_exp = "Addrinfo.getaddrinfo(#{addr.inspect}, nil, :INET6, :DGRAM).fetch(0)"
 
505
          if meth == :ipv6_v4compat? || meth == :ipv6_v4mapped?
 
506
            # MacOS X returns IPv4 address for ::ffff:1.2.3.4 and ::1.2.3.4.
 
507
            # Solaris returns IPv4 address for ::ffff:1.2.3.4.
 
508
            ai = ipv6(addr)
 
509
            assert(ai.ipv4? || ai.send(meth), "ai=#{addr_exp}; ai.ipv4? || .#{meth}")
 
510
          else
 
511
            assert(ipv6(addr).send(meth), "#{addr_exp}.#{meth}")
 
512
            assert_equal(addr, ipv6(addr).ip_address)
 
513
          end
 
514
          list.each {|meth2,|
 
515
            next if meth == meth2
 
516
            assert(!ipv6(addr).send(meth2), "!#{addr_exp}.#{meth2}")
 
517
          }
 
518
        }
 
519
      }
 
520
      mlist.each {|meth, *addrs|
 
521
        addrs.each {|addr|
 
522
          addr_exp = "Addrinfo.getaddrinfo(#{addr.inspect}, nil, :INET6, :DGRAM).fetch(0)"
 
523
          assert(ipv6(addr).send(meth), "#{addr_exp}.#{meth}")
 
524
          assert(ipv6(addr).ipv6_multicast?, "#{addr_exp}.ipv6_multicast?")
 
525
          mlist.each {|meth2,|
 
526
            next if meth == meth2
 
527
            assert(!ipv6(addr).send(meth2), "!#{addr_exp}.#{meth2}")
 
528
          }
 
529
          list.each {|meth2,|
 
530
            next if :ipv6_multicast? == meth2
 
531
            assert(!ipv6(addr).send(meth2), "!#{addr_exp}.#{meth2}")
 
532
          }
 
533
        }
 
534
      }
 
535
    end
 
536
 
 
537
    def test_ipv6_to_ipv4
 
538
      ai = Addrinfo.ip("::192.0.2.3")
 
539
      ai = ai.ipv6_to_ipv4 if !ai.ipv4?
 
540
      assert(ai.ipv4?)
 
541
      assert_equal("192.0.2.3", ai.ip_address)
 
542
 
 
543
      ai = Addrinfo.ip("::ffff:192.0.2.3")
 
544
      ai = ai.ipv6_to_ipv4 if !ai.ipv4?
 
545
      assert(ai.ipv4?)
 
546
      assert_equal("192.0.2.3", ai.ip_address)
 
547
 
 
548
      assert_nil(Addrinfo.ip("::1").ipv6_to_ipv4)
 
549
      assert_nil(Addrinfo.ip("192.0.2.3").ipv6_to_ipv4)
 
550
      if HAS_UNIXSOCKET
 
551
        assert_nil(Addrinfo.unix("/testdir/sock").ipv6_to_ipv4)
 
552
      end
 
553
    end
 
554
  end
 
555
 
 
556
  if HAS_UNIXSOCKET
 
557
 
 
558
    def test_addrinfo_unix
 
559
      ai = Addrinfo.unix("/testdir/sock")
 
560
      assert_equal("/testdir/sock", Socket.unpack_sockaddr_un(ai))
 
561
      assert_equal(Socket::AF_UNIX, ai.afamily)
 
562
      assert_equal(Socket::PF_UNIX, ai.pfamily)
 
563
      assert_equal(Socket::SOCK_STREAM, ai.socktype)
 
564
      assert_equal(0, ai.protocol)
 
565
    end
 
566
 
 
567
    def test_addrinfo_unix_dgram
 
568
      ai = Addrinfo.unix("/testdir/sock", :DGRAM)
 
569
      assert_equal("/testdir/sock", Socket.unpack_sockaddr_un(ai))
 
570
      assert_equal(Socket::AF_UNIX, ai.afamily)
 
571
      assert_equal(Socket::PF_UNIX, ai.pfamily)
 
572
      assert_equal(Socket::SOCK_DGRAM, ai.socktype)
 
573
      assert_equal(0, ai.protocol)
 
574
    end
 
575
 
 
576
    def test_addrinfo_unix_path
 
577
      ai = Addrinfo.unix("/testdir/sock1")
 
578
      assert_equal("/testdir/sock1", ai.unix_path)
 
579
    end
 
580
 
 
581
    def test_addrinfo_inspect_sockaddr_unix
 
582
      ai = Addrinfo.unix("/testdir/test_addrinfo_inspect_sockaddr_unix")
 
583
      assert_equal("/testdir/test_addrinfo_inspect_sockaddr_unix", ai.inspect_sockaddr)
 
584
    end
 
585
 
 
586
    def test_addrinfo_new_unix
 
587
      ai = Addrinfo.new(["AF_UNIX", "/testdir/sock"])
 
588
      assert_equal("/testdir/sock", Socket.unpack_sockaddr_un(ai))
 
589
      assert_equal(Socket::AF_UNIX, ai.afamily)
 
590
      assert_equal(Socket::PF_UNIX, ai.pfamily)
 
591
      assert_equal(Socket::SOCK_STREAM, ai.socktype) # UNIXSocket/UNIXServer is SOCK_STREAM only.
 
592
      assert_equal(0, ai.protocol)
 
593
    end
 
594
 
 
595
    def test_addrinfo_predicates_unix
 
596
      unix_ai = Addrinfo.new(Socket.sockaddr_un("/testdir/sososo"))
 
597
      assert(!unix_ai.ip?)
 
598
      assert(!unix_ai.ipv4?)
 
599
      assert(!unix_ai.ipv6?)
 
600
      assert(unix_ai.unix?)
 
601
    end
 
602
 
 
603
    def test_marshal_unix
 
604
      ai1 = Addrinfo.unix("/testdir/sock")
 
605
      ai2 = Marshal.load(Marshal.dump(ai1))
 
606
      assert_equal(ai1.afamily, ai2.afamily)
 
607
      assert_equal(ai1.unix_path, ai2.unix_path)
 
608
      assert_equal(ai1.pfamily, ai2.pfamily)
 
609
      assert_equal(ai1.socktype, ai2.socktype)
 
610
      assert_equal(ai1.protocol, ai2.protocol)
 
611
      assert_equal(ai1.canonname, ai2.canonname)
 
612
    end
 
613
 
 
614
  end
 
615
end