sim-lib-lang-matrix 0.1.6

SIM language conformance matrix assembly crate.
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

use std::collections::BTreeSet;
use std::sync::Arc;

use sim_kernel::{Cx, DefaultFactory, EagerPolicy, Symbol};
use sim_lib_lang_genconf::{generative_registry, run_all_generated};

use crate::language_matrix;

fn closure_cx() -> Cx {
    let mut cx = Cx::new(
        Arc::new(EagerPolicy),
        Arc::new(DefaultFactory),
        sim_kernel::HandleSeed::new(0x4d41_5401),
    );
    sim_test_support::register_core_classes(&mut cx);
    sim_test_support::register_f64_number_domain(&mut cx);
    cx
}

#[test]
fn closure_registry_tracks_the_curated_language_matrix() {
    let registry = generative_registry();
    let matrix = language_matrix();
    let mut names = BTreeSet::new();

    assert_eq!(registry.len(), matrix.language_count());
    assert_eq!(matrix.language_count(), 11);
    for row in &registry {
        assert!(
            names.insert(row.language.clone()),
            "duplicate generated row: {}",
            row.language,
        );
        assert!(
            matrix.row(&row.language).is_some(),
            "{} row must stay in the curated matrix",
            row.language,
        );
    }
}

#[test]
fn closure_registry_uses_live_language_codec_ids() {
    let registry = generative_registry();

    assert!(registry.iter().any(|row| {
        row.language == Symbol::new("scheme")
            && row.codec == Symbol::qualified("codec", "scheme-r7rs-small")
    }));
    assert!(registry.iter().any(|row| {
        row.language == Symbol::new("common-lisp")
            && row.codec == Symbol::qualified("codec", "common-lisp-lite")
    }));
    assert!(registry.iter().any(|row| {
        row.language == Symbol::new("prolog") && row.codec == Symbol::qualified("codec", "lisp")
    }));
}

#[test]
fn closure_reports_are_anchored_or_honest() {
    let mut cx = closure_cx();
    let reports = run_all_generated(&mut cx, 8);

    assert_eq!(reports.len(), generative_registry().len());
    for report in &reports {
        if !report.landmark_reproduced() {
            assert!(
                report.coverage_percent().is_none(),
                "{} must not publish unanchored coverage",
                report.language,
            );
        }
    }
    assert_eq!(language_matrix().language_count(), 11);
}