1
0
Fork 0
mirror of https://github.com/italicsjenga/valence.git synced 2025-02-03 17:16:34 +11:00
valence/serde_nbt/src/tests.rs
2022-09-01 20:19:42 -07:00

205 lines
5 KiB
Rust

use pretty_assertions::assert_eq;
use serde::{Deserialize, Serialize};
use crate::binary::{from_reader, to_writer, Deserializer, Serializer};
use crate::{byte_array, int_array, long_array, Compound, List, Value};
const ROOT_NAME: &str = "The root name‽";
#[derive(PartialEq, Debug, Serialize, Deserialize)]
struct Struct {
byte: i8,
list_of_int: Vec<i32>,
list_of_string: Vec<String>,
string: String,
inner: Inner,
#[serde(with = "int_array")]
int_array: Vec<i32>,
#[serde(with = "byte_array")]
byte_array: Vec<i8>,
#[serde(with = "long_array")]
long_array: Vec<i64>,
some_int: Option<i32>,
none_int: Option<i32>,
}
#[derive(PartialEq, Debug, Serialize, Deserialize)]
struct Inner {
int: i32,
long: i64,
float: f32,
double: f64,
}
impl Struct {
pub fn new() -> Self {
Self {
byte: 123,
list_of_int: vec![3, -7, 5],
list_of_string: vec!["foo".to_owned(), "bar".to_owned(), "baz".to_owned()],
string: "aé日".to_owned(),
inner: Inner {
int: i32::MIN,
long: i64::MAX,
float: 1e10_f32,
double: f64::NEG_INFINITY,
},
int_array: vec![5, -9, i32::MIN, 0, i32::MAX],
byte_array: vec![0, 1, 2],
long_array: vec![123, 456, 789],
some_int: Some(321),
none_int: None,
}
}
pub fn value() -> Value {
Value::Compound(
Compound::from_iter([
("byte".into(), 123_i8.into()),
("list_of_int".into(), List::Int(vec![3, -7, 5]).into()),
(
"list_of_string".into(),
List::String(vec!["foo".into(), "bar".into(), "baz".into()]).into(),
),
("string".into(), "aé日".into()),
(
"inner".into(),
Compound::from_iter([
("int".into(), i32::MIN.into()),
("long".into(), i64::MAX.into()),
("float".into(), 1e10_f32.into()),
("double".into(), f64::NEG_INFINITY.into()),
])
.into(),
),
(
"int_array".into(),
vec![5, -9, i32::MIN, 0, i32::MAX].into(),
),
("byte_array".into(), vec![0_i8, 1, 2].into()),
("long_array".into(), vec![123_i64, 456, 789].into()),
("some_int".into(), 321.into()),
])
.into(),
)
}
}
#[test]
fn round_trip_binary_struct() {
let mut buf = Vec::new();
let struct_ = Struct::new();
struct_
.serialize(&mut Serializer::new(&mut buf, ROOT_NAME))
.unwrap();
let reader = &mut buf.as_slice();
let mut de = Deserializer::new(reader, true);
let struct_de = Struct::deserialize(&mut de).unwrap();
assert_eq!(struct_, struct_de);
assert_eq!(de.root_name, ROOT_NAME);
}
#[test]
fn round_trip_binary_value() {
let mut buf = Vec::new();
let value = Struct::value();
value
.serialize(&mut Serializer::new(&mut buf, ROOT_NAME))
.unwrap();
let reader = &mut buf.as_slice();
let mut de = Deserializer::new(reader, true);
let value_de = Value::deserialize(&mut de).unwrap();
assert_eq!(value, value_de);
assert_eq!(de.root_name, ROOT_NAME);
}
#[test]
fn to_hematite() {
let mut buf = Vec::new();
let struct_ = Struct::new();
struct_
.serialize(&mut Serializer::new(&mut buf, ROOT_NAME))
.unwrap();
let struct_de: Struct = nbt::from_reader(&mut buf.as_slice()).unwrap();
assert_eq!(struct_, struct_de);
}
#[test]
fn root_requires_compound() {
let mut buf = Vec::new();
assert!(123
.serialize(&mut Serializer::new(&mut buf, ROOT_NAME))
.is_err());
}
#[test]
fn mismatched_array_element() {
#[derive(Serialize)]
struct Struct {
#[serde(with = "byte_array")]
data: Vec<i32>,
}
let struct_ = Struct {
data: vec![1, 2, 3],
};
let mut buf = Vec::new();
assert!(struct_
.serialize(&mut Serializer::new(&mut buf, ROOT_NAME))
.is_err());
}
#[test]
fn struct_to_value() {
let mut buf = Vec::new();
let struct_ = Struct::new();
to_writer(&mut buf, &struct_).unwrap();
let val: Value = from_reader(&mut buf.as_slice()).unwrap();
assert_eq!(val, Struct::value());
}
#[test]
fn value_to_struct() {
let mut buf = Vec::new();
to_writer(&mut buf, &Struct::value()).unwrap();
let struct_: Struct = from_reader(&mut buf.as_slice()).unwrap();
assert_eq!(struct_, Struct::new());
}
#[test]
fn value_from_json() {
let mut struct_ = Struct::new();
// JSON numbers only allow finite floats.
struct_.inner.double = 12345.0;
let string = serde_json::to_string_pretty(&struct_).unwrap();
let struct_de: Struct = serde_json::from_str(&string).unwrap();
assert_eq!(struct_, struct_de);
}