use std::collections::{HashMap, HashSet};
use crate::mask::is_placeholder;
const MAX_TRACKED_VALUES: usize = 10;
const MIN_AVG_REPETITION: f64 = 5.0;
fn looks_identifier_like(value: &str) -> bool {
value.contains(|c: char| c.is_ascii_digit())
|| value.contains("::")
|| value.contains('/')
|| value.contains('.')
}
#[derive(Clone)]
struct ValueEntry {
count: u64,
first_line_no: usize,
first_raw: String,
}
#[derive(Default)]
struct PositionValues {
values: HashMap<String, ValueEntry>,
overflowed: bool,
}
impl PositionValues {
fn record(&mut self, value: &str, line_no: usize, raw: &str) {
if self.overflowed {
return;
}
if let Some(e) = self.values.get_mut(value) {
e.count += 1;
return;
}
if self.values.len() >= MAX_TRACKED_VALUES {
self.overflowed = true;
self.values.clear();
return;
}
self.values.insert(
value.to_string(),
ValueEntry {
count: 1,
first_line_no: line_no,
first_raw: raw.to_string(),
},
);
}
}
pub struct NewValue {
pub value: String,
pub baseline_values: Vec<String>,
pub first_target_line_no: usize,
pub first_target_raw: String,
pub established: f64,
}
pub struct ValueTracker {
baselines: Vec<HashMap<(usize, usize), PositionValues>>,
target: HashMap<(usize, usize), PositionValues>,
}
impl ValueTracker {
pub fn with_baselines(n: usize) -> Self {
ValueTracker {
baselines: (0..n).map(|_| HashMap::new()).collect(),
target: HashMap::new(),
}
}
pub fn record_baseline(
&mut self,
baseline_idx: usize,
cluster_id: usize,
line_no: usize,
raw: &str,
tokens: &[String],
) {
let map = &mut self.baselines[baseline_idx];
for (pos, tok) in tokens.iter().enumerate() {
if is_placeholder(tok) || looks_identifier_like(tok) {
continue;
}
map.entry((cluster_id, pos))
.or_default()
.record(tok, line_no, raw);
}
}
pub fn record_target(
&mut self,
cluster_id: usize,
line_no: usize,
raw: &str,
tokens: &[String],
) {
for (pos, tok) in tokens.iter().enumerate() {
if is_placeholder(tok) || looks_identifier_like(tok) {
continue;
}
self.target
.entry((cluster_id, pos))
.or_default()
.record(tok, line_no, raw);
}
}
pub fn new_value_at(&self, cluster_id: usize, pos: usize) -> Option<NewValue> {
let key = (cluster_id, pos);
let mut baseline_set: HashSet<&str> = HashSet::new();
let mut baseline_total: u64 = 0;
for b in &self.baselines {
if let Some(pv) = b.get(&key) {
if pv.overflowed {
return None;
}
baseline_set.extend(pv.values.keys().map(String::as_str));
baseline_total += pv.values.values().map(|e| e.count).sum::<u64>();
}
}
if baseline_set.is_empty() || baseline_set.len() > MAX_TRACKED_VALUES {
return None;
}
let established = baseline_total as f64 / baseline_set.len() as f64;
if established < MIN_AVG_REPETITION {
return None;
}
let target_pv = self.target.get(&key)?;
if target_pv.overflowed {
return None;
}
let mut candidates: Vec<(&str, &ValueEntry)> = target_pv
.values
.iter()
.filter(|(v, _)| !baseline_set.contains(v.as_str()))
.map(|(v, e)| (v.as_str(), e))
.collect();
candidates.sort_by(|a, b| b.1.count.cmp(&a.1.count).then(a.0.cmp(b.0)));
let (value, entry) = candidates.into_iter().next()?;
let mut baseline_values: Vec<String> = baseline_set.into_iter().map(String::from).collect();
baseline_values.sort();
Some(NewValue {
value: value.to_string(),
baseline_values,
first_target_line_no: entry.first_line_no,
first_target_raw: entry.first_raw.clone(),
established,
})
}
}
#[cfg(test)]
mod tests {
use super::*;
fn record_n(
t: &mut ValueTracker,
baseline_idx: usize,
value: &str,
n: usize,
start_line: usize,
) {
for i in 0..n {
t.record_baseline(baseline_idx, 0, start_line + i, "r", &[value.to_string()]);
}
}
#[test]
fn flags_a_value_never_seen_in_any_baseline() {
let mut t = ValueTracker::with_baselines(1);
record_n(&mut t, 0, "PASSED", 8, 1);
t.record_target(0, 100, "raw100", &["FAILED".to_string()]);
let found = t.new_value_at(0, 0).expect("should flag FAILED as new");
assert_eq!(found.value, "FAILED");
assert_eq!(found.baseline_values, vec!["PASSED".to_string()]);
assert_eq!(found.first_target_line_no, 100);
assert_eq!(found.first_target_raw, "raw100");
}
#[test]
fn does_not_flag_a_value_already_seen_in_baseline() {
let mut t = ValueTracker::with_baselines(1);
record_n(&mut t, 0, "PASSED", 6, 1);
record_n(&mut t, 0, "FAILED", 6, 100);
t.record_target(0, 200, "r", &["FAILED".to_string()]);
assert!(t.new_value_at(0, 0).is_none());
}
#[test]
fn placeholder_tokens_are_never_tracked() {
let mut t = ValueTracker::with_baselines(1);
record_n(&mut t, 0, "<IP>", 8, 1);
t.record_target(0, 100, "r", &["<IP>".to_string()]);
assert!(t.new_value_at(0, 0).is_none());
}
#[test]
fn high_cardinality_position_is_not_flagged() {
let mut t = ValueTracker::with_baselines(1);
for i in 0..(MAX_TRACKED_VALUES + 5) {
let label = format!("status{}", (b'a' + (i % 26) as u8) as char);
t.record_baseline(0, 0, i, "r", &[label]);
}
t.record_target(0, 999, "r", &["status-new".to_string()]);
assert!(
t.new_value_at(0, 0).is_none(),
"a high-cardinality position must overflow and stop being reported"
);
}
#[test]
fn identifier_like_values_are_never_tracked() {
let mut t = ValueTracker::with_baselines(1);
for (i, worker) in ["gw0", "gw1", "gw2"].iter().cycle().take(9).enumerate() {
t.record_baseline(0, 0, i, "r", &[worker.to_string()]);
}
t.record_target(0, 100, "r", &["gw3".to_string()]);
assert!(
t.new_value_at(0, 0).is_none(),
"worker ids must not be tracked as values"
);
let mut t2 = ValueTracker::with_baselines(1);
for i in 0..8 {
t2.record_baseline(0, 0, i, "r", &["tests/test_a.py::test_x".to_string()]);
}
t2.record_target(0, 100, "r", &["tests/test_b.py::test_y".to_string()]);
assert!(
t2.new_value_at(0, 0).is_none(),
"test ids must not be tracked as values"
);
}
#[test]
fn low_repetition_baseline_values_are_not_established_enough() {
let mut t = ValueTracker::with_baselines(1);
t.record_baseline(0, 0, 1, "r", &["alpha".to_string()]);
t.record_baseline(0, 0, 2, "r", &["bravo".to_string()]);
t.record_baseline(0, 0, 3, "r", &["charlie".to_string()]);
t.record_target(0, 4, "r", &["delta".to_string()]);
assert!(t.new_value_at(0, 0).is_none());
}
#[test]
fn established_status_position_is_flagged_once_repetition_clears_the_bar() {
let mut t = ValueTracker::with_baselines(1);
record_n(&mut t, 0, "PASSED", 5, 1); t.record_target(0, 100, "r", &["FAILED".to_string()]);
assert!(t.new_value_at(0, 0).is_some());
}
#[test]
fn most_frequent_new_value_wins_ties_broken_alphabetically() {
let mut t = ValueTracker::with_baselines(1);
record_n(&mut t, 0, "PASSED", 6, 1);
t.record_target(0, 100, "r", &["FLAKY".to_string()]);
t.record_target(0, 101, "r", &["FLAKY".to_string()]);
t.record_target(0, 102, "r", &["ERROR".to_string()]);
let found = t.new_value_at(0, 0).unwrap();
assert_eq!(found.value, "FLAKY"); }
#[test]
fn multiple_baselines_union_their_seen_values() {
let mut t = ValueTracker::with_baselines(2);
record_n(&mut t, 0, "PASSED", 5, 1);
record_n(&mut t, 1, "SKIPPED", 5, 1);
t.record_target(0, 100, "r", &["SKIPPED".to_string()]);
assert!(t.new_value_at(0, 0).is_none());
}
#[test]
fn established_reflects_baseline_repetition() {
let mut t = ValueTracker::with_baselines(1);
record_n(&mut t, 0, "PASSED", 20, 1);
t.record_target(0, 100, "r", &["FAILED".to_string()]);
let found = t.new_value_at(0, 0).unwrap();
assert_eq!(found.established, 20.0); }
}