ktstr 0.10.0

Test harness for Linux process schedulers
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135

//! Unit tests for the `enforce` flag in `MonitorThresholds`:
//! the same violation must yield `passed=false` when
//! `enforce=true` and `passed=true` (report-only) when
//! `enforce=false`, with details and summary set accordingly.
//! Co-located via the sibling `*_tests.rs` pattern.

#![cfg(test)]

use super::*;

/// Behavioral pin: with `enforce: true`, a recorded violation flips
/// `verdict.passed` to false. The enforcement arithmetic at
/// src/monitor/mod.rs (passed = !failed || !enforce) reduces to
/// `passed = !failed` when enforce is true. A regression that
/// inverts this polarity (e.g. accidentally drops the negation on
/// `!self.enforce`) would let violations silently pass even under
/// enforce=true, defeating the test author's opt-in.
///
/// Parallel to `stuck_sustained_window_catches_real_stuck` above
/// (same fixture) but explicitly asserts the end-to-end arithmetic
/// rather than the canary-style "stall must fail" framing.
#[test]
fn enforce_true_with_violation_yields_passed_false() {
    let t = MonitorThresholds {
        fail_on_stall: true,
        sustained_samples: 3,
        enforce: true,
        ..Default::default()
    };
    let samples: Vec<_> = (0..4u64)
        .map(|i| MonitorSample {
            prog_stats: None,
            elapsed_ms: i * 100,
            cpus: vec![
                CpuSnapshot {
                    nr_running: 1,
                    rq_clock: 5000,
                    ..Default::default()
                },
                CpuSnapshot {
                    nr_running: 1,
                    rq_clock: 6000 + i * 500,
                    ..Default::default()
                },
            ],
        })
        .collect();
    let summary = MonitorSummary::from_samples(&samples);
    let report = MonitorReport {
        samples,
        summary,
        ..Default::default()
    };
    let v = t.evaluate(&report);
    assert!(
        !v.is_pass(),
        "enforce=true + violation must yield passed=false: {:?}",
        v.details
    );
    assert!(
        !v.details.is_empty(),
        "violation must be recorded in details even when enforce=true"
    );
    assert!(
        v.summary.contains("FAILED"),
        "summary must indicate failure: {}",
        v.summary
    );
}

/// Behavioral pin: with `enforce: false` (the report-only default),
/// the SAME violation that fails the enforced fixture above MUST
/// yield `verdict.passed == true`. The violation is still recorded
/// in `details` and the summary carries the report-only advisory;
/// only the boolean verdict flips. Catches a regression in the
/// `passed = !failed || !enforce` arithmetic at src/monitor/mod.rs
/// that would silently fail tests using the report-only default —
/// exactly the silent-bug class the report-only mode is designed to
/// prevent.
///
/// Same fixture as `enforce_true_with_violation_yields_passed_false`
/// above with enforce flipped to false; pair-tested to pin both
/// polarities of the same end-to-end evaluation arithmetic.
#[test]
fn enforce_false_with_violation_yields_passed_true_and_records_details() {
    let t = MonitorThresholds {
        fail_on_stall: true,
        sustained_samples: 3,
        enforce: false,
        ..Default::default()
    };
    let samples: Vec<_> = (0..4u64)
        .map(|i| MonitorSample {
            prog_stats: None,
            elapsed_ms: i * 100,
            cpus: vec![
                CpuSnapshot {
                    nr_running: 1,
                    rq_clock: 5000,
                    ..Default::default()
                },
                CpuSnapshot {
                    nr_running: 1,
                    rq_clock: 6000 + i * 500,
                    ..Default::default()
                },
            ],
        })
        .collect();
    let summary = MonitorSummary::from_samples(&samples);
    let report = MonitorReport {
        samples,
        summary,
        ..Default::default()
    };
    let v = t.evaluate(&report);
    assert!(
        v.is_pass(),
        "enforce=false + violation must yield passed=true (report-only mode)"
    );
    assert!(
        !v.details.is_empty(),
        "violation must STILL be recorded in details even under report-only mode"
    );
    assert!(
        v.details.iter().any(|d| d.contains("rq_clock stall")),
        "details must carry the rq_clock stall violation: {:?}",
        v.details
    );
    assert!(
        v.summary.contains("report-only") || v.summary.contains("flagged"),
        "summary must carry the report-only advisory: {}",
        v.summary
    );
}