fix data race

vimclient.go

@@ -12,6 +12,7 @@ import (
 	"io"
 	"math/rand"
 	"net"
+	"sync"
 	"time"
 )
 
@@ -50,15 +51,18 @@ var _ Handler = &getCliHandler{}
 type getCliHandler struct {
 	handler Handler
 
-	connected bool
-	chCli     chan *Client
+	connected   bool
+	connectedMu sync.RWMutex
+	chCli       chan *Client
 }
 
 func (h *getCliHandler) Serve(cli *Client, msg *Message) {
+	h.connectedMu.Lock()
 	if !h.connected {
 		h.chCli <- cli
 		h.connected = true
 	}
+	h.connectedMu.Unlock()
 	h.handler.Serve(cli, msg)
 }
 

vimclient_test.go

@@ -9,6 +9,7 @@ import (
 	"os"
 	"reflect"
 	"strings"
+	"sync"
 	"testing"
 	"time"
 
@@ -18,16 +19,26 @@ import (
 var cli *vim.Client
 
 var defaultServeFunc = func(cli *vim.Client, msg *vim.Message) {}
-var serveFunc = defaultServeFunc
+
+var (
+	serveFunc  = defaultServeFunc
+	serveFunMu sync.RWMutex
+)
 
 var vimArgs = []string{"-Nu", "NONE", "-i", "NONE", "-n"}
 
 var waitLog = func() { time.Sleep(1 * time.Millisecond) }
 
-type testHandler struct{}
+type testHandler struct {
+	f func(cli *vim.Client, msg *vim.Message)
+}
 
 func (h *testHandler) Serve(cli *vim.Client, msg *vim.Message) {
-	serveFunc(cli, msg)
+	fn := h.f
+	if fn == nil {
+		fn = defaultServeFunc
+	}
+	fn(cli, msg)
 }
 
 func TestMain(m *testing.M) {
@@ -53,23 +64,35 @@ func BenchmarkNewChildClient(b *testing.B) {
 
 func TestNewChildClient(t *testing.T) {
 	serveFuncCalled := false
+	var serveFuncCalledMu sync.RWMutex
+
+	serveFunMu.Lock()
 	serveFunc = func(cli *vim.Client, msg *vim.Message) {
 		// t.Log(msg)
+		serveFuncCalledMu.Lock()
 		serveFuncCalled = true
+		serveFuncCalledMu.Unlock()
 	}
-	defer func() { serveFunc = defaultServeFunc }()
+	defer func() {
+		serveFunMu.Unlock()
+		serveFunc = defaultServeFunc
+	}()
 
-	cli, closer, err := vim.NewChildClient(&testHandler{}, vimArgs)
+	cli, closer, err := vim.NewChildClient(&testHandler{f: serveFunc}, vimArgs)
 	if err != nil {
 		t.Fatal(err)
 	}
 	defer closer.Close()
 	if _, err = cli.Expr("1 + 1"); err != nil {
 		t.Fatal(err)
 	}
+
+	serveFuncCalledMu.Lock()
 	if !serveFuncCalled {
 		t.Error("serveFunc must be called")
 	}
+	serveFuncCalledMu.Unlock()
+
 	status, err := cli.Expr("ch_status(g:vim_go_client_handler)")
 	if err != nil {
 		t.Fatal(err)

vimserver.go

@@ -127,6 +127,8 @@ func connectTmpFile(addr string) (*os.File, error) {
 	}
 	defer tmpfile.Close()
 
-	connectTemplate.Execute(tmpfile, struct{ Addr string }{addr})
+	if err := connectTemplate.Execute(tmpfile, struct{ Addr string }{addr}); err != nil {
+		return nil, err
+	}
 	return tmpfile, nil
 }