loeres 0.15.0

Loeres shared mathematical contracts: scalar, access, problem, solver, error, dimension. no_std, no alloc, no storage.
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
105
106
107
108
109
110
111

//! Tests for the validation-state vocabulary (RFC 012).

use super::{
    FiniteCoverage, TrustKind, TrustToken, TrustedByCaller, ValidationCoverage, ValidationScope,
    ValidationState,
};

#[test]
fn scope_bits_are_distinct() {
    assert_ne!(ValidationScope::FINITE, ValidationScope::PROBLEM_CONFIG);
    assert_ne!(ValidationScope::PROBLEM_CONFIG, ValidationScope::PRELOOP);
    assert_ne!(ValidationScope::FINITE, ValidationScope::PRELOOP);
    assert_eq!(ValidationScope::empty(), ValidationScope::EMPTY);
}

#[test]
fn scope_union_intersect_contains() {
    let fc = ValidationScope::FINITE.union(ValidationScope::PROBLEM_CONFIG);
    assert!(fc.contains(ValidationScope::FINITE));
    assert!(fc.contains(ValidationScope::PROBLEM_CONFIG));
    assert!(!fc.contains(ValidationScope::PRELOOP));
    assert_eq!(
        fc.intersect(ValidationScope::FINITE),
        ValidationScope::FINITE
    );
    assert!(!ValidationScope::empty().contains(ValidationScope::FINITE));
    // operator conveniences agree with the named methods
    assert_eq!(
        ValidationScope::FINITE | ValidationScope::PRELOOP,
        ValidationScope::FINITE.union(ValidationScope::PRELOOP)
    );
    assert_eq!(fc & ValidationScope::FINITE, ValidationScope::FINITE);
}

#[test]
fn all_is_release_local_composition() {
    // ALL is composed from the current bits, not assumed to be 0xff.
    assert_eq!(
        ValidationScope::ALL,
        ValidationScope::FINITE
            .union(ValidationScope::PROBLEM_CONFIG)
            .union(ValidationScope::PRELOOP)
    );
    assert!(ValidationScope::ALL.contains(ValidationScope::FINITE));
    assert!(ValidationScope::ALL.contains(ValidationScope::PROBLEM_CONFIG));
    assert!(ValidationScope::ALL.contains(ValidationScope::PRELOOP));
}

#[test]
fn finite_coverage_is_distinct() {
    assert_ne!(FiniteCoverage::Checked, FiniteCoverage::NotApplicable);
}

#[test]
fn trust_token_roundtrip() {
    let t = TrustToken::new(42);
    assert_eq!(t.value(), 42);
}

#[test]
fn coverage_records_scope_and_finite() {
    let c = ValidationCoverage::new(ValidationScope::ALL, FiniteCoverage::Checked);
    assert_eq!(c.scope(), ValidationScope::ALL);
    assert_eq!(c.finite(), FiniteCoverage::Checked);
    let na = ValidationCoverage::new(ValidationScope::PRELOOP, FiniteCoverage::NotApplicable);
    assert_eq!(na.finite(), FiniteCoverage::NotApplicable);
}

#[test]
fn coverage_normalizes_finite_into_scope() {
    // Even a scope without FINITE is normalized to include it, so the scope bit
    // and the `finite` field can never contradict.
    let c = ValidationCoverage::new(ValidationScope::PRELOOP, FiniteCoverage::Checked);
    assert!(c.scope().contains(ValidationScope::FINITE));
    assert!(c.scope().contains(ValidationScope::PRELOOP));
    let na = ValidationCoverage::new(ValidationScope::empty(), FiniteCoverage::NotApplicable);
    assert!(na.scope().contains(ValidationScope::FINITE));
}

#[test]
fn trusted_by_caller_makes_scope_visible() {
    let trust = TrustedByCaller::caller_assertion(
        ValidationScope::FINITE,
        TrustToken::new(7),
        Some("ingest-pipeline-a"),
    );
    assert_eq!(trust.kind, TrustKind::CallerAssertion);
    assert_eq!(trust.scope, ValidationScope::FINITE);
    assert_eq!(trust.token.value(), 7);
    assert_eq!(trust.label, Some("ingest-pipeline-a"));
}

#[test]
fn state_variants() {
    let unval = ValidationState::Unvalidated;
    let val = ValidationState::Validated(ValidationCoverage::new(
        ValidationScope::ALL,
        FiniteCoverage::Checked,
    ));
    let trusted = ValidationState::Trusted(TrustedByCaller::caller_assertion(
        ValidationScope::ALL,
        TrustToken::new(1),
        None,
    ));
    assert_ne!(unval, val);
    assert_ne!(val, trusted);
    match val {
        ValidationState::Validated(c) => assert_eq!(c.finite(), FiniteCoverage::Checked),
        _ => panic!("expected Validated"),
    }
}