[simple]
main_type = "Simple"
definition = """
#[derive(PartialEq, Debug, Serialize)]
pub struct Simple {
pub integer: i32,
pub character: char,
pub float: f32,
pub string: String,
pub boolean: bool,
}
"""
value = """
Simple {
integer: 123,
character: 'c',
float: std::f32::consts::PI,
string: "text string".into(),
boolean: false
}
"""
[nested]
main_type = "Nested"
support_types = "Inner"
definition = """
#[derive(PartialEq, Debug, Serialize)]
pub struct Nested {
pub inner: Inner,
}
#[derive(PartialEq, Debug, Serialize)]
pub struct Inner {
pub value: i32,
}
"""
value = """
Nested {
inner: Inner {
value: 123
}
}
"""
[complex]
main_type = "Complex"
definition = """
#[derive(Debug, Serialize)]
pub struct Complex {
pub tuple: (i32, f32, String),
pub vector: Vec<i32>,
pub byte_arr: Vec<u8>,
pub map: std::collections::HashMap<String, String>,
}
"""
value = """
{
let mut map = std::collections::HashMap::new();
map.insert("0".into(), "test".into());
map.insert("120".into(), "test longer".into());
map.insert("\\"".into(), "test escaping".into());
Complex {
tuple: (1, 1.0, "tuple entry".into()),
vector: vec![1, 2, 3, 4, 5, -1, -2, -3, -4, -5],
byte_arr: b"asdfghj".to_vec(),
map
}
}
"""
test_values.tuple = "(1, 1.0, \"tuple entry\".into())"
test_values.vector = "vec![1, 2, 3, 4, 5, -1, -2, -3, -4, -5]"
test_values.byte_arr = "b\"asdfghj\".to_vec()"
test_values."map[\"0\"]" = "\"test\""
test_values."map[\"120\"]" = "\"test longer\""
test_values."map[\"\\\"\"]" = "\"test escaping\""
[floats]
main_type = "Floats"
definition = """
#[derive(PartialEq, Debug, Serialize)]
pub struct Floats(pub Vec<f32>);
"""
value = """
Floats(vec![
123456789e30,
123456789e-30,
12345.6789
])
"""
[enums]
main_type = "Container"
support_types = "Enum,Unit"
definition = """
#[derive(PartialEq, Debug, Serialize)]
pub struct Unit;
#[derive(PartialEq, Debug, Serialize)]
pub enum Enum {
Empty,
Unit(Unit),
Tuple(i32, String),
Struct{ key: i32, value: String },
EmptyTuple(),
EmptyStruct {},
}
#[derive(PartialEq, Debug, Serialize)]
pub struct Container(pub Vec<Enum>);
"""
value = """
{
Container(vec![
Enum::Unit(Unit),
Enum::Tuple(1, "test".into()),
Enum::Struct{ key: 1, value: "test".into() },
Enum::EmptyTuple(),
Enum::EmptyStruct{},
// this is intentionally last, to catch an error at previous step
Enum::Empty,
])
}
"""
test_values = { 0 = """&[
Enum::Unit(Unit),
Enum::Tuple(1, "test".into()),
Enum::Struct{ key: 1, value: "test".into() },
Enum::EmptyTuple(),
Enum::EmptyStruct{},
// this is intentionally last, to catch an error at previous step
Enum::Empty,
]""" }
[slice]
main_type = "Container"
definition = """
#[derive(PartialEq, Debug, Serialize)]
pub struct Container(pub Vec<u8>);
"""
value = """
Container(vec![1, 2])
"""
[tuple]
main_type = "Container"
definition = """
#[derive(PartialEq, Debug, Serialize)]
pub struct Container(pub (u8, u8));
"""
value = """
Container((1, 2))
"""
[unit]
main_type = "ZeroSizeContainer"
definition = """
#[derive(PartialEq, Debug, Serialize)]
pub struct ZeroSizeContainer(pub ());
"""
value = """
ZeroSizeContainer(())
"""
[empty_fields_issue_3]
main_type = "Foo"
support_types = "UnitType,UnitStruct,UnitTuple"
definition = """
#[derive(PartialEq, Debug, Serialize)]
pub struct UnitType;
#[derive(PartialEq, Debug, Serialize)]
pub struct UnitStruct {}
#[derive(PartialEq, Debug, Serialize)]
pub struct UnitTuple();
#[derive(Debug, Serialize)]
pub struct Foo {
pub vec: Vec<String>,
pub map: std::collections::HashMap<String, String>,
pub unit: (),
pub unit_type: UnitType,
pub unit_struct: UnitStruct,
pub unit_tuple: UnitTuple,
pub last: String
}
"""
value = """
{
Foo {
vec: vec![],
map: std::collections::HashMap::new(),
unit: (),
unit_type: UnitType,
unit_struct: UnitStruct {},
unit_tuple: UnitTuple(),
last: "".into()
}
}
"""
test_values.vec = "std::vec::Vec::<&str>::new()"
test_values."map.len()" = "0"
test_values.unit = "()"
test_values.unit_type = "UnitType"
test_values.unit_struct = "UnitStruct {}"
test_values.unit_tuple = "UnitTuple()"
test_values.last = "\"\""
[escapist_strings_issue_4]
main_type = "Foo"
definition = """
#[derive(PartialEq, Debug, Serialize)]
pub struct Foo {
pub s: Vec<String>,
pub c: Vec<char>,
}
"""
value = """
Foo {
s: vec!["\\"".into(), "\\n".into(), "'".into(), "❤".into()],
c: vec!['\\'', '\\n', '"', '❤'],
}
"""
test_values = { s = "[\"\\\"\", \"\\n\", \"'\", \"❤\"]", c = "['\\'', '\\n', '\"', '❤']" }