Retro68/gcc/libgo/go/net/iprawsock_test.go

194 lines
5.6 KiB
Go
Raw Normal View History

// Copyright 2009 The Go Authors. All rights reserved.
2012-03-27 23:13:14 +00:00
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
2019-06-02 15:48:37 +00:00
// +build !js
2012-03-27 23:13:14 +00:00
package net
import (
2014-09-21 17:33:12 +00:00
"reflect"
2012-03-27 23:13:14 +00:00
"testing"
)
2017-04-10 11:32:00 +00:00
// The full stack test cases for IPConn have been moved to the
// following:
// golang.org/x/net/ipv4
// golang.org/x/net/ipv6
// golang.org/x/net/icmp
2014-09-21 17:33:12 +00:00
type resolveIPAddrTest struct {
2017-04-10 11:32:00 +00:00
network string
2014-09-21 17:33:12 +00:00
litAddrOrName string
addr *IPAddr
err error
2012-03-27 23:13:14 +00:00
}
2014-09-21 17:33:12 +00:00
var resolveIPAddrTests = []resolveIPAddrTest{
{"ip", "127.0.0.1", &IPAddr{IP: IPv4(127, 0, 0, 1)}, nil},
{"ip4", "127.0.0.1", &IPAddr{IP: IPv4(127, 0, 0, 1)}, nil},
{"ip4:icmp", "127.0.0.1", &IPAddr{IP: IPv4(127, 0, 0, 1)}, nil},
2012-03-27 23:13:14 +00:00
2014-09-21 17:33:12 +00:00
{"ip", "::1", &IPAddr{IP: ParseIP("::1")}, nil},
{"ip6", "::1", &IPAddr{IP: ParseIP("::1")}, nil},
{"ip6:ipv6-icmp", "::1", &IPAddr{IP: ParseIP("::1")}, nil},
{"ip6:IPv6-ICMP", "::1", &IPAddr{IP: ParseIP("::1")}, nil},
{"ip", "::1%en0", &IPAddr{IP: ParseIP("::1"), Zone: "en0"}, nil},
{"ip6", "::1%911", &IPAddr{IP: ParseIP("::1"), Zone: "911"}, nil},
{"", "127.0.0.1", &IPAddr{IP: IPv4(127, 0, 0, 1)}, nil}, // Go 1.0 behavior
{"", "::1", &IPAddr{IP: ParseIP("::1")}, nil}, // Go 1.0 behavior
2017-04-10 11:32:00 +00:00
{"ip4:icmp", "", &IPAddr{}, nil},
2014-09-21 17:33:12 +00:00
{"l2tp", "127.0.0.1", nil, UnknownNetworkError("l2tp")},
{"l2tp:gre", "127.0.0.1", nil, UnknownNetworkError("l2tp:gre")},
{"tcp", "1.2.3.4:123", nil, UnknownNetworkError("tcp")},
{"ip4", "2001:db8::1", nil, &AddrError{Err: errNoSuitableAddress.Error(), Addr: "2001:db8::1"}},
{"ip4:icmp", "2001:db8::1", nil, &AddrError{Err: errNoSuitableAddress.Error(), Addr: "2001:db8::1"}},
{"ip6", "127.0.0.1", nil, &AddrError{Err: errNoSuitableAddress.Error(), Addr: "127.0.0.1"}},
{"ip6", "::ffff:127.0.0.1", nil, &AddrError{Err: errNoSuitableAddress.Error(), Addr: "::ffff:127.0.0.1"}},
{"ip6:ipv6-icmp", "127.0.0.1", nil, &AddrError{Err: errNoSuitableAddress.Error(), Addr: "127.0.0.1"}},
{"ip6:ipv6-icmp", "::ffff:127.0.0.1", nil, &AddrError{Err: errNoSuitableAddress.Error(), Addr: "::ffff:127.0.0.1"}},
2014-09-21 17:33:12 +00:00
}
func TestResolveIPAddr(t *testing.T) {
2017-04-10 11:32:00 +00:00
if !testableNetwork("ip+nopriv") {
t.Skip("ip+nopriv test")
2015-08-28 15:33:40 +00:00
}
2017-04-10 11:32:00 +00:00
origTestHookLookupIP := testHookLookupIP
defer func() { testHookLookupIP = origTestHookLookupIP }()
testHookLookupIP = lookupLocalhost
for _, tt := range resolveIPAddrTests {
2017-04-10 11:32:00 +00:00
addr, err := ResolveIPAddr(tt.network, tt.litAddrOrName)
if !reflect.DeepEqual(addr, tt.addr) || !reflect.DeepEqual(err, tt.err) {
t.Errorf("ResolveIPAddr(%q, %q) = %#v, %v, want %#v, %v", tt.network, tt.litAddrOrName, addr, err, tt.addr, tt.err)
2014-09-21 17:33:12 +00:00
continue
}
if err == nil {
addr2, err := ResolveIPAddr(addr.Network(), addr.String())
if !reflect.DeepEqual(addr2, tt.addr) || err != tt.err {
t.Errorf("(%q, %q): ResolveIPAddr(%q, %q) = %#v, %v, want %#v, %v", tt.network, tt.litAddrOrName, addr.Network(), addr.String(), addr2, err, tt.addr, tt.err)
}
2012-03-27 23:13:14 +00:00
}
}
}
2014-09-21 17:33:12 +00:00
var ipConnLocalNameTests = []struct {
net string
laddr *IPAddr
}{
{"ip4:icmp", &IPAddr{IP: IPv4(127, 0, 0, 1)}},
{"ip4:icmp", &IPAddr{}},
{"ip4:icmp", nil},
2012-03-27 23:13:14 +00:00
}
2014-09-21 17:33:12 +00:00
func TestIPConnLocalName(t *testing.T) {
for _, tt := range ipConnLocalNameTests {
2017-04-10 11:32:00 +00:00
if !testableNetwork(tt.net) {
t.Logf("skipping %s test", tt.net)
continue
}
2014-09-21 17:33:12 +00:00
c, err := ListenIP(tt.net, tt.laddr)
if err != nil {
2017-04-10 11:32:00 +00:00
t.Fatal(err)
2014-09-21 17:33:12 +00:00
}
defer c.Close()
if la := c.LocalAddr(); la == nil {
2017-04-10 11:32:00 +00:00
t.Fatal("should not fail")
2014-09-21 17:33:12 +00:00
}
2012-03-27 23:13:14 +00:00
}
}
2014-09-21 17:33:12 +00:00
func TestIPConnRemoteName(t *testing.T) {
2017-04-10 11:32:00 +00:00
if !testableNetwork("ip:tcp") {
t.Skip("ip:tcp test")
2014-09-21 17:33:12 +00:00
}
2012-03-27 23:13:14 +00:00
2015-08-28 15:33:40 +00:00
raddr := &IPAddr{IP: IPv4(127, 0, 0, 1).To4()}
2014-09-21 17:33:12 +00:00
c, err := DialIP("ip:tcp", &IPAddr{IP: IPv4(127, 0, 0, 1)}, raddr)
if err != nil {
2017-04-10 11:32:00 +00:00
t.Fatal(err)
2012-03-27 23:13:14 +00:00
}
2014-09-21 17:33:12 +00:00
defer c.Close()
if !reflect.DeepEqual(raddr, c.RemoteAddr()) {
2017-04-10 11:32:00 +00:00
t.Fatalf("got %#v; want %#v", c.RemoteAddr(), raddr)
2012-03-27 23:13:14 +00:00
}
}
2018-12-28 15:30:48 +00:00
func TestDialListenIPArgs(t *testing.T) {
type test struct {
argLists [][2]string
shouldFail bool
}
tests := []test{
{
argLists: [][2]string{
{"ip", "127.0.0.1"},
{"ip:", "127.0.0.1"},
{"ip::", "127.0.0.1"},
{"ip", "::1"},
{"ip:", "::1"},
{"ip::", "::1"},
{"ip4", "127.0.0.1"},
{"ip4:", "127.0.0.1"},
{"ip4::", "127.0.0.1"},
{"ip6", "::1"},
{"ip6:", "::1"},
{"ip6::", "::1"},
},
shouldFail: true,
},
}
if testableNetwork("ip") {
priv := test{shouldFail: false}
for _, tt := range []struct {
network, address string
args [2]string
}{
{"ip4:47", "127.0.0.1", [2]string{"ip4:47", "127.0.0.1"}},
{"ip6:47", "::1", [2]string{"ip6:47", "::1"}},
} {
c, err := ListenPacket(tt.network, tt.address)
if err != nil {
continue
}
c.Close()
priv.argLists = append(priv.argLists, tt.args)
}
if len(priv.argLists) > 0 {
tests = append(tests, priv)
}
}
for _, tt := range tests {
for _, args := range tt.argLists {
_, err := Dial(args[0], args[1])
if tt.shouldFail != (err != nil) {
t.Errorf("Dial(%q, %q) = %v; want (err != nil) is %t", args[0], args[1], err, tt.shouldFail)
}
_, err = ListenPacket(args[0], args[1])
if tt.shouldFail != (err != nil) {
t.Errorf("ListenPacket(%q, %q) = %v; want (err != nil) is %t", args[0], args[1], err, tt.shouldFail)
}
a, err := ResolveIPAddr("ip", args[1])
if err != nil {
t.Errorf("ResolveIPAddr(\"ip\", %q) = %v", args[1], err)
continue
}
_, err = DialIP(args[0], nil, a)
if tt.shouldFail != (err != nil) {
t.Errorf("DialIP(%q, %v) = %v; want (err != nil) is %t", args[0], a, err, tt.shouldFail)
}
_, err = ListenIP(args[0], a)
if tt.shouldFail != (err != nil) {
t.Errorf("ListenIP(%q, %v) = %v; want (err != nil) is %t", args[0], a, err, tt.shouldFail)
}
}
}
}