mirror of
https://github.com/italicsjenga/valence.git
synced 2025-02-03 09:06:35 +11:00
205 lines
5 KiB
Rust
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);
|
|
}
|