Method runTests

src/extension/test/vs_test_controller.ts:138–217

(debug: boolean, includeCoverage: boolean, request: vs.TestRunRequest, _token: vs.CancellationToken)

	}

	public async runTests(debug: boolean, includeCoverage: boolean, request: vs.TestRunRequest, _token: vs.CancellationToken): Promise<void> {
		const isRunningAll = !request.include;

		// If running all tests, ensure we have discovered them all first.
		if (isRunningAll)
			await this.discoverer?.ensureSuitesDiscovered();

		const testsToRun = new Set<vs.TestItem>();
		const testsToExclude = new Set<vs.TestItem>();
		(request.include ?? this.controller.items).forEach((item) => testsToRun.add(item));
		request.exclude?.forEach((item) => { testsToRun.delete(item); testsToExclude.add(item); });

		// For each item in the set, remove any of its descendants because they will be run by the parent.
		this.removeRedundantChildNodes(testsToRun);

		// Similarly, remove any excluded tests that are already excluded by their suite, because that will allow the
		// optimisation below (which requires only excluded suites) to work in more cases.
		this.removeRedundantChildNodes(testsToExclude);

		const run = this.controller.createTestRun(request);

		// Mark each node we will run as enqueued.
		this.markEnqueued(run, testsToRun, testsToExclude);

		try {
			// As an optimisation, if we're no-debug and running complete files (eg. all included or excluded items are
			// suites), we can run the "fast path" in a single `dart test` invocation.
			const nodesToRun = this.extractRunnableNodes(testsToRun);
			const nodesToExclude = this.extractRunnableNodes(testsToExclude);
			if (!debug && nodesToRun.every((item) => item instanceof SuiteNode) && nodesToExclude.every((item) => item instanceof SuiteNode)) {
				await vs.commands.executeCommand("_dart.runAllTestsWithoutDebugging", nodesToRun, nodesToExclude, includeCoverage, run, isRunningAll);
				return;
			}

			// Group into suites since we need to run each seperately (although we can run
			// multiple tests witthin one suite together).
			const testsBySuite = new Map<SuiteData, RunnableTreeNode[]>();

			nodesToRun.forEach((node) => {
				const testNodes = testsBySuite.get(node.suiteData) ?? [];
				testsBySuite.set(node.suiteData, testNodes);
				testNodes.push(node);
			});

			const command = debug
				? "_dart.startDebuggingTestsFromVsTestController"
				: "_dart.startWithoutDebuggingTestsFromVsTestController";
			const totalItems = testsBySuite.size;

			if (totalItems === 0)
				return; // Shouldn't get here
			else if (totalItems === 1) {
				const [[suite, nodes]] = testsBySuite.entries();
				await vs.commands.executeCommand(command, suite, nodes, false, includeCoverage, run, undefined);
			} else {
				const title = debug ? "Debugging" : "Running";
				await vs.window.withProgress({
					cancellable: true,