benchmark: add benchmark for NODE_V8_COVERAGE

PR-URL: #36972
Reviewed-By: Rich Trott <rtrott@gmail.com>
Reviewed-By: Benjamin Gruenbaum <benjamingr@gmail.com>
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Joyee Cheung <joyeec9h3@gmail.com>
Reviewed-By: Richard Lau <rlau@redhat.com>

Author: bcoe

benchmark/fixtures/coverage-many-branches.js

@@ -0,0 +1,115 @@
+'use strict';
+
+// Exercise coverage of a class. Note, this logic is silly and exists solely
+// to generate branch coverage code paths:
+classCoveredClass{
+constructor(x,y,opts){
+this.x=x;
+this.y=y;
+// Exercise coverage of nullish coalescing:
+this.opts=opts??(Math.random()>0.5 ? {} : undefined);
+}
+add(){
+returnthis.x+this.y;
+}
+addSpecial(){
+// Exercise coverage of optional chains:
+if(this.opts?.special&&this.opts?.special?.x&&this.opts?.special?.y){
+returnthis.opts.special.x+this.opts.special.y;
+}
+returnadd();
+}
+mult(){
+returnthis.x*this.y;
+}
+multSpecial(){
+if(this.opts?.special&&this.opts?.special?.x&&this.opts?.special?.y){
+returnthis.opts.special.x*this.opts.special.y;
+}
+returnmult();
+}
+}
+
+// Excercise coverage of functions:
+functionadd(x,y){
+constmt=newCoveredClass(x,y);
+returnmt.add();
+}
+
+functionaddSpecial(x,y){
+letmt;
+if(Math.random()>0.5){
+mt=newCoveredClass(x,y);
+}else{
+mt=newCoveredClass(x,y,{
+special: {
+x: Math.random()*x,
+y: Math.random()*y
+}
+});
+}
+returnmt.addSpecial();
+}
+
+functionmult(x,y){
+constmt=newCoveredClass(x,y);
+returnmt.mult();
+}
+
+functionmultSpecial(x,y){
+letmt;
+if(Math.random()>0.5){
+mt=newCoveredClass(x,y);
+}else{
+mt=newCoveredClass(x,y,{
+special: {
+x: Math.random()*x,
+y: Math.random()*y
+}
+});
+}
+returnmt.multSpecial();
+}
+
+for(leti=0;i<parseInt(process.env.N);i++){
+constoperations=['add','addSpecial','mult','multSpecial'];
+for(constoperationofoperations){
+// Exercise coverage of switch statements:
+switch(operation){
+case'add':
+if(add(Math.random()*10,Math.random()*10)>10){
+// Exercise coverage of ternary operations:
+letr=addSpecial(Math.random()*10,Math.random()*10)>10 ?
+mult(Math.random()*10,Math.random()*10) :
+add(Math.random()*10,Math.random()*10);
+// Exercise && and ||
+if(r&&Math.random()>0.5||Math.random()<0.5)r++;
+}
+break;
+case'addSpecial':
+if(addSpecial(Math.random()*10,Math.random()*10)>10&&
+add(Math.random()*10,Math.random()*10)>10){
+letr=mult(Math.random()*10,Math.random()*10)>10 ?
+add(Math.random()*10,Math.random()*10)>10 :
+mult(Math.random()*10,Math.random()*10);
+if(r&&Math.random()>0.5||Math.random()<0.5)r++;
+}
+break;
+case'mult':
+if(mult(Math.random()*10,Math.random()*10)>10){
+letr=multSpecial(Math.random()*10,Math.random()*10)>10 ?
+add(Math.random()*10,Math.random()*10) :
+mult(Math.random()*10,Math.random()*10);
+if(r&&Math.random()>0.5||Math.random()<0.5)r++;
+}
+break;
+case'multSpecial':
+while(multSpecial(Math.random()*10,Math.random()*10)<10){
+mult(Math.random()*10,Math.random()*10);
+}
+break;
+default:
+break;
+}
+}
+}

benchmark/process/coverage.js

@@ -0,0 +1,32 @@
+// This benchmark is meant to exercise a grab bag of code paths that would
+// be expected to run slower under coverage.
+'use strict';
+
+constcommon=require('../common.js');
+constbench=common.createBenchmark(main,{
+n: [1e5]
+});
+constpath=require('path');
+const{ rmSync }=require('fs');
+const{ spawnSync }=require('child_process');
+consttmpdir=require('../../test/common/tmpdir');
+
+constcoverageDir=path.join(tmpdir.path,`./cov-${Date.now()}`);
+
+functionmain({ n }){
+bench.start();
+constresult=spawnSync(process.execPath,[
+require.resolve('../fixtures/coverage-many-branches'),
+],{
+env: {
+NODE_V8_COVERAGE: coverageDir,
+N: n,
+ ...process.env
+}
+});
+bench.end(n);
+rmSync(coverageDir,{recursive: true,force: true});
+if(result.status!==0){
+thrownewError(result.stderr.toString('utf8'));
+}
+}