extern crate itch;
use serde::{Deserialize, Serialize};
use std::collections::HashMap;
#[derive(Debug, PartialEq, Serialize, Deserialize)]
struct Foo {
b: bool,
s: String,
}
#[derive(Debug, PartialEq, Serialize, Deserialize)]
enum TestEnum {
One,
Two,
Three,
}
#[derive(Debug, PartialEq, Serialize, Deserialize)]
struct Bar {
f: f64,
i: i64,
foos: Vec<Foo>,
}
#[derive(Debug, PartialEq, Serialize, Deserialize)]
struct TestStruct {
bar: Bar,
e: HashMap<String, TestEnum>,
}
impl TestStruct {
pub fn new() -> Self {
Self {
bar: Bar {
foos: vec![
Foo {
b: true,
s: "a".to_owned(),
},
Foo {
b: false,
s: "ab".to_owned(),
},
Foo {
b: true,
s: "abc".to_owned(),
},
],
f: 123.456,
i: 123456,
},
e: {
let mut hm = HashMap::new();
hm.insert("ein".to_owned(), TestEnum::One);
hm.insert("zwei".to_owned(), TestEnum::Two);
hm.insert("drei".to_owned(), TestEnum::Three);
hm
},
}
}
}
mod from_json {
use super::*;
#[test]
fn to_json() {
let input_json_string = serde_json::to_string(&TestStruct::new()).unwrap();
let input_json_bytes: &[u8] = input_json_string.as_bytes();
let mut output_json_bytes: Vec<u8> = Vec::new();
itch::convert(
&itch::FromType::Json,
&itch::ToType::Json,
input_json_bytes,
&mut output_json_bytes,
)
.unwrap();
let output: TestStruct =
serde_json::from_str(std::str::from_utf8(&output_json_bytes).unwrap()).unwrap();
assert_eq!(output, TestStruct::new());
}
#[test]
fn to_toml() {
let input_json_string = serde_json::to_string(&TestStruct::new()).unwrap();
let input_json_bytes: &[u8] = input_json_string.as_bytes();
let mut output_toml_bytes: Vec<u8> = Vec::new();
itch::convert(
&itch::FromType::Json,
&itch::ToType::Toml,
input_json_bytes,
&mut output_toml_bytes,
)
.unwrap();
let output: TestStruct =
toml::from_str(std::str::from_utf8(&output_toml_bytes).unwrap()).unwrap();
assert_eq!(output, TestStruct::new());
}
#[test]
fn to_url() {
let input_json_string = serde_json::to_string(&TestStruct::new()).unwrap();
let input_json_bytes: &[u8] = input_json_string.as_bytes();
let mut output_url_bytes: Vec<u8> = Vec::new();
itch::convert(
&itch::FromType::Json,
&itch::ToType::Url,
input_json_bytes,
&mut output_url_bytes,
)
.unwrap();
let output: TestStruct =
serde_qs::from_str(std::str::from_utf8(&output_url_bytes).unwrap()).unwrap();
assert_eq!(output, TestStruct::new());
}
#[test]
fn to_yaml() {
let input_json_string = serde_json::to_string(&TestStruct::new()).unwrap();
let input_json_bytes: &[u8] = input_json_string.as_bytes();
let mut output_yaml_bytes: Vec<u8> = Vec::new();
itch::convert(
&itch::FromType::Json,
&itch::ToType::Yaml,
input_json_bytes,
&mut output_yaml_bytes,
)
.unwrap();
let output: TestStruct =
serde_yaml::from_str(std::str::from_utf8(&output_yaml_bytes).unwrap()).unwrap();
assert_eq!(output, TestStruct::new());
}
}
mod from_toml {
use super::*;
#[test]
fn to_json() {
let input_toml_string = toml::to_string(&TestStruct::new()).unwrap();
let input_toml_bytes: &[u8] = input_toml_string.as_bytes();
let mut output_json_bytes: Vec<u8> = Vec::new();
itch::convert(
&itch::FromType::Toml,
&itch::ToType::Json,
input_toml_bytes,
&mut output_json_bytes,
)
.unwrap();
let output: TestStruct =
serde_json::from_str(std::str::from_utf8(&output_json_bytes).unwrap()).unwrap();
assert_eq!(output, TestStruct::new());
}
#[test]
fn to_toml() {
let input_toml_string = toml::to_string(&TestStruct::new()).unwrap();
let input_toml_bytes: &[u8] = input_toml_string.as_bytes();
let mut output_toml_bytes: Vec<u8> = Vec::new();
itch::convert(
&itch::FromType::Toml,
&itch::ToType::Toml,
input_toml_bytes,
&mut output_toml_bytes,
)
.unwrap();
let output: TestStruct =
toml::from_str(std::str::from_utf8(&output_toml_bytes).unwrap()).unwrap();
assert_eq!(output, TestStruct::new());
}
#[test]
fn to_url() {
let input_toml_string = toml::to_string(&TestStruct::new()).unwrap();
let input_toml_bytes: &[u8] = input_toml_string.as_bytes();
let mut output_url_bytes: Vec<u8> = Vec::new();
itch::convert(
&itch::FromType::Toml,
&itch::ToType::Url,
input_toml_bytes,
&mut output_url_bytes,
)
.unwrap();
let output: TestStruct =
serde_qs::from_str(std::str::from_utf8(&output_url_bytes).unwrap()).unwrap();
assert_eq!(output, TestStruct::new());
}
#[test]
fn to_yaml() {
let input_toml_string = toml::to_string(&TestStruct::new()).unwrap();
let input_toml_bytes: &[u8] = input_toml_string.as_bytes();
let mut output_yaml_bytes: Vec<u8> = Vec::new();
itch::convert(
&itch::FromType::Toml,
&itch::ToType::Yaml,
input_toml_bytes,
&mut output_yaml_bytes,
)
.unwrap();
let output: TestStruct =
serde_yaml::from_str(std::str::from_utf8(&output_yaml_bytes).unwrap()).unwrap();
assert_eq!(output, TestStruct::new());
}
}
mod from_yaml {
use super::*;
#[test]
fn to_json() {
let input_yaml_string = serde_yaml::to_string(&TestStruct::new()).unwrap();
let input_yaml_bytes: &[u8] = input_yaml_string.as_bytes();
let mut output_json_bytes: Vec<u8> = Vec::new();
itch::convert(
&itch::FromType::Yaml,
&itch::ToType::Json,
input_yaml_bytes,
&mut output_json_bytes,
)
.unwrap();
let output: TestStruct =
serde_json::from_str(std::str::from_utf8(&output_json_bytes).unwrap()).unwrap();
assert_eq!(output, TestStruct::new());
}
#[test]
fn to_toml() {
let input_yaml_string = serde_yaml::to_string(&TestStruct::new()).unwrap();
let input_yaml_bytes: &[u8] = input_yaml_string.as_bytes();
let mut output_toml_bytes: Vec<u8> = Vec::new();
itch::convert(
&itch::FromType::Yaml,
&itch::ToType::Toml,
input_yaml_bytes,
&mut output_toml_bytes,
)
.unwrap();
let output: TestStruct =
toml::from_str(std::str::from_utf8(&output_toml_bytes).unwrap()).unwrap();
assert_eq!(output, TestStruct::new());
}
#[test]
fn to_url() {
let input_yaml_string = serde_yaml::to_string(&TestStruct::new()).unwrap();
let input_yaml_bytes: &[u8] = input_yaml_string.as_bytes();
let mut output_url_bytes: Vec<u8> = Vec::new();
itch::convert(
&itch::FromType::Yaml,
&itch::ToType::Url,
input_yaml_bytes,
&mut output_url_bytes,
)
.unwrap();
let output: TestStruct =
serde_qs::from_str(std::str::from_utf8(&output_url_bytes).unwrap()).unwrap();
assert_eq!(output, TestStruct::new());
}
#[test]
fn to_yaml() {
let input_yaml_string = serde_yaml::to_string(&TestStruct::new()).unwrap();
let input_yaml_bytes: &[u8] = input_yaml_string.as_bytes();
let mut output_yaml_bytes: Vec<u8> = Vec::new();
itch::convert(
&itch::FromType::Yaml,
&itch::ToType::Yaml,
input_yaml_bytes,
&mut output_yaml_bytes,
)
.unwrap();
let output: TestStruct =
serde_yaml::from_str(std::str::from_utf8(&output_yaml_bytes).unwrap()).unwrap();
assert_eq!(output, TestStruct::new());
}
}