// rundir

// Copyright 2017 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// This test failed when the compiler didn't use the
// correct code to identify the type reflect.Method.
// The failing code relied on Type.String() which had
// formatting that depended on whether a package (in
// this case "reflect") was imported more than once.

		}
	}
}

func Test_stringToProtocol(t *testing.T) {
	tests := []string{
		"TCP", "UDP", "ICMP", "SCTP",
	}
	expected := []uint16{
		uint16(unix.IPPROTO_TCP), uint16(unix.IPPROTO_UDP), uint16(0), uint16(unix.IPPROTO_SCTP),
	}
	for i := range tests {
		got := stringToProtocol(tests[i])
		if got != expected[i] {
			t.Errorf("stringToProtocol() failed - got %#v, want %#v",

// rundir

// Copyright 2015 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Issue 9608: dead code elimination in switch statements.

// This has to be done as a package rather than as a file,
// because run.go runs files with 'go run', which passes the
// -complete flag to compiler, causing it to complain about
// the intentionally unimplemented function fail.

package net

import (
	"internal/syscall/unix"
	"runtime"
	"syscall"
	"unsafe"
)

const (
	_C_AF_INET      = syscall.AF_INET
	_C_AF_INET6     = syscall.AF_INET6
	_C_AF_UNSPEC    = syscall.AF_UNSPEC
	_C_EAI_AGAIN    = unix.EAI_AGAIN
	_C_EAI_NONAME   = unix.EAI_NONAME
	_C_EAI_SERVICE  = unix.EAI_SERVICE
	_C_EAI_NODATA   = unix.EAI_NODATA
	_C_EAI_OVERFLOW = unix.EAI_OVERFLOW
	_C_EAI_SYSTEM   = unix.EAI_SYSTEM

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package net

import "internal/syscall/unix"

	return conn.Control(func(descriptor uintptr) {
		err := unix.SetsockoptInt(int(descriptor), unix.SOL_SOCKET, unix.SO_REUSEADDR, 1)
		if err != nil {
			log.Errorf("Fail to set fd %d SO_REUSEADDR with error %v", descriptor, err)
		}
		err = unix.SetsockoptInt(int(descriptor), unix.SOL_SOCKET, unix.SO_REUSEPORT, 1)
		if err != nil {

// license that can be found in the LICENSE file.

//go:build unix

package net

import (
	"internal/syscall/unix"
	"testing"
)

// For backward compatibility, opening a net.Conn, turning it into an os.File,
// and calling the Fd method should return a blocking descriptor.
func TestFileFdBlocks(t *testing.T) {
	if !testableNetwork("unix") {
		t.Skipf("skipping: unix sockets not supported")
	}

	if !windows.SupportUnixSocket() {
		t.Skip("unix test")
	}
	handler := func(ls *localServer, ln Listener) {}
	for _, laddr := range []string{"", testUnixAddr(t)} {
		laddr := laddr
		taddr := testUnixAddr(t)
		ta, err := ResolveUnixAddr("unix", taddr)
		if err != nil {
			t.Fatal(err)
		}
		ln, err := ListenUnix("unix", ta)
		if err != nil {
			t.Fatal(err)
		}

package testpty

import (
	"internal/syscall/unix"
	"os"
	"syscall"
)

func open() (pty *os.File, processTTY string, err error) {
	m, err := unix.PosixOpenpt(syscall.O_RDWR)
	if err != nil {
		return nil, "", ptyError("posix_openpt", err)
	}
	if err := unix.Grantpt(m); err != nil {
		syscall.Close(m)
		return nil, "", ptyError("grantpt", err)
	}
	if err := unix.Unlockpt(m); err != nil {
		syscall.Close(m)

// limitations under the License.

package app

import "golang.org/x/sys/unix"

func raiseFileLimits() (uint64, error) {
	rlimit := unix.Rlimit{}
	if err := unix.Getrlimit(unix.RLIMIT_NOFILE, &rlimit); err != nil {
		return 0, err
	}
	rlimit.Cur = rlimit.Max
	if err := unix.Setrlimit(unix.RLIMIT_NOFILE, &rlimit); err != nil {
		return 0, err
	}

	return rlimit.Cur, nil