///|
#derive(Debug)
pub(all) struct TestComparison {
signature : TestSignature
before : TestStatistics
after : TestStatistics
mean_delta : Double?
failure_rate_delta : Double?
}
///|
#derive(Debug)
pub(all) struct BatchComparison {
before_yield : YieldSummary
after_yield : YieldSummary
tests : Array[TestComparison]
diagnostics : Array[Diagnostic]
}
///|
fn comparison_identity(signature : TestSignature) -> String {
"\{signature.kind}/\{signature.number}"
}
///|
fn comparison_unresolved(signature : TestSignature) -> Bool {
(signature.kind == "PTR" || signature.kind == "MPR") &&
signature.units is None
}
///|
fn comparison_delta(before : Double?, after : Double?) -> Double? {
match (before, after) {
(Some(a), Some(b)) => {
let delta = b - a
if a.is_finite() && b.is_finite() && delta.is_finite() {
Some(delta)
} else {
None
}
}
_ => None
}
}
///|
fn comparison_warn(
diagnostics : Array[Diagnostic],
signature : TestSignature,
side : String,
code : String,
) -> Unit {
diagnostics.push({
offset: 0,
code,
message: "\{side} batch: \{code}; \{@debug.to_string(signature)}",
})
}
///|
/// Compare raw batch statistics in left first-seen context order. Exact
/// signatures are required, independently of text. PTR/MPR with missing units
/// are unresolved, even if both sides have the same missing context. FTR can
/// match without units because it supplies execution status, not numeric data.
/// Every unmatched signature on either side produces a diagnostic; matched
/// variants do not hide additional changed variants. Diagnostics use offset 0
/// because a signature can aggregate observations at multiple source offsets.
/// Deltas are after minus before, absent if either metric or the delta is
/// nonfinite. No significance or causal claim is inferred from a difference.
pub fn compare_batches(
left : Array[Part],
right : Array[Part],
) -> BatchComparison {
let before = test_statistics(left)
let after = test_statistics(right)
let before_identities : Map[String, Bool] = Map([])
let after_identities : Map[String, Bool] = Map([])
let after_indexes : Map[TestSignature, Int32] = Map([])
for item in before {
before_identities[comparison_identity(item.signature)] = true
}
for i in 0..