preserves 5.0.0-rc.9

Implementation of the Preserves serialization format.
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
92
93
94
95
96
97
98
99

pub mod reader;
pub mod writer;

pub use reader::TextReader;
pub use writer::TextWriter;

#[cfg(test)]
mod formatting_tests {
    use crate::DebugDomainCodec;
    use crate::IOValue;
    use crate::read_text;
    use crate::test_domain::Dom;

    #[test] fn format_debug_and_parse() {
        let v = read_text::<Dom, _>("[1, {z: 2, a: #:\"One\"}, 3]", true, &mut DebugDomainCodec).unwrap();
        assert_eq!(format!("{:?}", &v), "[1, {a: #:\"One\", z: 2}, 3]");
    }

    #[test] fn format_pretty_debug_and_parse() {
        let v = read_text::<Dom, _>("[1, {z: 2, a: #:\"One\"}, 3]", true, &mut DebugDomainCodec).unwrap();
        assert_eq!(format!("{:#?}", &v), concat!(
            "[\n",
            "    1,\n",
            "    {\n",
            "        a: #:\"One\",\n",
            "        z: 2\n",
            "    },\n",
            "    3\n",
            "]"));
    }

    #[test] fn iovalue_parse() {
        let v = "[1 @{a:b c:d} @\"foo\" #:[2 3] 4]".parse::<IOValue>().unwrap();
        assert_eq!(format!("{:#?}", &v), concat!(
            "[\n",
            "    1,\n",
            "    @{\n",
            "        a: b,\n",
            "        c: d\n",
            "    } @\"foo\" #:[\n",
            "        2,\n",
            "        3\n",
            "    ],\n",
            "    4\n",
            "]"));
    }

    #[test]
    fn symbol_and_number_printing() {
        let v = IOValue::symbol("1e3e4");
        let w = IOValue::symbol("123e4");
        assert_eq!(format!("{:?}", &v), "1e3e4");
        assert_eq!(format!("{:?}", &w), "'123e4'");
    }
}

#[cfg(test)]
mod unusual_float_tests {
    use std::io;
    use crate::*;

    fn d64(u: u64, expected: &str) {
        let v = f64::from_bits(u);
        let w = IOValue::new(v);
        assert_eq!(format!("{:?}", w), expected);
        let x = expected.parse::<IOValue>().unwrap();
        assert_eq!(x, w);
    }

    #[test] fn subnormal64() -> io::Result<()> {
        d64(0x0000000000000100, "1.265e-321");
        d64(0x8000000000000100, "-1.265e-321");
        Ok(())
    }

    #[test] fn normal64() -> io::Result<()> {
        d64(0x0100000000000000, "7.291122019556398e-304");
        d64(0x8100000000000000, "-7.291122019556398e-304");
        Ok(())
    }

    #[test] fn nan64() -> io::Result<()> {
        d64(0x7ff8000000000000, "#xd\"7ff8000000000000\"");
        d64(0x7ff85a5a5a5a5a5a, "#xd\"7ff85a5a5a5a5a5a\"");
        d64(0x7ff0000000000001, "#xd\"7ff0000000000001\"");
        d64(0x7ff05a5a5a5a5a5a, "#xd\"7ff05a5a5a5a5a5a\"");
        d64(0xfff8000000000000, "#xd\"fff8000000000000\"");
        d64(0xfff85a5a5a5a5a5a, "#xd\"fff85a5a5a5a5a5a\"");
        d64(0xfff0000000000001, "#xd\"fff0000000000001\"");
        d64(0xfff05a5a5a5a5a5a, "#xd\"fff05a5a5a5a5a5a\"");
        Ok(())
    }

    #[test] fn inf64() -> io::Result<()> {
        d64(0x7ff0000000000000, "#xd\"7ff0000000000000\"");
        d64(0xfff0000000000000, "#xd\"fff0000000000000\"");
        Ok(())
    }
}