code review 1326042: changes &x -> x[0:] for array to slice conversion

src/pkg/net/server_test.go

 // Copyright 2009 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.
 
 package net
 
 import (
         "flag"
         "io"
         "os"
         "strings"
         "syscall"
         "testing"
 )
 
 // Do not test empty datagrams by default.
 // It causes unexplained timeouts on some systems,
 // including Snow Leopard.  I think that the kernel
 // doesn't quite expect them.
 var testUDP = flag.Bool("udp", false, "whether to test UDP datagrams")
 
 func runEcho(fd io.ReadWriter, done chan<- int) {
         var buf [1024]byte
 
         for {
-                n, err := fd.Read(&buf)
+                n, err := fd.Read(buf[0:])
                 if err != nil || n == 0 {
                         break
                 }
                 fd.Write(buf[0:n])
         }
         done <- 1
 }
 
 func runServe(t *testing.T, network, addr string, listening chan<- string, done chan<- int) {
         l, err := Listen(network, addr)
@@ skipping 30 matching lines @@
         if !isEmpty {
                 b = []byte("hello, world\n")
         }
         var b1 [100]byte
 
         n, err1 := fd.Write(b)
         if n != len(b) {
                 t.Fatalf("fd.Write(%q) = %d, %v", b, n, err1)
         }
 
-        n, err1 = fd.Read(&b1)
+        n, err1 = fd.Read(b1[0:])
         if n != len(b) || err1 != nil {
                 t.Fatalf("fd.Read() = %d, %v (want %d, nil)", n, err1, len(b))
         }
         fd.Close()
 }
 
 func doTest(t *testing.T, network, listenaddr, dialaddr string) {
         t.Logf("Test %s %s %s\n", network, listenaddr, dialaddr)
         listening := make(chan string)
         done := make(chan int)
@@ skipping 31 matching lines @@
 
 func runPacket(t *testing.T, network, addr string, listening chan<- string, done chan<- int) {
         c, err := ListenPacket(network, addr)
         if err != nil {
                 t.Fatalf("net.ListenPacket(%q, %q) = _, %v", network, addr, err)
         }
         listening <- c.LocalAddr().String()
         c.SetReadTimeout(10e6) // 10ms
         var buf [1000]byte
         for {
-                n, addr, err := c.ReadFrom(&buf)
+                n, addr, err := c.ReadFrom(buf[0:])
                 if e, ok := err.(Error); ok && e.Timeout() {
                         if done <- 1 {
                                 break
                         }
                         continue
                 }
                 if err != nil {
                         break
                 }
                 if _, err = c.WriteTo(buf[0:n], addr); err != nil {
@@ skipping 42 matching lines @@
                 os.Remove("/tmp/gotest1.net.local")
                 doTestPacket(t, "unixgram", "/tmp/gotest1.net", "/tmp/gotest1.net", isEmpty)
                 os.Remove("/tmp/gotest1.net")
                 os.Remove("/tmp/gotest1.net.local")
                 if syscall.OS == "linux" {
                         // Test abstract unix domain socket, a Linux-ism
                         doTestPacket(t, "unixgram", "@gotest1/net", "@gotest1/net", isEmpty)
                 }
         }
 }