我正在使用Inspector API来获得JavaScript的精确覆盖率。我在target.js中实现了一个目标函数（在解释中添加了target.js中的行注解以引用它们），并在m1n 1o1p上实现了一条测试运行程序，它应该收集精确的覆盖信息。您可以通过运行node main.js自行测试设置。

const inspector = require("node:inspector");
const fs = require("fs");

const target = require("./target.js").target;

async function run(session, data) {
    await new Promise((resolve, reject) => {
        session.post("Profiler.startPreciseCoverage", { callCount: true, detailed: true }, (err) => {
            err ? reject(err) : resolve();
        });
    });

    console.log("Input: ", data, " - Output: ", target(data));

    return await new Promise((resolve, reject) => {
        session.post("Profiler.takePreciseCoverage", (err, params) => {
            err ? reject(err) : resolve(params);
        });
    });
}

function printCoverage(result) {
    const content = fs.readFileSync("./target.js", { encoding: "utf-8" });

    for (let scriptCoverage of result) {
        if (!scriptCoverage.url.endsWith("target.js")) {
            continue;
        }

        for (let func of scriptCoverage.functions) {
            for (let range of func.ranges) {
                console.log(
                    func.functionName,
                    range.startOffset,
                    range.endOffset,
                    range.count,
                    content.substring(range.startOffset, range.endOffset).replaceAll("\n", "").replaceAll("\t", " ").replaceAll("    ", " ")
                );
            }
        }
    }
}

async function main() {
    inspector.open(9696);

    const session = new inspector.Session();
    session.connect();

    await new Promise((resolve, reject) => {
        session.post("Profiler.enable", (err) => {
            if (err) {
                reject(err);
            }

            resolve();
        });
    });

    const param1 = await run(session, "a");
    printCoverage(param1.result);

    const param2 = await run(session, "ab");
    printCoverage(param2.result);

    const param3 = await run(session, "ac");
    printCoverage(param3.result);
}

main();
// main.js

/* 1: */ function target(data) {
/* 2: */     if (data.length === 1) {
/* 3: */         return 1;
/* 4: */     }
/* 5: */ 
/* 6: */     if (data.length == 2) {
/* 7: */         if (data[0] === "a" && data[1] === "b") {
/* 8: */             return 2;
/* 9: */         }
/* a: */ 
/* b: */         if (data[0] === "a") {
/* c: */             return 3;
/* d: */         }
/* e: */     }
/* f: */ }

module.exports = {
    target: target
};
// target.js

不幸的是，下面的输出对我来说很不直观。我本以为覆盖率信息是：

• “a”：第1-3行
• “ab”：第1-8行
• “ac”：第1、2、6、7、b、c行（编辑1：固定范围）

相反，coverage输出似乎只是告诉我target（）函数已被覆盖，而target（（）中的某些范围未被覆盖。我是否使用了错误的API？还是我对区块覆盖率的预期是错误的？如何在JavaScript中获得“真实”的基本块覆盖率？

Input:  a  - Output:  1
target 0 259 1 function target(data) { if (data.length === 1) {  return 1; } if (data.length == 2) {  if (data[0] === "a" && data[1] === "b") {   return 2;  }  if (data[0] === "a") {   return 3;  } }}
target 76 257 0  if (data.length == 2) {  if (data[0] === "a" && data[1] === "b") {   return 2;  }  if (data[0] === "a") {   return 3;  } }
Input:  ab  - Output:  2
target 0 259 1 function target(data) { if (data.length === 1) {  return 1; } if (data.length == 2) {  if (data[0] === "a" && data[1] === "b") {   return 2;  }  if (data[0] === "a") {   return 3;  } }}
target 51 76 0 {  return 1; }
target 187 251 0   if (data[0] === "a") {   return 3;  }
Input:  ac  - Output:  3
target 0 259 1 function target(data) { if (data.length === 1) {  return 1; } if (data.length == 2) {  if (data[0] === "a" && data[1] === "b") {   return 2;  }  if (data[0] === "a") {   return 3;  } }}
target 51 76 0 {  return 1; }
target 154 187 0 {   return 2;  }

编辑1：
我认为下面的图片更适合解释我的期望。源代码中有9个基本块（如果包含未定义的隐式返回），我想检索哪些基本块已被覆盖。
例如，输入“ab”将覆盖五个块A、B、E、G、I。然而，从Inspector API中，我只得到了整个函数被覆盖的信息，而这个函数的某些字节没有被覆盖。从这一点上，我既不能（据我所知）导出函数中基本块的数量，也不能导出执行的块。

小时