slotgate 0.4.2

A bounded-parallelism job runner that gives each slot its own disjoint port range, so port-binding tests run in parallel without collisions.
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

// Copyright (c) 2025-2026 Umberto Gotti
// SPDX-License-Identifier: MIT

use crate::execution::job_outcome::JobOutcome;
use crate::execution::job_status::JobStatus;
use std::process::ExitCode;

pub struct RunSummary {
    pub passed: usize,
    pub failed: usize,
    pub timed_out: usize,
}

impl RunSummary {
    pub fn from_outcomes(outcomes: &[JobOutcome]) -> Self {
        let mut summary = Self {
            passed: 0,
            failed: 0,
            timed_out: 0,
        };
        for outcome in outcomes {
            match outcome.status {
                JobStatus::Passed => summary.passed += 1,
                JobStatus::Failed => summary.failed += 1,
                JobStatus::TimedOut => summary.timed_out += 1,
            }
        }
        summary
    }

    pub fn total(&self) -> usize {
        self.passed + self.failed + self.timed_out
    }

    pub fn is_success(&self) -> bool {
        self.failed == 0 && self.timed_out == 0
    }

    pub fn exit_code(&self) -> ExitCode {
        if self.is_success() {
            ExitCode::SUCCESS
        } else {
            ExitCode::FAILURE
        }
    }

    pub fn render(&self) -> String {
        format!(
            "SLOTGATE — SUMMARY: {} passed, {} failed, {} timed out (of {})",
            self.passed,
            self.failed,
            self.timed_out,
            self.total()
        )
    }
}