noether-core 0.7.1

Noether core: type system, effects, content-addressed stage schema, Ed25519 signing, stdlib
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

use noether_core::stage::validation::{validate_all, validate_stage};
use noether_core::stdlib::load_stdlib;

#[test]
fn all_stdlib_stages_pass_validation() {
    let stages = load_stdlib();
    let results = validate_all(&stages, 5);

    let mut failures = Vec::new();
    for result in &results {
        if !result.is_ok() {
            failures.push(format!(
                "Stage '{}' failed validation:\n{}",
                result.stage_description,
                result
                    .errors
                    .iter()
                    .map(|e| format!("  - {e}"))
                    .collect::<Vec<_>>()
                    .join("\n")
            ));
        }
    }

    assert!(
        failures.is_empty(),
        "Stdlib validation failures:\n{}",
        failures.join("\n\n")
    );
}

#[test]
fn each_stdlib_stage_has_at_least_5_examples() {
    let stages = load_stdlib();
    for stage in &stages {
        assert!(
            stage.examples.len() >= 5,
            "Stage '{}' has only {} examples (need 5+)",
            stage.description,
            stage.examples.len()
        );
    }
}

#[test]
fn stdlib_example_inputs_match_declared_types() {
    let stages = load_stdlib();
    for stage in &stages {
        let result = validate_stage(stage, 0);
        let input_errors: Vec<_> = result
            .errors
            .iter()
            .filter(|e| {
                matches!(
                    e,
                    noether_core::stage::validation::ValidationError::InputTypeMismatch { .. }
                )
            })
            .collect();
        assert!(
            input_errors.is_empty(),
            "Stage '{}' has input type mismatches: {:?}",
            stage.description,
            input_errors
        );
    }
}

#[test]
fn stdlib_example_outputs_match_declared_types() {
    let stages = load_stdlib();
    for stage in &stages {
        let result = validate_stage(stage, 0);
        let output_errors: Vec<_> = result
            .errors
            .iter()
            .filter(|e| {
                matches!(
                    e,
                    noether_core::stage::validation::ValidationError::OutputTypeMismatch { .. }
                )
            })
            .collect();
        assert!(
            output_errors.is_empty(),
            "Stage '{}' has output type mismatches: {:?}",
            stage.description,
            output_errors
        );
    }
}