gdtest 0.2.5

Fast external test runner for Godot 4 - Rust orchestrator + GDScript harness
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

//! Internal: run a fixed list of tests in a single persistent worker (M1.5
//! benchmark). This is a stopgap kept separate from the real pool + MPSC
//! dispatch. Output is one CSV line per test + a summary, so a bench script
//! can consume the data without regex-ing a pretty report.

use std::time::Instant;

use anyhow::{Result, anyhow};

use crate::protocol::{Command, Event};
use crate::worker::{Config, Worker};

#[tokio::main(flavor = "current_thread")]
pub async fn run(script: &str, funcs: &[String], cfg: &Config) -> Result<()> {
    let wall_start = Instant::now();
    let mut w = Worker::spawn(cfg)?;
    w.drain_stderr_to_log();
    w.wait_for(|ev| matches!(ev, Event::Ready { .. })).await?;
    let startup_us = wall_start.elapsed().as_micros();

    let mut pass = 0u32;
    let mut fail = 0u32;
    let mut error = 0u32;
    let mut test_us_total: u128 = 0;

    println!("# kind,name,dispatch_us,test_us");

    for func in funcs {
        let t = Instant::now();
        w.send(&Command::RunTest {
            script: script.to_string(),
            func: func.clone(),
        })
        .await?;
        let ev = w
            .wait_for(|ev| {
                matches!(
                    ev,
                    Event::TestPass { .. } | Event::TestFail { .. } | Event::TestError { .. }
                )
            })
            .await?;
        let dispatch_us = t.elapsed().as_micros();
        match ev {
            Event::TestPass { name, us } => {
                pass += 1;
                test_us_total += us as u128;
                println!("pass,{name},{dispatch_us},{us}");
            }
            Event::TestFail { name, us, failures } => {
                fail += 1;
                test_us_total += us as u128;
                println!("fail,{name},{dispatch_us},{us} # {}", failures.join(" | "));
            }
            Event::TestError { name, message } => {
                error += 1;
                println!("error,{name},{dispatch_us},0 # {message}");
            }
            _ => unreachable!(),
        }
    }

    w.shutdown().await?;

    let wall_us = wall_start.elapsed().as_micros();
    println!(
        "# summary pass={pass} fail={fail} error={error} startup_us={startup_us} test_us_total={test_us_total} wall_us={wall_us}"
    );

    if fail > 0 || error > 0 {
        return Err(anyhow!("{fail} failed, {error} errored"));
    }
    Ok(())
}