├── .eslintrc.json
├── .gitignore
├── .vscode
├── extensions.json
├── launch.json
├── settings.json
└── tasks.json
├── .vscodeignore
├── CHANGELOG.md
├── LICENCE
├── README.md
├── html_report
└── overview_template.html
├── images
├── code_highlight_example.png
└── template_example.png
├── package-lock.json
├── package.json
├── src
├── arrayUtils.ts
├── coverageCache.ts
├── extension.ts
├── fsScanning.ts
└── gcovInterface.ts
└── tsconfig.json
/.eslintrc.json:
--------------------------------------------------------------------------------
1 | {
2 | "root": true,
3 | "parser": "@typescript-eslint/parser",
4 | "parserOptions": {
5 | "ecmaVersion": 6,
6 | "sourceType": "module"
7 | },
8 | "plugins": [
9 | "@typescript-eslint"
10 | ],
11 | "rules": {
12 | "@typescript-eslint/class-name-casing": "warn",
13 | "@typescript-eslint/semi": "warn",
14 | "curly": "warn",
15 | "eqeqeq": "warn",
16 | "no-throw-literal": "warn",
17 | "semi": "off"
18 | }
19 | }
20 |
--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
1 | out
2 | node_modules
3 | .vscode-test/
4 | *.vsix
5 |
--------------------------------------------------------------------------------
/.vscode/extensions.json:
--------------------------------------------------------------------------------
1 | {
2 | // See http://go.microsoft.com/fwlink/?LinkId=827846
3 | // for the documentation about the extensions.json format
4 | "recommendations": [
5 | "dbaeumer.vscode-eslint"
6 | ]
7 | }
8 |
--------------------------------------------------------------------------------
/.vscode/launch.json:
--------------------------------------------------------------------------------
1 | // A launch configuration that compiles the extension and then opens it inside a new window
2 | // Use IntelliSense to learn about possible attributes.
3 | // Hover to view descriptions of existing attributes.
4 | // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
5 | {
6 | "version": "0.2.0",
7 | "configurations": [
8 | {
9 | "name": "Run Extension",
10 | "type": "extensionHost",
11 | "request": "launch",
12 | "runtimeExecutable": "${execPath}",
13 | "args": [
14 | "--extensionDevelopmentPath=${workspaceFolder}"
15 | ],
16 | "outFiles": [
17 | "${workspaceFolder}/out/**/*.js"
18 | ],
19 | "preLaunchTask": "${defaultBuildTask}"
20 | }
21 | ]
22 | }
23 |
--------------------------------------------------------------------------------
/.vscode/settings.json:
--------------------------------------------------------------------------------
1 | // Place your settings in this file to overwrite default and user settings.
2 | {
3 | "files.exclude": {
4 | "out": false // set this to true to hide the "out" folder with the compiled JS files
5 | },
6 | "search.exclude": {
7 | "out": true // set this to false to include "out" folder in search results
8 | },
9 | // Turn off tsc task auto detection since we have the necessary tasks as npm scripts
10 | "typescript.tsc.autoDetect": "off",
11 | "editor.formatOnSave": true,
12 | "editor.defaultFormatter": "esbenp.prettier-vscode"
13 | }
14 |
--------------------------------------------------------------------------------
/.vscode/tasks.json:
--------------------------------------------------------------------------------
1 | // See https://go.microsoft.com/fwlink/?LinkId=733558
2 | // for the documentation about the tasks.json format
3 | {
4 | "version": "2.0.0",
5 | "tasks": [
6 | {
7 | "type": "npm",
8 | "script": "watch",
9 | "problemMatcher": "$tsc-watch",
10 | "isBackground": true,
11 | "presentation": {
12 | "reveal": "never"
13 | },
14 | "group": {
15 | "kind": "build",
16 | "isDefault": true
17 | }
18 | }
19 | ]
20 | }
21 |
--------------------------------------------------------------------------------
/.vscodeignore:
--------------------------------------------------------------------------------
1 | .vscode/**
2 | .vscode-test/**
3 | out/test/**
4 | src/**
5 | .gitignore
6 | vsc-extension-quickstart.md
7 | **/tsconfig.json
8 | **/.eslintrc.json
9 | **/*.map
10 | **/*.ts
11 |
--------------------------------------------------------------------------------
/CHANGELOG.md:
--------------------------------------------------------------------------------
1 | ## Unreleased
2 |
3 | ## 0.6.0 - 2024-07-22
4 |
5 | ### Changed
6 |
7 | - The gcov binary can now be overridden per workspace or folder.
8 |
9 | ### Fixed
10 |
11 | - Slightly improved error reporting when invoking gcov.
12 |
13 | ## 0.5.0 - 2022-12-04
14 |
15 | ### Added
16 |
17 | - Show function coverage in percent.
18 | - Show file coverage in status bar.
19 | - New `Generate Summary as HTML` command.
20 |
21 | ### Changed
22 |
23 | - The `View Functions by Call Count` command now shortens templated function names.
24 |
25 | ## 0.4.0 - 2020-08-26
26 |
27 | ### Fixed
28 |
29 | - Better support for Windows paths when using MinGW-gcc.
30 |
31 | ## 0.3.0 - 2020-07-11
32 |
33 | ### Changed
34 |
35 | - Suggest using `--coverage` instead of `-fprofile-arcs -ftest-coverage` in readme.
36 | - Sort lines in tooltip by call count.
37 | - Improve error messages.
38 |
39 | ## 0.2.0 - 2020-06-21
40 |
41 | ### Changed
42 |
43 | - Renamed "include directories" to "build directories".
44 | - Improved error message when no .gcda files have been found.
45 | - Make gcc version requirement a bit more clear in readme.
46 |
47 | ## 0.1.0 - 2020-06-20
48 |
49 | ### Added
50 |
51 | - New `Gcov Viewer: Show` command.
52 | - New `Gcov Viewer: Hide` command.
53 | - New `Gcov Viewer: Toggle` command.
54 | - New `Gcov Viewer: Reload .gcda Files` command.
55 | - New `Gcov Viewer: Delete .gcda Files` command.
56 | - New `Gcov Viewer: Select Include Directory` command.
57 | - New `Gcov Viewer: Dump Paths with Coverage Data` command.
58 | - New `Gcov Viewer: View Functions by Call Count` command.
59 | - New `gcovViewer.includeDirectories` setting.
60 | - New `gcovViewer.gcovBinary` setting.
61 | - New `gcovViewer.highlightMissedLines` setting.
62 |
--------------------------------------------------------------------------------
/LICENCE:
--------------------------------------------------------------------------------
1 | MIT License
2 |
3 | Copyright (c) 2020 Jacques Lucke
4 |
5 | Permission is hereby granted, free of charge, to any person obtaining a copy
6 | of this software and associated documentation files (the "Software"), to deal
7 | in the Software without restriction, including without limitation the rights
8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 |
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 |
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 |
--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | # Gcov Viewer
2 |
3 | [Gcov](https://gcc.gnu.org/onlinedocs/gcc/Gcov.html) is a tool you can use in conjunction with GCC to test code coverage in your programs. This extension visualizes the output of gcov in Visual Studio Code. It allows you to see which lines of the program have been executed and how often.
4 |
5 | ## Usage
6 |
7 | 1. Compile your code with `gcc`/`g++` (version >= 9) with `--coverage` and without optimizations.
8 | 2. Run your program or tests.
9 | 3. Open a source file in vscode and use `ctrl+shift+P` to run the `Gcov Viewer: Show` command.
10 |
11 | During compilation, `gcc` will generate a `.gcno` file next to every `.o` file. When you run the program, it will create `.gcda` files in the same location. Those contain information about how often functions and lines have been executed.
12 |
13 | This vscode extension uses the `gcov` program to parse these additional files and displays the information on top of your source files. For this to work, it has to find the generated `.gcda` for a given project. Those are usually in your build directory. If the extension does not find them on its own, you have to edit the `gcovViewer.buildDirectories` setting of your workspace folder. The most convenient way to do this is to use the `Gcov Viewer: Select Build Directory` command.
14 |
15 | ## Troubleshooting
16 |
17 | - Try passing `-fprofile-abs-path` to gcc. This helps the extension to match source files with their corresponding coverage data.
18 |
19 | ## Known Issues
20 |
21 | - Sometimes lines are counted more than once when they do more than one thing. That might be confusing in some cases. Usually it is quite easy to get the correct number by looking at neighboring lines.
22 | - When the `Highlight Missed Lines` setting is enabled, some missed lines might not be marked as such.
23 |
24 | ## Limitations
25 |
26 | - Only works with version 9 or higher of `gcc`, `g++` and `gcov`. If you have multiple versions of `gcov`, you might have to change the `Gcov Binary` setting.
27 |
28 | ## Screenshots
29 |
30 | 
31 | 
32 |
--------------------------------------------------------------------------------
/html_report/overview_template.html:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 | Coverage Results
5 |
6 |
46 |
47 | = new Map();
14 | demangledNames: Map = new Map();
15 | loadedGcdaFiles: string[] = [];
16 |
17 | async loadGcdaFiles(gcdaPaths: string[]) {
18 | const gcovDataArray = await loadGcovData(gcdaPaths);
19 |
20 | for (const gcovData of gcovDataArray) {
21 | for (const fileData of gcovData.files) {
22 | let fileCoverage = this.dataByFile.get(fileData.file);
23 | if (fileCoverage === undefined) {
24 | fileCoverage = new FileCoverage(fileData.file);
25 | this.dataByFile.set(fileData.file, fileCoverage);
26 | }
27 |
28 | fileCoverage.rawLines.push(...fileData.lines);
29 | fileCoverage.rawFunctions.push(...fileData.functions);
30 |
31 | for (const functionData of fileData.functions) {
32 | this.demangledNames.set(
33 | functionData.name,
34 | functionData.demangled_name
35 | );
36 | }
37 | }
38 | }
39 | this.loadedGcdaFiles.push(...gcdaPaths);
40 | }
41 |
42 | hasData() {
43 | return this.loadedGcdaFiles.length > 0;
44 | }
45 | }
46 |
47 | export class FileCoverage {
48 | path: string;
49 | rawLines: GcovLineData[] = [];
50 | rawFunctions: GcovFunctionData[] = [];
51 |
52 | calledLines?: number;
53 | totalLines?: number;
54 | maxLine?: number;
55 | dataByLine?: Map;
56 | functionsByStart?: Map;
57 |
58 | constructor(path: string) {
59 | this.path = path;
60 | }
61 |
62 | ensureAnalysed() {
63 | this.ensureFileCoverate();
64 | this.ensureLineCoverage();
65 | this.ensureFunctionCoverage();
66 | }
67 |
68 | ensureFileCoverate() {
69 | if (this.calledLines !== undefined) {
70 | return;
71 | }
72 | this.ensureLineCoverage();
73 | this.totalLines = this.dataByLine?.size;
74 | this.calledLines = 0;
75 | for (const lineCoverage of this.dataByLine!.values()) {
76 | if (lineCoverage.executionCount > 0) {
77 | this.calledLines++;
78 | }
79 | }
80 | }
81 |
82 | ensureLineCoverage() {
83 | if (this.dataByLine !== undefined) {
84 | return;
85 | }
86 | this.maxLine = -1;
87 | this.dataByLine = new Map();
88 | for (const rawLine of this.rawLines) {
89 | const line = rawLineToIndex(rawLine.line_number);
90 | let lineCoverage = this.dataByLine.get(line);
91 | if (lineCoverage === undefined) {
92 | lineCoverage = {
93 | line,
94 | raw: [],
95 | executionCount: 0,
96 | };
97 | this.dataByLine.set(line, lineCoverage);
98 | }
99 | lineCoverage.raw.push(rawLine);
100 | lineCoverage.executionCount += rawLine.count;
101 | if (line > this.maxLine) {
102 | this.maxLine = line;
103 | }
104 | }
105 | }
106 |
107 | ensureFunctionCoverage() {
108 | if (this.functionsByStart !== undefined) {
109 | return;
110 | }
111 | this.ensureLineCoverage();
112 |
113 | this.functionsByStart = new Map();
114 | for (const rawFunction of this.rawFunctions) {
115 | const startLine = rawLineToIndex(rawFunction.start_line);
116 | const endLine = rawLineToIndex(rawFunction.end_line);
117 | let functionCoverage = this.functionsByStart.get(startLine);
118 | if (functionCoverage === undefined) {
119 | functionCoverage = {
120 | startLine: startLine,
121 | endLine: endLine,
122 | baseName: extractCoreFunctionName(rawFunction.demangled_name),
123 | executionCount: 0,
124 | raw: [],
125 | calledLines: 0,
126 | totalLines: 0,
127 | };
128 | this.functionsByStart.set(startLine, functionCoverage);
129 | }
130 | functionCoverage.executionCount += rawFunction.execution_count;
131 | functionCoverage.raw.push(rawFunction);
132 | }
133 | for (const functionCoverage of this.functionsByStart.values()) {
134 | for (
135 | let line = functionCoverage.startLine;
136 | line <= functionCoverage.endLine;
137 | line++
138 | ) {
139 | const lineCoverage = this.dataByLine?.get(line);
140 | if (lineCoverage === undefined) {
141 | continue;
142 | }
143 | functionCoverage.totalLines++;
144 | if (lineCoverage.executionCount > 0) {
145 | functionCoverage.calledLines++;
146 | }
147 | }
148 | }
149 | }
150 | }
151 |
152 | export interface LineCoverage {
153 | line: number;
154 | raw: GcovLineData[];
155 | executionCount: number;
156 | }
157 |
158 | export interface FunctionCoverage {
159 | startLine: number;
160 | endLine: number;
161 | raw: GcovFunctionData[];
162 | baseName: string;
163 | executionCount: number;
164 | calledLines: number;
165 | totalLines: number;
166 | }
167 |
168 | function extractCoreFunctionName(demangledName: string) {
169 | /* Remove parts in parenthesis and templates. */
170 | let name = "";
171 | let templateDepth = 0;
172 | let parenthesisDepth = 0;
173 | let lastClosingParenthesis = 0;
174 | for (const c of demangledName) {
175 | if (c === "(") {
176 | parenthesisDepth++;
177 | } else if (c === ")") {
178 | parenthesisDepth--;
179 | if (parenthesisDepth === 0) {
180 | lastClosingParenthesis = name.length;
181 | }
182 | } else if (c == "<") {
183 | templateDepth++;
184 | } else if (c == ">") {
185 | templateDepth--;
186 | if (parenthesisDepth === 0 && templateDepth === 0) {
187 | name += "<...>";
188 | }
189 | } else if (parenthesisDepth === 0 && templateDepth == 0) {
190 | name += c;
191 | }
192 | }
193 | /* Remove possible stuff after the parameter list. */
194 | name = name.slice(0, lastClosingParenthesis);
195 | /* Remove return value. */
196 | name = name.split(" ").pop()!;
197 | /* Fix case for call operator. */
198 | if (name.endsWith("::operator")) {
199 | name += "()";
200 | }
201 | return name;
202 | }
203 |
204 | /** Lines in gcov start counting at 1. */
205 | function rawLineToIndex(lineNumber: number) {
206 | return lineNumber - 1;
207 | }
208 |
--------------------------------------------------------------------------------
/src/extension.ts:
--------------------------------------------------------------------------------
1 | import * as vscode from "vscode";
2 | import * as fs from "fs";
3 | import * as util from "util";
4 | import * as os from "os";
5 | import * as tmp from "tmp";
6 | import * as fs_path from "path";
7 | import {
8 | GcovLineData,
9 | isGcovCompatible,
10 | GcovFunctionData,
11 | GcovFileData,
12 | } from "./gcovInterface";
13 | import { findAllFilesRecursively } from "./fsScanning";
14 | import { splitArrayInChunks, shuffleArray } from "./arrayUtils";
15 | import {
16 | CoverageCache,
17 | FileCoverage,
18 | LineCoverage,
19 | FunctionCoverage,
20 | } from "./coverageCache";
21 |
22 | let isShowingDecorations: boolean = false;
23 | let coverageStatusBarItem: vscode.StatusBarItem;
24 |
25 | export function activate(context: vscode.ExtensionContext) {
26 | const commands: [string, any][] = [
27 | ["gcov-viewer.show", COMMAND_showDecorations],
28 | ["gcov-viewer.hide", COMMAND_hideDecorations],
29 | ["gcov-viewer.toggle", COMMAND_toggleDecorations],
30 | ["gcov-viewer.reloadGcdaFiles", COMMAND_reloadGcdaFiles],
31 | ["gcov-viewer.deleteGcdaFiles", COMMAND_deleteGcdaFiles],
32 | ["gcov-viewer.selectBuildDirectory", COMMAND_selectBuildDirectory],
33 | [
34 | "gcov-viewer.dumpPathsWithCoverageData",
35 | COMMAND_dumpPathsWithCoverageData,
36 | ],
37 | ["gcov-viewer.viewFunctionsByCallCount", COMMAND_viewFunctionsByCallCount],
38 | ["gcov-viewer.generateSummaryHTML", COMMAND_generateSummaryHTML],
39 | ];
40 |
41 | for (const item of commands) {
42 | context.subscriptions.push(
43 | vscode.commands.registerCommand(item[0], item[1])
44 | );
45 | }
46 |
47 | coverageStatusBarItem = vscode.window.createStatusBarItem(
48 | vscode.StatusBarAlignment.Right,
49 | 100
50 | );
51 | context.subscriptions.push(coverageStatusBarItem);
52 |
53 | vscode.window.onDidChangeVisibleTextEditors(async (editors) => {
54 | if (isShowingDecorations) {
55 | await COMMAND_showDecorations();
56 | }
57 | });
58 | vscode.workspace.onDidChangeConfiguration(async () => {
59 | if (isShowingDecorations) {
60 | await COMMAND_showDecorations();
61 | }
62 | });
63 | vscode.window.onDidChangeActiveTextEditor(updateStatusBar);
64 | }
65 |
66 | export function deactivate() {}
67 |
68 | const calledLineColor = "rgba(50, 240, 50, 0.1)";
69 | const calledLinesDecorationType = vscode.window.createTextEditorDecorationType({
70 | isWholeLine: true,
71 | backgroundColor: calledLineColor,
72 | overviewRulerColor: calledLineColor,
73 | rangeBehavior: vscode.DecorationRangeBehavior.ClosedClosed,
74 | });
75 |
76 | const missedLineColor = "rgba(240, 50, 50, 0.1)";
77 | const missedLinesDecorationType = vscode.window.createTextEditorDecorationType({
78 | isWholeLine: true,
79 | backgroundColor: missedLineColor,
80 | overviewRulerColor: missedLineColor,
81 | rangeBehavior: vscode.DecorationRangeBehavior.ClosedClosed,
82 | });
83 |
84 | function getWorkspaceFolderConfig(workspaceFolder: vscode.WorkspaceFolder) {
85 | return vscode.workspace.getConfiguration("gcovViewer", workspaceFolder);
86 | }
87 |
88 | function getTextDocumentConfig(document: vscode.TextDocument) {
89 | return vscode.workspace.getConfiguration("gcovViewer", document);
90 | }
91 |
92 | function getBuildDirectories(): string[] {
93 | if (vscode.workspace.workspaceFolders === undefined) {
94 | return [];
95 | }
96 |
97 | const buildDirectories: string[] = [];
98 | const workspaceFolderPaths: string[] = [];
99 | for (const workspaceFolder of vscode.workspace.workspaceFolders) {
100 | workspaceFolderPaths.push(workspaceFolder.uri.fsPath);
101 | const config = getWorkspaceFolderConfig(workspaceFolder);
102 | const dirs = config.get("buildDirectories");
103 | if (dirs !== undefined) {
104 | for (let dir of dirs) {
105 | dir = dir.replace("${workspaceFolder}", workspaceFolder.uri.fsPath);
106 | buildDirectories.push(dir);
107 | }
108 | }
109 | }
110 | if (buildDirectories.length === 0) {
111 | buildDirectories.push(...workspaceFolderPaths);
112 | }
113 | return buildDirectories;
114 | }
115 |
116 | async function getGcdaPaths(
117 | progress?: MyProgress,
118 | token?: vscode.CancellationToken
119 | ) {
120 | progress?.report({ message: "Searching .gcda files" });
121 | const buildDirectories = getBuildDirectories();
122 |
123 | let counter = 0;
124 | const gcdaPaths: Set = new Set();
125 | for (const buildDirectory of buildDirectories) {
126 | await findAllFilesRecursively(
127 | buildDirectory,
128 | (path) => {
129 | if (path.endsWith(".gcda")) {
130 | gcdaPaths.add(path);
131 | }
132 | counter++;
133 | progress?.report({
134 | message: `[${counter}] Scanning (found ${gcdaPaths.size}): ${path}`,
135 | });
136 | },
137 | token
138 | );
139 | }
140 |
141 | return Array.from(gcdaPaths);
142 | }
143 |
144 | let coverageCache = new CoverageCache();
145 |
146 | type MyProgress = vscode.Progress<{ message?: string; increment?: number }>;
147 |
148 | async function reloadCoverageDataFromPaths(
149 | paths: string[],
150 | totalPaths: number,
151 | progress: MyProgress,
152 | token: vscode.CancellationToken
153 | ) {
154 | /* Process multiple paths per gcov invocation to avoid some overhead.
155 | * Don't process too many files at once so that the progress bar looks more active. */
156 | const chunks = splitArrayInChunks(paths, Math.ceil(paths.length / 30));
157 | for (const pathsChunk of chunks) {
158 | if (token.isCancellationRequested) {
159 | return;
160 | }
161 |
162 | await coverageCache.loadGcdaFiles(pathsChunk);
163 |
164 | progress.report({
165 | increment: (100 * pathsChunk.length) / totalPaths,
166 | message: `[${coverageCache.loadedGcdaFiles.length}/${totalPaths}] Parsing`,
167 | });
168 | }
169 | }
170 |
171 | function showNoFilesFoundMessage() {
172 | const message = `
173 | Cannot find any coverage data (.gcda files). Possible problems:
174 | 1) You have not built your program with --coverage.
175 | 2) The build directory is located somewhere else, you have to specify it using the button below.
176 | 3) You have not run the program yet.
177 | `;
178 |
179 | vscode.window
180 | .showErrorMessage(message, "Select Build Directory")
181 | .then((value) => {
182 | if (value === "Select Build Directory") {
183 | COMMAND_selectBuildDirectory();
184 | }
185 | });
186 | }
187 |
188 | async function reloadGcdaFiles() {
189 | if (!(await isGcovCompatible())) {
190 | return;
191 | }
192 | await vscode.window.withProgress(
193 | {
194 | location: vscode.ProgressLocation.Notification,
195 | cancellable: true,
196 | title: "Reload Coverage Data",
197 | },
198 | async (progress, token) => {
199 | coverageCache = new CoverageCache();
200 | progress.report({ increment: 0 });
201 |
202 | const gcdaPaths = await getGcdaPaths(progress, token);
203 | if (gcdaPaths.length === 0) {
204 | showNoFilesFoundMessage();
205 | return;
206 | }
207 |
208 | /* Shuffle paths make the processing time of the individual chunks more similar. */
209 | shuffleArray(gcdaPaths);
210 | const pathChunks = splitArrayInChunks(gcdaPaths, os.cpus().length);
211 |
212 | /* Process chunks asynchronously, so that gcov is invoked multiple times in parallel. */
213 | const promises = [];
214 | for (const pathChunk of pathChunks) {
215 | promises.push(
216 | reloadCoverageDataFromPaths(
217 | pathChunk,
218 | gcdaPaths.length,
219 | progress,
220 | token
221 | )
222 | );
223 | }
224 | await Promise.all(promises);
225 | }
226 | );
227 | }
228 |
229 | async function COMMAND_reloadGcdaFiles() {
230 | await reloadGcdaFiles();
231 | await showDecorations();
232 | updateStatusBar();
233 | }
234 |
235 | async function COMMAND_deleteGcdaFiles() {
236 | coverageCache = new CoverageCache();
237 |
238 | await vscode.window.withProgress(
239 | {
240 | location: vscode.ProgressLocation.Notification,
241 | cancellable: true,
242 | title: "Delete .gcda files",
243 | },
244 | async (progress, token) => {
245 | await COMMAND_hideDecorations();
246 | isShowingDecorations = false;
247 | progress.report({ increment: 0 });
248 | const paths = await getGcdaPaths(progress, token);
249 | const increment = 100 / paths.length;
250 | for (const [i, path] of paths.entries()) {
251 | if (token.isCancellationRequested) {
252 | return;
253 | }
254 | await util.promisify(fs.unlink)(path);
255 | progress.report({
256 | increment: increment,
257 | message: `[${i}/${paths.length}] Delete`,
258 | });
259 | }
260 | }
261 | );
262 | }
263 |
264 | async function COMMAND_toggleDecorations() {
265 | if (isShowingDecorations) {
266 | await COMMAND_hideDecorations();
267 | } else {
268 | await COMMAND_showDecorations();
269 | }
270 | }
271 |
272 | async function COMMAND_hideDecorations() {
273 | for (const editor of vscode.window.visibleTextEditors) {
274 | editor.setDecorations(calledLinesDecorationType, []);
275 | editor.setDecorations(missedLinesDecorationType, []);
276 | }
277 | isShowingDecorations = false;
278 | updateStatusBar();
279 | }
280 |
281 | async function showDecorations() {
282 | for (const editor of vscode.window.visibleTextEditors) {
283 | await decorateEditor(editor);
284 | }
285 | if (coverageCache.hasData()) {
286 | isShowingDecorations = true;
287 | }
288 | }
289 |
290 | async function COMMAND_showDecorations() {
291 | if (!isCoverageDataLoaded()) {
292 | await reloadGcdaFiles();
293 | }
294 | await showDecorations();
295 | updateStatusBar();
296 | }
297 |
298 | function findCachedDataForFile(absolutePath: string): FileCoverage | undefined {
299 | /* Check if there is cached data for the exact path. */
300 | const dataOfFile = coverageCache.dataByFile.get(absolutePath);
301 | if (dataOfFile !== undefined) {
302 | return dataOfFile;
303 | }
304 | /* Path of win32 is case insensitive and path separators may be different. */
305 | if (os.platform() === "win32") {
306 | const absolutePathWin = absolutePath.replace(/\\/g, "/").toLowerCase();
307 | for (const [storedPath, dataOfFile] of coverageCache.dataByFile.entries()) {
308 | if (
309 | storedPath.toLowerCase() === absolutePathWin &&
310 | dataOfFile !== undefined
311 | ) {
312 | return dataOfFile;
313 | }
314 | }
315 | }
316 | /* Try to guess which cached data belongs to the given path.
317 | * This might have to be improved in the future when we learn more about
318 | * the ways this can fail. */
319 | for (const [storedPath, dataOfFile] of coverageCache.dataByFile.entries()) {
320 | if (absolutePath.endsWith(storedPath)) {
321 | return dataOfFile;
322 | }
323 | }
324 | return undefined;
325 | }
326 |
327 | function isCoverageDataLoaded() {
328 | return coverageCache.dataByFile.size > 0;
329 | }
330 |
331 | function groupData(
332 | values: T[],
333 | getKey: (value: T) => Key
334 | ): Map {
335 | const map: Map = new Map();
336 | for (const value of values) {
337 | const key: Key = getKey(value);
338 | if (map.get(key)?.push(value) === undefined) {
339 | map.set(key, [value]);
340 | }
341 | }
342 | return map;
343 | }
344 |
345 | function computeSum(values: T[], getSummand: (value: T) => number) {
346 | return values.reduce((sum, value) => sum + getSummand(value), 0);
347 | }
348 |
349 | function sumTotalCalls(lines: GcovLineData[]): number {
350 | return computeSum(lines, (x) => x.count);
351 | }
352 |
353 | function createRangeForLine(lineIndex: number) {
354 | return new vscode.Range(
355 | new vscode.Position(lineIndex, 0),
356 | new vscode.Position(lineIndex, 100000)
357 | );
358 | }
359 |
360 | function createTooltipForCalledLine(
361 | lineDataByFunction: Map
362 | ) {
363 | const tooltipLinesWithCallCount: [string, number][] = [];
364 | for (const [functionName, dataArray] of lineDataByFunction.entries()) {
365 | let count = computeSum(dataArray, (x) => x.count);
366 | if (count > 0) {
367 | const demangledName = coverageCache.demangledNames.get(functionName)!;
368 | const tooltipLine = `${count.toLocaleString()}x in \`${demangledName}\`\n\n`;
369 | tooltipLinesWithCallCount.push([tooltipLine, count]);
370 | }
371 | }
372 | tooltipLinesWithCallCount.sort((a, b) => b[1] - a[1]);
373 | const tooltip = tooltipLinesWithCallCount.map((x) => x[0]).join("\n");
374 | return tooltip;
375 | }
376 |
377 | function createMissedLineDecoration(range: vscode.Range) {
378 | const decoration: vscode.DecorationOptions = {
379 | range: range,
380 | hoverMessage: "Line has not been executed",
381 | };
382 | return decoration;
383 | }
384 |
385 | function createCalledLineDecoration(
386 | range: vscode.Range,
387 | lineCoverage: LineCoverage,
388 | functionCoverage: FunctionCoverage | undefined
389 | ) {
390 | const calls = lineCoverage.executionCount;
391 | const isFunctionStart = functionCoverage !== undefined;
392 | const rawLineDataByFunction = groupData(
393 | lineCoverage.raw,
394 | (x) => x.function_name
395 | );
396 | const tooltip = createTooltipForCalledLine(rawLineDataByFunction);
397 | let text = ` ${calls.toLocaleString()}x`;
398 | if (isFunctionStart) {
399 | const coveratePercentage =
400 | (functionCoverage.calledLines / functionCoverage.totalLines) * 100;
401 | text += ` [${Number(coveratePercentage).toFixed(1)}%]`;
402 | }
403 | const decoration: vscode.DecorationOptions = {
404 | range: range,
405 | hoverMessage: tooltip,
406 | renderOptions: {
407 | after: {
408 | contentText: text,
409 | color: new vscode.ThemeColor("editorCodeLens.foreground"),
410 | fontStyle: "italic",
411 | },
412 | },
413 | };
414 | return decoration;
415 | }
416 |
417 | class LineDecorationsGroup {
418 | calledLineDecorations: vscode.DecorationOptions[] = [];
419 | missedLineDecorations: vscode.DecorationOptions[] = [];
420 | }
421 |
422 | function createDecorationsForFile(
423 | fileCoverage: FileCoverage
424 | ): LineDecorationsGroup {
425 | const decorations = new LineDecorationsGroup();
426 |
427 | fileCoverage.ensureAnalysed();
428 |
429 | for (let line = 0; line < fileCoverage.maxLine!; line++) {
430 | const lineCoverage = fileCoverage.dataByLine?.get(line);
431 | if (lineCoverage === undefined) {
432 | continue;
433 | }
434 | const functionCoverage = fileCoverage.functionsByStart?.get(line);
435 | const range = createRangeForLine(line);
436 |
437 | if (lineCoverage.executionCount === 0) {
438 | decorations.missedLineDecorations.push(createMissedLineDecoration(range));
439 | } else {
440 | decorations.calledLineDecorations.push(
441 | createCalledLineDecoration(range, lineCoverage, functionCoverage)
442 | );
443 | }
444 | }
445 |
446 | return decorations;
447 | }
448 |
449 | async function decorateEditor(editor: vscode.TextEditor) {
450 | const path = editor.document.uri.fsPath;
451 | const fileCoverage = findCachedDataForFile(path);
452 | if (fileCoverage === undefined) {
453 | return;
454 | }
455 |
456 | const config = getTextDocumentConfig(editor.document);
457 |
458 | const decorations = createDecorationsForFile(fileCoverage);
459 | editor.setDecorations(
460 | calledLinesDecorationType,
461 | decorations.calledLineDecorations
462 | );
463 | if (config.get("highlightMissedLines")) {
464 | editor.setDecorations(
465 | missedLinesDecorationType,
466 | decorations.missedLineDecorations
467 | );
468 | } else {
469 | editor.setDecorations(missedLinesDecorationType, []);
470 | }
471 | }
472 |
473 | async function COMMAND_selectBuildDirectory() {
474 | if (vscode.workspace.workspaceFolders === undefined) {
475 | return;
476 | }
477 |
478 | const value = await vscode.window.showOpenDialog({
479 | canSelectFiles: false,
480 | canSelectFolders: true,
481 | canSelectMany: true,
482 | openLabel: "Select Build Directory",
483 | });
484 | if (value === undefined) {
485 | return;
486 | }
487 |
488 | const paths: string[] = [];
489 | for (const uri of value) {
490 | paths.push(uri.fsPath);
491 | }
492 |
493 | for (const workspaceFolder of vscode.workspace.workspaceFolders) {
494 | const config = getWorkspaceFolderConfig(workspaceFolder);
495 | config.update("buildDirectories", paths);
496 | }
497 | }
498 |
499 | async function COMMAND_dumpPathsWithCoverageData() {
500 | if (vscode.workspace.workspaceFolders === undefined) {
501 | return;
502 | }
503 |
504 | if (!isCoverageDataLoaded()) {
505 | await reloadGcdaFiles();
506 | }
507 |
508 | const paths = Array.from(coverageCache.dataByFile.keys());
509 | paths.sort();
510 | const dumpedPaths = paths.join("\n");
511 | const document = await vscode.workspace.openTextDocument({
512 | content: dumpedPaths,
513 | });
514 | vscode.window.showTextDocument(document);
515 | }
516 |
517 | async function COMMAND_generateSummaryHTML() {
518 | if (!isCoverageDataLoaded()) {
519 | await reloadGcdaFiles();
520 | }
521 |
522 | const data = [];
523 | for (const [path, fileCoverage] of coverageCache.dataByFile.entries()) {
524 | fileCoverage.ensureAnalysed();
525 | const functionData = [];
526 | for (const functionCoverage of fileCoverage.functionsByStart!.values()) {
527 | functionData.push({
528 | name: functionCoverage.baseName,
529 | total: functionCoverage.totalLines,
530 | called: functionCoverage.calledLines,
531 | });
532 | }
533 | data.push({
534 | path,
535 | total: fileCoverage.totalLines,
536 | called: fileCoverage.calledLines,
537 | functions: functionData,
538 | });
539 | }
540 |
541 | const template = fs.readFileSync(
542 | fs_path.join(
543 | fs_path.dirname(__dirname),
544 | "html_report",
545 | "overview_template.html"
546 | ),
547 | "utf8"
548 | );
549 | const coverageDump = template.replace(
550 | "// analysisData = [{ dummy: 42 }];",
551 | `analysisData = ${JSON.stringify(data)}`
552 | );
553 |
554 | tmp.file({ postfix: ".html" }, (err, path) => {
555 | fs.writeFileSync(path, coverageDump);
556 | vscode.env.openExternal(vscode.Uri.file(path));
557 | });
558 | }
559 |
560 | async function COMMAND_viewFunctionsByCallCount() {
561 | const editor = vscode.window.activeTextEditor;
562 | if (editor === undefined) {
563 | return;
564 | }
565 |
566 | if (!isCoverageDataLoaded()) {
567 | await reloadGcdaFiles();
568 | }
569 |
570 | const fileCoverage = findCachedDataForFile(editor.document.uri.fsPath);
571 | if (fileCoverage === undefined) {
572 | return;
573 | }
574 |
575 | interface FunctionPickItem extends vscode.QuickPickItem {
576 | functionCoverage: FunctionCoverage;
577 | }
578 |
579 | fileCoverage.ensureAnalysed();
580 |
581 | let items: FunctionPickItem[] = [];
582 | for (const functionCoverage of fileCoverage.functionsByStart!.values()) {
583 | items.push({
584 | label: `${functionCoverage.executionCount.toLocaleString()}x ${
585 | functionCoverage.baseName
586 | }`,
587 | functionCoverage,
588 | });
589 | }
590 | items.sort(
591 | (a, b) =>
592 | b.functionCoverage.executionCount - a.functionCoverage.executionCount
593 | );
594 |
595 | const quickPick = vscode.window.createQuickPick();
596 | quickPick.items = items;
597 | quickPick.onDidHide(() => quickPick.dispose());
598 | quickPick.onDidChangeSelection(() => quickPick.hide());
599 | quickPick.onDidChangeActive((items) => {
600 | const functionCoverage = (items[0] as FunctionPickItem).functionCoverage;
601 | const startLine = functionCoverage.startLine;
602 | const endLine = functionCoverage.endLine;
603 | editor.selection = new vscode.Selection(
604 | new vscode.Position(startLine, 0),
605 | new vscode.Position(startLine, 0)
606 | );
607 | editor.revealRange(
608 | new vscode.Range(startLine, 0, endLine, 0),
609 | vscode.TextEditorRevealType.InCenter
610 | );
611 | });
612 | quickPick.show();
613 | }
614 |
615 | function updateStatusBar() {
616 | coverageStatusBarItem.hide();
617 | if (!isCoverageDataLoaded()) {
618 | return;
619 | }
620 | if (!isShowingDecorations) {
621 | return;
622 | }
623 | const path = vscode.window.activeTextEditor?.document.uri.fsPath;
624 | if (path === undefined) {
625 | return;
626 | }
627 | const fileCoverage = findCachedDataForFile(path);
628 | if (fileCoverage === undefined) {
629 | return;
630 | }
631 | fileCoverage.ensureAnalysed();
632 |
633 | const percentage =
634 | fileCoverage.totalLines! === 0
635 | ? 100
636 | : (fileCoverage.calledLines! / fileCoverage.totalLines!) * 100;
637 | coverageStatusBarItem.text = `Coverage: ${fileCoverage.calledLines!}/${fileCoverage.totalLines!} [${percentage.toFixed(
638 | 1
639 | )}%]`;
640 | coverageStatusBarItem.show();
641 | }
642 |
--------------------------------------------------------------------------------
/src/fsScanning.ts:
--------------------------------------------------------------------------------
1 | import * as vscode from "vscode";
2 | import * as fs from "fs";
3 | import { join } from "path";
4 |
5 | function readdirOrEmpty(path: string) {
6 | return new Promise((resolve) => {
7 | fs.readdir(path, (err, paths) => {
8 | if (err) {
9 | resolve([]);
10 | } else {
11 | resolve(paths);
12 | }
13 | });
14 | });
15 | }
16 |
17 | function statsOrUndefined(path: string) {
18 | return new Promise((resolve) => {
19 | fs.stat(path, (err, stats) => {
20 | if (err) {
21 | console.error(err);
22 | resolve(undefined);
23 | } else {
24 | resolve(stats);
25 | }
26 | });
27 | });
28 | }
29 |
30 | /**
31 | * Calls the given callback with every found file path in the given directory.
32 | * Other implementations return all paths at once, but the progress can't be
33 | * reported in the ui. Furthermore, this function can be cancelled by the user
34 | * if it takes too long.
35 | */
36 | export async function findAllFilesRecursively(
37 | directory: string,
38 | callback: (path: string) => void,
39 | token?: vscode.CancellationToken
40 | ) {
41 | let fileNames: string[] = await readdirOrEmpty(directory);
42 |
43 | for (const fileName of fileNames) {
44 | const path = join(directory, fileName);
45 | const stats = await statsOrUndefined(path);
46 | if (stats === undefined) {
47 | continue;
48 | }
49 | if (stats.isFile()) {
50 | if (token?.isCancellationRequested) {
51 | return;
52 | }
53 | callback(path);
54 | } else {
55 | await findAllFilesRecursively(path, callback, token);
56 | }
57 | }
58 | }
59 |
--------------------------------------------------------------------------------
/src/gcovInterface.ts:
--------------------------------------------------------------------------------
1 | import * as vscode from "vscode";
2 | import * as child_process from "child_process";
3 |
4 | export interface GcovLineData {
5 | count: number;
6 | function_name: string;
7 | line_number: number;
8 | unexecuted_block: boolean;
9 | }
10 |
11 | export interface GcovFunctionData {
12 | blocks: number;
13 | blocks_executed: number;
14 | demangled_name: string;
15 | start_column: number;
16 | start_line: number;
17 | end_column: number;
18 | end_line: number;
19 | execution_count: number;
20 | name: string;
21 | }
22 |
23 | export interface GcovFileData {
24 | file: string;
25 | lines: GcovLineData[];
26 | functions: GcovFunctionData[];
27 | }
28 |
29 | export interface GcovData {
30 | files: GcovFileData[];
31 | current_working_directory: string;
32 | data_file: string;
33 | }
34 |
35 | function getGcovBinary() {
36 | const config = vscode.workspace.getConfiguration("gcovViewer", null);
37 | const gcovBinary = config.get("gcovBinary");
38 | return gcovBinary;
39 | }
40 |
41 | export async function isGcovCompatible() {
42 | const gcovBinary = getGcovBinary();
43 | const command = `${gcovBinary} --help`;
44 | return new Promise((resolve, reject) => {
45 | child_process.exec(command, (err, stdout, stderr) => {
46 | if (err) {
47 | vscode.window.showErrorMessage(
48 | `Error while trying to run gcov, try to change the "Gcov Binary" setting. ${err}`
49 | );
50 | resolve(false);
51 | return;
52 | }
53 | const gcovOutput = stdout.toString();
54 | const supportsRequiredArgs =
55 | gcovOutput.includes("--json-format") && gcovOutput.includes("--stdout");
56 | if (!supportsRequiredArgs) {
57 | vscode.window.showErrorMessage(
58 | `The gcov version is not compatible. Please use at least version 9.`
59 | );
60 | }
61 | resolve(supportsRequiredArgs);
62 | });
63 | });
64 | }
65 |
66 | export async function loadGcovData(paths: string[]): Promise {
67 | if (paths.length === 0) {
68 | return [];
69 | }
70 |
71 | const gcovBinary = getGcovBinary();
72 |
73 | let command = `${gcovBinary} --stdout --json-format`;
74 | for (const path of paths) {
75 | command += ` "${path}"`;
76 | }
77 | return new Promise((resolve, reject) => {
78 | child_process.exec(
79 | command,
80 | { maxBuffer: 256 * 1024 * 1024 },
81 | (err, stdout, stderr) => {
82 | if (err) {
83 | vscode.window.showErrorMessage(
84 | `Error invoking gcov: ${stderr.toString()}`
85 | );
86 | console.log(err);
87 | reject();
88 | return;
89 | }
90 | const gcovOutput = stdout.toString();
91 | const output = [];
92 | const parts = gcovOutput.split("\n");
93 | for (const part of parts) {
94 | if (part.length === 0) {
95 | continue;
96 | }
97 | output.push(JSON.parse(part));
98 | }
99 | resolve(output);
100 | }
101 | );
102 | });
103 | }
104 |
--------------------------------------------------------------------------------
/tsconfig.json:
--------------------------------------------------------------------------------
1 | {
2 | "compilerOptions": {
3 | "module": "commonjs",
4 | "target": "es6",
5 | "outDir": "out",
6 | "lib": [
7 | "es6"
8 | ],
9 | "sourceMap": true,
10 | "rootDir": "src",
11 | "strict": true /* enable all strict type-checking options */
12 | /* Additional Checks */
13 | // "noImplicitReturns": true, /* Report error when not all code paths in function return a value. */
14 | // "noFallthroughCasesInSwitch": true, /* Report errors for fallthrough cases in switch statement. */
15 | // "noUnusedParameters": true, /* Report errors on unused parameters. */
16 | },
17 | "exclude": [
18 | "node_modules",
19 | ".vscode-test"
20 | ]
21 | }
22 |
--------------------------------------------------------------------------------