bitt 0.5.0

Bevy integration testing toolkit
Documentation 
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

use std::{fs::File, path::PathBuf, time::Duration};

use bevy::prelude::*;
use serde::Serialize;

use super::{artefact_paths::ArtefactPaths, StartTime, TestQuitEvent};

#[derive(Debug, Default, Resource)]
struct FrameCollector(Vec<Duration>);

const OUTLIERS: usize = 10;

impl FrameCollector {
    fn write_to(&self, path: PathBuf) {
        let mut sum = Duration::default();
        let mut best = vec![];
        let mut worst = vec![];

        // For some reason, first one has a delta time of 0.0
        for frame in self.0.iter().skip(1) {
            sum += *frame;

            if best.len() < OUTLIERS {
                best.push(*frame);
                worst.push(*frame);
                continue;
            }

            let best_of_worst = worst.iter().min().unwrap().to_owned();
            let worst_of_best = best.iter().max().unwrap().to_owned();

            if *frame > best_of_worst {
                worst.retain(|f| f != &best_of_worst);
                worst.push(*frame);
            } else if *frame < worst_of_best {
                best.retain(|f| f != &worst_of_best);
                best.push(*frame);
            }
        }

        best.sort();
        worst.sort();

        let metrics = FrameMetrics {
            frames: to_millivec(self.0.clone()),
            average: 1000.0 * sum.as_secs_f32() / self.0.len() as f32,
            best: to_millivec(best),
            worst: to_millivec(worst),
        };

        let mut file = File::create(path).unwrap();

        serde_json::to_writer_pretty(&mut file, &metrics).unwrap();
    }
}

fn to_millivec(durations: Vec<Duration>) -> Vec<f32> {
    durations
        .into_iter()
        .map(|f| 1000.0 * f.as_secs_f32())
        .collect()
}

#[derive(Debug, Default, Serialize)]
struct FrameMetrics {
    average: f32,
    best: Vec<f32>,
    worst: Vec<f32>,
    frames: Vec<f32>,
}

#[derive(Debug)]
pub struct FrameMetricPlugin;

impl Plugin for FrameMetricPlugin {
    fn build(&self, app: &mut App) {
        app.add_systems(Update, record_frame_metrics)
            .add_systems(
                Update,
                write_frame_metrics.run_if(on_event::<TestQuitEvent>()),
            )
            .init_resource::<FrameCollector>();
    }
}

fn record_frame_metrics(
    mut frame_metrics: ResMut<FrameCollector>,
    time: Res<Time<Real>>,
    first_update: Option<Res<StartTime>>,
) {
    if first_update.is_some() {
        frame_metrics.0.push(time.delta());
    }
}

fn write_frame_metrics(
    frame_metrics: Res<FrameCollector>,
    artefact_paths: Res<ArtefactPaths>,
    mut test_quit_events: EventReader<TestQuitEvent>,
) {
    if test_quit_events.read().next().is_some() {
        frame_metrics.write_to(artefact_paths.frame_metrics());
    }
}