cubek-test-utils 0.2.0

CubeK: Test Utils
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

//! Test-mode policy.
//!
//! Reads `cubek.toml` (see `crate::config`) once and decides whether each
//! test outcome should `Accept` or `Reject`. The TOML's `[test] policy`
//! field controls the pass/fail logic; the `[print]` section drives what
//! gets dumped to stdout (in `correctness::render`).

use crate::config::{TestPolicy, config};
use crate::{TestDecision, TestOutcome, ValidationResult};

/// Decide whether a test outcome passes or fails under the active policy.
pub fn decide(outcome: TestOutcome) -> TestDecision {
    use TestDecision::*;
    use TestOutcome::*;
    use ValidationResult::*;

    let cfg = config();
    let print_force_fail = cfg.print.enabled && cfg.print.force_fail;

    match cfg.test.policy {
        TestPolicy::Correct => match outcome {
            Validated(result) => match result {
                Pass => {
                    if print_force_fail {
                        Reject("print mode: tensors dumped".into())
                    } else {
                        Accept
                    }
                }
                Fail(reason) => Reject(reason),
                Error(reason) => Reject(reason),
                Skipped(_) => Accept,
            },
            CompileError(reason) => {
                if print_force_fail {
                    Reject(reason)
                } else {
                    Accept
                }
            }
        },
        TestPolicy::Strict => match outcome {
            Validated(result) => match result {
                Pass => {
                    if print_force_fail {
                        Reject("print mode: tensors dumped".into())
                    } else {
                        Accept
                    }
                }
                Fail(reason) => Reject(reason),
                Error(reason) => Reject(reason),
                Skipped(reason) => Reject(reason),
            },
            CompileError(reason) => Reject(reason),
        },
        TestPolicy::FailIfRun => match outcome {
            Validated(result) => match result {
                Pass => Reject("Actually passed, but fail-if-run policy active".into()),
                Fail(_) => Accept,
                Error(_) => Accept,
                Skipped(_) => Accept,
            },
            CompileError(_) => Accept,
        },
    }
}