...
Run Format

Source file src/net/platform_test.go

Documentation: net

     1  // Copyright 2015 The Go Authors. All rights reserved.
     2  // Use of this source code is governed by a BSD-style
     3  // license that can be found in the LICENSE file.
     4  
     5  package net
     6  
     7  import (
     8  	"internal/testenv"
     9  	"os"
    10  	"runtime"
    11  	"strings"
    12  	"testing"
    13  )
    14  
    15  // testableNetwork reports whether network is testable on the current
    16  // platform configuration.
    17  func testableNetwork(network string) bool {
    18  	ss := strings.Split(network, ":")
    19  	switch ss[0] {
    20  	case "ip+nopriv":
    21  		switch runtime.GOOS {
    22  		case "nacl":
    23  			return false
    24  		}
    25  	case "ip", "ip4", "ip6":
    26  		switch runtime.GOOS {
    27  		case "nacl", "plan9":
    28  			return false
    29  		default:
    30  			if os.Getuid() != 0 {
    31  				return false
    32  			}
    33  		}
    34  	case "unix", "unixgram":
    35  		switch runtime.GOOS {
    36  		case "android", "nacl", "plan9", "windows":
    37  			return false
    38  		}
    39  		// iOS does not support unix, unixgram.
    40  		if runtime.GOOS == "darwin" && (runtime.GOARCH == "arm" || runtime.GOARCH == "arm64") {
    41  			return false
    42  		}
    43  	case "unixpacket":
    44  		switch runtime.GOOS {
    45  		case "android", "darwin", "nacl", "plan9", "windows":
    46  			return false
    47  		case "netbsd":
    48  			// It passes on amd64 at least. 386 fails (Issue 22927). arm is unknown.
    49  			if runtime.GOARCH == "386" {
    50  				return false
    51  			}
    52  		}
    53  	}
    54  	switch ss[0] {
    55  	case "tcp4", "udp4", "ip4":
    56  		if !supportsIPv4() {
    57  			return false
    58  		}
    59  	case "tcp6", "udp6", "ip6":
    60  		if !supportsIPv6() {
    61  			return false
    62  		}
    63  	}
    64  	return true
    65  }
    66  
    67  // testableAddress reports whether address of network is testable on
    68  // the current platform configuration.
    69  func testableAddress(network, address string) bool {
    70  	switch ss := strings.Split(network, ":"); ss[0] {
    71  	case "unix", "unixgram", "unixpacket":
    72  		// Abstract unix domain sockets, a Linux-ism.
    73  		if address[0] == '@' && runtime.GOOS != "linux" {
    74  			return false
    75  		}
    76  	}
    77  	return true
    78  }
    79  
    80  // testableListenArgs reports whether arguments are testable on the
    81  // current platform configuration.
    82  func testableListenArgs(network, address, client string) bool {
    83  	if !testableNetwork(network) || !testableAddress(network, address) {
    84  		return false
    85  	}
    86  
    87  	var err error
    88  	var addr Addr
    89  	switch ss := strings.Split(network, ":"); ss[0] {
    90  	case "tcp", "tcp4", "tcp6":
    91  		addr, err = ResolveTCPAddr("tcp", address)
    92  	case "udp", "udp4", "udp6":
    93  		addr, err = ResolveUDPAddr("udp", address)
    94  	case "ip", "ip4", "ip6":
    95  		addr, err = ResolveIPAddr("ip", address)
    96  	default:
    97  		return true
    98  	}
    99  	if err != nil {
   100  		return false
   101  	}
   102  	var ip IP
   103  	var wildcard bool
   104  	switch addr := addr.(type) {
   105  	case *TCPAddr:
   106  		ip = addr.IP
   107  		wildcard = addr.isWildcard()
   108  	case *UDPAddr:
   109  		ip = addr.IP
   110  		wildcard = addr.isWildcard()
   111  	case *IPAddr:
   112  		ip = addr.IP
   113  		wildcard = addr.isWildcard()
   114  	}
   115  
   116  	// Test wildcard IP addresses.
   117  	if wildcard && !testenv.HasExternalNetwork() {
   118  		return false
   119  	}
   120  
   121  	// Test functionality of IPv4 communication using AF_INET and
   122  	// IPv6 communication using AF_INET6 sockets.
   123  	if !supportsIPv4() && ip.To4() != nil {
   124  		return false
   125  	}
   126  	if !supportsIPv6() && ip.To16() != nil && ip.To4() == nil {
   127  		return false
   128  	}
   129  	cip := ParseIP(client)
   130  	if cip != nil {
   131  		if !supportsIPv4() && cip.To4() != nil {
   132  			return false
   133  		}
   134  		if !supportsIPv6() && cip.To16() != nil && cip.To4() == nil {
   135  			return false
   136  		}
   137  	}
   138  
   139  	// Test functionality of IPv4 communication using AF_INET6
   140  	// sockets.
   141  	if !supportsIPv4map() && supportsIPv4() && (network == "tcp" || network == "udp" || network == "ip") && wildcard {
   142  		// At this point, we prefer IPv4 when ip is nil.
   143  		// See favoriteAddrFamily for further information.
   144  		if ip.To16() != nil && ip.To4() == nil && cip.To4() != nil { // a pair of IPv6 server and IPv4 client
   145  			return false
   146  		}
   147  		if (ip.To4() != nil || ip == nil) && cip.To16() != nil && cip.To4() == nil { // a pair of IPv4 server and IPv6 client
   148  			return false
   149  		}
   150  	}
   151  
   152  	return true
   153  }
   154  
   155  func condFatalf(t *testing.T, network string, format string, args ...interface{}) {
   156  	t.Helper()
   157  	// A few APIs like File and Read/WriteMsg{UDP,IP} are not
   158  	// fully implemented yet on Plan 9 and Windows.
   159  	switch runtime.GOOS {
   160  	case "windows":
   161  		if network == "file+net" {
   162  			t.Logf(format, args...)
   163  			return
   164  		}
   165  	case "plan9":
   166  		t.Logf(format, args...)
   167  		return
   168  	}
   169  	t.Fatalf(format, args...)
   170  }
   171  

View as plain text