gopls/internal/regtest/runner.go - tools - Git at Google

 // Copyright 2020 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 regtest

 import (
 	"bytes"
 	"context"
 	"fmt"
 	"io"
 	"io/ioutil"
 	"net"
 	"os"
 	"os/exec"
 	"path/filepath"
 	"runtime/pprof"
 	"strings"
 	"sync"
 	"testing"
 	"time"

 	"golang.org/x/tools/gopls/internal/hooks"
 	"golang.org/x/tools/internal/jsonrpc2"
 	"golang.org/x/tools/internal/jsonrpc2/servertest"
 	"golang.org/x/tools/internal/lsp/cache"
 	"golang.org/x/tools/internal/lsp/debug"
 	"golang.org/x/tools/internal/lsp/fake"
 	"golang.org/x/tools/internal/lsp/lsprpc"
 	"golang.org/x/tools/internal/lsp/protocol"
 	"golang.org/x/tools/internal/lsp/source"
 )

 // Mode is a bitmask that defines for which execution modes a test should run.
 type Mode int

 const (
 	// Singleton mode uses a separate in-process gopls instance for each test,
 	// and communicates over pipes to mimic the gopls sidecar execution mode,
 	// which communicates over stdin/stderr.
 	Singleton Mode = 1 << iota
 	// Forwarded forwards connections to a shared in-process gopls instance.
 	Forwarded
 	// SeparateProcess forwards connection to a shared separate gopls process.
 	SeparateProcess
 	// Experimental enables all of the experimental configurations that are
 	// being developed. Currently, it enables the workspace module.
 	Experimental
 	// WithoutExperiments are the modes that run without experimental features,
 	// like the workspace module. These should be used for tests that only work
 	// in the default modes.
 	WithoutExperiments = Singleton | Forwarded
 	// NormalModes are the global default execution modes, when unmodified by
 	// test flags or by individual test options.
 	NormalModes = Singleton | Experimental
 )

 // A Runner runs tests in gopls execution environments, as specified by its
 // modes. For modes that share state (for example, a shared cache or common
 // remote), any tests that execute on the same Runner will share the same
 // state.
 type Runner struct {
 	DefaultModes             Mode
 	Timeout                  time.Duration
 	GoplsPath                string
 	PrintGoroutinesOnFailure bool
 	TempDir                  string
 	SkipCleanup              bool

 	mu        sync.Mutex
 	ts        *servertest.TCPServer
 	socketDir string
 	// closers is a queue of clean-up functions to run at the end of the entire
 	// test suite.
 	closers []io.Closer
 }

 type runConfig struct {
 	editor      fake.EditorConfig
 	sandbox     fake.SandboxConfig
 	modes       Mode
 	timeout     time.Duration
 	debugAddr   string
 	skipLogs    bool
 	skipHooks   bool
 	nestWorkdir bool
 }

 func (r *Runner) defaultConfig() *runConfig {
 	return &runConfig{
 		modes:   r.DefaultModes,
 		timeout: r.Timeout,
 	}
 }

 // A RunOption augments the behavior of the test runner.
 type RunOption interface {
 	set(*runConfig)
 }

 type optionSetter func(*runConfig)

 func (f optionSetter) set(opts *runConfig) {
 	f(opts)
 }

 // WithTimeout configures a custom timeout for this test run.
 func WithTimeout(d time.Duration) RunOption {
 	return optionSetter(func(opts *runConfig) {
 		opts.timeout = d
 	})
 }

 // WithProxyFiles configures a file proxy using the given txtar-encoded string.
 func WithProxyFiles(txt string) RunOption {
 	return optionSetter(func(opts *runConfig) {
 		opts.sandbox.ProxyFiles = txt
 	})
 }

 // WithModes configures the execution modes that the test should run in.
 func WithModes(modes Mode) RunOption {
 	return optionSetter(func(opts *runConfig) {
 		opts.modes = modes
 	})
 }

 func SendPID() RunOption {
 	return optionSetter(func(opts *runConfig) {
 		opts.editor.SendPID = true
 	})
 }

 // EditorConfig is a RunOption option that configured the regtest editor.
 type EditorConfig fake.EditorConfig

 func (c EditorConfig) set(opts *runConfig) {
 	opts.editor = fake.EditorConfig(c)
 }

 // WithoutWorkspaceFolders prevents workspace folders from being sent as part
 // of the sandbox's initialization. It is used to simulate opening a single
 // file in the editor, without a workspace root. In that case, the client sends
 // neither workspace folders nor a root URI.
 func WithoutWorkspaceFolders() RunOption {
 	return optionSetter(func(opts *runConfig) {
 		opts.editor.WithoutWorkspaceFolders = true
 	})
 }

 // WithRootPath specifies the rootURI of the workspace folder opened in the
 // editor. By default, the sandbox opens the top-level directory, but some
 // tests need to check other cases.
 func WithRootPath(path string) RunOption {
 	return optionSetter(func(opts *runConfig) {
 		opts.editor.WorkspaceRoot = path
 	})
 }

 // InGOPATH configures the workspace working directory to be GOPATH, rather
 // than a separate working directory for use with modules.
 func InGOPATH() RunOption {
 	return optionSetter(func(opts *runConfig) {
 		opts.sandbox.InGoPath = true
 	})
 }

 // WithDebugAddress configures a debug server bound to addr. This option is
 // currently only supported when executing in Singleton mode. It is intended to
 // be used for long-running stress tests.
 func WithDebugAddress(addr string) RunOption {
 	return optionSetter(func(opts *runConfig) {
 		opts.debugAddr = addr
 	})
 }

 // SkipLogs skips the buffering of logs during test execution. It is intended
 // for long-running stress tests.
 func SkipLogs() RunOption {
 	return optionSetter(func(opts *runConfig) {
 		opts.skipLogs = true
 	})
 }

 // InExistingDir runs the test in a pre-existing directory. If set, no initial
 // files may be passed to the runner. It is intended for long-running stress
 // tests.
 func InExistingDir(dir string) RunOption {
 	return optionSetter(func(opts *runConfig) {
 		opts.sandbox.Workdir = dir
 	})
 }

 // SkipHooks allows for disabling the test runner's client hooks that are used
 // for instrumenting expectations (tracking diagnostics, logs, work done,
 // etc.). It is intended for performance-sensitive stress tests or benchmarks.
 func SkipHooks(skip bool) RunOption {
 	return optionSetter(func(opts *runConfig) {
 		opts.skipHooks = skip
 	})
 }

 // WithGOPROXY configures the test environment to have an explicit proxy value.
 // This is intended for stress tests -- to ensure their isolation, regtests
 // should instead use WithProxyFiles.
 func WithGOPROXY(goproxy string) RunOption {
 	return optionSetter(func(opts *runConfig) {
 		opts.sandbox.GOPROXY = goproxy
 	})
 }

 // LimitWorkspaceScope sets the LimitWorkspaceScope configuration.
 func LimitWorkspaceScope() RunOption {
 	return optionSetter(func(opts *runConfig) {
 		opts.editor.LimitWorkspaceScope = true
 	})
 }

 // NestWorkdir inserts the sandbox working directory in a subdirectory of the
 // editor workspace.
 func NestWorkdir() RunOption {
 	return optionSetter(func(opts *runConfig) {
 		opts.nestWorkdir = true
 	})
 }

 type TestFunc func(t *testing.T, env *Env)

 // Run executes the test function in the default configured gopls execution
 // modes. For each a test run, a new workspace is created containing the
 // un-txtared files specified by filedata.
 func (r *Runner) Run(t *testing.T, files string, test TestFunc, opts ...RunOption) {
 	t.Helper()

 	tests := []struct {
 		name      string
 		mode      Mode
 		getServer func(context.Context, *testing.T) jsonrpc2.StreamServer
 	}{
 		{"singleton", Singleton, singletonServer},
 		{"forwarded", Forwarded, r.forwardedServer},
 		{"separate_process", SeparateProcess, r.separateProcessServer},
 		{"experimental_workspace_module", Experimental, experimentalWorkspaceModule},
 	}

 	for _, tc := range tests {
 		tc := tc
 		config := r.defaultConfig()
 		for _, opt := range opts {
 			opt.set(config)
 		}
 		if config.modes&tc.mode == 0 {
 			continue
 		}
 		if config.debugAddr != "" && tc.mode != Singleton {
 			// Debugging is useful for running stress tests, but since the daemon has
 			// likely already been started, it would be too late to debug.
 			t.Fatalf("debugging regtest servers only works in Singleton mode, "+
 				"got debug addr %q and mode %v", config.debugAddr, tc.mode)
 		}

 		t.Run(tc.name, func(t *testing.T) {
 			ctx, cancel := context.WithTimeout(context.Background(), config.timeout)
 			defer cancel()
 			ctx = debug.WithInstance(ctx, "", "off")
 			if config.debugAddr != "" {
 				di := debug.GetInstance(ctx)
 				di.DebugAddress = config.debugAddr
 				di.Serve(ctx)
 				di.MonitorMemory(ctx)
 			}

 			rootDir := filepath.Join(r.TempDir, filepath.FromSlash(t.Name()))
 			if err := os.MkdirAll(rootDir, 0755); err != nil {
 				t.Fatal(err)
 			}
 			if config.nestWorkdir {
 				config.sandbox.Workdir = "work/nested"
 			}
 			config.sandbox.Files = files
 			config.sandbox.RootDir = rootDir
 			sandbox, err := fake.NewSandbox(&config.sandbox)
 			if err != nil {
 				t.Fatal(err)
 			}
 			workdir := sandbox.Workdir.RootURI().SpanURI().Filename()
 			if config.nestWorkdir {
 				// Now that we know the actual workdir, set our workspace to be the
 				// parent directory.
 				config.editor.WorkspaceRoot = filepath.Clean(filepath.Join(workdir, ".."))
 			}
 			// Deferring the closure of ws until the end of the entire test suite
 			// has, in testing, given the LSP server time to properly shutdown and
 			// release any file locks held in workspace, which is a problem on
 			// Windows. This may still be flaky however, and in the future we need a
 			// better solution to ensure that all Go processes started by gopls have
 			// exited before we clean up.
 			r.AddCloser(sandbox)
 			ss := tc.getServer(ctx, t)
 			framer := jsonrpc2.NewRawStream
 			ls := &loggingFramer{}
 			if !config.skipLogs {
 				framer = ls.framer(jsonrpc2.NewRawStream)
 			}
 			ts := servertest.NewPipeServer(ctx, ss, framer)
 			env := NewEnv(ctx, t, sandbox, ts, config.editor, !config.skipHooks)
 			defer func() {
 				if t.Failed() && r.PrintGoroutinesOnFailure {
 					pprof.Lookup("goroutine").WriteTo(os.Stderr, 1)
 				}
 				if t.Failed() || testing.Verbose() {
 					ls.printBuffers(t.Name(), os.Stderr)
 				}
 				env.CloseEditor()
 			}()
 			// Always await the initial workspace load.
 			env.Await(InitialWorkspaceLoad)
 			test(t, env)
 		})
 	}
 }

 type loggingFramer struct {
 	mu      sync.Mutex
 	buffers []*safeBuffer
 }

 // safeBuffer is a threadsafe buffer for logs.
 type safeBuffer struct {
 	mu  sync.Mutex
 	buf bytes.Buffer
 }

 func (b *safeBuffer) Write(p []byte) (int, error) {
 	b.mu.Lock()
 	defer b.mu.Unlock()
 	return b.buf.Write(p)
 }

 func (s *loggingFramer) framer(f jsonrpc2.Framer) jsonrpc2.Framer {
 	return func(nc net.Conn) jsonrpc2.Stream {
 		s.mu.Lock()
 		buf := &safeBuffer{buf: bytes.Buffer{}}
 		s.buffers = append(s.buffers, buf)
 		s.mu.Unlock()
 		stream := f(nc)
 		return protocol.LoggingStream(stream, buf)
 	}
 }

 func (s *loggingFramer) printBuffers(testname string, w io.Writer) {
 	s.mu.Lock()
 	defer s.mu.Unlock()

 	for i, buf := range s.buffers {
 		fmt.Fprintf(os.Stderr, "#### Start Gopls Test Logs %d of %d for %q\n", i+1, len(s.buffers), testname)
 		buf.mu.Lock()
 		io.Copy(w, &buf.buf)
 		buf.mu.Unlock()
 		fmt.Fprintf(os.Stderr, "#### End Gopls Test Logs %d of %d for %q\n", i+1, len(s.buffers), testname)
 	}
 }

 func singletonServer(ctx context.Context, t *testing.T) jsonrpc2.StreamServer {
 	return lsprpc.NewStreamServer(cache.New(ctx, hooks.Options), false)
 }

 func experimentalWorkspaceModule(ctx context.Context, t *testing.T) jsonrpc2.StreamServer {
 	options := func(o *source.Options) {
 		hooks.Options(o)
 		o.ExperimentalWorkspaceModule = true
 	}
 	return lsprpc.NewStreamServer(cache.New(ctx, options), false)
 }

 func (r *Runner) forwardedServer(ctx context.Context, t *testing.T) jsonrpc2.StreamServer {
 	ts := r.getTestServer()
 	return lsprpc.NewForwarder("tcp", ts.Addr)
 }

 // getTestServer gets the shared test server instance to connect to, or creates
 // one if it doesn't exist.
 func (r *Runner) getTestServer() *servertest.TCPServer {
 	r.mu.Lock()
 	defer r.mu.Unlock()
 	if r.ts == nil {
 		ctx := context.Background()
 		ctx = debug.WithInstance(ctx, "", "off")
 		ss := lsprpc.NewStreamServer(cache.New(ctx, hooks.Options), false)
 		r.ts = servertest.NewTCPServer(ctx, ss, nil)
 	}
 	return r.ts
 }

 func (r *Runner) separateProcessServer(ctx context.Context, t *testing.T) jsonrpc2.StreamServer {
 	// TODO(rfindley): can we use the autostart behavior here, instead of
 	// pre-starting the remote?
 	socket := r.getRemoteSocket(t)
 	return lsprpc.NewForwarder("unix", socket)
 }

 // runTestAsGoplsEnvvar triggers TestMain to run gopls instead of running
 // tests. It's a trick to allow tests to find a binary to use to start a gopls
 // subprocess.
 const runTestAsGoplsEnvvar = "_GOPLS_TEST_BINARY_RUN_AS_GOPLS"

 func (r *Runner) getRemoteSocket(t *testing.T) string {
 	t.Helper()
 	r.mu.Lock()
 	defer r.mu.Unlock()
 	const daemonFile = "gopls-test-daemon"
 	if r.socketDir != "" {
 		return filepath.Join(r.socketDir, daemonFile)
 	}

 	if r.GoplsPath == "" {
 		t.Fatal("cannot run tests with a separate process unless a path to a gopls binary is configured")
 	}
 	var err error
 	r.socketDir, err = ioutil.TempDir(r.TempDir, "gopls-regtest-socket")
 	if err != nil {
 		t.Fatalf("creating tempdir: %v", err)
 	}
 	socket := filepath.Join(r.socketDir, daemonFile)
 	args := []string{"serve", "-listen", "unix;" + socket, "-listen.timeout", "10s"}
 	cmd := exec.Command(r.GoplsPath, args...)
 	cmd.Env = append(os.Environ(), runTestAsGoplsEnvvar+"=true")
 	var stderr bytes.Buffer
 	cmd.Stderr = &stderr
 	go func() {
 		if err := cmd.Run(); err != nil {
 			panic(fmt.Sprintf("error running external gopls: %v\nstderr:\n%s", err, stderr.String()))
 		}
 	}()
 	return socket
 }

 // AddCloser schedules a closer to be closed at the end of the test run. This
 // is useful for Windows in particular, as
 func (r *Runner) AddCloser(closer io.Closer) {
 	r.mu.Lock()
 	defer r.mu.Unlock()
 	r.closers = append(r.closers, closer)
 }

 // Close cleans up resource that have been allocated to this workspace.
 func (r *Runner) Close() error {
 	r.mu.Lock()
 	defer r.mu.Unlock()

 	var errmsgs []string
 	if r.ts != nil {
 		if err := r.ts.Close(); err != nil {
 			errmsgs = append(errmsgs, err.Error())
 		}
 	}
 	if r.socketDir != "" {
 		if err := os.RemoveAll(r.socketDir); err != nil {
 			errmsgs = append(errmsgs, err.Error())
 		}
 	}
 	if !r.SkipCleanup {
 		for _, closer := range r.closers {
 			if err := closer.Close(); err != nil {
 				errmsgs = append(errmsgs, err.Error())
 			}
 		}
 		if err := os.RemoveAll(r.TempDir); err != nil {
 			errmsgs = append(errmsgs, err.Error())
 		}
 	}
 	if len(errmsgs) > 0 {
 		return fmt.Errorf("errors closing the test runner:\n\t%s", strings.Join(errmsgs, "\n\t"))
 	}
 	return nil
 }
	// Copyright 2020 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 regtest

	import (
	"bytes"
	"context"
	"fmt"
	"io"
	"io/ioutil"
	"net"
	"os"
	"os/exec"
	"path/filepath"
	"runtime/pprof"
	"strings"
	"sync"
	"testing"
	"time"

	"golang.org/x/tools/gopls/internal/hooks"
	"golang.org/x/tools/internal/jsonrpc2"
	"golang.org/x/tools/internal/jsonrpc2/servertest"
	"golang.org/x/tools/internal/lsp/cache"
	"golang.org/x/tools/internal/lsp/debug"
	"golang.org/x/tools/internal/lsp/fake"
	"golang.org/x/tools/internal/lsp/lsprpc"
	"golang.org/x/tools/internal/lsp/protocol"
	"golang.org/x/tools/internal/lsp/source"
	)

	// Mode is a bitmask that defines for which execution modes a test should run.
	type Mode int

	const (
	// Singleton mode uses a separate in-process gopls instance for each test,
	// and communicates over pipes to mimic the gopls sidecar execution mode,
	// which communicates over stdin/stderr.
	Singleton Mode = 1 << iota
	// Forwarded forwards connections to a shared in-process gopls instance.
	Forwarded
	// SeparateProcess forwards connection to a shared separate gopls process.
	SeparateProcess
	// Experimental enables all of the experimental configurations that are
	// being developed. Currently, it enables the workspace module.
	Experimental
	// WithoutExperiments are the modes that run without experimental features,
	// like the workspace module. These should be used for tests that only work
	// in the default modes.
	WithoutExperiments = Singleton \| Forwarded
	// NormalModes are the global default execution modes, when unmodified by
	// test flags or by individual test options.
	NormalModes = Singleton \| Experimental
	)

	// A Runner runs tests in gopls execution environments, as specified by its
	// modes. For modes that share state (for example, a shared cache or common
	// remote), any tests that execute on the same Runner will share the same
	// state.
	type Runner struct {
	DefaultModes Mode
	Timeout time.Duration
	GoplsPath string
	PrintGoroutinesOnFailure bool
	TempDir string
	SkipCleanup bool

	mu sync.Mutex
	ts *servertest.TCPServer
	socketDir string
	// closers is a queue of clean-up functions to run at the end of the entire
	// test suite.
	closers []io.Closer
	}

	type runConfig struct {
	editor fake.EditorConfig
	sandbox fake.SandboxConfig
	modes Mode
	timeout time.Duration
	debugAddr string
	skipLogs bool
	skipHooks bool
	nestWorkdir bool
	}

	func (r Runner) defaultConfig() runConfig {
	return &runConfig{
	modes: r.DefaultModes,
	timeout: r.Timeout,
	}
	}

	// A RunOption augments the behavior of the test runner.
	type RunOption interface {
	set(*runConfig)
	}

	type optionSetter func(*runConfig)

	func (f optionSetter) set(opts *runConfig) {
	f(opts)
	}

	// WithTimeout configures a custom timeout for this test run.
	func WithTimeout(d time.Duration) RunOption {
	return optionSetter(func(opts *runConfig) {
	opts.timeout = d
	})
	}

	// WithProxyFiles configures a file proxy using the given txtar-encoded string.
	func WithProxyFiles(txt string) RunOption {
	return optionSetter(func(opts *runConfig) {
	opts.sandbox.ProxyFiles = txt
	})
	}

	// WithModes configures the execution modes that the test should run in.
	func WithModes(modes Mode) RunOption {
	return optionSetter(func(opts *runConfig) {
	opts.modes = modes
	})
	}

	func SendPID() RunOption {
	return optionSetter(func(opts *runConfig) {
	opts.editor.SendPID = true
	})
	}

	// EditorConfig is a RunOption option that configured the regtest editor.
	type EditorConfig fake.EditorConfig

	func (c EditorConfig) set(opts *runConfig) {
	opts.editor = fake.EditorConfig(c)
	}

	// WithoutWorkspaceFolders prevents workspace folders from being sent as part
	// of the sandbox's initialization. It is used to simulate opening a single
	// file in the editor, without a workspace root. In that case, the client sends
	// neither workspace folders nor a root URI.
	func WithoutWorkspaceFolders() RunOption {
	return optionSetter(func(opts *runConfig) {
	opts.editor.WithoutWorkspaceFolders = true
	})
	}

	// WithRootPath specifies the rootURI of the workspace folder opened in the
	// editor. By default, the sandbox opens the top-level directory, but some
	// tests need to check other cases.
	func WithRootPath(path string) RunOption {
	return optionSetter(func(opts *runConfig) {
	opts.editor.WorkspaceRoot = path
	})
	}

	// InGOPATH configures the workspace working directory to be GOPATH, rather
	// than a separate working directory for use with modules.
	func InGOPATH() RunOption {
	return optionSetter(func(opts *runConfig) {
	opts.sandbox.InGoPath = true
	})
	}

	// WithDebugAddress configures a debug server bound to addr. This option is
	// currently only supported when executing in Singleton mode. It is intended to
	// be used for long-running stress tests.
	func WithDebugAddress(addr string) RunOption {
	return optionSetter(func(opts *runConfig) {
	opts.debugAddr = addr
	})
	}

	// SkipLogs skips the buffering of logs during test execution. It is intended
	// for long-running stress tests.
	func SkipLogs() RunOption {
	return optionSetter(func(opts *runConfig) {
	opts.skipLogs = true
	})
	}

	// InExistingDir runs the test in a pre-existing directory. If set, no initial
	// files may be passed to the runner. It is intended for long-running stress
	// tests.
	func InExistingDir(dir string) RunOption {
	return optionSetter(func(opts *runConfig) {
	opts.sandbox.Workdir = dir
	})
	}

	// SkipHooks allows for disabling the test runner's client hooks that are used
	// for instrumenting expectations (tracking diagnostics, logs, work done,
	// etc.). It is intended for performance-sensitive stress tests or benchmarks.
	func SkipHooks(skip bool) RunOption {
	return optionSetter(func(opts *runConfig) {
	opts.skipHooks = skip
	})
	}

	// WithGOPROXY configures the test environment to have an explicit proxy value.
	// This is intended for stress tests -- to ensure their isolation, regtests
	// should instead use WithProxyFiles.
	func WithGOPROXY(goproxy string) RunOption {
	return optionSetter(func(opts *runConfig) {
	opts.sandbox.GOPROXY = goproxy
	})
	}

	// LimitWorkspaceScope sets the LimitWorkspaceScope configuration.
	func LimitWorkspaceScope() RunOption {
	return optionSetter(func(opts *runConfig) {
	opts.editor.LimitWorkspaceScope = true
	})
	}

	// NestWorkdir inserts the sandbox working directory in a subdirectory of the
	// editor workspace.
	func NestWorkdir() RunOption {
	return optionSetter(func(opts *runConfig) {
	opts.nestWorkdir = true
	})
	}

	type TestFunc func(t testing.T, env Env)

	// Run executes the test function in the default configured gopls execution
	// modes. For each a test run, a new workspace is created containing the
	// un-txtared files specified by filedata.
	func (r Runner) Run(t testing.T, files string, test TestFunc, opts ...RunOption) {
	t.Helper()

	tests := []struct {
	name string
	mode Mode
	getServer func(context.Context, *testing.T) jsonrpc2.StreamServer
	}{
	{"singleton", Singleton, singletonServer},
	{"forwarded", Forwarded, r.forwardedServer},
	{"separate_process", SeparateProcess, r.separateProcessServer},
	{"experimental_workspace_module", Experimental, experimentalWorkspaceModule},
	}

	for _, tc := range tests {
	tc := tc
	config := r.defaultConfig()
	for _, opt := range opts {
	opt.set(config)
	}
	if config.modes&tc.mode == 0 {
	continue
	}
	if config.debugAddr != "" && tc.mode != Singleton {
	// Debugging is useful for running stress tests, but since the daemon has
	// likely already been started, it would be too late to debug.
	t.Fatalf("debugging regtest servers only works in Singleton mode, "+
	"got debug addr %q and mode %v", config.debugAddr, tc.mode)
	}

	t.Run(tc.name, func(t *testing.T) {
	ctx, cancel := context.WithTimeout(context.Background(), config.timeout)
	defer cancel()
	ctx = debug.WithInstance(ctx, "", "off")
	if config.debugAddr != "" {
	di := debug.GetInstance(ctx)
	di.DebugAddress = config.debugAddr
	di.Serve(ctx)
	di.MonitorMemory(ctx)
	}

	rootDir := filepath.Join(r.TempDir, filepath.FromSlash(t.Name()))
	if err := os.MkdirAll(rootDir, 0755); err != nil {
	t.Fatal(err)
	}
	if config.nestWorkdir {
	config.sandbox.Workdir = "work/nested"
	}
	config.sandbox.Files = files
	config.sandbox.RootDir = rootDir
	sandbox, err := fake.NewSandbox(&config.sandbox)
	if err != nil {
	t.Fatal(err)
	}
	workdir := sandbox.Workdir.RootURI().SpanURI().Filename()
	if config.nestWorkdir {
	// Now that we know the actual workdir, set our workspace to be the
	// parent directory.
	config.editor.WorkspaceRoot = filepath.Clean(filepath.Join(workdir, ".."))
	}
	// Deferring the closure of ws until the end of the entire test suite
	// has, in testing, given the LSP server time to properly shutdown and
	// release any file locks held in workspace, which is a problem on
	// Windows. This may still be flaky however, and in the future we need a
	// better solution to ensure that all Go processes started by gopls have
	// exited before we clean up.
	r.AddCloser(sandbox)
	ss := tc.getServer(ctx, t)
	framer := jsonrpc2.NewRawStream
	ls := &loggingFramer{}
	if !config.skipLogs {
	framer = ls.framer(jsonrpc2.NewRawStream)
	}
	ts := servertest.NewPipeServer(ctx, ss, framer)
	env := NewEnv(ctx, t, sandbox, ts, config.editor, !config.skipHooks)
	defer func() {
	if t.Failed() && r.PrintGoroutinesOnFailure {
	pprof.Lookup("goroutine").WriteTo(os.Stderr, 1)
	}
	if t.Failed() \|\| testing.Verbose() {
	ls.printBuffers(t.Name(), os.Stderr)
	}
	env.CloseEditor()
	}()
	// Always await the initial workspace load.
	env.Await(InitialWorkspaceLoad)
	test(t, env)
	})
	}
	}

	type loggingFramer struct {
	mu sync.Mutex
	buffers []*safeBuffer
	}

	// safeBuffer is a threadsafe buffer for logs.
	type safeBuffer struct {
	mu sync.Mutex
	buf bytes.Buffer
	}

	func (b *safeBuffer) Write(p []byte) (int, error) {
	b.mu.Lock()
	defer b.mu.Unlock()
	return b.buf.Write(p)
	}

	func (s *loggingFramer) framer(f jsonrpc2.Framer) jsonrpc2.Framer {
	return func(nc net.Conn) jsonrpc2.Stream {
	s.mu.Lock()
	buf := &safeBuffer{buf: bytes.Buffer{}}
	s.buffers = append(s.buffers, buf)
	s.mu.Unlock()
	stream := f(nc)
	return protocol.LoggingStream(stream, buf)
	}
	}

	func (s *loggingFramer) printBuffers(testname string, w io.Writer) {
	s.mu.Lock()
	defer s.mu.Unlock()

	for i, buf := range s.buffers {
	fmt.Fprintf(os.Stderr, "#### Start Gopls Test Logs %d of %d for %q\n", i+1, len(s.buffers), testname)
	buf.mu.Lock()
	io.Copy(w, &buf.buf)
	buf.mu.Unlock()
	fmt.Fprintf(os.Stderr, "#### End Gopls Test Logs %d of %d for %q\n", i+1, len(s.buffers), testname)
	}
	}

	func singletonServer(ctx context.Context, t *testing.T) jsonrpc2.StreamServer {
	return lsprpc.NewStreamServer(cache.New(ctx, hooks.Options), false)
	}

	func experimentalWorkspaceModule(ctx context.Context, t *testing.T) jsonrpc2.StreamServer {
	options := func(o *source.Options) {
	hooks.Options(o)
	o.ExperimentalWorkspaceModule = true
	}
	return lsprpc.NewStreamServer(cache.New(ctx, options), false)
	}

	func (r Runner) forwardedServer(ctx context.Context, t testing.T) jsonrpc2.StreamServer {
	ts := r.getTestServer()
	return lsprpc.NewForwarder("tcp", ts.Addr)
	}

	// getTestServer gets the shared test server instance to connect to, or creates
	// one if it doesn't exist.
	func (r Runner) getTestServer() servertest.TCPServer {
	r.mu.Lock()
	defer r.mu.Unlock()
	if r.ts == nil {
	ctx := context.Background()
	ctx = debug.WithInstance(ctx, "", "off")
	ss := lsprpc.NewStreamServer(cache.New(ctx, hooks.Options), false)
	r.ts = servertest.NewTCPServer(ctx, ss, nil)
	}
	return r.ts
	}

	func (r Runner) separateProcessServer(ctx context.Context, t testing.T) jsonrpc2.StreamServer {
	// TODO(rfindley): can we use the autostart behavior here, instead of
	// pre-starting the remote?
	socket := r.getRemoteSocket(t)
	return lsprpc.NewForwarder("unix", socket)
	}

	// runTestAsGoplsEnvvar triggers TestMain to run gopls instead of running
	// tests. It's a trick to allow tests to find a binary to use to start a gopls
	// subprocess.
	const runTestAsGoplsEnvvar = "_GOPLS_TEST_BINARY_RUN_AS_GOPLS"

	func (r Runner) getRemoteSocket(t testing.T) string {
	t.Helper()
	r.mu.Lock()
	defer r.mu.Unlock()
	const daemonFile = "gopls-test-daemon"
	if r.socketDir != "" {
	return filepath.Join(r.socketDir, daemonFile)
	}

	if r.GoplsPath == "" {
	t.Fatal("cannot run tests with a separate process unless a path to a gopls binary is configured")
	}
	var err error
	r.socketDir, err = ioutil.TempDir(r.TempDir, "gopls-regtest-socket")
	if err != nil {
	t.Fatalf("creating tempdir: %v", err)
	}
	socket := filepath.Join(r.socketDir, daemonFile)
	args := []string{"serve", "-listen", "unix;" + socket, "-listen.timeout", "10s"}
	cmd := exec.Command(r.GoplsPath, args...)
	cmd.Env = append(os.Environ(), runTestAsGoplsEnvvar+"=true")
	var stderr bytes.Buffer
	cmd.Stderr = &stderr
	go func() {
	if err := cmd.Run(); err != nil {
	panic(fmt.Sprintf("error running external gopls: %v\nstderr:\n%s", err, stderr.String()))
	}
	}()
	return socket
	}

	// AddCloser schedules a closer to be closed at the end of the test run. This
	// is useful for Windows in particular, as
	func (r *Runner) AddCloser(closer io.Closer) {
	r.mu.Lock()
	defer r.mu.Unlock()
	r.closers = append(r.closers, closer)
	}

	// Close cleans up resource that have been allocated to this workspace.
	func (r *Runner) Close() error {
	r.mu.Lock()
	defer r.mu.Unlock()

	var errmsgs []string
	if r.ts != nil {
	if err := r.ts.Close(); err != nil {
	errmsgs = append(errmsgs, err.Error())
	}
	}
	if r.socketDir != "" {
	if err := os.RemoveAll(r.socketDir); err != nil {
	errmsgs = append(errmsgs, err.Error())
	}
	}
	if !r.SkipCleanup {
	for _, closer := range r.closers {
	if err := closer.Close(); err != nil {
	errmsgs = append(errmsgs, err.Error())
	}
	}
	if err := os.RemoveAll(r.TempDir); err != nil {
	errmsgs = append(errmsgs, err.Error())
	}
	}
	if len(errmsgs) > 0 {
	return fmt.Errorf("errors closing the test runner:\n\t%s", strings.Join(errmsgs, "\n\t"))
	}
	return nil
	}