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
103
104
105
106
107
108
109
110
111
|
use ron::value::{Map, Number, Value};
use serde::Serialize;
#[test]
fn bool() {
assert_eq!("true".parse(), Ok(Value::Bool(true)));
assert_eq!("false".parse(), Ok(Value::Bool(false)));
}
#[test]
fn char() {
assert_eq!("'a'".parse(), Ok(Value::Char('a')));
}
#[test]
fn map() {
let mut map = Map::new();
map.insert(Value::Char('a'), Value::Number(Number::new(1)));
map.insert(Value::Char('b'), Value::Number(Number::new(2f64)));
assert_eq!("{ 'a': 1, 'b': 2.0 }".parse(), Ok(Value::Map(map)));
}
#[test]
fn number() {
assert_eq!("42".parse(), Ok(Value::Number(Number::new(42))));
assert_eq!("3.1415".parse(), Ok(Value::Number(Number::new(3.1415f64))));
}
#[test]
fn option() {
let opt = Some(Box::new(Value::Char('c')));
assert_eq!("Some('c')".parse(), Ok(Value::Option(opt)));
}
#[test]
fn string() {
let normal = "\"String\"";
assert_eq!(normal.parse(), Ok(Value::String("String".into())));
let raw = "r\"Raw String\"";
assert_eq!(raw.parse(), Ok(Value::String("Raw String".into())));
let raw_hashes = "r#\"Raw String\"#";
assert_eq!(raw_hashes.parse(), Ok(Value::String("Raw String".into())));
let raw_escaped = "r##\"Contains \"#\"##";
assert_eq!(
raw_escaped.parse(),
Ok(Value::String("Contains \"#".into()))
);
let raw_multi_line = "r\"Multi\nLine\"";
assert_eq!(
raw_multi_line.parse(),
Ok(Value::String("Multi\nLine".into()))
);
}
#[test]
fn seq() {
let seq = vec![
Value::Number(Number::new(1)),
Value::Number(Number::new(2f64)),
];
assert_eq!("[1, 2.0]".parse(), Ok(Value::Seq(seq)));
}
#[test]
fn unit() {
use ron::error::{Error, ErrorCode, Position};
assert_eq!("()".parse(), Ok(Value::Unit));
assert_eq!("Foo".parse(), Ok(Value::Unit));
assert_eq!(
"".parse::<Value>(),
Err(Error {
code: ErrorCode::Eof,
position: 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::{de::from_str, ser::to_string};
{
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);
}
}
|
