1
use radio_core::metrics::CpuWindow;
2
 
3
#[test]
4
fn cpu_windows_measure_each_core_and_keep_u64_counters() {
5
    let mut meter = CpuWindow::default();
6
    let base = u32::MAX as u64 + 1_000_000;
7
    assert_eq!(meter.sample(base, [base - 1000, base - 2000]), [None, None]);
8
    assert_eq!(
9
        meter.sample(base + 1_000_000, [base + 799_000, base + 398_000]),
10
        [Some(2000), Some(6000)]
11
    );
12
    assert_eq!(
13
        meter.sample(base + 2_000_000, [base + 1_799_000, base + 398_000]),
14
        [Some(0), Some(10_000)]
15
    );
16
}
17
 
18
#[test]
19
fn invalid_or_discontinuous_accounting_is_unavailable_and_recovers() {
20
    let mut meter = CpuWindow::default();
21
    meter.sample(1_000_000, [500_000, 500_000]);
22
    assert_eq!(meter.sample(2_000_000, [400_000, 1_600_000]), [None, None]);
23
    assert_eq!(
24
        meter.sample(3_000_000, [900_000, 2_100_000]),
25
        [Some(5000), Some(5000)]
26
    );
27
    assert_eq!(
28
        meter.sample(10_000_000, [1_000_000, 2_200_000]),
29
        [None, None]
30
    );
31
    assert_eq!(
32
        meter.sample(10_000_001, [1_000_001, 2_200_001]),
33
        [None, None]
34
    );
35
    assert_eq!(
36
        meter.sample(11_000_001, [1_500_001, 2_700_001]),
37
        [Some(5000), Some(5000)]
38
    );
39
    assert_eq!(meter.sample(0, [0, 0]), [None, None]);
40
}
41
 
42
#[test]
43
fn hardware_telemetry_fits_the_transport_data_limit_at_counter_limits() {
44
    use radio_core::{
45
        metrics::{Hardware, Memory},
46
        protocol::{Color, MusicStatus, SpectrumStatus, Telemetry},
47
    };
48
    let memory = Memory {
49
        free: u32::MAX,
50
        minimum_free: u32::MAX,
51
        largest_block: u32::MAX,
52
    };
53
    let packet = Telemetry {
54
        event: "telemetry",
55
        firmware: "rust",
56
        sequence: u64::MAX,
57
        uptime_ms: u64::MAX,
58
        position_ms: u32::MAX,
59
        duration_ms: u32::MAX,
60
        playback_revision: u32::MAX,
61
        music: MusicStatus {
62
            cache_bytes: u32::MAX,
63
            index_bytes: u32::MAX,
64
            reads: u32::MAX,
65
            max_read_us: u32::MAX,
66
        },
67
        paused: false,
68
        rssi: Some(-127),
69
        heap: u32::MAX,
70
        led: Color([255; 3]),
71
        audio_errors: u64::MAX,
72
        data_errors: u64::MAX,
73
        skipped_frames: u64::MAX,
74
        rejected_commands: u64::MAX,
75
        dropped_commands: u32::MAX,
76
        stack_free: u32::MAX,
77
        spectrum: SpectrumStatus {
78
            frames: u64::MAX,
79
            errors: u64::MAX,
80
            resets: u64::MAX,
81
            input_dropped: u64::MAX,
82
            output_dropped: u64::MAX,
83
            stale: u64::MAX,
84
            mean_us: u32::MAX,
85
            max_us: u32::MAX,
86
            stack_free: u32::MAX,
87
            ..SpectrumStatus::default()
88
        },
89
        hardware: Some(Hardware {
90
            sampled_at_ms: u64::MAX,
91
            cpu_busy_bps: [Some(10000); 2],
92
            chip_temperature_mc: Some(-10000),
93
            internal: memory,
94
            psram: memory,
95
            sample_cost_us: u32::MAX,
96
            sampler_stack_free: u32::MAX,
97
        }),
98
    };
99
    let bytes = serde_json::to_vec(&packet).unwrap();
100
    assert!(
101
        bytes.len() <= 2048,
102
        "{} bytes exceed the native packet capacity",
103
        bytes.len()
104
    );
105
    assert!(
106
        !serde_json::from_slice::<serde_json::Value>(&bytes)
107
            .unwrap()
108
            .as_object()
109
            .unwrap()
110
            .contains_key("random")
111
    );
112
}