1a2f01efa6
Update the Go library to the 1.10beta1 release.
Requires a few changes to the compiler for modifications to the map
runtime code, and to handle some nowritebarrier cases in the runtime.
Reviewed-on: https://go-review.googlesource.com/86455
gotools/:
* Makefile.am (go_cmd_vet_files): New variable.
(go_cmd_buildid_files, go_cmd_test2json_files): New variables.
(s-zdefaultcc): Change from constants to functions.
(noinst_PROGRAMS): Add vet, buildid, and test2json.
(cgo$(EXEEXT)): Link against $(LIBGOTOOL).
(vet$(EXEEXT)): New target.
(buildid$(EXEEXT)): New target.
(test2json$(EXEEXT)): New target.
(install-exec-local): Install all $(noinst_PROGRAMS).
(uninstall-local): Uninstasll all $(noinst_PROGRAMS).
(check-go-tool): Depend on $(noinst_PROGRAMS). Copy down
objabi.go.
(check-runtime): Depend on $(noinst_PROGRAMS).
(check-cgo-test, check-carchive-test): Likewise.
(check-vet): New target.
(check): Depend on check-vet. Look at cmd_vet-testlog.
(.PHONY): Add check-vet.
* Makefile.in: Rebuild.
From-SVN: r256365
67 lines
1.6 KiB
Go
67 lines
1.6 KiB
Go
// 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.
|
|
|
|
// +build darwin dragonfly freebsd linux netbsd openbsd solaris
|
|
|
|
package net
|
|
|
|
import (
|
|
"bytes"
|
|
"syscall"
|
|
"testing"
|
|
"time"
|
|
)
|
|
|
|
// Test that a client can't trigger an endless loop of write system
|
|
// calls on the server by shutting down the write side on the client.
|
|
// Possibility raised in the discussion of https://golang.org/cl/71973.
|
|
func TestEndlessWrite(t *testing.T) {
|
|
t.Parallel()
|
|
c := make(chan bool)
|
|
server := func(cs *TCPConn) error {
|
|
cs.CloseWrite()
|
|
<-c
|
|
return nil
|
|
}
|
|
client := func(ss *TCPConn) error {
|
|
// Tell the server to return when we return.
|
|
defer close(c)
|
|
|
|
// Loop writing to the server. The server is not reading
|
|
// anything, so this will eventually block, and then time out.
|
|
b := bytes.Repeat([]byte{'a'}, 8192)
|
|
cagain := 0
|
|
for {
|
|
n, err := ss.conn.fd.pfd.WriteOnce(b)
|
|
if n > 0 {
|
|
cagain = 0
|
|
}
|
|
switch err {
|
|
case nil:
|
|
case syscall.EAGAIN:
|
|
if cagain == 0 {
|
|
// We've written enough data to
|
|
// start blocking. Set a deadline
|
|
// so that we will stop.
|
|
ss.SetWriteDeadline(time.Now().Add(5 * time.Millisecond))
|
|
}
|
|
cagain++
|
|
if cagain > 20 {
|
|
t.Error("looping on EAGAIN")
|
|
return nil
|
|
}
|
|
if err = ss.conn.fd.pfd.WaitWrite(); err != nil {
|
|
t.Logf("client WaitWrite: %v", err)
|
|
return nil
|
|
}
|
|
default:
|
|
// We expect to eventually get an error.
|
|
t.Logf("client WriteOnce: %v", err)
|
|
return nil
|
|
}
|
|
}
|
|
}
|
|
withTCPConnPair(t, client, server)
|
|
}
|