test_runner: support combining coverage reports

doc/api/cli.md

@@ -624,6 +624,10 @@ Use this flag to enable [ShadowRealm][] support.
 added:
  - v19.7.0
  - v18.15.0
+changes:
+ - version: REPLACEME
+ pr-url: https://github.com/nodejs/node/pull/47686
+ description: This option can be used with `--test`.
 -->
 
 When used in conjunction with the `node:test` module, a code coverage report is

doc/api/test.md

@@ -428,10 +428,6 @@ if (anAlwaysFalseCondition){
 The test runner's code coverage functionality has the following limitations,
 which will be addressed in a future Node.js release:
 
-* Although coverage data is collected for child processes, this information is
- not included in the coverage report. Because the command line test runner uses
- child processes to execute test files, it cannot be used with
- `--experimental-test-coverage`.
 * Source maps are not supported.
 * Excluding specific files or directories from the coverage report is not
  supported.

lib/internal/test_runner/coverage.js

@@ -1,13 +1,15 @@
 'use strict';
 const{
+ ArrayFrom,
  ArrayPrototypeMap,
  ArrayPrototypePush,
  JSONParse,
  MathFloor,
  NumberParseInt,
- RegExp,
  RegExpPrototypeExec,
  RegExpPrototypeSymbolSplit,
+ SafeMap,
+ SafeSet,
  StringPrototypeIncludes,
  StringPrototypeLocaleCompare,
  StringPrototypeStartsWith,
@@ -23,9 +25,7 @@ const{setupCoverageHooks } = require('internal/util');
 const{ tmpdir }=require('os');
 const{ join, resolve }=require('path');
 const{ fileURLToPath }=require('url');
-constkCoveragePattern=
-`^coverage\\-${process.pid}\\-(\\d{13})\\-(\\d+)\\.json$`;
-constkCoverageFileRegex=newRegExp(kCoveragePattern);
+constkCoverageFileRegex=/^coverage-(\d+)-(\d{13})-(\d+)\.json$/;
 constkIgnoreRegex=/\/\*node:coverageignorenext(?<count>\d+)?\*\//;
 constkLineEndingRegex=/\r?\n$/u;
 constkLineSplitRegex=/(?<=\r?\n)/u;
@@ -95,13 +95,6 @@ class TestCoverage{
 for(leti=0;i<coverage.length;++i){
 const{ functions, url }=coverage[i];
 
-if(StringPrototypeStartsWith(url,'node:')||
-StringPrototypeIncludes(url,'/node_modules/')||
-// On Windows some generated coverages are invalid.
-!StringPrototypeStartsWith(url,'file:')){
-continue;
-}
-
 // Split the file source into lines. Make sure the lines maintain their
 // original line endings because those characters are necessary for
 // determining offsets in the file.
@@ -345,8 +338,7 @@ function mapRangeToLines(range, lines){
 }
 
 functiongetCoverageFromDirectory(coverageDirectory){
-// TODO(cjihrig): Instead of only reading the coverage file for this process,
-// combine all coverage files in the directory into a single data structure.
+constresult=newSafeMap();
 letdir;
 
 try{
@@ -359,13 +351,149 @@ function getCoverageFromDirectory(coverageDirectory){
 
 constcoverageFile=join(coverageDirectory,entry.name);
 constcoverage=JSONParse(readFileSync(coverageFile,'utf8'));
-returncoverage.result;
+
+mergeCoverage(result,coverage.result);
 }
+
+returnArrayFrom(result.values());
 }finally{
 if(dir){
 dir.closeSync();
 }
 }
 }
 
+functionmergeCoverage(merged,coverage){
+for(leti=0;i<coverage.length;++i){
+constnewScript=coverage[i];
+const{ url }=newScript;
+
+// Filter out core modules and the node_modules/ directory from results.
+if(StringPrototypeStartsWith(url,'node:')||
+StringPrototypeIncludes(url,'/node_modules/')||
+// On Windows some generated coverages are invalid.
+!StringPrototypeStartsWith(url,'file:')){
+continue;
+}
+
+constoldScript=merged.get(url);
+
+if(oldScript===undefined){
+merged.set(url,newScript);
+}else{
+mergeCoverageScripts(oldScript,newScript);
+}
+}
+}
+
+functionmergeCoverageScripts(oldScript,newScript){
+// Merge the functions from the new coverage into the functions from the
+// existing (merged) coverage.
+for(leti=0;i<newScript.functions.length;++i){
+constnewFn=newScript.functions[i];
+letfound=false;
+
+for(letj=0;j<oldScript.functions.length;++j){
+constoldFn=oldScript.functions[j];
+
+if(newFn.functionName===oldFn.functionName&&
+newFn.ranges?.[0].startOffset===oldFn.ranges?.[0].startOffset&&
+newFn.ranges?.[0].endOffset===oldFn.ranges?.[0].endOffset){
+// These are the same functions.
+found=true;
+
+// If newFn is block level coverage, then it will:
+// - Replace oldFn if oldFn is not block level coverage.
+// - Merge with oldFn if it is also block level coverage.
+// If newFn is not block level coverage, then it has no new data.
+if(newFn.isBlockCoverage){
+if(oldFn.isBlockCoverage){
+// Merge the oldFn ranges with the newFn ranges.
+mergeCoverageRanges(oldFn,newFn);
+}else{
+// Replace oldFn with newFn.
+oldFn.isBlockCoverage=true;
+oldFn.ranges=newFn.ranges;
+}
+}
+
+break;
+}
+}
+
+if(!found){
+// This is a new function to track. This is possible because V8 can
+// generate a different list of functions depending on which code paths
+// are executed. For example, if a code path dynamically creates a
+// function, but that code path is not executed then the function does
+// not show up in the coverage report. Unfortunately, this also means
+// that the function counts in the coverage summary can never be
+// guaranteed to be 100% accurate.
+ArrayPrototypePush(oldScript.functions,newFn);
+}
+}
+}
+
+functionmergeCoverageRanges(oldFn,newFn){
+constmergedRanges=newSafeSet();
+
+// Keep all of the existing covered ranges.
+for(leti=0;i<oldFn.ranges.length;++i){
+constoldRange=oldFn.ranges[i];
+
+if(oldRange.count>0){
+mergedRanges.add(oldRange);
+}
+}
+
+// Merge in the new ranges where appropriate.
+for(leti=0;i<newFn.ranges.length;++i){
+constnewRange=newFn.ranges[i];
+letexactMatch=false;
+
+for(letj=0;j<oldFn.ranges.length;++j){
+constoldRange=oldFn.ranges[j];
+
+if(doesRangeEqualOtherRange(newRange,oldRange)){
+// These are the same ranges, so keep the existing one.
+oldRange.count+=newRange.count;
+mergedRanges.add(oldRange);
+exactMatch=true;
+break;
+}
+
+// Look at ranges representing missing coverage and add ranges that
+// represent the intersection.
+if(oldRange.count===0&&newRange.count===0){
+if(doesRangeContainOtherRange(oldRange,newRange)){
+// The new range is completely within the old range. Discard the
+// larger (old) range, and keep the smaller (new) range.
+mergedRanges.add(newRange);
+}elseif(doesRangeContainOtherRange(newRange,oldRange)){
+// The old range is completely within the new range. Discard the
+// larger (new) range, and keep the smaller (old) range.
+mergedRanges.add(oldRange);
+}
+}
+}
+
+// Add new ranges that do not represent missing coverage.
+if(newRange.count>0&&!exactMatch){
+mergedRanges.add(newRange);
+}
+}
+
+oldFn.ranges=ArrayFrom(mergedRanges);
+}
+
+functiondoesRangeEqualOtherRange(range,otherRange){
+returnrange.startOffset===otherRange.startOffset&&
+range.endOffset===otherRange.endOffset;
+}
+
+functiondoesRangeContainOtherRange(range,otherRange){
+returnrange.startOffset<=otherRange.startOffset&&
+range.endOffset>=otherRange.endOffset;
+}
+
 module.exports={ setupCoverage };

src/node_options.cc

@@ -141,13 +141,6 @@ void EnvironmentOptions::CheckOptions(std::vector<std::string>* errors,
  }
 
 if (test_runner){
-if (test_runner_coverage){
-// TODO(cjihrig): This restriction can be removed once multi-process
-// code coverage is supported.
- errors->push_back(
-"--experimental-test-coverage cannot be used with --test");
- }
-
 if (syntax_check_only){
  errors->push_back("either --test or --check can be used, not both");
  }

test/fixtures/v8-coverage/combined_coverage/common.js

@@ -0,0 +1,69 @@
+'use strict';
+functionfnA(){
+letcnt=0;
+
+try{
+cnt++;
+thrownewError('boom');
+cnt++;
+}catch(err){
+cnt++;
+}finally{
+if(false){
+
+}
+
+returncnt;
+}
+cnt++;
+}
+
+functionfnB(arr){
+for(leti=0;i<arr.length;++i){
+if(i===2){
+continue;
+}else{
+fnE(1);
+}
+}
+}
+
+functionfnC(arg1,arg2){
+if(arg1===1){
+if(arg2===3){
+return-1;
+}
+
+if(arg2===4){
+return3;
+}
+
+if(arg2===5){
+return9;
+}
+}
+}
+
+functionfnD(arg){
+letcnt=0;
+
+if(arg%2===0){
+cnt++;
+}elseif(arg===1){
+cnt++;
+}elseif(arg===3){
+cnt++;
+}else{
+fnC(1,5);
+}
+
+returncnt;
+}
+
+functionfnE(arg){
+consta=arg??5;
+
+returna;
+}
+
+module.exports={ fnA, fnB, fnC, fnD, fnE };

test/fixtures/v8-coverage/combined_coverage/first.test.js

@@ -0,0 +1,12 @@
+'use strict'
+const{test } = require('node:test');
+const common = require('./common');
+
+function notCalled(){
+}
+
+test('first 1', () =>{
+ common.fnA();
+ common.fnD(100);
+ common.fnB([1, 2, 3]);
+});

test/fixtures/v8-coverage/combined_coverage/second.test.js

@@ -0,0 +1,8 @@
+'use strict'
+const{test } = require('node:test');
+const common = require('./common');
+
+test('second 1', () =>{
+ common.fnB([1, 2, 3]);
+ common.fnD(3);
+});

test/fixtures/v8-coverage/combined_coverage/third.test.js

@@ -0,0 +1,8 @@
+'use strict';
+const{ test }=require('node:test');
+constcommon=require('./common');
+
+test('third 1',()=>{
+common.fnC(1,4);
+common.fnD(99);
+});