[go: up one dir, main page]

ron 0.4.1

Rusty Object Notation
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
100
101
102

extern crate ron;
#[macro_use]
extern crate serde;

use std::collections::BTreeMap;

use ron::value::{Number, Value};

#[test]
fn bool() {
    assert_eq!(Value::from_str("true"), Ok(Value::Bool(true)));
    assert_eq!(Value::from_str("false"), Ok(Value::Bool(false)));
}

#[test]
fn char() {
    assert_eq!(Value::from_str("'a'"), Ok(Value::Char('a')));
}

#[test]
fn map() {
    let mut map = BTreeMap::new();
    map.insert(Value::Char('a'), Value::Number(Number::new(1f64)));
    map.insert(Value::Char('b'), Value::Number(Number::new(2f64)));
    assert_eq!(Value::from_str("{ 'a': 1, 'b': 2 }"), Ok(Value::Map(map)));
}

#[test]
fn number() {
    assert_eq!(Value::from_str("42"), Ok(Value::Number(Number::new(42f64))));
    assert_eq!(Value::from_str("3.1415"), Ok(Value::Number(Number::new(3.1415f64))));
}

#[test]
fn option() {
    let opt = Some(Box::new(Value::Char('c')));
    assert_eq!(Value::from_str("Some('c')"), Ok(Value::Option(opt)));
}

#[test]
fn string() {
    let normal = "\"String\"";
    assert_eq!(Value::from_str(normal), Ok(Value::String("String".into())));

    let raw = "r\"Raw String\"";
    assert_eq!(Value::from_str(raw), Ok(Value::String("Raw String".into())));

    let raw_hashes = "r#\"Raw String\"#";
    assert_eq!(Value::from_str(raw_hashes), Ok(Value::String("Raw String".into())));

    let raw_escaped = "r##\"Contains \"#\"##";
    assert_eq!(Value::from_str(raw_escaped), Ok(Value::String("Contains \"#".into())));

    let raw_multi_line = "r\"Multi\nLine\"";
    assert_eq!(Value::from_str(raw_multi_line), Ok(Value::String("Multi\nLine".into())));
}

#[test]
fn seq() {
    let seq = vec![Value::Number(Number::new(1f64)), Value::Number(Number::new(2f64))];
    assert_eq!(Value::from_str("[1, 2]"), Ok(Value::Seq(seq)));
}

#[test]
fn unit() {
    use ron::de::{Error, ParseError, Position};

    assert_eq!(Value::from_str("()"), Ok(Value::Unit));
    assert_eq!(Value::from_str("Foo"), Ok(Value::Unit));

    assert_eq!(Value::from_str(""), Err(Error::Parser(
        ParseError::Eof,
        Position { col: 1, line: 1 }
    )));
}

#[derive(Serialize)]
struct Scene(Option<(u32, u32)>);

#[derive(Serialize)]
struct Scene2 {
    foo: Option<(u32, u32)>,
}

#[test]
fn roundtrip() {
    use ron::ser::to_string;
    use ron::de::from_str;

    {
        let s = to_string(&Scene2 { foo: Some((122, 13)) }).unwrap();
        println!("{}", s);
        let scene: Value = from_str(&s).unwrap();
        println!("{:?}", scene);
    }
    {
        let s = to_string(&Scene( Some((13, 122)) )).unwrap();
        println!("{}", s);
        let scene: Value = from_str(&s).unwrap();
        println!("{:?}", scene);
    }
}