libgo/go/net/tcpsock_test.go

   1 // Copyright 2012 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         "fmt"
   9         "internal/testenv"
  10         "io"
  11         "reflect"
  12         "runtime"
  13         "sync"
  14         "testing"
  15         "time"
  16 )
  17
  18 func BenchmarkTCP4OneShot(b *testing.B) {
  19         benchmarkTCP(b, false, false, "127.0.0.1:0")
  20 }
  21
  22 func BenchmarkTCP4OneShotTimeout(b *testing.B) {
  23         benchmarkTCP(b, false, true, "127.0.0.1:0")
  24 }
  25
  26 func BenchmarkTCP4Persistent(b *testing.B) {
  27         benchmarkTCP(b, true, false, "127.0.0.1:0")
  28 }
  29
  30 func BenchmarkTCP4PersistentTimeout(b *testing.B) {
  31         benchmarkTCP(b, true, true, "127.0.0.1:0")
  32 }
  33
  34 func BenchmarkTCP6OneShot(b *testing.B) {
  35         if !supportsIPv6 {
  36                 b.Skip("ipv6 is not supported")
  37         }
  38         benchmarkTCP(b, false, false, "[::1]:0")
  39 }
  40
  41 func BenchmarkTCP6OneShotTimeout(b *testing.B) {
  42         if !supportsIPv6 {
  43                 b.Skip("ipv6 is not supported")
  44         }
  45         benchmarkTCP(b, false, true, "[::1]:0")
  46 }
  47
  48 func BenchmarkTCP6Persistent(b *testing.B) {
  49         if !supportsIPv6 {
  50                 b.Skip("ipv6 is not supported")
  51         }
  52         benchmarkTCP(b, true, false, "[::1]:0")
  53 }
  54
  55 func BenchmarkTCP6PersistentTimeout(b *testing.B) {
  56         if !supportsIPv6 {
  57                 b.Skip("ipv6 is not supported")
  58         }
  59         benchmarkTCP(b, true, true, "[::1]:0")
  60 }
  61
  62 func benchmarkTCP(b *testing.B, persistent, timeout bool, laddr string) {
  63         testHookUninstaller.Do(uninstallTestHooks)
  64
  65         const msgLen = 512
  66         conns := b.N
  67         numConcurrent := runtime.GOMAXPROCS(-1) * 2
  68         msgs := 1
  69         if persistent {
  70                 conns = numConcurrent
  71                 msgs = b.N / conns
  72                 if msgs == 0 {
  73                         msgs = 1
  74                 }
  75                 if conns > b.N {
  76                         conns = b.N
  77                 }
  78         }
  79         sendMsg := func(c Conn, buf []byte) bool {
  80                 n, err := c.Write(buf)
  81                 if n != len(buf) || err != nil {
  82                         b.Log(err)
  83                         return false
  84                 }
  85                 return true
  86         }
  87         recvMsg := func(c Conn, buf []byte) bool {
  88                 for read := 0; read != len(buf); {
  89                         n, err := c.Read(buf)
  90                         read += n
  91                         if err != nil {
  92                                 b.Log(err)
  93                                 return false
  94                         }
  95                 }
  96                 return true
  97         }
  98         ln, err := Listen("tcp", laddr)
  99         if err != nil {
 100                 b.Fatal(err)
 101         }
 102         defer ln.Close()
 103         serverSem := make(chan bool, numConcurrent)
 104         // Acceptor.
 105         go func() {
 106                 for {
 107                         c, err := ln.Accept()
 108                         if err != nil {
 109                                 break
 110                         }
 111                         serverSem <- true
 112                         // Server connection.
 113                         go func(c Conn) {
 114                                 defer func() {
 115                                         c.Close()
 116                                         <-serverSem
 117                                 }()
 118                                 if timeout {
 119                                         c.SetDeadline(time.Now().Add(time.Hour)) // Not intended to fire.
 120                                 }
 121                                 var buf [msgLen]byte
 122                                 for m := 0; m < msgs; m++ {
 123                                         if !recvMsg(c, buf[:]) || !sendMsg(c, buf[:]) {
 124                                                 break
 125                                         }
 126                                 }
 127                         }(c)
 128                 }
 129         }()
 130         clientSem := make(chan bool, numConcurrent)
 131         for i := 0; i < conns; i++ {
 132                 clientSem <- true
 133                 // Client connection.
 134                 go func() {
 135                         defer func() {
 136                                 <-clientSem
 137                         }()
 138                         c, err := Dial("tcp", ln.Addr().String())
 139                         if err != nil {
 140                                 b.Log(err)
 141                                 return
 142                         }
 143                         defer c.Close()
 144                         if timeout {
 145                                 c.SetDeadline(time.Now().Add(time.Hour)) // Not intended to fire.
 146                         }
 147                         var buf [msgLen]byte
 148                         for m := 0; m < msgs; m++ {
 149                                 if !sendMsg(c, buf[:]) || !recvMsg(c, buf[:]) {
 150                                         break
 151                                 }
 152                         }
 153                 }()
 154         }
 155         for i := 0; i < numConcurrent; i++ {
 156                 clientSem <- true
 157                 serverSem <- true
 158         }
 159 }
 160
 161 func BenchmarkTCP4ConcurrentReadWrite(b *testing.B) {
 162         benchmarkTCPConcurrentReadWrite(b, "127.0.0.1:0")
 163 }
 164
 165 func BenchmarkTCP6ConcurrentReadWrite(b *testing.B) {
 166         if !supportsIPv6 {
 167                 b.Skip("ipv6 is not supported")
 168         }
 169         benchmarkTCPConcurrentReadWrite(b, "[::1]:0")
 170 }
 171
 172 func benchmarkTCPConcurrentReadWrite(b *testing.B, laddr string) {
 173         testHookUninstaller.Do(uninstallTestHooks)
 174
 175         // The benchmark creates GOMAXPROCS client/server pairs.
 176         // Each pair creates 4 goroutines: client reader/writer and server reader/writer.
 177         // The benchmark stresses concurrent reading and writing to the same connection.
 178         // Such pattern is used in net/http and net/rpc.
 179
 180         b.StopTimer()
 181
 182         P := runtime.GOMAXPROCS(0)
 183         N := b.N / P
 184         W := 1000
 185
 186         // Setup P client/server connections.
 187         clients := make([]Conn, P)
 188         servers := make([]Conn, P)
 189         ln, err := Listen("tcp", laddr)
 190         if err != nil {
 191                 b.Fatal(err)
 192         }
 193         defer ln.Close()
 194         done := make(chan bool)
 195         go func() {
 196                 for p := 0; p < P; p++ {
 197                         s, err := ln.Accept()
 198                         if err != nil {
 199                                 b.Error(err)
 200                                 return
 201                         }
 202                         servers[p] = s
 203                 }
 204                 done <- true
 205         }()
 206         for p := 0; p < P; p++ {
 207                 c, err := Dial("tcp", ln.Addr().String())
 208                 if err != nil {
 209                         b.Fatal(err)
 210                 }
 211                 clients[p] = c
 212         }
 213         <-done
 214
 215         b.StartTimer()
 216
 217         var wg sync.WaitGroup
 218         wg.Add(4 * P)
 219         for p := 0; p < P; p++ {
 220                 // Client writer.
 221                 go func(c Conn) {
 222                         defer wg.Done()
 223                         var buf [1]byte
 224                         for i := 0; i < N; i++ {
 225                                 v := byte(i)
 226                                 for w := 0; w < W; w++ {
 227                                         v *= v
 228                                 }
 229                                 buf[0] = v
 230                                 _, err := c.Write(buf[:])
 231                                 if err != nil {
 232                                         b.Error(err)
 233                                         return
 234                                 }
 235                         }
 236                 }(clients[p])
 237
 238                 // Pipe between server reader and server writer.
 239                 pipe := make(chan byte, 128)
 240
 241                 // Server reader.
 242                 go func(s Conn) {
 243                         defer wg.Done()
 244                         var buf [1]byte
 245                         for i := 0; i < N; i++ {
 246                                 _, err := s.Read(buf[:])
 247                                 if err != nil {
 248                                         b.Error(err)
 249                                         return
 250                                 }
 251                                 pipe <- buf[0]
 252                         }
 253                 }(servers[p])
 254
 255                 // Server writer.
 256                 go func(s Conn) {
 257                         defer wg.Done()
 258                         var buf [1]byte
 259                         for i := 0; i < N; i++ {
 260                                 v := <-pipe
 261                                 for w := 0; w < W; w++ {
 262                                         v *= v
 263                                 }
 264                                 buf[0] = v
 265                                 _, err := s.Write(buf[:])
 266                                 if err != nil {
 267                                         b.Error(err)
 268                                         return
 269                                 }
 270                         }
 271                         s.Close()
 272                 }(servers[p])
 273
 274                 // Client reader.
 275                 go func(c Conn) {
 276                         defer wg.Done()
 277                         var buf [1]byte
 278                         for i := 0; i < N; i++ {
 279                                 _, err := c.Read(buf[:])
 280                                 if err != nil {
 281                                         b.Error(err)
 282                                         return
 283                                 }
 284                         }
 285                         c.Close()
 286                 }(clients[p])
 287         }
 288         wg.Wait()
 289 }
 290
 291 type resolveTCPAddrTest struct {
 292         network       string
 293         litAddrOrName string
 294         addr          *TCPAddr
 295         err           error
 296 }
 297
 298 var resolveTCPAddrTests = []resolveTCPAddrTest{
 299         {"tcp", "127.0.0.1:0", &TCPAddr{IP: IPv4(127, 0, 0, 1), Port: 0}, nil},
 300         {"tcp4", "127.0.0.1:65535", &TCPAddr{IP: IPv4(127, 0, 0, 1), Port: 65535}, nil},
 301
 302         {"tcp", "[::1]:0", &TCPAddr{IP: ParseIP("::1"), Port: 0}, nil},
 303         {"tcp6", "[::1]:65535", &TCPAddr{IP: ParseIP("::1"), Port: 65535}, nil},
 304
 305         {"tcp", "[::1%en0]:1", &TCPAddr{IP: ParseIP("::1"), Port: 1, Zone: "en0"}, nil},
 306         {"tcp6", "[::1%911]:2", &TCPAddr{IP: ParseIP("::1"), Port: 2, Zone: "911"}, nil},
 307
 308         {"", "127.0.0.1:0", &TCPAddr{IP: IPv4(127, 0, 0, 1), Port: 0}, nil}, // Go 1.0 behavior
 309         {"", "[::1]:0", &TCPAddr{IP: ParseIP("::1"), Port: 0}, nil},         // Go 1.0 behavior
 310
 311         {"tcp", ":12345", &TCPAddr{Port: 12345}, nil},
 312
 313         {"http", "127.0.0.1:0", nil, UnknownNetworkError("http")},
 314
 315         {"tcp", "127.0.0.1:http", &TCPAddr{IP: ParseIP("127.0.0.1"), Port: 80}, nil},
 316         {"tcp", "[::ffff:127.0.0.1]:http", &TCPAddr{IP: ParseIP("::ffff:127.0.0.1"), Port: 80}, nil},
 317         {"tcp", "[2001:db8::1]:http", &TCPAddr{IP: ParseIP("2001:db8::1"), Port: 80}, nil},
 318         {"tcp4", "127.0.0.1:http", &TCPAddr{IP: ParseIP("127.0.0.1"), Port: 80}, nil},
 319         {"tcp4", "[::ffff:127.0.0.1]:http", &TCPAddr{IP: ParseIP("127.0.0.1"), Port: 80}, nil},
 320         {"tcp6", "[2001:db8::1]:http", &TCPAddr{IP: ParseIP("2001:db8::1"), Port: 80}, nil},
 321
 322         {"tcp4", "[2001:db8::1]:http", nil, &AddrError{Err: errNoSuitableAddress.Error(), Addr: "2001:db8::1"}},
 323         {"tcp6", "127.0.0.1:http", nil, &AddrError{Err: errNoSuitableAddress.Error(), Addr: "127.0.0.1"}},
 324         {"tcp6", "[::ffff:127.0.0.1]:http", nil, &AddrError{Err: errNoSuitableAddress.Error(), Addr: "::ffff:127.0.0.1"}},
 325 }
 326
 327 func TestResolveTCPAddr(t *testing.T) {
 328         origTestHookLookupIP := testHookLookupIP
 329         defer func() { testHookLookupIP = origTestHookLookupIP }()
 330         testHookLookupIP = lookupLocalhost
 331
 332         for _, tt := range resolveTCPAddrTests {
 333                 addr, err := ResolveTCPAddr(tt.network, tt.litAddrOrName)
 334                 if !reflect.DeepEqual(addr, tt.addr) || !reflect.DeepEqual(err, tt.err) {
 335                         t.Errorf("ResolveTCPAddr(%q, %q) = %#v, %v, want %#v, %v", tt.network, tt.litAddrOrName, addr, err, tt.addr, tt.err)
 336                         continue
 337                 }
 338                 if err == nil {
 339                         addr2, err := ResolveTCPAddr(addr.Network(), addr.String())
 340                         if !reflect.DeepEqual(addr2, tt.addr) || err != tt.err {
 341                                 t.Errorf("(%q, %q): ResolveTCPAddr(%q, %q) = %#v, %v, want %#v, %v", tt.network, tt.litAddrOrName, addr.Network(), addr.String(), addr2, err, tt.addr, tt.err)
 342                         }
 343                 }
 344         }
 345 }
 346
 347 var tcpListenerNameTests = []struct {
 348         net   string
 349         laddr *TCPAddr
 350 }{
 351         {"tcp4", &TCPAddr{IP: IPv4(127, 0, 0, 1)}},
 352         {"tcp4", &TCPAddr{}},
 353         {"tcp4", nil},
 354 }
 355
 356 func TestTCPListenerName(t *testing.T) {
 357         testenv.MustHaveExternalNetwork(t)
 358
 359         for _, tt := range tcpListenerNameTests {
 360                 ln, err := ListenTCP(tt.net, tt.laddr)
 361                 if err != nil {
 362                         t.Fatal(err)
 363                 }
 364                 defer ln.Close()
 365                 la := ln.Addr()
 366                 if a, ok := la.(*TCPAddr); !ok || a.Port == 0 {
 367                         t.Fatalf("got %v; expected a proper address with non-zero port number", la)
 368                 }
 369         }
 370 }
 371
 372 func TestIPv6LinkLocalUnicastTCP(t *testing.T) {
 373         testenv.MustHaveExternalNetwork(t)
 374
 375         if !supportsIPv6 {
 376                 t.Skip("IPv6 is not supported")
 377         }
 378
 379         for i, tt := range ipv6LinkLocalUnicastTCPTests {
 380                 ln, err := Listen(tt.network, tt.address)
 381                 if err != nil {
 382                         // It might return "LookupHost returned no
 383                         // suitable address" error on some platforms.
 384                         t.Log(err)
 385                         continue
 386                 }
 387                 ls, err := (&streamListener{Listener: ln}).newLocalServer()
 388                 if err != nil {
 389                         t.Fatal(err)
 390                 }
 391                 defer ls.teardown()
 392                 ch := make(chan error, 1)
 393                 handler := func(ls *localServer, ln Listener) { transponder(ln, ch) }
 394                 if err := ls.buildup(handler); err != nil {
 395                         t.Fatal(err)
 396                 }
 397                 if la, ok := ln.Addr().(*TCPAddr); !ok || !tt.nameLookup && la.Zone == "" {
 398                         t.Fatalf("got %v; expected a proper address with zone identifier", la)
 399                 }
 400
 401                 c, err := Dial(tt.network, ls.Listener.Addr().String())
 402                 if err != nil {
 403                         t.Fatal(err)
 404                 }
 405                 defer c.Close()
 406                 if la, ok := c.LocalAddr().(*TCPAddr); !ok || !tt.nameLookup && la.Zone == "" {
 407                         t.Fatalf("got %v; expected a proper address with zone identifier", la)
 408                 }
 409                 if ra, ok := c.RemoteAddr().(*TCPAddr); !ok || !tt.nameLookup && ra.Zone == "" {
 410                         t.Fatalf("got %v; expected a proper address with zone identifier", ra)
 411                 }
 412
 413                 if _, err := c.Write([]byte("TCP OVER IPV6 LINKLOCAL TEST")); err != nil {
 414                         t.Fatal(err)
 415                 }
 416                 b := make([]byte, 32)
 417                 if _, err := c.Read(b); err != nil {
 418                         t.Fatal(err)
 419                 }
 420
 421                 for err := range ch {
 422                         t.Errorf("#%d: %v", i, err)
 423                 }
 424         }
 425 }
 426
 427 func TestTCPConcurrentAccept(t *testing.T) {
 428         defer runtime.GOMAXPROCS(runtime.GOMAXPROCS(4))
 429         ln, err := Listen("tcp", "127.0.0.1:0")
 430         if err != nil {
 431                 t.Fatal(err)
 432         }
 433         const N = 10
 434         var wg sync.WaitGroup
 435         wg.Add(N)
 436         for i := 0; i < N; i++ {
 437                 go func() {
 438                         for {
 439                                 c, err := ln.Accept()
 440                                 if err != nil {
 441                                         break
 442                                 }
 443                                 c.Close()
 444                         }
 445                         wg.Done()
 446                 }()
 447         }
 448         attempts := 10 * N
 449         fails := 0
 450         d := &Dialer{Timeout: 200 * time.Millisecond}
 451         for i := 0; i < attempts; i++ {
 452                 c, err := d.Dial("tcp", ln.Addr().String())
 453                 if err != nil {
 454                         fails++
 455                 } else {
 456                         c.Close()
 457                 }
 458         }
 459         ln.Close()
 460         wg.Wait()
 461         if fails > attempts/9 { // see issues 7400 and 7541
 462                 t.Fatalf("too many Dial failed: %v", fails)
 463         }
 464         if fails > 0 {
 465                 t.Logf("# of failed Dials: %v", fails)
 466         }
 467 }
 468
 469 func TestTCPReadWriteAllocs(t *testing.T) {
 470         if runtime.Compiler == "gccgo" {
 471                 t.Skip("skipping for gccgo until escape analysis is enabled")
 472         }
 473
 474         switch runtime.GOOS {
 475         case "plan9":
 476                 // The implementation of asynchronous cancelable
 477                 // I/O on Plan 9 allocates memory.
 478                 // See net/fd_io_plan9.go.
 479                 t.Skipf("not supported on %s", runtime.GOOS)
 480         case "nacl":
 481                 // NaCl needs to allocate pseudo file descriptor
 482                 // stuff. See syscall/fd_nacl.go.
 483                 t.Skipf("not supported on %s", runtime.GOOS)
 484         }
 485
 486         ln, err := Listen("tcp", "127.0.0.1:0")
 487         if err != nil {
 488                 t.Fatal(err)
 489         }
 490         defer ln.Close()
 491         var server Conn
 492         errc := make(chan error, 1)
 493         go func() {
 494                 var err error
 495                 server, err = ln.Accept()
 496                 errc <- err
 497         }()
 498         client, err := Dial("tcp", ln.Addr().String())
 499         if err != nil {
 500                 t.Fatal(err)
 501         }
 502         defer client.Close()
 503         if err := <-errc; err != nil {
 504                 t.Fatal(err)
 505         }
 506         defer server.Close()
 507
 508         var buf [128]byte
 509         allocs := testing.AllocsPerRun(1000, func() {
 510                 _, err := server.Write(buf[:])
 511                 if err != nil {
 512                         t.Fatal(err)
 513                 }
 514                 _, err = io.ReadFull(client, buf[:])
 515                 if err != nil {
 516                         t.Fatal(err)
 517                 }
 518         })
 519         // For gccgo changed "> 0" to "> 7".
 520         if allocs > 7 {
 521                 t.Fatalf("got %v; want 0", allocs)
 522         }
 523
 524         var bufwrt [128]byte
 525         ch := make(chan bool)
 526         defer close(ch)
 527         go func() {
 528                 for <-ch {
 529                         _, err := server.Write(bufwrt[:])
 530                         errc <- err
 531                 }
 532         }()
 533         allocs = testing.AllocsPerRun(1000, func() {
 534                 ch <- true
 535                 if _, err = io.ReadFull(client, buf[:]); err != nil {
 536                         t.Fatal(err)
 537                 }
 538                 if err := <-errc; err != nil {
 539                         t.Fatal(err)
 540                 }
 541         })
 542         if allocs > 0 {
 543                 t.Fatalf("got %v; want 0", allocs)
 544         }
 545 }
 546
 547 func TestTCPStress(t *testing.T) {
 548         const conns = 2
 549         const msgLen = 512
 550         msgs := int(1e4)
 551         if testing.Short() {
 552                 msgs = 1e2
 553         }
 554
 555         sendMsg := func(c Conn, buf []byte) bool {
 556                 n, err := c.Write(buf)
 557                 if n != len(buf) || err != nil {
 558                         t.Log(err)
 559                         return false
 560                 }
 561                 return true
 562         }
 563         recvMsg := func(c Conn, buf []byte) bool {
 564                 for read := 0; read != len(buf); {
 565                         n, err := c.Read(buf)
 566                         read += n
 567                         if err != nil {
 568                                 t.Log(err)
 569                                 return false
 570                         }
 571                 }
 572                 return true
 573         }
 574
 575         ln, err := Listen("tcp", "127.0.0.1:0")
 576         if err != nil {
 577                 t.Fatal(err)
 578         }
 579         done := make(chan bool)
 580         // Acceptor.
 581         go func() {
 582                 defer func() {
 583                         done <- true
 584                 }()
 585                 for {
 586                         c, err := ln.Accept()
 587                         if err != nil {
 588                                 break
 589                         }
 590                         // Server connection.
 591                         go func(c Conn) {
 592                                 defer c.Close()
 593                                 var buf [msgLen]byte
 594                                 for m := 0; m < msgs; m++ {
 595                                         if !recvMsg(c, buf[:]) || !sendMsg(c, buf[:]) {
 596                                                 break
 597                                         }
 598                                 }
 599                         }(c)
 600                 }
 601         }()
 602         for i := 0; i < conns; i++ {
 603                 // Client connection.
 604                 go func() {
 605                         defer func() {
 606                                 done <- true
 607                         }()
 608                         c, err := Dial("tcp", ln.Addr().String())
 609                         if err != nil {
 610                                 t.Log(err)
 611                                 return
 612                         }
 613                         defer c.Close()
 614                         var buf [msgLen]byte
 615                         for m := 0; m < msgs; m++ {
 616                                 if !sendMsg(c, buf[:]) || !recvMsg(c, buf[:]) {
 617                                         break
 618                                 }
 619                         }
 620                 }()
 621         }
 622         for i := 0; i < conns; i++ {
 623                 <-done
 624         }
 625         ln.Close()
 626         <-done
 627 }
 628
 629 func TestTCPSelfConnect(t *testing.T) {
 630         if runtime.GOOS == "windows" {
 631                 // TODO(brainman): do not know why it hangs.
 632                 t.Skip("known-broken test on windows")
 633         }
 634
 635         ln, err := newLocalListener("tcp")
 636         if err != nil {
 637                 t.Fatal(err)
 638         }
 639         var d Dialer
 640         c, err := d.Dial(ln.Addr().Network(), ln.Addr().String())
 641         if err != nil {
 642                 ln.Close()
 643                 t.Fatal(err)
 644         }
 645         network := c.LocalAddr().Network()
 646         laddr := *c.LocalAddr().(*TCPAddr)
 647         c.Close()
 648         ln.Close()
 649
 650         // Try to connect to that address repeatedly.
 651         n := 100000
 652         if testing.Short() {
 653                 n = 1000
 654         }
 655         switch runtime.GOOS {
 656         case "darwin", "dragonfly", "freebsd", "netbsd", "openbsd", "plan9", "solaris", "windows":
 657                 // Non-Linux systems take a long time to figure
 658                 // out that there is nothing listening on localhost.
 659                 n = 100
 660         }
 661         for i := 0; i < n; i++ {
 662                 d.Timeout = time.Millisecond
 663                 c, err := d.Dial(network, laddr.String())
 664                 if err == nil {
 665                         addr := c.LocalAddr().(*TCPAddr)
 666                         if addr.Port == laddr.Port || addr.IP.Equal(laddr.IP) {
 667                                 t.Errorf("Dial %v should fail", addr)
 668                         } else {
 669                                 t.Logf("Dial %v succeeded - possibly racing with other listener", addr)
 670                         }
 671                         c.Close()
 672                 }
 673         }
 674 }
 675
 676 // Test that >32-bit reads work on 64-bit systems.
 677 // On 32-bit systems this tests that maxint reads work.
 678 func TestTCPBig(t *testing.T) {
 679         if !*testTCPBig {
 680                 t.Skip("test disabled; use -tcpbig to enable")
 681         }
 682
 683         for _, writev := range []bool{false, true} {
 684                 t.Run(fmt.Sprintf("writev=%v", writev), func(t *testing.T) {
 685                         ln, err := newLocalListener("tcp")
 686                         if err != nil {
 687                                 t.Fatal(err)
 688                         }
 689                         defer ln.Close()
 690
 691                         x := int(1 << 30)
 692                         x = x*5 + 1<<20 // just over 5 GB on 64-bit, just over 1GB on 32-bit
 693                         done := make(chan int)
 694                         go func() {
 695                                 defer close(done)
 696                                 c, err := ln.Accept()
 697                                 if err != nil {
 698                                         t.Error(err)
 699                                         return
 700                                 }
 701                                 buf := make([]byte, x)
 702                                 var n int
 703                                 if writev {
 704                                         var n64 int64
 705                                         n64, err = (&Buffers{buf}).WriteTo(c)
 706                                         n = int(n64)
 707                                 } else {
 708                                         n, err = c.Write(buf)
 709                                 }
 710                                 if n != len(buf) || err != nil {
 711                                         t.Errorf("Write(buf) = %d, %v, want %d, nil", n, err, x)
 712                                 }
 713                                 c.Close()
 714                         }()
 715
 716                         c, err := Dial("tcp", ln.Addr().String())
 717                         if err != nil {
 718                                 t.Fatal(err)
 719                         }
 720                         buf := make([]byte, x)
 721                         n, err := io.ReadFull(c, buf)
 722                         if n != len(buf) || err != nil {
 723                                 t.Errorf("Read(buf) = %d, %v, want %d, nil", n, err, x)
 724                         }
 725                         c.Close()
 726                         <-done
 727                 })
 728         }
 729 }