#![cfg(feature = "serde-codec")]
extern crate alloc;
use alloc::collections::BTreeMap;
use core::convert::TryFrom;
use serde::{ser, Serialize};
use serde_bytes::ByteBuf;
use libipld_core::cid::Cid;
use libipld_core::ipld::Ipld;
use libipld_core::serde::to_ipld;
fn assert_serialized<T>(input: T, ipld: Ipld)
where
T: ser::Serialize,
{
let serialized = to_ipld(input).unwrap();
assert_eq!(serialized, ipld);
}
#[test]
#[allow(clippy::let_unit_value)]
fn ipld_serializer_unit() {
let unit = ();
let serialized = to_ipld(unit);
assert!(serialized.is_err());
}
#[test]
fn ipld_serializer_unit_struct() {
#[derive(Clone, Debug, Serialize, PartialEq)]
struct UnitStruct;
let unit_struct = UnitStruct;
let serialized = to_ipld(unit_struct);
assert!(serialized.is_err());
}
#[test]
fn ipld_serializer_bool() {
let bool = false;
let ipld = Ipld::Bool(bool);
assert_serialized(bool, ipld);
}
#[test]
fn ipld_serializer_u8() {
let integer = 34u8;
let ipld = Ipld::Integer(integer.into());
assert_serialized(integer, ipld);
}
#[test]
fn ipld_serializer_u16() {
let integer = 345u16;
let ipld = Ipld::Integer(integer.into());
assert_serialized(integer, ipld);
}
#[test]
fn ipld_serializer_u32() {
let integer = 345678u32;
let ipld = Ipld::Integer(integer.into());
assert_serialized(integer, ipld);
}
#[test]
fn ipld_serializer_u64() {
let integer = 34567890123u64;
let ipld = Ipld::Integer(integer.into());
assert_serialized(integer, ipld);
}
#[test]
fn ipld_serializer_i8() {
let integer = -23i8;
let ipld = Ipld::Integer(integer.into());
assert_serialized(integer, ipld);
}
#[test]
fn ipld_serializer_i16() {
let integer = 2345i16;
let ipld = Ipld::Integer(integer.into());
assert_serialized(integer, ipld);
}
#[test]
fn ipld_serializer_i32() {
let integer = 234567i32;
let ipld = Ipld::Integer(integer.into());
assert_serialized(integer, ipld);
}
#[test]
fn ipld_serializer_i64() {
let integer = 2345678901i64;
let ipld = Ipld::Integer(integer.into());
assert_serialized(integer, ipld);
}
#[test]
fn ipld_serializer_i128() {
let integer = 34567890123467890123i128;
let ipld = Ipld::Integer(integer);
assert_serialized(integer, ipld);
}
#[test]
fn ipld_serializer_f32() {
let float = 7.3f32;
let ipld = Ipld::Float(float.into());
assert_serialized(float, ipld);
}
#[test]
fn ipld_serializer_f64() {
let float = 427.8f64;
let ipld = Ipld::Float(float);
assert_serialized(float, ipld);
}
#[test]
fn ipld_serializer_char() {
let char = 'x';
let ipld = Ipld::String(char.to_string());
assert_serialized(char, ipld);
}
#[test]
fn ipld_serializer_str() {
let str: &str = "hello";
let ipld = Ipld::String(str.to_string());
assert_serialized(str, ipld);
}
#[test]
fn ipld_serializer_bytes() {
let bytes = vec![0x68, 0x65, 0x6c, 0x6c, 0x6f];
let ipld = Ipld::Bytes(bytes.clone());
assert_serialized(ByteBuf::from(bytes), ipld);
}
#[test]
fn ipld_serializer_list() {
let list = vec![0x68, 0x65, 0x6c, 0x6c, 0x6f];
let ipld = Ipld::List(vec![
Ipld::Integer(0x68),
Ipld::Integer(0x65),
Ipld::Integer(0x6c),
Ipld::Integer(0x6c),
Ipld::Integer(0x6f),
]);
assert_serialized(list, ipld);
}
#[test]
fn ipld_serializer_tuple() {
let tuple = (true, "hello".to_string());
let ipld = Ipld::List(vec![Ipld::Bool(tuple.0), Ipld::String(tuple.1.clone())]);
assert_serialized(tuple, ipld);
}
#[test]
fn ipld_serializer_tuple_struct() {
#[derive(Clone, Debug, Serialize, PartialEq)]
struct TupleStruct(u8, bool);
let tuple_struct = TupleStruct(82, true);
let ipld = Ipld::List(vec![Ipld::Integer(82), Ipld::Bool(true)]);
assert_serialized(tuple_struct, ipld);
}
#[test]
fn ipld_serializer_map() {
let map = BTreeMap::from([("hello".to_string(), true), ("world!".to_string(), false)]);
let ipld = Ipld::Map(BTreeMap::from([
("hello".to_string(), Ipld::Bool(true)),
("world!".to_string(), Ipld::Bool(false)),
]));
assert_serialized(map, ipld);
}
#[test]
fn ipld_serializer_cid() {
let cid = Cid::try_from("bafkreie74tgmnxqwojhtumgh5dzfj46gi4mynlfr7dmm7duwzyvnpw7h7m").unwrap();
let ipld = Ipld::Link(cid);
assert_serialized(cid, ipld);
}
#[test]
fn ipld_serializer_newtype_struct() {
#[derive(Clone, Debug, Serialize, PartialEq)]
struct Wrapped(u8);
let newtype_struct = Wrapped(3);
let ipld = Ipld::Integer(3);
assert_serialized(newtype_struct, ipld);
}
#[test]
fn ipld_serializer_newtype_struct_cid() {
#[derive(Clone, Debug, Serialize, PartialEq)]
struct Wrapped(Cid);
let cid = Cid::try_from("bafkreie74tgmnxqwojhtumgh5dzfj46gi4mynlfr7dmm7duwzyvnpw7h7m").unwrap();
let newtype_struct = Wrapped(cid);
let ipld = Ipld::Link(cid);
assert_serialized(newtype_struct, ipld);
}
#[test]
fn ipld_serializer_option() {
let option_some: Option<u8> = Some(58u8);
let option_none: Option<u8> = None;
let ipld_some = Ipld::Integer(option_some.unwrap().into());
let ipld_none = Ipld::Null;
assert_serialized(option_some, ipld_some);
assert_serialized(option_none, ipld_none);
}
#[test]
fn ipld_serializer_enum() {
#[derive(Clone, Debug, Serialize, PartialEq)]
enum MyEnum {
One,
Two(u8),
Three { value: bool },
}
let enum_one = MyEnum::One;
let ipld_one = Ipld::String("One".into());
assert_serialized(enum_one, ipld_one);
let enum_two = MyEnum::Two(4);
let ipld_two = Ipld::Map(BTreeMap::from([("Two".into(), Ipld::Integer(4))]));
assert_serialized(enum_two, ipld_two);
let enum_three = MyEnum::Three { value: true };
let ipld_three = Ipld::Map(BTreeMap::from([(
"Three".into(),
Ipld::Map(BTreeMap::from([("value".into(), Ipld::Bool(true))])),
)]));
assert_serialized(enum_three, ipld_three);
}
#[test]
fn ipld_serializer_struct() {
#[derive(Clone, Debug, Serialize, PartialEq)]
struct MyStruct {
hello: u8,
world: bool,
}
let my_struct = MyStruct {
hello: 91,
world: false,
};
let ipld = Ipld::Map(BTreeMap::from([
("hello".into(), Ipld::Integer(my_struct.hello.into())),
("world".into(), Ipld::Bool(my_struct.world)),
]));
assert_serialized(my_struct, ipld);
}