@mark1russell7/rigor-bench 0.2.21 → 0.2.23

package/build/index.js

@@ -2295,6 +2295,110 @@ function trueOutcome(ratio, verdict = {}) {
 	if ((verdict.rule ?? "difference") === "difference" && Math.abs(Math.log(ratio)) <= verdictMargin(verdict)) return "same";
 	return ratio < 1 ? "faster" : ratio > 1 ? "slower" : "same";
 }
+// src/results.ts
+const keyOf = (row) => JSON.stringify([
+	row.case,
+	row.base,
+	row.head
+]);
+/** This function checks the parsed content of a file of rows. A row with an empty field, or the same row two times, stops the read with an error. */
+function resultRows(content) {
+	if (!Array.isArray(content)) throw new Error("resultRows: the rows are an array.");
+	const known = /* @__PURE__ */ new Set();
+	return content.map((item, index) => {
+		const row = typeof item === "object" && item !== null ? item : {};
+		const where = `resultRows: row ${String(index)}`;
+		const { case: name, base, head, reason } = row;
+		if (typeof name !== "string" || name === "") throw new Error(`${where} has no case.`);
+		if (typeof base !== "string" || base === "") throw new Error(`${where} has no hash of the base.`);
+		if (typeof head !== "string" || head === "") throw new Error(`${where} has no hash of the head.`);
+		if (typeof reason !== "string" || reason.trim() === "") throw new Error(`${where} has no reason.`);
+		const key = keyOf({
+			case: name,
+			base,
+			head
+		});
+		if (known.has(key)) throw new Error(`${where} repeats the case ${JSON.stringify(name)} with the same hashes.`);
+		known.add(key);
+		return {
+			case: name,
+			base,
+			head,
+			reason
+		};
+	});
+}
+/** This function tells which side of a run differs from a row. */
+function moved(item, row) {
+	if (item.base !== row.base && item.head !== row.head) return "both sides moved";
+	return item.base !== row.base ? "the base moved" : "the head moved";
+}
+/** This function gives the line of a case that no row accepts. */
+function refusal(item, live, spent) {
+	const start = `The case ${JSON.stringify(item.case)} gives two different results`;
+	if (spent.has(keyOf(item))) return `${start}, and the base already has the row of this change, so that row is spent. Delete that row in its own pull request, then add the row again.`;
+	const others = live.filter((row) => row.case === item.case);
+	const read = `base ${item.base} and head ${item.head}`;
+	if (others.length > 0) return `${start}: ${read}. ${others.map((row) => `A row accepts base ${row.base} and head ${row.head}, so ${moved(item, row)}.`).join(" ")}`;
+	return `${start}, and no row accepts them. To accept this change, add the row ${JSON.stringify({
+		case: item.case,
+		base: item.base,
+		head: item.head,
+		reason: "the reason for the change"
+	})} in this pull request.`;
+}
+/**
+* This function gives the verdict over the results of a run. A case with two different results passes only with a new row of its exact hashes.
+* The verdict reads results only, so an accepted case still needs its time verdict.
+*/
+function resultVerdict(results, rows) {
+	const spentKeys = new Set(rows.base.map(keyOf));
+	const live = rows.head.filter((row) => !spentKeys.has(keyOf(row)));
+	const used = /* @__PURE__ */ new Set();
+	const cases = results.filter((item) => item.base !== item.head).map((item) => {
+		const row = live.find((other) => keyOf(other) === keyOf(item));
+		if (row === void 0) return {
+			case: item.case,
+			base: item.base,
+			head: item.head,
+			outcome: "refused",
+			line: refusal(item, live, spentKeys)
+		};
+		used.add(keyOf(row));
+		return {
+			case: item.case,
+			base: item.base,
+			head: item.head,
+			outcome: "accepted",
+			line: `The case ${JSON.stringify(item.case)} changes its result from ${item.base} to ${item.head}, and a row accepts this: ${row.reason}`
+		};
+	});
+	const named = new Set(results.map((item) => item.case));
+	const idle = live.filter((row) => !used.has(keyOf(row)));
+	const unused = idle.filter((row) => named.has(row.case)).map((row) => ({
+		row,
+		line: `The new row of the case ${JSON.stringify(row.case)} accepts no change of this run. Delete or correct the row.`
+	}));
+	const absent = idle.filter((row) => !named.has(row.case)).map((row) => ({
+		row,
+		line: `The new row of the case ${JSON.stringify(row.case)} has no read: the case has no result in this run.`
+	}));
+	const spent = rows.head.filter((row) => spentKeys.has(keyOf(row)));
+	const fails = cases.some((item) => item.outcome === "refused") || unused.length > 0 || absent.length > 0;
+	const count = spent.length > 0 ? [`The spent rows: ${String(spent.length)}. The base has them, so they accept nothing.`] : [];
+	return {
+		outcome: fails ? "fail" : "pass",
+		cases,
+		unused,
+		absent,
+		spent,
+		lines: [...[
+			...cases,
+			...unused,
+			...absent
+		].map((item) => item.line), ...count]
+	};
+}
 // src/rounds.ts
 /**
 * The timed rounds of one case in one process. The two arms first run for a warm-up time. Then the count of calls of
@@ -2351,6 +2455,6 @@ function timeRounds(arms, options) {
 		sink
 	};
 }
-export { BUDGET_LOOKS, CEILING_ONLY, GATE_LOOKS, LADDER_FORMAT, UNKNOWN_MODEL, aaBand, aaSpread, armModels, armOrder, armVerdicts, balanceOrders, budgetLookSpend, budgetLooksVerdict, budgetVerdict, caseIntervals, caseRatios, caseTails, checkLadder, checkMeasures, checkPairedTime, controlFactor, firstArm, gateOf, jointClaim, ladderVerdict, limitOnModel, limitVerdict, modelRowText, modelTest, notSlowerVerdict, orderSize, poolRecords, pooledBand, pooledLimitVerdict, pooledVerdict, rungVerdict, tailFalseFails, tailLimitVerdict, timeRounds, timeVerdict, verdictMargin, verdictPower, visibleShift, winClaim };
+export { BUDGET_LOOKS, CEILING_ONLY, GATE_LOOKS, LADDER_FORMAT, UNKNOWN_MODEL, aaBand, aaSpread, armModels, armOrder, armVerdicts, balanceOrders, budgetLookSpend, budgetLooksVerdict, budgetVerdict, caseIntervals, caseRatios, caseTails, checkLadder, checkMeasures, checkPairedTime, controlFactor, firstArm, gateOf, jointClaim, ladderVerdict, limitOnModel, limitVerdict, modelRowText, modelTest, notSlowerVerdict, orderSize, poolRecords, pooledBand, pooledLimitVerdict, pooledVerdict, resultRows, resultVerdict, rungVerdict, tailFalseFails, tailLimitVerdict, timeRounds, timeVerdict, verdictMargin, verdictPower, visibleShift, winClaim };
 
 //# sourceMappingURL=index.js.map