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
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
|
#![allow(
clippy::derive_partial_eq_without_eq,
clippy::eq_op,
clippy::uninlined_format_args
)]
use indoc::indoc;
use serde::de::IntoDeserializer;
use serde::Deserialize;
use serde_derive::{Deserialize, Serialize};
use serde_yaml::{Number, Value};
#[test]
fn test_nan() {
let pos_nan = serde_yaml::from_str::<Value>(".nan").unwrap();
assert!(pos_nan.is_f64());
assert_eq!(pos_nan, pos_nan);
let neg_fake_nan = serde_yaml::from_str::<Value>("-.nan").unwrap();
assert!(neg_fake_nan.is_string());
let significand_mask = 0xF_FFFF_FFFF_FFFF;
let bits = (f64::NAN.to_bits() ^ significand_mask) | 1;
let different_pos_nan = Value::Number(Number::from(f64::from_bits(bits)));
assert_eq!(pos_nan, different_pos_nan);
}
#[test]
fn test_digits() {
let num_string = serde_yaml::from_str::<Value>("01").unwrap();
assert!(num_string.is_string());
}
#[test]
fn test_into_deserializer() {
#[derive(Debug, Deserialize, PartialEq)]
struct Test {
first: String,
second: u32,
}
let value = serde_yaml::from_str::<Value>("xyz").unwrap();
let s = String::deserialize(value.into_deserializer()).unwrap();
assert_eq!(s, "xyz");
let value = serde_yaml::from_str::<Value>("- first\n- second\n- third").unwrap();
let arr = Vec::<String>::deserialize(value.into_deserializer()).unwrap();
assert_eq!(arr, &["first", "second", "third"]);
let value = serde_yaml::from_str::<Value>("first: abc\nsecond: 99").unwrap();
let test = Test::deserialize(value.into_deserializer()).unwrap();
assert_eq!(
test,
Test {
first: "abc".to_string(),
second: 99
}
);
}
#[test]
fn test_merge() {
// From https://yaml.org/type/merge.html.
let yaml = indoc! {"
---
- &CENTER { x: 1, y: 2 }
- &LEFT { x: 0, y: 2 }
- &BIG { r: 10 }
- &SMALL { r: 1 }
# All the following maps are equal:
- # Explicit keys
x: 1
y: 2
r: 10
label: center/big
- # Merge one map
<< : *CENTER
r: 10
label: center/big
- # Merge multiple maps
<< : [ *CENTER, *BIG ]
label: center/big
- # Override
<< : [ *BIG, *LEFT, *SMALL ]
x: 1
label: center/big
"};
let mut value: Value = serde_yaml::from_str(yaml).unwrap();
value.apply_merge().unwrap();
for i in 5..=7 {
assert_eq!(value[4], value[i]);
}
}
#[test]
fn test_debug() {
let yaml = indoc! {"
'Null': ~
Bool: true
Number: 1
String: ...
Sequence:
- true
EmptySequence: []
EmptyMapping: {}
Tagged: !tag true
"};
let value: Value = serde_yaml::from_str(yaml).unwrap();
let debug = format!("{:#?}", value);
let expected = indoc! {r#"
Mapping {
"Null": Null,
"Bool": Bool(true),
"Number": Number(1),
"String": String("..."),
"Sequence": Sequence [
Bool(true),
],
"EmptySequence": Sequence [],
"EmptyMapping": Mapping {},
"Tagged": TaggedValue {
tag: !tag,
value: Bool(true),
},
}"#
};
assert_eq!(debug, expected);
}
#[test]
fn test_tagged() {
#[derive(Serialize)]
enum Enum {
Variant(usize),
}
let value = serde_yaml::to_value(&Enum::Variant(0)).unwrap();
let deserialized: serde_yaml::Value = serde_yaml::from_value(value.clone()).unwrap();
assert_eq!(value, deserialized);
let serialized = serde_yaml::to_value(&value).unwrap();
assert_eq!(value, serialized);
}
|
