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

pub mod syntax;
pub mod compiler;
pub mod support;
pub mod gen;

#[cfg(test)]
mod tests {
    #[test]
    fn can_access_preserves_core() {
        use preserves::value::*;
        assert_eq!(format!("{:?}", UnwrappedIOValue::from(3 + 4)), "7");
    }

    #[test]
    fn simple_rendering() {
        use crate::*;
        use crate::syntax::block::*;

        let code = semiblock![
            seq!["f", parens!["a", "b", "c"]],
            seq!["f", parens!["a", "b", "c"]],
            seq!["f", parens!["a", "b", "c"]],
            seq!["f", parens!["a", "b", "c"]],
            seq!["f", parens!["a", "b", "c"]],
            seq!["f", parens!["a", "b", "c"]],
            seq!["g", parens![]],
            parens![]
        ];
        println!("{}", Formatter::to_string(&code));
    }

    #[test]
    fn metaschema_parsing() -> Result<(), std::io::Error> {
        use preserves::value::{BinarySource, IOBinarySource, IOValue, Reader};
        use std::convert::TryFrom;
        use std::convert::From;
        use crate::gen::schema::*;

        let mut f = std::fs::File::open("../../../schema/schema.bin")?;
        let mut src = IOBinarySource::new(&mut f);
        let mut reader = src.packed_iovalues();
        let schema = reader.demand_next(false)?;
        let parsed = Schema::try_from(&schema).expect("successful parse");
        assert_eq!(schema, IOValue::from(&parsed));
        Ok(())
    }
}