#[macro_use]
extern crate serde_derive;
extern crate serde;
extern crate serde_yaml;
extern crate unindent;
use unindent::unindent;
use std::collections::BTreeMap;
use std::fmt::Debug;
fn test_de<T>(yaml: &str, expected: &T)
where
T: serde::de::DeserializeOwned + PartialEq + Debug,
{
let deserialized: T = serde_yaml::from_str(yaml).unwrap();
assert_eq!(*expected, deserialized);
serde_yaml::from_str::<serde_yaml::Value>(yaml).unwrap();
serde_yaml::from_str::<serde::de::IgnoredAny>(yaml).unwrap();
}
#[test]
fn test_alias() {
let yaml = unindent(
"
---
first:
&alias
1
second:
*alias
third: 3",
);
let mut expected = BTreeMap::new();
{
expected.insert(String::from("first"), 1);
expected.insert(String::from("second"), 1);
expected.insert(String::from("third"), 3);
}
test_de(&yaml, &expected);
}
#[test]
fn test_option() {
#[derive(Deserialize, PartialEq, Debug)]
struct Data {
a: Option<f64>,
b: Option<String>,
c: Option<bool>,
}
let yaml = unindent(
"
---
b:
c: true",
);
let expected = Data {
a: None,
b: None,
c: Some(true),
};
test_de(&yaml, &expected);
}
#[test]
fn test_option_alias() {
#[derive(Deserialize, PartialEq, Debug)]
struct Data {
a: Option<f64>,
b: Option<String>,
c: Option<bool>,
d: Option<f64>,
e: Option<String>,
f: Option<bool>,
}
let yaml = unindent(
"
---
none_f:
&none_f
~
none_s:
&none_s
~
none_b:
&none_b
~
some_f:
&some_f
1.0
some_s:
&some_s
x
some_b:
&some_b
true
a: *none_f
b: *none_s
c: *none_b
d: *some_f
e: *some_s
f: *some_b",
);
let expected = Data {
a: None,
b: None,
c: None,
d: Some(1.0),
e: Some("x".to_owned()),
f: Some(true),
};
test_de(&yaml, &expected);
}
#[test]
fn test_enum_alias() {
#[derive(Deserialize, PartialEq, Debug)]
enum E {
A,
B(u8, u8),
}
#[derive(Deserialize, PartialEq, Debug)]
struct Data {
a: E,
b: E,
}
let yaml = unindent(
"
---
aref:
&aref
A
bref:
&bref
B:
- 1
- 2
a: *aref
b: *bref",
);
let expected = Data {
a: E::A,
b: E::B(1, 2),
};
test_de(&yaml, &expected);
}
#[test]
fn test_number_as_string() {
#[derive(Deserialize, PartialEq, Debug)]
struct Num {
value: String,
}
let yaml = unindent(
"
---
value: 123456789012345678901234567890",
);
let expected = Num {
value: "123456789012345678901234567890".to_owned(),
};
test_de(&yaml, &expected);
}
#[test]
fn test_number_alias_as_string() {
#[derive(Deserialize, PartialEq, Debug)]
struct Num {
version: String,
value: String,
}
let yaml = unindent(
"
---
version: &a 1.10
value: *a",
);
let expected = Num {
version: "1.10".to_owned(),
value: "1.10".to_owned(),
};
test_de(&yaml, &expected);
}
#[test]
fn test_de_mapping() {
#[derive(Debug, Deserialize, PartialEq)]
struct Data {
pub substructure: serde_yaml::Mapping,
}
let yaml = unindent(
"
---
substructure:
a: 'foo'
b: 'bar'",
);
let mut expected = Data {
substructure: serde_yaml::Mapping::new(),
};
expected.substructure.insert(
serde_yaml::Value::String("a".to_owned()),
serde_yaml::Value::String("foo".to_owned()),
);
expected.substructure.insert(
serde_yaml::Value::String("b".to_owned()),
serde_yaml::Value::String("bar".to_owned()),
);
test_de(&yaml, &expected);
}
#[test]
fn test_bomb() {
#[derive(Debug, Deserialize, PartialEq)]
struct Data {
expected: String,
}
let yaml = unindent(
"
---
a: &a ~
b: &b [*a,*a,*a,*a,*a,*a,*a,*a,*a]
c: &c [*b,*b,*b,*b,*b,*b,*b,*b,*b]
d: &d [*c,*c,*c,*c,*c,*c,*c,*c,*c]
e: &e [*d,*d,*d,*d,*d,*d,*d,*d,*d]
f: &f [*e,*e,*e,*e,*e,*e,*e,*e,*e]
g: &g [*f,*f,*f,*f,*f,*f,*f,*f,*f]
h: &h [*g,*g,*g,*g,*g,*g,*g,*g,*g]
i: &i [*h,*h,*h,*h,*h,*h,*h,*h,*h]
j: &j [*i,*i,*i,*i,*i,*i,*i,*i,*i]
k: &k [*j,*j,*j,*j,*j,*j,*j,*j,*j]
l: &l [*k,*k,*k,*k,*k,*k,*k,*k,*k]
m: &m [*l,*l,*l,*l,*l,*l,*l,*l,*l]
n: &n [*m,*m,*m,*m,*m,*m,*m,*m,*m]
o: &o [*n,*n,*n,*n,*n,*n,*n,*n,*n]
p: &p [*o,*o,*o,*o,*o,*o,*o,*o,*o]
q: &q [*p,*p,*p,*p,*p,*p,*p,*p,*p]
r: &r [*q,*q,*q,*q,*q,*q,*q,*q,*q]
s: &s [*r,*r,*r,*r,*r,*r,*r,*r,*r]
t: &t [*s,*s,*s,*s,*s,*s,*s,*s,*s]
u: &u [*t,*t,*t,*t,*t,*t,*t,*t,*t]
v: &v [*u,*u,*u,*u,*u,*u,*u,*u,*u]
w: &w [*v,*v,*v,*v,*v,*v,*v,*v,*v]
x: &x [*w,*w,*w,*w,*w,*w,*w,*w,*w]
y: &y [*x,*x,*x,*x,*x,*x,*x,*x,*x]
z: &z [*y,*y,*y,*y,*y,*y,*y,*y,*y]
expected: string",
);
let expected = Data {
expected: "string".to_owned(),
};
assert_eq!(expected, serde_yaml::from_str::<Data>(&yaml).unwrap());
}