test_runner: match dotfiles in default coverage exclude

The default coverage exclude globs did not match dotfiles, so test
files such as `test/.foo.test.js` were incorrectly included in coverage
reports. Apply the `dot: true` minimatch option when matching the
relative path so the default exclude patterns cover dotfiles, while
keeping plain matching for the absolute path to avoid misinterpreting
dot segments in the filesystem path (e.g. tmp dirs like `test/.tmp.0`).
Fixes: #63397
Signed-off-by: semimikoh <ejffjeosms@gmail.com>
PR-URL: #63401
Reviewed-By: Matteo Collina <matteo.collina@gmail.com>
Reviewed-By: Aviv Keller <me@aviv.sh>
Reviewed-By: Chemi Atlow <chemi@atlow.co.il>
Reviewed-By: Benjamin Gruenbaum <benjamingr@gmail.com>
Reviewed-By: Moshe Atlow <moshe@atlow.co.il>

Author: semimikoh

lib/internal/test_runner/coverage.js

@@ -47,6 +47,9 @@ const kIgnoreRegex = /\/\* node:coverage ignore next (?<count>\d+ )?\*\//;
 constkLineEndingRegex=/\r?\n$/u;
 constkLineSplitRegex=/(?<=\r?\n)/u;
 constkStatusRegex=/\/\*node:coverage(?<status>enable|disable)\*\//;
+// Match dotfiles (e.g. `test/.foo.js`) when applying coverage globs so the
+// default exclude patterns cover them.
+constkMatchGlobPatternOptions={__proto__: null,dot: true};
 constkTypeOnlyImportRegex=/^\s*import\s+type\b/u;
 constkTypeScriptSourceRegex=/\.(?:cts|mts|ts)$/u;
 constkSourceFileGlob='**/*.{cjs,cts,js,mjs,mts,ts}';
@@ -63,6 +66,14 @@ function getStripTypeScriptTypesForCoverage() {
 returnstripTypeScriptTypesForCoverage;
 }
 
+functioncreateCoverageMatcher(pattern){
+return{
+__proto__: null,
+relative: createMatcher(pattern,kMatchGlobPatternOptions),
+absolute: createMatcher(pattern),
+};
+}
+
 classCoverageLine{
 constructor(line,startOffset,src,length=src?.length){
 constnewlineLength=src==null ? 0 :
@@ -605,23 +616,28 @@ class TestCoverage {
 // TestCoverage instance, so compile each glob to a matcher once and reuse
 // it for every file. Building a fresh Minimatch per call (the previous
 // behavior) dominated the coverage report time, scaling with
-// files * globs.
+// files * globs. Each glob compiles to a matcher pair: `relative` enables
+// dot:true so globs match dotfiles within the project, while `absolute`
+// keeps the default behavior to avoid misinterpreting dot segments in the
+// absolute filesystem path (e.g. tmp dirs like `test/.tmp.0`).
 this.#excludeMatchers ??=ArrayPrototypeMap(
-this.options.coverageExcludeGlobs??[],(pattern)=>createMatcher(pattern));
+this.options.coverageExcludeGlobs??[],createCoverageMatcher);
 this.#includeMatchers ??=ArrayPrototypeMap(
-this.options.coverageIncludeGlobs??[],(pattern)=>createMatcher(pattern));
+this.options.coverageIncludeGlobs??[],createCoverageMatcher);
 
 // This check filters out files that match the exclude globs.
 for(leti=0;i<this.#excludeMatchers.length;++i){
 constmatcher=this.#excludeMatchers[i];
-if(matcher.match(relativePath)||matcher.match(absolutePath))returntrue;
+if(matcher.relative.match(relativePath)||
+matcher.absolute.match(absolutePath))returntrue;
 }
 
 // This check filters out files that do not match the include globs.
 if(this.#includeMatchers.length>0){
 for(leti=0;i<this.#includeMatchers.length;++i){
 constmatcher=this.#includeMatchers[i];
-if(matcher.match(relativePath)||matcher.match(absolutePath))returnfalse;
+if(matcher.relative.match(relativePath)||
+matcher.absolute.match(absolutePath))returnfalse;
 }
 returntrue;
 }

test/fixtures/test-runner/coverage-default-exclusion/test/.dotfile.cjs

@@ -0,0 +1,7 @@
+consttest=require('node:test');
+constassert=require('node:assert');
+const{ foo }=require('../logic-file.js');
+
+test('foo returns 1 from a dotfile test',()=>{
+assert.strictEqual(foo(),1);
+});

test/parallel/test-runner-coverage-default-exclusion.mjs

@@ -16,6 +16,16 @@ async function setupFixtures() {
 awaitcp(fixtureDir,tmpdir.path,{recursive: true});
 }
 
+functionassertDefaultExclusions(stdout){
+assert.match(stdout,/#startofcoveragereport/);
+assert.doesNotMatch(stdout,/#file-test\.js\s+\|/);
+assert.doesNotMatch(stdout,/#file\.test\.mjs\s+\|/);
+assert.doesNotMatch(stdout,/#file\.test\.ts\s+\|/);
+assert.doesNotMatch(stdout,/#test\.cjs\s+\|/);
+assert.doesNotMatch(stdout,/#\s+not-matching-test-name\.js\s+\|/);
+assert.match(stdout,/#endofcoveragereport/);
+}
+
 describe('test runner coverage default exclusion',skipIfNoInspector,()=>{
 before(async()=>{
 awaitsetupFixtures();
@@ -58,18 +68,6 @@ describe('test runner coverage default exclusion', skipIfNoInspector, () => {
 });
 
 it('should exclude test files from coverage by default',async()=>{
-constreport=[
-'# start of coverage report',
-'# --------------------------------------------------------------',
-'# file | line % | branch % | funcs % | uncovered lines',
-'# --------------------------------------------------------------',
-'# logic-file.js | 66.67 | 100.00 | 50.00 | 5-7',
-'# --------------------------------------------------------------',
-'# all files | 66.67 | 100.00 | 50.00 | ',
-'# --------------------------------------------------------------',
-'# end of coverage report',
-].join('\n');
-
 constargs=[
 '--no-experimental-strip-types',
 '--test',
@@ -82,23 +80,11 @@ describe('test runner coverage default exclusion', skipIfNoInspector, () => {
 });
 
 assert.strictEqual(result.stderr.toString(),'');
-assert(result.stdout.toString().includes(report));
+assertDefaultExclusions(result.stdout.toString());
 assert.strictEqual(result.status,0);
 });
 
 it('should exclude ts test files',async()=>{
-constreport=[
-'# start of coverage report',
-'# --------------------------------------------------------------',
-'# file | line % | branch % | funcs % | uncovered lines',
-'# --------------------------------------------------------------',
-'# logic-file.js | 66.67 | 100.00 | 50.00 | 5-7',
-'# --------------------------------------------------------------',
-'# all files | 66.67 | 100.00 | 50.00 | ',
-'# --------------------------------------------------------------',
-'# end of coverage report',
-].join('\n');
-
 constargs=[
 '--test',
 '--experimental-test-coverage',
@@ -111,7 +97,26 @@ describe('test runner coverage default exclusion', skipIfNoInspector, () => {
 });
 
 assert.strictEqual(result.stderr.toString(),'');
-assert(result.stdout.toString().includes(report));
+assertDefaultExclusions(result.stdout.toString());
+assert.strictEqual(result.status,0);
+});
+
+it('should exclude dotfile test files from coverage by default',async()=>{
+constargs=[
+'--no-experimental-strip-types',
+'--test',
+'--experimental-test-coverage',
+'--test-reporter=tap',
+'test/.dotfile.cjs',
+];
+constresult=spawnSync(process.execPath,args,{
+env: { ...process.env,NODE_TEST_TMPDIR: tmpdir.path},
+cwd: tmpdir.path
+});
+
+assert.strictEqual(result.stderr.toString(),'');
+assertDefaultExclusions(result.stdout.toString());
+assert.doesNotMatch(result.stdout.toString(),/#\s+\.dotfile\.cjs\s+\|/);
 assert.strictEqual(result.status,0);
 });
 });

lib/internal/test_runner/coverage.js

@@ -47,6 +47,9 @@ const kIgnoreRegex = /\/\* node:coverage ignore next (?<count>\d+ )?\*\//;
 constkLineEndingRegex=/\r?\n$/u;
 constkLineSplitRegex=/(?<=\r?\n)/u;
 constkStatusRegex=/\/\*node:coverage(?<status>enable|disable)\*\//;
+// Match dotfiles (e.g. `test/.foo.js`) when applying coverage globs so the
+// default exclude patterns cover them.
+constkMatchGlobPatternOptions={__proto__: null,dot: true};
 constkTypeOnlyImportRegex=/^\s*import\s+type\b/u;
 constkTypeScriptSourceRegex=/\.(?:cts|mts|ts)$/u;
 constkSourceFileGlob='**/*.{cjs,cts,js,mjs,mts,ts}';
@@ -63,6 +66,14 @@ function getStripTypeScriptTypesForCoverage() {
 returnstripTypeScriptTypesForCoverage;
 }
 
+functioncreateCoverageMatcher(pattern){
+return{
+__proto__: null,
+relative: createMatcher(pattern,kMatchGlobPatternOptions),
+absolute: createMatcher(pattern),
+};
+}
+
 classCoverageLine{
 constructor(line,startOffset,src,length=src?.length){
 constnewlineLength=src==null ? 0 :
@@ -605,23 +616,28 @@ class TestCoverage {
 // TestCoverage instance, so compile each glob to a matcher once and reuse
 // it for every file. Building a fresh Minimatch per call (the previous
 // behavior) dominated the coverage report time, scaling with
-// files * globs.
+// files * globs. Each glob compiles to a matcher pair: `relative` enables
+// dot:true so globs match dotfiles within the project, while `absolute`
+// keeps the default behavior to avoid misinterpreting dot segments in the
+// absolute filesystem path (e.g. tmp dirs like `test/.tmp.0`).
 this.#excludeMatchers ??=ArrayPrototypeMap(
-this.options.coverageExcludeGlobs??[],(pattern)=>createMatcher(pattern));
+this.options.coverageExcludeGlobs??[],createCoverageMatcher);
 this.#includeMatchers ??=ArrayPrototypeMap(
-this.options.coverageIncludeGlobs??[],(pattern)=>createMatcher(pattern));
+this.options.coverageIncludeGlobs??[],createCoverageMatcher);
 
 // This check filters out files that match the exclude globs.
 for(leti=0;i<this.#excludeMatchers.length;++i){
 constmatcher=this.#excludeMatchers[i];
-if(matcher.match(relativePath)||matcher.match(absolutePath))returntrue;
+if(matcher.relative.match(relativePath)||
+matcher.absolute.match(absolutePath))returntrue;
 }
 
 // This check filters out files that do not match the include globs.
 if(this.#includeMatchers.length>0){
 for(leti=0;i<this.#includeMatchers.length;++i){
 constmatcher=this.#includeMatchers[i];
-if(matcher.match(relativePath)||matcher.match(absolutePath))returnfalse;
+if(matcher.relative.match(relativePath)||
+matcher.absolute.match(absolutePath))returnfalse;
 }
 returntrue;
 }

test/fixtures/test-runner/coverage-default-exclusion/test/.dotfile.cjs

@@ -0,0 +1,7 @@
+consttest=require('node:test');
+constassert=require('node:assert');
+const{ foo }=require('../logic-file.js');
+
+test('foo returns 1 from a dotfile test',()=>{
+assert.strictEqual(foo(),1);
+});

test/parallel/test-runner-coverage-default-exclusion.mjs

@@ -16,6 +16,16 @@ async function setupFixtures() {
 awaitcp(fixtureDir,tmpdir.path,{recursive: true});
 }
 
+functionassertDefaultExclusions(stdout){
+assert.match(stdout,/#startofcoveragereport/);
+assert.doesNotMatch(stdout,/#file-test\.js\s+\|/);
+assert.doesNotMatch(stdout,/#file\.test\.mjs\s+\|/);
+assert.doesNotMatch(stdout,/#file\.test\.ts\s+\|/);
+assert.doesNotMatch(stdout,/#test\.cjs\s+\|/);
+assert.doesNotMatch(stdout,/#\s+not-matching-test-name\.js\s+\|/);
+assert.match(stdout,/#endofcoveragereport/);
+}
+
 describe('test runner coverage default exclusion',skipIfNoInspector,()=>{
 before(async()=>{
 awaitsetupFixtures();
@@ -58,18 +68,6 @@ describe('test runner coverage default exclusion', skipIfNoInspector, () => {
 });
 
 it('should exclude test files from coverage by default',async()=>{
-constreport=[
-'# start of coverage report',
-'# --------------------------------------------------------------',
-'# file | line % | branch % | funcs % | uncovered lines',
-'# --------------------------------------------------------------',
-'# logic-file.js | 66.67 | 100.00 | 50.00 | 5-7',
-'# --------------------------------------------------------------',
-'# all files | 66.67 | 100.00 | 50.00 | ',
-'# --------------------------------------------------------------',
-'# end of coverage report',
-].join('\n');
-
 constargs=[
 '--no-experimental-strip-types',
 '--test',
@@ -82,23 +80,11 @@ describe('test runner coverage default exclusion', skipIfNoInspector, () => {
 });
 
 assert.strictEqual(result.stderr.toString(),'');
-assert(result.stdout.toString().includes(report));
+assertDefaultExclusions(result.stdout.toString());
 assert.strictEqual(result.status,0);
 });
 
 it('should exclude ts test files',async()=>{
-constreport=[
-'# start of coverage report',
-'# --------------------------------------------------------------',
-'# file | line % | branch % | funcs % | uncovered lines',
-'# --------------------------------------------------------------',
-'# logic-file.js | 66.67 | 100.00 | 50.00 | 5-7',
-'# --------------------------------------------------------------',
-'# all files | 66.67 | 100.00 | 50.00 | ',
-'# --------------------------------------------------------------',
-'# end of coverage report',
-].join('\n');
-
 constargs=[
 '--test',
 '--experimental-test-coverage',
@@ -111,7 +97,26 @@ describe('test runner coverage default exclusion', skipIfNoInspector, () => {
 });
 
 assert.strictEqual(result.stderr.toString(),'');
-assert(result.stdout.toString().includes(report));
+assertDefaultExclusions(result.stdout.toString());
+assert.strictEqual(result.status,0);
+});
+
+it('should exclude dotfile test files from coverage by default',async()=>{
+constargs=[
+'--no-experimental-strip-types',
+'--test',
+'--experimental-test-coverage',
+'--test-reporter=tap',
+'test/.dotfile.cjs',
+];
+constresult=spawnSync(process.execPath,args,{
+env: { ...process.env,NODE_TEST_TMPDIR: tmpdir.path},
+cwd: tmpdir.path
+});
+
+assert.strictEqual(result.stderr.toString(),'');
+assertDefaultExclusions(result.stdout.toString());
+assert.doesNotMatch(result.stdout.toString(),/#\s+\.dotfile\.cjs\s+\|/);
 assert.strictEqual(result.status,0);
 });
 });

lib/internal/test_runner/coverage.js

@@ -47,6 +47,9 @@ const kIgnoreRegex = /\/\* node:coverage ignore next (?<count>\d+ )?\*\//;
 constkLineEndingRegex=/\r?\n$/u;
 constkLineSplitRegex=/(?<=\r?\n)/u;
 constkStatusRegex=/\/\*node:coverage(?<status>enable|disable)\*\//;
+// Match dotfiles (e.g. `test/.foo.js`) when applying coverage globs so the
+// default exclude patterns cover them.
+constkMatchGlobPatternOptions={__proto__: null,dot: true};
 constkTypeOnlyImportRegex=/^\s*import\s+type\b/u;
 constkTypeScriptSourceRegex=/\.(?:cts|mts|ts)$/u;
 constkSourceFileGlob='**/*.{cjs,cts,js,mjs,mts,ts}';
@@ -63,6 +66,14 @@ function getStripTypeScriptTypesForCoverage() {
 returnstripTypeScriptTypesForCoverage;
 }
 
+functioncreateCoverageMatcher(pattern){
+return{
+__proto__: null,
+relative: createMatcher(pattern,kMatchGlobPatternOptions),
+absolute: createMatcher(pattern),
+};
+}
+
 classCoverageLine{
 constructor(line,startOffset,src,length=src?.length){
 constnewlineLength=src==null ? 0 :
@@ -605,23 +616,28 @@ class TestCoverage {
 // TestCoverage instance, so compile each glob to a matcher once and reuse
 // it for every file. Building a fresh Minimatch per call (the previous
 // behavior) dominated the coverage report time, scaling with
-// files * globs.
+// files * globs. Each glob compiles to a matcher pair: `relative` enables
+// dot:true so globs match dotfiles within the project, while `absolute`
+// keeps the default behavior to avoid misinterpreting dot segments in the
+// absolute filesystem path (e.g. tmp dirs like `test/.tmp.0`).
 this.#excludeMatchers ??=ArrayPrototypeMap(
-this.options.coverageExcludeGlobs??[],(pattern)=>createMatcher(pattern));
+this.options.coverageExcludeGlobs??[],createCoverageMatcher);
 this.#includeMatchers ??=ArrayPrototypeMap(
-this.options.coverageIncludeGlobs??[],(pattern)=>createMatcher(pattern));
+this.options.coverageIncludeGlobs??[],createCoverageMatcher);
 
 // This check filters out files that match the exclude globs.
 for(leti=0;i<this.#excludeMatchers.length;++i){
 constmatcher=this.#excludeMatchers[i];
-if(matcher.match(relativePath)||matcher.match(absolutePath))returntrue;
+if(matcher.relative.match(relativePath)||
+matcher.absolute.match(absolutePath))returntrue;
 }
 
 // This check filters out files that do not match the include globs.
 if(this.#includeMatchers.length>0){
 for(leti=0;i<this.#includeMatchers.length;++i){
 constmatcher=this.#includeMatchers[i];
-if(matcher.match(relativePath)||matcher.match(absolutePath))returnfalse;
+if(matcher.relative.match(relativePath)||
+matcher.absolute.match(absolutePath))returnfalse;
 }
 returntrue;
 }

test/fixtures/test-runner/coverage-default-exclusion/test/.dotfile.cjs

@@ -0,0 +1,7 @@
+consttest=require('node:test');
+constassert=require('node:assert');
+const{ foo }=require('../logic-file.js');
+
+test('foo returns 1 from a dotfile test',()=>{
+assert.strictEqual(foo(),1);
+});

test/parallel/test-runner-coverage-default-exclusion.mjs

@@ -16,6 +16,16 @@ async function setupFixtures() {
 awaitcp(fixtureDir,tmpdir.path,{recursive: true});
 }
 
+functionassertDefaultExclusions(stdout){
+assert.match(stdout,/#startofcoveragereport/);
+assert.doesNotMatch(stdout,/#file-test\.js\s+\|/);
+assert.doesNotMatch(stdout,/#file\.test\.mjs\s+\|/);
+assert.doesNotMatch(stdout,/#file\.test\.ts\s+\|/);
+assert.doesNotMatch(stdout,/#test\.cjs\s+\|/);
+assert.doesNotMatch(stdout,/#\s+not-matching-test-name\.js\s+\|/);
+assert.match(stdout,/#endofcoveragereport/);
+}
+
 describe('test runner coverage default exclusion',skipIfNoInspector,()=>{
 before(async()=>{
 awaitsetupFixtures();
@@ -58,18 +68,6 @@ describe('test runner coverage default exclusion', skipIfNoInspector, () => {
 });
 
 it('should exclude test files from coverage by default',async()=>{
-constreport=[
-'# start of coverage report',
-'# --------------------------------------------------------------',
-'# file | line % | branch % | funcs % | uncovered lines',
-'# --------------------------------------------------------------',
-'# logic-file.js | 66.67 | 100.00 | 50.00 | 5-7',
-'# --------------------------------------------------------------',
-'# all files | 66.67 | 100.00 | 50.00 | ',
-'# --------------------------------------------------------------',
-'# end of coverage report',
-].join('\n');
-
 constargs=[
 '--no-experimental-strip-types',
 '--test',
@@ -82,23 +80,11 @@ describe('test runner coverage default exclusion', skipIfNoInspector, () => {
 });
 
 assert.strictEqual(result.stderr.toString(),'');
-assert(result.stdout.toString().includes(report));
+assertDefaultExclusions(result.stdout.toString());
 assert.strictEqual(result.status,0);
 });
 
 it('should exclude ts test files',async()=>{
-constreport=[
-'# start of coverage report',
-'# --------------------------------------------------------------',
-'# file | line % | branch % | funcs % | uncovered lines',
-'# --------------------------------------------------------------',
-'# logic-file.js | 66.67 | 100.00 | 50.00 | 5-7',
-'# --------------------------------------------------------------',
-'# all files | 66.67 | 100.00 | 50.00 | ',
-'# --------------------------------------------------------------',
-'# end of coverage report',
-].join('\n');
-
 constargs=[
 '--test',
 '--experimental-test-coverage',
@@ -111,7 +97,26 @@ describe('test runner coverage default exclusion', skipIfNoInspector, () => {
 });
 
 assert.strictEqual(result.stderr.toString(),'');
-assert(result.stdout.toString().includes(report));
+assertDefaultExclusions(result.stdout.toString());
+assert.strictEqual(result.status,0);
+});
+
+it('should exclude dotfile test files from coverage by default',async()=>{
+constargs=[
+'--no-experimental-strip-types',
+'--test',
+'--experimental-test-coverage',
+'--test-reporter=tap',
+'test/.dotfile.cjs',
+];
+constresult=spawnSync(process.execPath,args,{
+env: { ...process.env,NODE_TEST_TMPDIR: tmpdir.path},
+cwd: tmpdir.path
+});
+
+assert.strictEqual(result.stderr.toString(),'');
+assertDefaultExclusions(result.stdout.toString());
+assert.doesNotMatch(result.stdout.toString(),/#\s+\.dotfile\.cjs\s+\|/);
 assert.strictEqual(result.status,0);
 });
 });

lib/internal/test_runner/coverage.js

@@ -47,6 +47,9 @@ const kIgnoreRegex = /\/\* node:coverage ignore next (?<count>\d+ )?\*\//;
 constkLineEndingRegex=/\r?\n$/u;
 constkLineSplitRegex=/(?<=\r?\n)/u;
 constkStatusRegex=/\/\*node:coverage(?<status>enable|disable)\*\//;
+// Match dotfiles (e.g. `test/.foo.js`) when applying coverage globs so the
+// default exclude patterns cover them.
+constkMatchGlobPatternOptions={__proto__: null,dot: true};
 constkTypeOnlyImportRegex=/^\s*import\s+type\b/u;
 constkTypeScriptSourceRegex=/\.(?:cts|mts|ts)$/u;
 constkSourceFileGlob='**/*.{cjs,cts,js,mjs,mts,ts}';
@@ -63,6 +66,14 @@ function getStripTypeScriptTypesForCoverage() {
 returnstripTypeScriptTypesForCoverage;
 }
 
+functioncreateCoverageMatcher(pattern){
+return{
+__proto__: null,
+relative: createMatcher(pattern,kMatchGlobPatternOptions),
+absolute: createMatcher(pattern),
+};
+}
+
 classCoverageLine{
 constructor(line,startOffset,src,length=src?.length){
 constnewlineLength=src==null ? 0 :
@@ -605,23 +616,28 @@ class TestCoverage {
 // TestCoverage instance, so compile each glob to a matcher once and reuse
 // it for every file. Building a fresh Minimatch per call (the previous
 // behavior) dominated the coverage report time, scaling with
-// files * globs.
+// files * globs. Each glob compiles to a matcher pair: `relative` enables
+// dot:true so globs match dotfiles within the project, while `absolute`
+// keeps the default behavior to avoid misinterpreting dot segments in the
+// absolute filesystem path (e.g. tmp dirs like `test/.tmp.0`).
 this.#excludeMatchers ??=ArrayPrototypeMap(
-this.options.coverageExcludeGlobs??[],(pattern)=>createMatcher(pattern));
+this.options.coverageExcludeGlobs??[],createCoverageMatcher);
 this.#includeMatchers ??=ArrayPrototypeMap(
-this.options.coverageIncludeGlobs??[],(pattern)=>createMatcher(pattern));
+this.options.coverageIncludeGlobs??[],createCoverageMatcher);
 
 // This check filters out files that match the exclude globs.
 for(leti=0;i<this.#excludeMatchers.length;++i){
 constmatcher=this.#excludeMatchers[i];
-if(matcher.match(relativePath)||matcher.match(absolutePath))returntrue;
+if(matcher.relative.match(relativePath)||
+matcher.absolute.match(absolutePath))returntrue;
 }
 
 // This check filters out files that do not match the include globs.
 if(this.#includeMatchers.length>0){
 for(leti=0;i<this.#includeMatchers.length;++i){
 constmatcher=this.#includeMatchers[i];
-if(matcher.match(relativePath)||matcher.match(absolutePath))returnfalse;
+if(matcher.relative.match(relativePath)||
+matcher.absolute.match(absolutePath))returnfalse;
 }
 returntrue;
 }

test/fixtures/test-runner/coverage-default-exclusion/test/.dotfile.cjs

@@ -0,0 +1,7 @@
+consttest=require('node:test');
+constassert=require('node:assert');
+const{ foo }=require('../logic-file.js');
+
+test('foo returns 1 from a dotfile test',()=>{
+assert.strictEqual(foo(),1);
+});

test/parallel/test-runner-coverage-default-exclusion.mjs

@@ -16,6 +16,16 @@ async function setupFixtures() {
 awaitcp(fixtureDir,tmpdir.path,{recursive: true});
 }
 
+functionassertDefaultExclusions(stdout){
+assert.match(stdout,/#startofcoveragereport/);
+assert.doesNotMatch(stdout,/#file-test\.js\s+\|/);
+assert.doesNotMatch(stdout,/#file\.test\.mjs\s+\|/);
+assert.doesNotMatch(stdout,/#file\.test\.ts\s+\|/);
+assert.doesNotMatch(stdout,/#test\.cjs\s+\|/);
+assert.doesNotMatch(stdout,/#\s+not-matching-test-name\.js\s+\|/);
+assert.match(stdout,/#endofcoveragereport/);
+}
+
 describe('test runner coverage default exclusion',skipIfNoInspector,()=>{
 before(async()=>{
 awaitsetupFixtures();
@@ -58,18 +68,6 @@ describe('test runner coverage default exclusion', skipIfNoInspector, () => {
 });
 
 it('should exclude test files from coverage by default',async()=>{
-constreport=[
-'# start of coverage report',
-'# --------------------------------------------------------------',
-'# file | line % | branch % | funcs % | uncovered lines',
-'# --------------------------------------------------------------',
-'# logic-file.js | 66.67 | 100.00 | 50.00 | 5-7',
-'# --------------------------------------------------------------',
-'# all files | 66.67 | 100.00 | 50.00 | ',
-'# --------------------------------------------------------------',
-'# end of coverage report',
-].join('\n');
-
 constargs=[
 '--no-experimental-strip-types',
 '--test',
@@ -82,23 +80,11 @@ describe('test runner coverage default exclusion', skipIfNoInspector, () => {
 });
 
 assert.strictEqual(result.stderr.toString(),'');
-assert(result.stdout.toString().includes(report));
+assertDefaultExclusions(result.stdout.toString());
 assert.strictEqual(result.status,0);
 });
 
 it('should exclude ts test files',async()=>{
-constreport=[
-'# start of coverage report',
-'# --------------------------------------------------------------',
-'# file | line % | branch % | funcs % | uncovered lines',
-'# --------------------------------------------------------------',
-'# logic-file.js | 66.67 | 100.00 | 50.00 | 5-7',
-'# --------------------------------------------------------------',
-'# all files | 66.67 | 100.00 | 50.00 | ',
-'# --------------------------------------------------------------',
-'# end of coverage report',
-].join('\n');
-
 constargs=[
 '--test',
 '--experimental-test-coverage',
@@ -111,7 +97,26 @@ describe('test runner coverage default exclusion', skipIfNoInspector, () => {
 });
 
 assert.strictEqual(result.stderr.toString(),'');
-assert(result.stdout.toString().includes(report));
+assertDefaultExclusions(result.stdout.toString());
+assert.strictEqual(result.status,0);
+});
+
+it('should exclude dotfile test files from coverage by default',async()=>{
+constargs=[
+'--no-experimental-strip-types',
+'--test',
+'--experimental-test-coverage',
+'--test-reporter=tap',
+'test/.dotfile.cjs',
+];
+constresult=spawnSync(process.execPath,args,{
+env: { ...process.env,NODE_TEST_TMPDIR: tmpdir.path},
+cwd: tmpdir.path
+});
+
+assert.strictEqual(result.stderr.toString(),'');
+assertDefaultExclusions(result.stdout.toString());
+assert.doesNotMatch(result.stdout.toString(),/#\s+\.dotfile\.cjs\s+\|/);
 assert.strictEqual(result.status,0);
 });
 });

lib/internal/test_runner/coverage.js

@@ -47,6 +47,9 @@ const kIgnoreRegex = /\/\* node:coverage ignore next (?<count>\d+ )?\*\//;
 constkLineEndingRegex=/\r?\n$/u;
 constkLineSplitRegex=/(?<=\r?\n)/u;
 constkStatusRegex=/\/\*node:coverage(?<status>enable|disable)\*\//;
+// Match dotfiles (e.g. `test/.foo.js`) when applying coverage globs so the
+// default exclude patterns cover them.
+constkMatchGlobPatternOptions={__proto__: null,dot: true};
 constkTypeOnlyImportRegex=/^\s*import\s+type\b/u;
 constkTypeScriptSourceRegex=/\.(?:cts|mts|ts)$/u;
 constkSourceFileGlob='**/*.{cjs,cts,js,mjs,mts,ts}';
@@ -63,6 +66,14 @@ function getStripTypeScriptTypesForCoverage() {
 returnstripTypeScriptTypesForCoverage;
 }
 
+functioncreateCoverageMatcher(pattern){
+return{
+__proto__: null,
+relative: createMatcher(pattern,kMatchGlobPatternOptions),
+absolute: createMatcher(pattern),
+};
+}
+
 classCoverageLine{
 constructor(line,startOffset,src,length=src?.length){
 constnewlineLength=src==null ? 0 :
@@ -605,23 +616,28 @@ class TestCoverage {
 // TestCoverage instance, so compile each glob to a matcher once and reuse
 // it for every file. Building a fresh Minimatch per call (the previous
 // behavior) dominated the coverage report time, scaling with
-// files * globs.
+// files * globs. Each glob compiles to a matcher pair: `relative` enables
+// dot:true so globs match dotfiles within the project, while `absolute`
+// keeps the default behavior to avoid misinterpreting dot segments in the
+// absolute filesystem path (e.g. tmp dirs like `test/.tmp.0`).
 this.#excludeMatchers ??=ArrayPrototypeMap(
-this.options.coverageExcludeGlobs??[],(pattern)=>createMatcher(pattern));
+this.options.coverageExcludeGlobs??[],createCoverageMatcher);
 this.#includeMatchers ??=ArrayPrototypeMap(
-this.options.coverageIncludeGlobs??[],(pattern)=>createMatcher(pattern));
+this.options.coverageIncludeGlobs??[],createCoverageMatcher);
 
 // This check filters out files that match the exclude globs.
 for(leti=0;i<this.#excludeMatchers.length;++i){
 constmatcher=this.#excludeMatchers[i];
-if(matcher.match(relativePath)||matcher.match(absolutePath))returntrue;
+if(matcher.relative.match(relativePath)||
+matcher.absolute.match(absolutePath))returntrue;
 }
 
 // This check filters out files that do not match the include globs.
 if(this.#includeMatchers.length>0){
 for(leti=0;i<this.#includeMatchers.length;++i){
 constmatcher=this.#includeMatchers[i];
-if(matcher.match(relativePath)||matcher.match(absolutePath))returnfalse;
+if(matcher.relative.match(relativePath)||
+matcher.absolute.match(absolutePath))returnfalse;
 }
 returntrue;
 }

test/fixtures/test-runner/coverage-default-exclusion/test/.dotfile.cjs

@@ -0,0 +1,7 @@
+consttest=require('node:test');
+constassert=require('node:assert');
+const{ foo }=require('../logic-file.js');
+
+test('foo returns 1 from a dotfile test',()=>{
+assert.strictEqual(foo(),1);
+});

test/parallel/test-runner-coverage-default-exclusion.mjs

@@ -16,6 +16,16 @@ async function setupFixtures() {
 awaitcp(fixtureDir,tmpdir.path,{recursive: true});
 }
 
+functionassertDefaultExclusions(stdout){
+assert.match(stdout,/#startofcoveragereport/);
+assert.doesNotMatch(stdout,/#file-test\.js\s+\|/);
+assert.doesNotMatch(stdout,/#file\.test\.mjs\s+\|/);
+assert.doesNotMatch(stdout,/#file\.test\.ts\s+\|/);
+assert.doesNotMatch(stdout,/#test\.cjs\s+\|/);
+assert.doesNotMatch(stdout,/#\s+not-matching-test-name\.js\s+\|/);
+assert.match(stdout,/#endofcoveragereport/);
+}
+
 describe('test runner coverage default exclusion',skipIfNoInspector,()=>{
 before(async()=>{
 awaitsetupFixtures();
@@ -58,18 +68,6 @@ describe('test runner coverage default exclusion', skipIfNoInspector, () => {
 });
 
 it('should exclude test files from coverage by default',async()=>{
-constreport=[
-'# start of coverage report',
-'# --------------------------------------------------------------',
-'# file | line % | branch % | funcs % | uncovered lines',
-'# --------------------------------------------------------------',
-'# logic-file.js | 66.67 | 100.00 | 50.00 | 5-7',
-'# --------------------------------------------------------------',
-'# all files | 66.67 | 100.00 | 50.00 | ',
-'# --------------------------------------------------------------',
-'# end of coverage report',
-].join('\n');
-
 constargs=[
 '--no-experimental-strip-types',
 '--test',
@@ -82,23 +80,11 @@ describe('test runner coverage default exclusion', skipIfNoInspector, () => {
 });
 
 assert.strictEqual(result.stderr.toString(),'');
-assert(result.stdout.toString().includes(report));
+assertDefaultExclusions(result.stdout.toString());
 assert.strictEqual(result.status,0);
 });
 
 it('should exclude ts test files',async()=>{
-constreport=[
-'# start of coverage report',
-'# --------------------------------------------------------------',
-'# file | line % | branch % | funcs % | uncovered lines',
-'# --------------------------------------------------------------',
-'# logic-file.js | 66.67 | 100.00 | 50.00 | 5-7',
-'# --------------------------------------------------------------',
-'# all files | 66.67 | 100.00 | 50.00 | ',
-'# --------------------------------------------------------------',
-'# end of coverage report',
-].join('\n');
-
 constargs=[
 '--test',
 '--experimental-test-coverage',
@@ -111,7 +97,26 @@ describe('test runner coverage default exclusion', skipIfNoInspector, () => {
 });
 
 assert.strictEqual(result.stderr.toString(),'');
-assert(result.stdout.toString().includes(report));
+assertDefaultExclusions(result.stdout.toString());
+assert.strictEqual(result.status,0);
+});
+
+it('should exclude dotfile test files from coverage by default',async()=>{
+constargs=[
+'--no-experimental-strip-types',
+'--test',
+'--experimental-test-coverage',
+'--test-reporter=tap',
+'test/.dotfile.cjs',
+];
+constresult=spawnSync(process.execPath,args,{
+env: { ...process.env,NODE_TEST_TMPDIR: tmpdir.path},
+cwd: tmpdir.path
+});
+
+assert.strictEqual(result.stderr.toString(),'');
+assertDefaultExclusions(result.stdout.toString());
+assert.doesNotMatch(result.stdout.toString(),/#\s+\.dotfile\.cjs\s+\|/);
 assert.strictEqual(result.status,0);
 });
 });

lib/internal/test_runner/coverage.js

@@ -47,6 +47,9 @@ const kIgnoreRegex = /\/\* node:coverage ignore next (?<count>\d+ )?\*\//;
 constkLineEndingRegex=/\r?\n$/u;
 constkLineSplitRegex=/(?<=\r?\n)/u;
 constkStatusRegex=/\/\*node:coverage(?<status>enable|disable)\*\//;
+// Match dotfiles (e.g. `test/.foo.js`) when applying coverage globs so the
+// default exclude patterns cover them.
+constkMatchGlobPatternOptions={__proto__: null,dot: true};
 constkTypeOnlyImportRegex=/^\s*import\s+type\b/u;
 constkTypeScriptSourceRegex=/\.(?:cts|mts|ts)$/u;
 constkSourceFileGlob='**/*.{cjs,cts,js,mjs,mts,ts}';
@@ -63,6 +66,14 @@ function getStripTypeScriptTypesForCoverage() {
 returnstripTypeScriptTypesForCoverage;
 }
 
+functioncreateCoverageMatcher(pattern){
+return{
+__proto__: null,
+relative: createMatcher(pattern,kMatchGlobPatternOptions),
+absolute: createMatcher(pattern),
+};
+}
+
 classCoverageLine{
 constructor(line,startOffset,src,length=src?.length){
 constnewlineLength=src==null ? 0 :
@@ -605,23 +616,28 @@ class TestCoverage {
 // TestCoverage instance, so compile each glob to a matcher once and reuse
 // it for every file. Building a fresh Minimatch per call (the previous
 // behavior) dominated the coverage report time, scaling with
-// files * globs.
+// files * globs. Each glob compiles to a matcher pair: `relative` enables
+// dot:true so globs match dotfiles within the project, while `absolute`
+// keeps the default behavior to avoid misinterpreting dot segments in the
+// absolute filesystem path (e.g. tmp dirs like `test/.tmp.0`).
 this.#excludeMatchers ??=ArrayPrototypeMap(
-this.options.coverageExcludeGlobs??[],(pattern)=>createMatcher(pattern));
+this.options.coverageExcludeGlobs??[],createCoverageMatcher);
 this.#includeMatchers ??=ArrayPrototypeMap(
-this.options.coverageIncludeGlobs??[],(pattern)=>createMatcher(pattern));
+this.options.coverageIncludeGlobs??[],createCoverageMatcher);
 
 // This check filters out files that match the exclude globs.
 for(leti=0;i<this.#excludeMatchers.length;++i){
 constmatcher=this.#excludeMatchers[i];
-if(matcher.match(relativePath)||matcher.match(absolutePath))returntrue;
+if(matcher.relative.match(relativePath)||
+matcher.absolute.match(absolutePath))returntrue;
 }
 
 // This check filters out files that do not match the include globs.
 if(this.#includeMatchers.length>0){
 for(leti=0;i<this.#includeMatchers.length;++i){
 constmatcher=this.#includeMatchers[i];
-if(matcher.match(relativePath)||matcher.match(absolutePath))returnfalse;
+if(matcher.relative.match(relativePath)||
+matcher.absolute.match(absolutePath))returnfalse;
 }
 returntrue;
 }

test/fixtures/test-runner/coverage-default-exclusion/test/.dotfile.cjs

@@ -0,0 +1,7 @@
+consttest=require('node:test');
+constassert=require('node:assert');
+const{ foo }=require('../logic-file.js');
+
+test('foo returns 1 from a dotfile test',()=>{
+assert.strictEqual(foo(),1);
+});

test/parallel/test-runner-coverage-default-exclusion.mjs

@@ -16,6 +16,16 @@ async function setupFixtures() {
 awaitcp(fixtureDir,tmpdir.path,{recursive: true});
 }
 
+functionassertDefaultExclusions(stdout){
+assert.match(stdout,/#startofcoveragereport/);
+assert.doesNotMatch(stdout,/#file-test\.js\s+\|/);
+assert.doesNotMatch(stdout,/#file\.test\.mjs\s+\|/);
+assert.doesNotMatch(stdout,/#file\.test\.ts\s+\|/);
+assert.doesNotMatch(stdout,/#test\.cjs\s+\|/);
+assert.doesNotMatch(stdout,/#\s+not-matching-test-name\.js\s+\|/);
+assert.match(stdout,/#endofcoveragereport/);
+}
+
 describe('test runner coverage default exclusion',skipIfNoInspector,()=>{
 before(async()=>{
 awaitsetupFixtures();
@@ -58,18 +68,6 @@ describe('test runner coverage default exclusion', skipIfNoInspector, () => {
 });
 
 it('should exclude test files from coverage by default',async()=>{
-constreport=[
-'# start of coverage report',
-'# --------------------------------------------------------------',
-'# file | line % | branch % | funcs % | uncovered lines',
-'# --------------------------------------------------------------',
-'# logic-file.js | 66.67 | 100.00 | 50.00 | 5-7',
-'# --------------------------------------------------------------',
-'# all files | 66.67 | 100.00 | 50.00 | ',
-'# --------------------------------------------------------------',
-'# end of coverage report',
-].join('\n');
-
 constargs=[
 '--no-experimental-strip-types',
 '--test',
@@ -82,23 +80,11 @@ describe('test runner coverage default exclusion', skipIfNoInspector, () => {
 });
 
 assert.strictEqual(result.stderr.toString(),'');
-assert(result.stdout.toString().includes(report));
+assertDefaultExclusions(result.stdout.toString());
 assert.strictEqual(result.status,0);
 });
 
 it('should exclude ts test files',async()=>{
-constreport=[
-'# start of coverage report',
-'# --------------------------------------------------------------',
-'# file | line % | branch % | funcs % | uncovered lines',
-'# --------------------------------------------------------------',
-'# logic-file.js | 66.67 | 100.00 | 50.00 | 5-7',
-'# --------------------------------------------------------------',
-'# all files | 66.67 | 100.00 | 50.00 | ',
-'# --------------------------------------------------------------',
-'# end of coverage report',
-].join('\n');
-
 constargs=[
 '--test',
 '--experimental-test-coverage',
@@ -111,7 +97,26 @@ describe('test runner coverage default exclusion', skipIfNoInspector, () => {
 });
 
 assert.strictEqual(result.stderr.toString(),'');
-assert(result.stdout.toString().includes(report));
+assertDefaultExclusions(result.stdout.toString());
+assert.strictEqual(result.status,0);
+});
+
+it('should exclude dotfile test files from coverage by default',async()=>{
+constargs=[
+'--no-experimental-strip-types',
+'--test',
+'--experimental-test-coverage',
+'--test-reporter=tap',
+'test/.dotfile.cjs',
+];
+constresult=spawnSync(process.execPath,args,{
+env: { ...process.env,NODE_TEST_TMPDIR: tmpdir.path},
+cwd: tmpdir.path
+});
+
+assert.strictEqual(result.stderr.toString(),'');
+assertDefaultExclusions(result.stdout.toString());
+assert.doesNotMatch(result.stdout.toString(),/#\s+\.dotfile\.cjs\s+\|/);
 assert.strictEqual(result.status,0);
 });
 });

lib/internal/test_runner/coverage.js

@@ -47,6 +47,9 @@ const kIgnoreRegex = /\/\* node:coverage ignore next (?<count>\d+ )?\*\//;
 constkLineEndingRegex=/\r?\n$/u;
 constkLineSplitRegex=/(?<=\r?\n)/u;
 constkStatusRegex=/\/\*node:coverage(?<status>enable|disable)\*\//;
+// Match dotfiles (e.g. `test/.foo.js`) when applying coverage globs so the
+// default exclude patterns cover them.
+constkMatchGlobPatternOptions={__proto__: null,dot: true};
 constkTypeOnlyImportRegex=/^\s*import\s+type\b/u;
 constkTypeScriptSourceRegex=/\.(?:cts|mts|ts)$/u;
 constkSourceFileGlob='**/*.{cjs,cts,js,mjs,mts,ts}';
@@ -63,6 +66,14 @@ function getStripTypeScriptTypesForCoverage() {
 returnstripTypeScriptTypesForCoverage;
 }
 
+functioncreateCoverageMatcher(pattern){
+return{
+__proto__: null,
+relative: createMatcher(pattern,kMatchGlobPatternOptions),
+absolute: createMatcher(pattern),
+};
+}
+
 classCoverageLine{
 constructor(line,startOffset,src,length=src?.length){
 constnewlineLength=src==null ? 0 :
@@ -605,23 +616,28 @@ class TestCoverage {
 // TestCoverage instance, so compile each glob to a matcher once and reuse
 // it for every file. Building a fresh Minimatch per call (the previous
 // behavior) dominated the coverage report time, scaling with
-// files * globs.
+// files * globs. Each glob compiles to a matcher pair: `relative` enables
+// dot:true so globs match dotfiles within the project, while `absolute`
+// keeps the default behavior to avoid misinterpreting dot segments in the
+// absolute filesystem path (e.g. tmp dirs like `test/.tmp.0`).
 this.#excludeMatchers ??=ArrayPrototypeMap(
-this.options.coverageExcludeGlobs??[],(pattern)=>createMatcher(pattern));
+this.options.coverageExcludeGlobs??[],createCoverageMatcher);
 this.#includeMatchers ??=ArrayPrototypeMap(
-this.options.coverageIncludeGlobs??[],(pattern)=>createMatcher(pattern));
+this.options.coverageIncludeGlobs??[],createCoverageMatcher);
 
 // This check filters out files that match the exclude globs.
 for(leti=0;i<this.#excludeMatchers.length;++i){
 constmatcher=this.#excludeMatchers[i];
-if(matcher.match(relativePath)||matcher.match(absolutePath))returntrue;
+if(matcher.relative.match(relativePath)||
+matcher.absolute.match(absolutePath))returntrue;
 }
 
 // This check filters out files that do not match the include globs.
 if(this.#includeMatchers.length>0){
 for(leti=0;i<this.#includeMatchers.length;++i){
 constmatcher=this.#includeMatchers[i];
-if(matcher.match(relativePath)||matcher.match(absolutePath))returnfalse;
+if(matcher.relative.match(relativePath)||
+matcher.absolute.match(absolutePath))returnfalse;
 }
 returntrue;
 }

test/fixtures/test-runner/coverage-default-exclusion/test/.dotfile.cjs

@@ -0,0 +1,7 @@
+consttest=require('node:test');
+constassert=require('node:assert');
+const{ foo }=require('../logic-file.js');
+
+test('foo returns 1 from a dotfile test',()=>{
+assert.strictEqual(foo(),1);
+});

test/parallel/test-runner-coverage-default-exclusion.mjs

@@ -16,6 +16,16 @@ async function setupFixtures() {
 awaitcp(fixtureDir,tmpdir.path,{recursive: true});
 }
 
+functionassertDefaultExclusions(stdout){
+assert.match(stdout,/#startofcoveragereport/);
+assert.doesNotMatch(stdout,/#file-test\.js\s+\|/);
+assert.doesNotMatch(stdout,/#file\.test\.mjs\s+\|/);
+assert.doesNotMatch(stdout,/#file\.test\.ts\s+\|/);
+assert.doesNotMatch(stdout,/#test\.cjs\s+\|/);
+assert.doesNotMatch(stdout,/#\s+not-matching-test-name\.js\s+\|/);
+assert.match(stdout,/#endofcoveragereport/);
+}
+
 describe('test runner coverage default exclusion',skipIfNoInspector,()=>{
 before(async()=>{
 awaitsetupFixtures();
@@ -58,18 +68,6 @@ describe('test runner coverage default exclusion', skipIfNoInspector, () => {
 });
 
 it('should exclude test files from coverage by default',async()=>{
-constreport=[
-'# start of coverage report',
-'# --------------------------------------------------------------',
-'# file | line % | branch % | funcs % | uncovered lines',
-'# --------------------------------------------------------------',
-'# logic-file.js | 66.67 | 100.00 | 50.00 | 5-7',
-'# --------------------------------------------------------------',
-'# all files | 66.67 | 100.00 | 50.00 | ',
-'# --------------------------------------------------------------',
-'# end of coverage report',
-].join('\n');
-
 constargs=[
 '--no-experimental-strip-types',
 '--test',
@@ -82,23 +80,11 @@ describe('test runner coverage default exclusion', skipIfNoInspector, () => {
 });
 
 assert.strictEqual(result.stderr.toString(),'');
-assert(result.stdout.toString().includes(report));
+assertDefaultExclusions(result.stdout.toString());
 assert.strictEqual(result.status,0);
 });
 
 it('should exclude ts test files',async()=>{
-constreport=[
-'# start of coverage report',
-'# --------------------------------------------------------------',
-'# file | line % | branch % | funcs % | uncovered lines',
-'# --------------------------------------------------------------',
-'# logic-file.js | 66.67 | 100.00 | 50.00 | 5-7',
-'# --------------------------------------------------------------',
-'# all files | 66.67 | 100.00 | 50.00 | ',
-'# --------------------------------------------------------------',
-'# end of coverage report',
-].join('\n');
-
 constargs=[
 '--test',
 '--experimental-test-coverage',
@@ -111,7 +97,26 @@ describe('test runner coverage default exclusion', skipIfNoInspector, () => {
 });
 
 assert.strictEqual(result.stderr.toString(),'');
-assert(result.stdout.toString().includes(report));
+assertDefaultExclusions(result.stdout.toString());
+assert.strictEqual(result.status,0);
+});
+
+it('should exclude dotfile test files from coverage by default',async()=>{
+constargs=[
+'--no-experimental-strip-types',
+'--test',
+'--experimental-test-coverage',
+'--test-reporter=tap',
+'test/.dotfile.cjs',
+];
+constresult=spawnSync(process.execPath,args,{
+env: { ...process.env,NODE_TEST_TMPDIR: tmpdir.path},
+cwd: tmpdir.path
+});
+
+assert.strictEqual(result.stderr.toString(),'');
+assertDefaultExclusions(result.stdout.toString());
+assert.doesNotMatch(result.stdout.toString(),/#\s+\.dotfile\.cjs\s+\|/);
 assert.strictEqual(result.status,0);
 });
 });

lib/internal/test_runner/coverage.js

@@ -47,6 +47,9 @@ const kIgnoreRegex = /\/\* node:coverage ignore next (?<count>\d+ )?\*\//;
 constkLineEndingRegex=/\r?\n$/u;
 constkLineSplitRegex=/(?<=\r?\n)/u;
 constkStatusRegex=/\/\*node:coverage(?<status>enable|disable)\*\//;
+// Match dotfiles (e.g. `test/.foo.js`) when applying coverage globs so the
+// default exclude patterns cover them.
+constkMatchGlobPatternOptions={__proto__: null,dot: true};
 constkTypeOnlyImportRegex=/^\s*import\s+type\b/u;
 constkTypeScriptSourceRegex=/\.(?:cts|mts|ts)$/u;
 constkSourceFileGlob='**/*.{cjs,cts,js,mjs,mts,ts}';
@@ -63,6 +66,14 @@ function getStripTypeScriptTypesForCoverage() {
 returnstripTypeScriptTypesForCoverage;
 }
 
+functioncreateCoverageMatcher(pattern){
+return{
+__proto__: null,
+relative: createMatcher(pattern,kMatchGlobPatternOptions),
+absolute: createMatcher(pattern),
+};
+}
+
 classCoverageLine{
 constructor(line,startOffset,src,length=src?.length){
 constnewlineLength=src==null ? 0 :
@@ -605,23 +616,28 @@ class TestCoverage {
 // TestCoverage instance, so compile each glob to a matcher once and reuse
 // it for every file. Building a fresh Minimatch per call (the previous
 // behavior) dominated the coverage report time, scaling with
-// files * globs.
+// files * globs. Each glob compiles to a matcher pair: `relative` enables
+// dot:true so globs match dotfiles within the project, while `absolute`
+// keeps the default behavior to avoid misinterpreting dot segments in the
+// absolute filesystem path (e.g. tmp dirs like `test/.tmp.0`).
 this.#excludeMatchers ??=ArrayPrototypeMap(
-this.options.coverageExcludeGlobs??[],(pattern)=>createMatcher(pattern));
+this.options.coverageExcludeGlobs??[],createCoverageMatcher);
 this.#includeMatchers ??=ArrayPrototypeMap(
-this.options.coverageIncludeGlobs??[],(pattern)=>createMatcher(pattern));
+this.options.coverageIncludeGlobs??[],createCoverageMatcher);
 
 // This check filters out files that match the exclude globs.
 for(leti=0;i<this.#excludeMatchers.length;++i){
 constmatcher=this.#excludeMatchers[i];
-if(matcher.match(relativePath)||matcher.match(absolutePath))returntrue;
+if(matcher.relative.match(relativePath)||
+matcher.absolute.match(absolutePath))returntrue;
 }
 
 // This check filters out files that do not match the include globs.
 if(this.#includeMatchers.length>0){
 for(leti=0;i<this.#includeMatchers.length;++i){
 constmatcher=this.#includeMatchers[i];
-if(matcher.match(relativePath)||matcher.match(absolutePath))returnfalse;
+if(matcher.relative.match(relativePath)||
+matcher.absolute.match(absolutePath))returnfalse;
 }
 returntrue;
 }

test/fixtures/test-runner/coverage-default-exclusion/test/.dotfile.cjs

@@ -0,0 +1,7 @@
+consttest=require('node:test');
+constassert=require('node:assert');
+const{ foo }=require('../logic-file.js');
+
+test('foo returns 1 from a dotfile test',()=>{
+assert.strictEqual(foo(),1);
+});

test/parallel/test-runner-coverage-default-exclusion.mjs

@@ -16,6 +16,16 @@ async function setupFixtures() {
 awaitcp(fixtureDir,tmpdir.path,{recursive: true});
 }
 
+functionassertDefaultExclusions(stdout){
+assert.match(stdout,/#startofcoveragereport/);
+assert.doesNotMatch(stdout,/#file-test\.js\s+\|/);
+assert.doesNotMatch(stdout,/#file\.test\.mjs\s+\|/);
+assert.doesNotMatch(stdout,/#file\.test\.ts\s+\|/);
+assert.doesNotMatch(stdout,/#test\.cjs\s+\|/);
+assert.doesNotMatch(stdout,/#\s+not-matching-test-name\.js\s+\|/);
+assert.match(stdout,/#endofcoveragereport/);
+}
+
 describe('test runner coverage default exclusion',skipIfNoInspector,()=>{
 before(async()=>{
 awaitsetupFixtures();
@@ -58,18 +68,6 @@ describe('test runner coverage default exclusion', skipIfNoInspector, () => {
 });
 
 it('should exclude test files from coverage by default',async()=>{
-constreport=[
-'# start of coverage report',
-'# --------------------------------------------------------------',
-'# file | line % | branch % | funcs % | uncovered lines',
-'# --------------------------------------------------------------',
-'# logic-file.js | 66.67 | 100.00 | 50.00 | 5-7',
-'# --------------------------------------------------------------',
-'# all files | 66.67 | 100.00 | 50.00 | ',
-'# --------------------------------------------------------------',
-'# end of coverage report',
-].join('\n');
-
 constargs=[
 '--no-experimental-strip-types',
 '--test',
@@ -82,23 +80,11 @@ describe('test runner coverage default exclusion', skipIfNoInspector, () => {
 });
 
 assert.strictEqual(result.stderr.toString(),'');
-assert(result.stdout.toString().includes(report));
+assertDefaultExclusions(result.stdout.toString());
 assert.strictEqual(result.status,0);
 });
 
 it('should exclude ts test files',async()=>{
-constreport=[
-'# start of coverage report',
-'# --------------------------------------------------------------',
-'# file | line % | branch % | funcs % | uncovered lines',
-'# --------------------------------------------------------------',
-'# logic-file.js | 66.67 | 100.00 | 50.00 | 5-7',
-'# --------------------------------------------------------------',
-'# all files | 66.67 | 100.00 | 50.00 | ',
-'# --------------------------------------------------------------',
-'# end of coverage report',
-].join('\n');
-
 constargs=[
 '--test',
 '--experimental-test-coverage',
@@ -111,7 +97,26 @@ describe('test runner coverage default exclusion', skipIfNoInspector, () => {
 });
 
 assert.strictEqual(result.stderr.toString(),'');
-assert(result.stdout.toString().includes(report));
+assertDefaultExclusions(result.stdout.toString());
+assert.strictEqual(result.status,0);
+});
+
+it('should exclude dotfile test files from coverage by default',async()=>{
+constargs=[
+'--no-experimental-strip-types',
+'--test',
+'--experimental-test-coverage',
+'--test-reporter=tap',
+'test/.dotfile.cjs',
+];
+constresult=spawnSync(process.execPath,args,{
+env: { ...process.env,NODE_TEST_TMPDIR: tmpdir.path},
+cwd: tmpdir.path
+});
+
+assert.strictEqual(result.stderr.toString(),'');
+assertDefaultExclusions(result.stdout.toString());
+assert.doesNotMatch(result.stdout.toString(),/#\s+\.dotfile\.cjs\s+\|/);
 assert.strictEqual(result.status,0);
 });
 });