sml-rs 0.4.0

Smart Message Language (SML) parser written in Rust
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

use std::iter::FromIterator;
use std::{
    collections::HashSet,
    ffi::{OsStr, OsString},
};

#[test]
fn test_repo_validation() {
    let dir = std::fs::read_dir("./tests/libsml-testing").expect("test folder does not exist");
    let mut bin_filenames = HashSet::new();
    let mut hex_filenames = HashSet::new();
    for entry in dir {
        let entry = entry.unwrap().path();
        match (entry.file_stem(), entry.extension().and_then(OsStr::to_str)) {
            (Some(name), Some("bin")) => {
                bin_filenames.insert(name.to_os_string());
            }
            (Some(name), Some("hex")) => {
                hex_filenames.insert(name.to_os_string());
            }
            _ => {} // ignore other files
        }
    }

    assert_eq!(bin_filenames, hex_filenames);

    if bin_filenames.is_empty() {
        panic!("There are no test files in tests/libsml-testing.\n")
    }

    // check that bin and hex files contain the same content
    for filename in bin_filenames {
        let path = std::path::Path::new("./tests/libsml-testing");

        let bin_path = path.join(OsString::from_iter([
            filename.clone(),
            ".bin".to_string().into(),
        ]));
        let bin_bytes = std::fs::read(bin_path).expect("Couldn't read file");
        let hex_path = path.join(OsString::from_iter([filename, ".hex".to_string().into()]));
        let hex_string = std::fs::read_to_string(hex_path).expect("Couldn't read file");
        let hex_bytes = hex::decode(hex_string.trim()).expect("Couldn't decode hex string");

        assert_eq!(bin_bytes, hex_bytes);
    }
}

#[cfg(feature = "alloc")]
#[test]
fn test_files() {
    use std::fmt::Write;

    insta::glob!("libsml-testing/*.bin", |path| {
        let bytes = std::fs::read(path).unwrap();

        let mut decoder =
            sml_rs::transport::decode_streaming::<sml_rs::util::ArrayBuf<2048>>(bytes);

        let mut s = String::new();
        while let Some(result) = decoder.next() {
            // write!(s, "{:?}\n", result.map(|x| x.len())).unwrap();
            write!(
                s,
                "{:#?}\n",
                result.map(|x| {
                    let res = sml_rs::parser::complete::parse(x);
                    res.expect("Error while parsing:").messages
                })
            )
            .unwrap();
        }
        insta::assert_snapshot!(s);
    });
}