diff --git a/src/goRunTestCodelens.ts b/src/goRunTestCodelens.ts
index f53388b..587450a 100644
--- a/src/goRunTestCodelens.ts
+++ b/src/goRunTestCodelens.ts
@@ -10,21 +10,12 @@
 import { GoBaseCodeLensProvider } from './goBaseCodelens';
 import { GoDocumentSymbolProvider } from './goOutline';
 import { getBenchmarkFunctions, getTestFunctions } from './testUtils';
-import { getCurrentGoPath, getGoConfig } from './util';
+import { getGoConfig } from './util';
 
 export class GoRunTestCodeLensProvider extends GoBaseCodeLensProvider {
 	private readonly benchmarkRegex = /^Benchmark.+/;
-	private readonly debugConfig: any = {
-		name: 'Launch',
-		type: 'go',
-		request: 'launch',
-		mode: 'test',
-		env: {
-			GOPATH: getCurrentGoPath() // Passing current GOPATH to Delve as it runs in another process
-		}
-	};
 
-	public provideCodeLenses(document: TextDocument, token: CancellationToken): CodeLens[] | Thenable<CodeLens[]> {
+	public async provideCodeLenses(document: TextDocument, token: CancellationToken): Promise<CodeLens[]> {
 		if (!this.enabled) {
 			return [];
 		}
@@ -35,24 +26,19 @@
 			return [];
 		}
 
-		return Promise.all([
+		const codelenses = await Promise.all([
 			this.getCodeLensForPackage(document, token),
-			this.getCodeLensForFunctions(config, document, token)
-		]).then(([pkg, fns]) => {
-			let res: any[] = [];
-			if (pkg && Array.isArray(pkg)) {
-				res = res.concat(pkg);
-			}
-			if (fns && Array.isArray(fns)) {
-				res = res.concat(fns);
-			}
-			return res;
-		});
+			this.getCodeLensForFunctions(document, token)
+		]);
+		return ([] as CodeLens[]).concat(...codelenses);
 	}
 
 	private async getCodeLensForPackage(document: TextDocument, token: CancellationToken): Promise<CodeLens[]> {
 		const documentSymbolProvider = new GoDocumentSymbolProvider();
 		const symbols = await documentSymbolProvider.provideDocumentSymbols(document, token);
+		if (!symbols || symbols.length === 0) {
+			return [];
+		}
 		const pkg = symbols[0];
 		if (!pkg) {
 			return [];
@@ -69,7 +55,7 @@
 			})
 		];
 		if (
-			symbols[0].children.some(
+			pkg.children.some(
 				(sym) => sym.kind === vscode.SymbolKind.Function && this.benchmarkRegex.test(sym.name)
 			)
 		) {
@@ -87,54 +73,50 @@
 		return packageCodeLens;
 	}
 
-	private async getCodeLensForFunctions(
-		vsConfig: vscode.WorkspaceConfiguration,
-		document: TextDocument,
-		token: CancellationToken
-	): Promise<CodeLens[]> {
-		const codelens: CodeLens[] = [];
-
-		const testPromise = getTestFunctions(document, token).then((testFunctions) => {
-			testFunctions.forEach((func) => {
-				const runTestCmd: Command = {
+	private async getCodeLensForFunctions(document: TextDocument, token: CancellationToken): Promise<CodeLens[]> {
+		const testPromise = async (): Promise<CodeLens[]> => {
+			const testFunctions = await getTestFunctions(document, token);
+			if (!testFunctions) {
+				return [];
+			}
+			const codelens: CodeLens[] = [];
+			for (const f of testFunctions) {
+				codelens.push(new CodeLens(f.range, {
 					title: 'run test',
 					command: 'go.test.cursor',
-					arguments: [{ functionName: func.name }]
-				};
-
-				codelens.push(new CodeLens(func.range, runTestCmd));
-
-				const debugTestCmd: Command = {
+					arguments: [{ functionName: f.name }]
+				}));
+				codelens.push(new CodeLens(f.range, {
 					title: 'debug test',
 					command: 'go.debug.cursor',
-					arguments: [{ functionName: func.name }]
-				};
+					arguments: [{ functionName: f.name }]
+				}));
+			}
+			return codelens;
+		};
 
-				codelens.push(new CodeLens(func.range, debugTestCmd));
-			});
-		});
-
-		const benchmarkPromise = getBenchmarkFunctions(document, token).then((benchmarkFunctions) => {
-			benchmarkFunctions.forEach((func) => {
-				const runBenchmarkCmd: Command = {
+		const benchmarkPromise = (async (): Promise<CodeLens[]> => {
+			const benchmarkFunctions = await getBenchmarkFunctions(document, token);
+			if (!benchmarkFunctions) {
+				return [];
+			}
+			const codelens: CodeLens[] = [];
+			for (const f of benchmarkFunctions) {
+				codelens.push(new CodeLens(f.range, {
 					title: 'run benchmark',
 					command: 'go.benchmark.cursor',
-					arguments: [{ functionName: func.name }]
-				};
-
-				codelens.push(new CodeLens(func.range, runBenchmarkCmd));
-
-				const debugTestCmd: Command = {
+					arguments: [{ functionName: f.name }]
+				}));
+				codelens.push(new CodeLens(f.range, {
 					title: 'debug benchmark',
 					command: 'go.debug.cursor',
-					arguments: [{ functionName: func.name }]
-				};
-
-				codelens.push(new CodeLens(func.range, debugTestCmd));
-			});
+					arguments: [{ functionName: f.name }]
+				}));
+			}
+			return codelens;
 		});
 
-		await Promise.all([testPromise, benchmarkPromise]);
-		return codelens;
+		const codelenses = await Promise.all([testPromise(), benchmarkPromise()]);
+		return ([] as CodeLens[]).concat(...codelenses);
 	}
 }
diff --git a/test/fixtures/codelens/codelens_benchmark_test.go b/test/fixtures/codelens/codelens_benchmark_test.go
new file mode 100644
index 0000000..ecd6ed6
--- /dev/null
+++ b/test/fixtures/codelens/codelens_benchmark_test.go
@@ -0,0 +1,20 @@
+package main
+
+import (
+	"testing"
+)
+
+func BenchmarkSample(b *testing.B) {
+	b.Run("sample test passing", func(t *testing.B) {
+
+	})
+
+	b.Run("sample test failing", func(t *testing.B) {
+		t.FailNow()
+	})
+
+	testName := "dynamic test name"
+	b.Run(testName, func(t *testing.B) {
+		t.FailNow()
+	})
+}
diff --git a/test/fixtures/subtests/subtests_test.go b/test/fixtures/codelens/codelens_test.go
similarity index 100%
rename from test/fixtures/subtests/subtests_test.go
rename to test/fixtures/codelens/codelens_test.go
diff --git a/test/fixtures/subtests/go.mod b/test/fixtures/codelens/go.mod
similarity index 100%
rename from test/fixtures/subtests/go.mod
rename to test/fixtures/codelens/go.mod
diff --git a/test/integration/codelens.test.ts b/test/integration/codelens.test.ts
new file mode 100644
index 0000000..9bd80c3
--- /dev/null
+++ b/test/integration/codelens.test.ts
@@ -0,0 +1,134 @@
+/*---------------------------------------------------------
+ * Copyright (C) Microsoft Corporation. All rights reserved.
+ * Modification copyright 2020 The Go Authors. All rights reserved.
+ * Licensed under the MIT License. See LICENSE in the project root for license information.
+ *--------------------------------------------------------*/
+
+'use strict';
+
+import * as assert from 'assert';
+import fs = require('fs-extra');
+import path = require('path');
+import sinon = require('sinon');
+import vscode = require('vscode');
+import { updateGoVarsFromConfig } from '../../src/goInstallTools';
+import { GoRunTestCodeLensProvider } from '../../src/goRunTestCodelens';
+import { subTestAtCursor } from '../../src/goTest';
+import { getCurrentGoPath } from '../../src/util';
+
+suite('Code lenses for testing and benchmarking', function () {
+	this.timeout(20000);
+
+	let gopath: string;
+	let repoPath: string;
+	let fixturePath: string;
+	let fixtureSourcePath: string;
+
+	let goConfig: vscode.WorkspaceConfiguration;
+	let document: vscode.TextDocument;
+
+	const cancellationTokenSource = new vscode.CancellationTokenSource();
+	const codeLensProvider = new GoRunTestCodeLensProvider();
+
+	suiteSetup(async () => {
+		await updateGoVarsFromConfig();
+
+		gopath = getCurrentGoPath();
+		if (!gopath) {
+			assert.fail('Cannot run tests without a configured GOPATH');
+		}
+		console.log(`Using GOPATH: ${gopath}`);
+
+		// Set up the test fixtures.
+		repoPath = path.join(gopath, 'src', 'test');
+		fixturePath = path.join(repoPath, 'testfixture');
+		fixtureSourcePath = path.join(__dirname, '..', '..', '..', 'test', 'fixtures', 'codelens');
+
+		fs.removeSync(repoPath);
+		fs.copySync(fixtureSourcePath, fixturePath, {
+			recursive: true,
+			// All of the tests run in GOPATH mode for now.
+			// TODO(rstambler): Run tests in GOPATH and module mode.
+			filter: (src: string): boolean => {
+				if (path.basename(src) === 'go.mod') {
+					return false;
+				}
+				return true;
+			},
+		});
+		goConfig = vscode.workspace.getConfiguration('go');
+		const uri = vscode.Uri.file(path.join(fixturePath, 'codelens_test.go'));
+		document = await vscode.workspace.openTextDocument(uri);
+	});
+
+	suiteTeardown(() => {
+		fs.removeSync(repoPath);
+	});
+
+	teardown(() => {
+		sinon.restore();
+	});
+
+	test('Subtests - runs a test with cursor on t.Run line', async () => {
+		const editor = await vscode.window.showTextDocument(document);
+		editor.selection = new vscode.Selection(7, 4, 7, 4);
+		const result = await subTestAtCursor(goConfig, []);
+		assert.equal(result, true);
+	});
+
+	test('Subtests - runs a test with cursor within t.Run function', async () => {
+		const editor = await vscode.window.showTextDocument(document);
+		editor.selection = new vscode.Selection(8, 4, 8, 4);
+		const result = await subTestAtCursor(goConfig, []);
+		assert.equal(result, true);
+	});
+
+	test('Subtests - returns false for a failing test', async () => {
+		const editor = await vscode.window.showTextDocument(document);
+		editor.selection = new vscode.Selection(11, 4, 11, 4);
+		const result = await subTestAtCursor(goConfig, []);
+		assert.equal(result, false);
+	});
+
+	test('Subtests - does nothing for a dynamically defined subtest', async () => {
+		const editor = await vscode.window.showTextDocument(document);
+		editor.selection = new vscode.Selection(17, 4, 17, 4);
+		const result = await subTestAtCursor(goConfig, []);
+		assert.equal(result, undefined);
+	});
+
+	test('Subtests - does nothing when cursor outside of a test function', async () => {
+		const editor = await vscode.window.showTextDocument(document);
+		editor.selection = new vscode.Selection(5, 0, 5, 0);
+		const result = await subTestAtCursor(goConfig, []);
+		assert.equal(result, undefined);
+	});
+
+	test('Subtests - does nothing when no test function covers the cursor and a function name is passed in', async () => {
+		const editor = await vscode.window.showTextDocument(document);
+		editor.selection = new vscode.Selection(5, 0, 5, 0);
+		const result = await subTestAtCursor(goConfig, { functionName: 'TestMyFunction' });
+		assert.equal(result, undefined);
+	});
+
+	test('Test codelenses', async () => {
+		const codeLenses = await codeLensProvider.provideCodeLenses(document, cancellationTokenSource.token);
+		assert.equal(codeLenses.length, 4);
+		const wantCommands = ['go.test.package', 'go.test.file', 'go.test.cursor', 'go.debug.cursor'];
+		for (let i = 0; i < codeLenses.length; i++) {
+			assert.equal(codeLenses[i].command.command, wantCommands[i]);
+		}
+	});
+
+	test('Benchmark codelenses', async () => {
+		const uri = vscode.Uri.file(path.join(fixturePath, 'codelens_benchmark_test.go'));
+		const benchmarkDocument = await vscode.workspace.openTextDocument(uri);
+		const codeLenses = await codeLensProvider.provideCodeLenses(benchmarkDocument, cancellationTokenSource.token);
+		assert.equal(codeLenses.length, 6);
+		const wantCommands = ['go.test.package', 'go.test.file', 'go.benchmark.package',
+			'go.benchmark.file', 'go.benchmark.cursor', 'go.debug.cursor'];
+		for (let i = 0; i < codeLenses.length; i++) {
+			assert.equal(codeLenses[i].command.command, wantCommands[i]);
+		}
+	});
+});
diff --git a/test/integration/extension.test.ts b/test/integration/extension.test.ts
index 1299a92..b8c752d 100644
--- a/test/integration/extension.test.ts
+++ b/test/integration/extension.test.ts
@@ -28,12 +28,11 @@
 import { GoSignatureHelpProvider } from '../../src/goSignature';
 import { GoCompletionItemProvider } from '../../src/goSuggest';
 import { getWorkspaceSymbols } from '../../src/goSymbol';
-import { subTestAtCursor, testCurrentFile } from '../../src/goTest';
+import { testCurrentFile } from '../../src/goTest';
 import {
 	getBinPath,
 	getCurrentGoPath,
 	getGoConfig,
-	getGoVersion,
 	getImportPath,
 	getToolsGopath,
 	ICheckResult,
@@ -113,10 +112,6 @@
 			path.join(fixtureSourcePath, 'diffTestData', 'file2.go'),
 			path.join(fixturePath, 'diffTest2Data', 'file2.go')
 		);
-		fs.copySync(
-			path.join(fixtureSourcePath, 'subtests', 'subtests_test.go'),
-			path.join(fixturePath, 'subtests', 'subtests_test.go')
-		);
 	});
 
 	suiteTeardown(() => {
@@ -1542,76 +1537,4 @@
 		await runFillStruct(editor);
 		assert.equal(vscode.window.activeTextEditor && vscode.window.activeTextEditor.document.getText(), golden);
 	});
-
-	test('Subtests - runs a test with cursor on t.Run line', async () => {
-		const config = vscode.workspace.getConfiguration('go');
-		const uri = vscode.Uri.file(path.join(fixturePath, 'subtests', 'subtests_test.go'));
-		const document = await vscode.workspace.openTextDocument(uri);
-		const editor = await vscode.window.showTextDocument(document);
-		const selection = new vscode.Selection(7, 4, 7, 4);
-		editor.selection = selection;
-
-		const result = await subTestAtCursor(config, []);
-		assert.equal(result, true);
-	});
-
-	test('Subtests - runs a test with cursor within t.Run function', async () => {
-		const config = vscode.workspace.getConfiguration('go');
-		const uri = vscode.Uri.file(path.join(fixturePath, 'subtests', 'subtests_test.go'));
-		const document = await vscode.workspace.openTextDocument(uri);
-		const editor = await vscode.window.showTextDocument(document);
-		const selection = new vscode.Selection(8, 4, 8, 4);
-		editor.selection = selection;
-
-		const result = await subTestAtCursor(config, []);
-		assert.equal(result, true);
-	});
-
-	test('Subtests - returns false for a failing test', async () => {
-		const config = vscode.workspace.getConfiguration('go');
-		const uri = vscode.Uri.file(path.join(fixturePath, 'subtests', 'subtests_test.go'));
-		const document = await vscode.workspace.openTextDocument(uri);
-		const editor = await vscode.window.showTextDocument(document);
-		const selection = new vscode.Selection(11, 4, 11, 4);
-		editor.selection = selection;
-
-		const result = await subTestAtCursor(config, []);
-		assert.equal(result, false);
-	});
-
-	test('Subtests - does nothing for a dynamically defined subtest', async () => {
-		const config = vscode.workspace.getConfiguration('go');
-		const uri = vscode.Uri.file(path.join(fixturePath, 'subtests', 'subtests_test.go'));
-		const document = await vscode.workspace.openTextDocument(uri);
-		const editor = await vscode.window.showTextDocument(document);
-		const selection = new vscode.Selection(17, 4, 17, 4);
-		editor.selection = selection;
-
-		const result = await subTestAtCursor(config, []);
-		assert.equal(result, undefined);
-	});
-
-	test('Subtests - does nothing when cursor outside of a test function', async () => {
-		const config = vscode.workspace.getConfiguration('go');
-		const uri = vscode.Uri.file(path.join(fixturePath, 'subtests', 'subtests_test.go'));
-		const document = await vscode.workspace.openTextDocument(uri);
-		const editor = await vscode.window.showTextDocument(document);
-		const selection = new vscode.Selection(5, 0, 5, 0);
-		editor.selection = selection;
-
-		const result = await subTestAtCursor(config, []);
-		assert.equal(result, undefined);
-	});
-
-	test('Subtests - does nothing when no test function covers the cursor and a function name is passed in', async () => {
-		const config = vscode.workspace.getConfiguration('go');
-		const uri = vscode.Uri.file(path.join(fixturePath, 'subtests', 'subtests_test.go'));
-		const document = await vscode.workspace.openTextDocument(uri);
-		const editor = await vscode.window.showTextDocument(document);
-		const selection = new vscode.Selection(5, 0, 5, 0);
-		editor.selection = selection;
-
-		const result = await subTestAtCursor(config, {functionName: 'TestMyFunction'});
-		assert.equal(result, undefined);
-	});
 });
diff --git a/test/integration/index.ts b/test/integration/index.ts
index 12e0292..a86f9cd 100644
--- a/test/integration/index.ts
+++ b/test/integration/index.ts
@@ -15,7 +15,7 @@
 	const testsRoot = path.resolve(__dirname, '..');
 
 	return new Promise((c, e) => {
-		glob('integration/**.test.js', { cwd: testsRoot }, (err, files) => {
+		glob('integration/codelens.test.js', { cwd: testsRoot }, (err, files) => {
 			if (err) {
 				return e(err);
 			}