use std::sync::{Mutex, OnceLock}; use log::{Level, Log, Metadata, Record}; use crate::{LOG_TARGET, ReportErrorLogMode}; #[derive(Clone, Debug, Eq, PartialEq)]struct LogEntry {    target: String,    level: Level,    message: String,} struct TestLogger; static LOGGER: TestLogger = TestLogger;static LOGS: OnceLock<Mutex<Vec<LogEntry>>> = OnceLock::new(); impl Log for TestLogger {    fn enabled(&self, _metadata: &Metadata) -> bool {        true    }     fn log(&self, record: &Record) {        logs().lock().unwrap().push(LogEntry {            target: record.target().to_owned(),            level: record.level(),            message: record.args().to_string(),        });    }     fn flush(&self) {}} fn logs() -> &'static Mutex<Vec<LogEntry>> {    LOGS.get_or_init(|| Mutex::new(Vec::new()))} fn init_logger() {    let _ = log::set_logger(&LOGGER);    log::set_max_level(log::LevelFilter::Trace);    logs().lock().unwrap().clear();} fn logged_report_count(message: &str) -> usize {    logs()        .lock()        .unwrap()        .iter()        .filter(|entry| {            entry.target == LOG_TARGET && entry.level == Level::Error && entry.message == message        })        .count()} fn report_once_per_run_error() {    report_error!(        anyhow::anyhow!("once per run"),        ReportErrorLogMode::OncePerRun    );} fn report_first_callsite_once_per_run_error() {    report_error!(        anyhow::anyhow!("separate once per run"),        ReportErrorLogMode::OncePerRun    );} fn report_second_callsite_once_per_run_error() {    report_error!(        anyhow::anyhow!("separate once per run"),        ReportErrorLogMode::OncePerRun    );} fn report_if_error_once_per_run(result: Result<(), anyhow::Error>) {    report_if_error!(result, ReportErrorLogMode::OncePerRun);} #[test]fn report_error_log_mode_controls_log_frequency() {    init_logger();     for _ in 0..2 {        report_error!(anyhow::anyhow!("default"));    }    assert_eq!(logged_report_count("default"), 2);     logs().lock().unwrap().clear();    for _ in 0..2 {        report_error!(            anyhow::anyhow!("explicit every time"),            ReportErrorLogMode::EveryTime        );    }    assert_eq!(logged_report_count("explicit every time"), 2);     logs().lock().unwrap().clear();    report_once_per_run_error();    report_once_per_run_error();    assert_eq!(logged_report_count("once per run"), 1);     logs().lock().unwrap().clear();    for _ in 0..2 {        report_first_callsite_once_per_run_error();        report_second_callsite_once_per_run_error();    }    assert_eq!(logged_report_count("separate once per run"), 2);     logs().lock().unwrap().clear();    for _ in 0..2 {        report_if_error_once_per_run(Err(anyhow::anyhow!("result once per run")));    }    assert_eq!(logged_report_count("result once per run"), 1);} #[test]fn new_macro_forms_log_as_expected() {    init_logger();     // Bare string-literal form wraps the message in an anyhow error and reports it.    report_error!("a static message");    assert_eq!(logged_report_count("a static message"), 1);     // `extra: { .. }` appends fields to the log line (Display default, `?` Debug).    logs().lock().unwrap().clear();    let items = vec![1, 2, 3];    report_error!(        anyhow::anyhow!("boom"),        extra: { "count" => 3, "items" => ?items }    );    assert_eq!(logged_report_count("boom [count=3, items=[1, 2, 3]]"), 1);     // Literal message plus extra.    logs().lock().unwrap().clear();    report_error!("load failed", extra: { "id" => 7 });    assert_eq!(logged_report_count("load failed [id=7]"), 1);     // report_if_error! with extra only reports on Err.    logs().lock().unwrap().clear();    let ok: Result<(), anyhow::Error> = Ok(());    report_if_error!(ok, extra: { "k" => 1 });    assert_eq!(logs().lock().unwrap().len(), 0);    let err: Result<(), anyhow::Error> = Err(anyhow::anyhow!("nope"));    report_if_error!(err, extra: { "k" => 1 });    assert_eq!(logged_report_count("nope [k=1]"), 1);}