sim-lib-lang-matrix 0.1.0

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
76
77
78
79

#![forbid(unsafe_code)]
#![deny(missing_docs)]
//! Assembly point for the SIM language conformance matrix.

use sim_lib_lang_cl::cl_lite_matrix_row;
use sim_lib_lang_clojure::clojure_core_matrix_row;
use sim_lib_lang_islisp::islisp_matrix_row;
use sim_lib_lang_julia::julia_core_matrix_row;
use sim_lib_lang_lua::lua_core_matrix_row;
use sim_lib_lang_prolog::prolog_matrix_row;
use sim_lib_lang_ruby::ruby_dsl_matrix_row;
use sim_lib_lang_scheme::r7rs_small_matrix_row;
use sim_lib_lang_typed_lazy::typed_lazy_matrix_row;
use sim_lib_standard_core::ConformanceMatrix;

/// Builds the complete runtime language conformance matrix.
pub fn language_matrix() -> ConformanceMatrix {
    let mut matrix = ConformanceMatrix::new();
    matrix.register(r7rs_small_matrix_row());
    matrix.register(cl_lite_matrix_row());
    matrix.register(clojure_core_matrix_row());
    matrix.register(islisp_matrix_row());
    matrix.register(julia_core_matrix_row());
    matrix.register(lua_core_matrix_row());
    matrix.register(ruby_dsl_matrix_row());
    matrix.register(typed_lazy_matrix_row());
    matrix.register(prolog_matrix_row());
    matrix
}

#[cfg(test)]
mod tests {
    use std::collections::BTreeSet;

    use sim_kernel::Symbol;

    use super::*;

    #[test]
    fn language_matrix_has_exactly_nine_rows() {
        let matrix = language_matrix();

        assert_eq!(matrix.language_count(), 9);
    }

    #[test]
    fn language_matrix_has_no_duplicate_row_names() {
        let matrix = language_matrix();
        let names: Vec<_> = matrix
            .iter_rows()
            .map(|row| row.language.to_string())
            .collect();
        let unique: BTreeSet<_> = names.iter().cloned().collect();

        assert_eq!(unique.len(), names.len());
    }

    #[test]
    fn language_matrix_rows_are_populated() {
        let matrix = language_matrix();

        for language in [
            "scheme",
            "common-lisp",
            "clojure",
            "islisp",
            "julia",
            "lua",
            "ruby",
            "typed-lazy",
            "prolog",
        ] {
            let row = matrix
                .row(&Symbol::new(language))
                .unwrap_or_else(|| panic!("{language} row must be registered"));
            assert!(!row.is_empty(), "{language} row must have cases");
        }
    }
}