diff --git a/test_suite/tests/test_ser.rs b/test_suite/tests/test_ser.rs index 5abce420..0105d760 100644 --- a/test_suite/tests/test_ser.rs +++ b/test_suite/tests/test_ser.rs @@ -4,7 +4,6 @@ use std::cell::RefCell; use std::collections::{BTreeMap, BTreeSet, HashMap, HashSet}; use std::ffi::CString; -use std::mem; use std::net; use std::num::Wrapping; use std::ops::Bound; @@ -72,547 +71,730 @@ enum Enum { ////////////////////////////////////////////////////////////////////////// -macro_rules! declare_tests { - ( - $readable:tt - $($name:ident { $($value:expr => $tokens:expr,)+ })+ - ) => { - $( - #[test] - fn $name() { - $( - assert_ser_tokens(&$value.$readable(), $tokens); - )+ - } - )+ - }; - - ($($name:ident { $($value:expr => $tokens:expr,)+ })+) => { - $( - #[test] - fn $name() { - $( - assert_ser_tokens(&$value, $tokens); - )+ - } - )+ - } +#[test] +fn test_unit() { + assert_ser_tokens(&(), &[Token::Unit]); } -declare_tests! { - test_unit { - () => &[Token::Unit], - } - test_bool { - true => &[Token::Bool(true)], - false => &[Token::Bool(false)], - } - test_isizes { - 0i8 => &[Token::I8(0)], - 0i16 => &[Token::I16(0)], - 0i32 => &[Token::I32(0)], - 0i64 => &[Token::I64(0)], - } - test_usizes { - 0u8 => &[Token::U8(0)], - 0u16 => &[Token::U16(0)], - 0u32 => &[Token::U32(0)], - 0u64 => &[Token::U64(0)], - } - test_floats { - 0f32 => &[Token::F32(0.)], - 0f64 => &[Token::F64(0.)], - } - test_char { - 'a' => &[Token::Char('a')], - } - test_str { - "abc" => &[Token::Str("abc")], - "abc".to_owned() => &[Token::Str("abc")], - } - test_option { - None:: => &[Token::None], - Some(1) => &[ - Token::Some, - Token::I32(1), - ], - } - test_result { - Ok::(0) => &[ - Token::NewtypeVariant { name: "Result", variant: "Ok" }, +#[test] +fn test_bool() { + assert_ser_tokens(&true, &[Token::Bool(true)]); + assert_ser_tokens(&false, &[Token::Bool(false)]); +} + +#[test] +fn test_isizes() { + assert_ser_tokens(&0i8, &[Token::I8(0)]); + assert_ser_tokens(&0i16, &[Token::I16(0)]); + assert_ser_tokens(&0i32, &[Token::I32(0)]); + assert_ser_tokens(&0i64, &[Token::I64(0)]); +} + +#[test] +fn test_usizes() { + assert_ser_tokens(&0u8, &[Token::U8(0)]); + assert_ser_tokens(&0u16, &[Token::U16(0)]); + assert_ser_tokens(&0u32, &[Token::U32(0)]); + assert_ser_tokens(&0u64, &[Token::U64(0)]); +} + +#[test] +fn test_floats() { + assert_ser_tokens(&0f32, &[Token::F32(0.)]); + assert_ser_tokens(&0f64, &[Token::F64(0.)]); +} + +#[test] +fn test_char() { + assert_ser_tokens(&'a', &[Token::Char('a')]); +} + +#[test] +fn test_str() { + assert_ser_tokens(&"abc", &[Token::Str("abc")]); + assert_ser_tokens(&"abc".to_owned(), &[Token::Str("abc")]); +} + +#[test] +fn test_option() { + assert_ser_tokens(&None::, &[Token::None]); + assert_ser_tokens(&Some(1), &[Token::Some, Token::I32(1)]); +} + +#[test] +fn test_result() { + assert_ser_tokens( + &Ok::(0), + &[ + Token::NewtypeVariant { + name: "Result", + variant: "Ok", + }, Token::I32(0), ], - Err::(1) => &[ - Token::NewtypeVariant { name: "Result", variant: "Err" }, + ); + assert_ser_tokens( + &Err::(1), + &[ + Token::NewtypeVariant { + name: "Result", + variant: "Err", + }, Token::I32(1), ], - } - test_slice { - &[0][..0] => &[ - Token::Seq { len: Some(0) }, - Token::SeqEnd, - ], - &[1, 2, 3][..] => &[ - Token::Seq { len: Some(3) }, - Token::I32(1), - Token::I32(2), - Token::I32(3), - Token::SeqEnd, - ], - } - test_array { - [0; 0] => &[ - Token::Tuple { len: 0 }, - Token::TupleEnd, - ], - [1, 2, 3] => &[ - Token::Tuple { len: 3 }, - Token::I32(1), - Token::I32(2), - Token::I32(3), - Token::TupleEnd, - ], - } - test_vec { - Vec::::new() => &[ - Token::Seq { len: Some(0) }, - Token::SeqEnd, - ], - vec![vec![], vec![1], vec![2, 3]] => &[ - Token::Seq { len: Some(3) }, - Token::Seq { len: Some(0) }, - Token::SeqEnd, + ); +} - Token::Seq { len: Some(1) }, - Token::I32(1), - Token::SeqEnd, +#[test] +fn test_slice() { + assert_ser_tokens(&[0][..0], &[Token::Seq { len: Some(0) }, Token::SeqEnd]); + assert_ser_tokens( + &[1, 2, 3][..], + &[ + Token::Seq { len: Some(3) }, + Token::I32(1), + Token::I32(2), + Token::I32(3), + Token::SeqEnd, + ], + ); +} - Token::Seq { len: Some(2) }, - Token::I32(2), - Token::I32(3), - Token::SeqEnd, - Token::SeqEnd, - ], - } - test_btreeset { - BTreeSet::::new() => &[ - Token::Seq { len: Some(0) }, - Token::SeqEnd, - ], - btreeset![1] => &[ - Token::Seq { len: Some(1) }, - Token::I32(1), - Token::SeqEnd, - ], - } - test_hashset { - HashSet::::new() => &[ - Token::Seq { len: Some(0) }, - Token::SeqEnd, - ], - hashset![1] => &[ - Token::Seq { len: Some(1) }, - Token::I32(1), - Token::SeqEnd, - ], - hashset![FnvHasher @ 1] => &[ - Token::Seq { len: Some(1) }, - Token::I32(1), - Token::SeqEnd, - ], - } - test_tuple { - (1,) => &[ - Token::Tuple { len: 1 }, - Token::I32(1), - Token::TupleEnd, - ], - (1, 2, 3) => &[ +#[test] +fn test_array() { + assert_ser_tokens(&[0; 0], &[Token::Tuple { len: 0 }, Token::TupleEnd]); + assert_ser_tokens( + &[1, 2, 3], + &[ Token::Tuple { len: 3 }, - Token::I32(1), - Token::I32(2), - Token::I32(3), + Token::I32(1), + Token::I32(2), + Token::I32(3), Token::TupleEnd, ], - } - test_btreemap { - btreemap![1 => 2] => &[ + ); +} + +#[test] +fn test_vec() { + assert_ser_tokens( + &Vec::::new(), + &[Token::Seq { len: Some(0) }, Token::SeqEnd], + ); + assert_ser_tokens( + &vec![vec![], vec![1], vec![2, 3]], + &[ + Token::Seq { len: Some(3) }, + Token::Seq { len: Some(0) }, + Token::SeqEnd, + Token::Seq { len: Some(1) }, + Token::I32(1), + Token::SeqEnd, + Token::Seq { len: Some(2) }, + Token::I32(2), + Token::I32(3), + Token::SeqEnd, + Token::SeqEnd, + ], + ); +} + +#[test] +fn test_btreeset() { + assert_ser_tokens( + &BTreeSet::::new(), + &[Token::Seq { len: Some(0) }, Token::SeqEnd], + ); + assert_ser_tokens( + &btreeset![1], + &[Token::Seq { len: Some(1) }, Token::I32(1), Token::SeqEnd], + ); +} + +#[test] +fn test_hashset() { + assert_ser_tokens( + &HashSet::::new(), + &[Token::Seq { len: Some(0) }, Token::SeqEnd], + ); + assert_ser_tokens( + &hashset![1], + &[Token::Seq { len: Some(1) }, Token::I32(1), Token::SeqEnd], + ); + assert_ser_tokens( + &hashset![FnvHasher @ 1], + &[Token::Seq { len: Some(1) }, Token::I32(1), Token::SeqEnd], + ); +} + +#[test] +fn test_tuple() { + assert_ser_tokens( + &(1,), + &[Token::Tuple { len: 1 }, Token::I32(1), Token::TupleEnd], + ); + assert_ser_tokens( + &(1, 2, 3), + &[ + Token::Tuple { len: 3 }, + Token::I32(1), + Token::I32(2), + Token::I32(3), + Token::TupleEnd, + ], + ); +} + +#[test] +fn test_btreemap() { + assert_ser_tokens( + &btreemap![1 => 2], + &[ Token::Map { len: Some(1) }, - Token::I32(1), - Token::I32(2), + Token::I32(1), + Token::I32(2), Token::MapEnd, ], - btreemap![1 => 2, 3 => 4] => &[ + ); + assert_ser_tokens( + &btreemap![1 => 2, 3 => 4], + &[ Token::Map { len: Some(2) }, - Token::I32(1), - Token::I32(2), - - Token::I32(3), - Token::I32(4), + Token::I32(1), + Token::I32(2), + Token::I32(3), + Token::I32(4), Token::MapEnd, ], - btreemap![1 => btreemap![], 2 => btreemap![3 => 4, 5 => 6]] => &[ + ); + assert_ser_tokens( + &btreemap![1 => btreemap![], 2 => btreemap![3 => 4, 5 => 6]], + &[ Token::Map { len: Some(2) }, - Token::I32(1), - Token::Map { len: Some(0) }, - Token::MapEnd, - - Token::I32(2), - Token::Map { len: Some(2) }, - Token::I32(3), - Token::I32(4), - - Token::I32(5), - Token::I32(6), - Token::MapEnd, - Token::MapEnd, - ], - } - test_hashmap { - HashMap::::new() => &[ + Token::I32(1), Token::Map { len: Some(0) }, Token::MapEnd, - ], - hashmap![1 => 2] => &[ - Token::Map { len: Some(1) }, - Token::I32(1), - Token::I32(2), + Token::I32(2), + Token::Map { len: Some(2) }, + Token::I32(3), + Token::I32(4), + Token::I32(5), + Token::I32(6), + Token::MapEnd, Token::MapEnd, ], - hashmap![FnvHasher @ 1 => 2] => &[ + ); +} + +#[test] +fn test_hashmap() { + assert_ser_tokens( + &HashMap::::new(), + &[Token::Map { len: Some(0) }, Token::MapEnd], + ); + assert_ser_tokens( + &hashmap![1 => 2], + &[ Token::Map { len: Some(1) }, - Token::I32(1), - Token::I32(2), + Token::I32(1), + Token::I32(2), Token::MapEnd, ], - } - test_unit_struct { - UnitStruct => &[Token::UnitStruct { name: "UnitStruct" }], - } - test_tuple_struct { - TupleStruct(1, 2, 3) => &[ - Token::TupleStruct { name: "TupleStruct", len: 3 }, - Token::I32(1), - Token::I32(2), - Token::I32(3), + ); + assert_ser_tokens( + &hashmap![FnvHasher @ 1 => 2], + &[ + Token::Map { len: Some(1) }, + Token::I32(1), + Token::I32(2), + Token::MapEnd, + ], + ); +} + +#[test] +fn test_unit_struct() { + assert_ser_tokens(&UnitStruct, &[Token::UnitStruct { name: "UnitStruct" }]); +} + +#[test] +fn test_tuple_struct() { + assert_ser_tokens( + &TupleStruct(1, 2, 3), + &[ + Token::TupleStruct { + name: "TupleStruct", + len: 3, + }, + Token::I32(1), + Token::I32(2), + Token::I32(3), Token::TupleStructEnd, ], - } - test_struct { - Struct { a: 1, b: 2, c: 3 } => &[ - Token::Struct { name: "Struct", len: 3 }, - Token::Str("a"), - Token::I32(1), + ); +} - Token::Str("b"), - Token::I32(2), - - Token::Str("c"), - Token::I32(3), +#[test] +fn test_struct() { + assert_ser_tokens( + &Struct { a: 1, b: 2, c: 3 }, + &[ + Token::Struct { + name: "Struct", + len: 3, + }, + Token::Str("a"), + Token::I32(1), + Token::Str("b"), + Token::I32(2), + Token::Str("c"), + Token::I32(3), Token::StructEnd, ], - } - test_enum { - Enum::Unit => &[ - Token::UnitVariant { name: "Enum", variant: "Unit" }, - ], - Enum::One(42) => &[ - Token::NewtypeVariant { name: "Enum", variant: "One" }, + ); +} + +#[test] +fn test_enum() { + assert_ser_tokens( + &Enum::Unit, + &[Token::UnitVariant { + name: "Enum", + variant: "Unit", + }], + ); + assert_ser_tokens( + &Enum::One(42), + &[ + Token::NewtypeVariant { + name: "Enum", + variant: "One", + }, Token::I32(42), ], - Enum::Seq(1, 2) => &[ - Token::TupleVariant { name: "Enum", variant: "Seq", len: 2 }, - Token::I32(1), - Token::I32(2), + ); + assert_ser_tokens( + &Enum::Seq(1, 2), + &[ + Token::TupleVariant { + name: "Enum", + variant: "Seq", + len: 2, + }, + Token::I32(1), + Token::I32(2), Token::TupleVariantEnd, ], - Enum::Map { a: 1, b: 2 } => &[ - Token::StructVariant { name: "Enum", variant: "Map", len: 2 }, - Token::Str("a"), - Token::I32(1), - - Token::Str("b"), - Token::I32(2), + ); + assert_ser_tokens( + &Enum::Map { a: 1, b: 2 }, + &[ + Token::StructVariant { + name: "Enum", + variant: "Map", + len: 2, + }, + Token::Str("a"), + Token::I32(1), + Token::Str("b"), + Token::I32(2), Token::StructVariantEnd, ], - Enum::OneWithSkipped(NotSerializable) => &[ - Token::UnitVariant { name: "Enum", variant: "OneWithSkipped" }, - ], - } - test_box { - Box::new(0i32) => &[Token::I32(0)], - } - test_boxed_slice { - Box::new([0, 1, 2]) => &[ + ); + assert_ser_tokens( + &Enum::OneWithSkipped(NotSerializable), + &[Token::UnitVariant { + name: "Enum", + variant: "OneWithSkipped", + }], + ); +} + +#[test] +fn test_box() { + assert_ser_tokens(&Box::new(0i32), &[Token::I32(0)]); +} + +#[test] +fn test_boxed_slice() { + assert_ser_tokens( + &Box::new([0, 1, 2]), + &[ Token::Tuple { len: 3 }, Token::I32(0), Token::I32(1), Token::I32(2), Token::TupleEnd, ], - } - test_duration { - Duration::new(1, 2) => &[ - Token::Struct { name: "Duration", len: 2 }, - Token::Str("secs"), - Token::U64(1), + ); +} - Token::Str("nanos"), - Token::U32(2), +#[test] +fn test_duration() { + assert_ser_tokens( + &Duration::new(1, 2), + &[ + Token::Struct { + name: "Duration", + len: 2, + }, + Token::Str("secs"), + Token::U64(1), + Token::Str("nanos"), + Token::U32(2), Token::StructEnd, ], - } - test_system_time { - UNIX_EPOCH + Duration::new(1, 200) => &[ - Token::Struct { name: "SystemTime", len: 2 }, - Token::Str("secs_since_epoch"), - Token::U64(1), + ); +} - Token::Str("nanos_since_epoch"), - Token::U32(200), +#[test] +fn test_system_time() { + let system_time = UNIX_EPOCH + Duration::new(1, 200); + assert_ser_tokens( + &system_time, + &[ + Token::Struct { + name: "SystemTime", + len: 2, + }, + Token::Str("secs_since_epoch"), + Token::U64(1), + Token::Str("nanos_since_epoch"), + Token::U32(200), Token::StructEnd, ], - } - test_range { - 1u32..2u32 => &[ - Token::Struct { name: "Range", len: 2 }, - Token::Str("start"), - Token::U32(1), + ); +} - Token::Str("end"), - Token::U32(2), +#[test] +fn test_range() { + assert_ser_tokens( + &(1u32..2u32), + &[ + Token::Struct { + name: "Range", + len: 2, + }, + Token::Str("start"), + Token::U32(1), + Token::Str("end"), + Token::U32(2), Token::StructEnd, ], - } - test_range_inclusive { - 1u32..=2u32 => &[ - Token::Struct { name: "RangeInclusive", len: 2 }, - Token::Str("start"), - Token::U32(1), + ); +} - Token::Str("end"), - Token::U32(2), +#[test] +fn test_range_inclusive() { + assert_ser_tokens( + &(1u32..=2u32), + &[ + Token::Struct { + name: "RangeInclusive", + len: 2, + }, + Token::Str("start"), + Token::U32(1), + Token::Str("end"), + Token::U32(2), Token::StructEnd, ], - } - test_bound { - Bound::Unbounded::<()> => &[ + ); +} + +#[test] +fn test_bound() { + assert_ser_tokens( + &Bound::Unbounded::<()>, + &[ Token::Enum { name: "Bound" }, Token::Str("Unbounded"), Token::Unit, ], - Bound::Included(0u8) => &[ + ); + assert_ser_tokens( + &Bound::Included(0u8), + &[ Token::Enum { name: "Bound" }, Token::Str("Included"), Token::U8(0), ], - Bound::Excluded(0u8) => &[ + ); + assert_ser_tokens( + &Bound::Excluded(0u8), + &[ Token::Enum { name: "Bound" }, Token::Str("Excluded"), Token::U8(0), ], - } - test_path { - Path::new("/usr/local/lib") => &[ - Token::Str("/usr/local/lib"), - ], - } - test_path_buf { - PathBuf::from("/usr/local/lib") => &[ - Token::Str("/usr/local/lib"), - ], - } - test_cstring { - CString::new("abc").unwrap() => &[ - Token::Bytes(b"abc"), - ], - } - test_cstr { - (&*CString::new("abc").unwrap()) => &[ - Token::Bytes(b"abc"), - ], - } - test_rc { - Rc::new(true) => &[ - Token::Bool(true), - ], - } - test_rc_weak_some { - { - let rc = Rc::new(true); - mem::forget(rc.clone()); - Rc::downgrade(&rc) - } => &[ - Token::Some, - Token::Bool(true), - ], - } - test_rc_weak_none { - RcWeak::::new() => &[ - Token::None, - ], - } - test_arc { - Arc::new(true) => &[ - Token::Bool(true), - ], - } - test_arc_weak_some { - { - let arc = Arc::new(true); - mem::forget(arc.clone()); - Arc::downgrade(&arc) - } => &[ - Token::Some, - Token::Bool(true), - ], - } - test_arc_weak_none { - ArcWeak::::new() => &[ - Token::None, - ], - } - test_wrapping { - Wrapping(1usize) => &[ - Token::U64(1), - ], - } - test_rc_dst { - Rc::::from("s") => &[ - Token::Str("s"), - ], - Rc::<[bool]>::from(&[true][..]) => &[ + ); +} + +#[test] +fn test_path() { + assert_ser_tokens( + &Path::new("/usr/local/lib"), + &[Token::Str("/usr/local/lib")], + ); +} + +#[test] +fn test_path_buf() { + assert_ser_tokens( + &PathBuf::from("/usr/local/lib"), + &[Token::Str("/usr/local/lib")], + ); +} + +#[test] +fn test_cstring() { + assert_ser_tokens(&CString::new("abc").unwrap(), &[Token::Bytes(b"abc")]); +} + +#[test] +fn test_cstr() { + let cstring = CString::new("abc").unwrap(); + assert_ser_tokens(cstring.as_c_str(), &[Token::Bytes(b"abc")]); +} + +#[test] +fn test_rc() { + assert_ser_tokens(&Rc::new(true), &[Token::Bool(true)]); +} + +#[test] +fn test_rc_weak_some() { + let rc = Rc::new(true); + assert_ser_tokens(&Rc::downgrade(&rc), &[Token::Some, Token::Bool(true)]); +} + +#[test] +fn test_rc_weak_none() { + assert_ser_tokens(&RcWeak::::new(), &[Token::None]); +} + +#[test] +fn test_arc() { + assert_ser_tokens(&Arc::new(true), &[Token::Bool(true)]); +} + +#[test] +fn test_arc_weak_some() { + let arc = Arc::new(true); + assert_ser_tokens(&Arc::downgrade(&arc), &[Token::Some, Token::Bool(true)]); +} + +#[test] +fn test_arc_weak_none() { + assert_ser_tokens(&ArcWeak::::new(), &[Token::None]); +} + +#[test] +fn test_wrapping() { + assert_ser_tokens(&Wrapping(1usize), &[Token::U64(1)]); +} + +#[test] +fn test_rc_dst() { + assert_ser_tokens(&Rc::::from("s"), &[Token::Str("s")]); + assert_ser_tokens( + &Rc::<[bool]>::from(&[true][..]), + &[ Token::Seq { len: Some(1) }, Token::Bool(true), Token::SeqEnd, ], - } - test_arc_dst { - Arc::::from("s") => &[ - Token::Str("s"), - ], - Arc::<[bool]>::from(&[true][..]) => &[ + ); +} + +#[test] +fn test_arc_dst() { + assert_ser_tokens(&Arc::::from("s"), &[Token::Str("s")]); + assert_ser_tokens( + &Arc::<[bool]>::from(&[true][..]), + &[ Token::Seq { len: Some(1) }, Token::Bool(true), Token::SeqEnd, ], - } - test_fmt_arguments { - format_args!("{}{}", 1, 'a') => &[ - Token::Str("1a"), - ], - } - test_atomic { - AtomicBool::new(false) => &[Token::Bool(false)], - AtomicBool::new(true) => &[Token::Bool(true)], - AtomicI8::new(63i8) => &[Token::I8(63i8)], - AtomicI16::new(-318i16) => &[Token::I16(-318i16)], - AtomicI32::new(65792i32) => &[Token::I32(65792i32)], - AtomicIsize::new(-65792isize) => &[Token::I64(-65792i64)], - AtomicU8::new(192u8) => &[Token::U8(192u8)], - AtomicU16::new(510u16) => &[Token::U16(510u16)], - AtomicU32::new(131072u32) => &[Token::U32(131072u32)], - AtomicUsize::new(655360usize) => &[Token::U64(655360u64)], - } + ); +} + +#[test] +fn test_fmt_arguments() { + assert_ser_tokens(&format_args!("{}{}", 1, 'a'), &[Token::Str("1a")]); +} + +#[test] +fn test_atomic() { + assert_ser_tokens(&AtomicBool::new(false), &[Token::Bool(false)]); + assert_ser_tokens(&AtomicBool::new(true), &[Token::Bool(true)]); + assert_ser_tokens(&AtomicI8::new(63i8), &[Token::I8(63i8)]); + assert_ser_tokens(&AtomicI16::new(-318i16), &[Token::I16(-318i16)]); + assert_ser_tokens(&AtomicI32::new(65792i32), &[Token::I32(65792i32)]); + assert_ser_tokens(&AtomicIsize::new(-65792isize), &[Token::I64(-65792i64)]); + assert_ser_tokens(&AtomicU8::new(192u8), &[Token::U8(192u8)]); + assert_ser_tokens(&AtomicU16::new(510u16), &[Token::U16(510u16)]); + assert_ser_tokens(&AtomicU32::new(131072u32), &[Token::U32(131072u32)]); + assert_ser_tokens(&AtomicUsize::new(655360usize), &[Token::U64(655360u64)]); } #[cfg(target_arch = "x86_64")] -declare_tests! { - test_atomic64 { - AtomicI64::new(-4295032832i64) => &[Token::I64(-4295032832i64)], - AtomicU64::new(12884901888u64) => &[Token::U64(12884901888u64)], - } +#[test] +fn test_atomic64() { + assert_ser_tokens( + &AtomicI64::new(-4295032832i64), + &[Token::I64(-4295032832i64)], + ); + assert_ser_tokens( + &AtomicU64::new(12884901888u64), + &[Token::U64(12884901888u64)], + ); } -declare_tests! { - readable - - test_net_ipv4addr_readable { - "1.2.3.4".parse::().unwrap() => &[Token::Str("1.2.3.4")], - } - test_net_ipv6addr_readable { - "::1".parse::().unwrap() => &[Token::Str("::1")], - } - test_net_ipaddr_readable { - "1.2.3.4".parse::().unwrap() => &[Token::Str("1.2.3.4")], - } - test_net_socketaddr_readable { - "1.2.3.4:1234".parse::().unwrap() => &[Token::Str("1.2.3.4:1234")], - "1.2.3.4:1234".parse::().unwrap() => &[Token::Str("1.2.3.4:1234")], - "[::1]:1234".parse::().unwrap() => &[Token::Str("[::1]:1234")], - } +#[test] +fn test_net_ipv4addr_readable() { + assert_ser_tokens( + &"1.2.3.4".parse::().unwrap().readable(), + &[Token::Str("1.2.3.4")], + ); } -declare_tests! { - compact +#[test] +fn test_net_ipv6addr_readable() { + assert_ser_tokens( + &"::1".parse::().unwrap().readable(), + &[Token::Str("::1")], + ); +} - test_net_ipv4addr_compact { - net::Ipv4Addr::from(*b"1234") => &seq![ +#[test] +fn test_net_ipaddr_readable() { + assert_ser_tokens( + &"1.2.3.4".parse::().unwrap().readable(), + &[Token::Str("1.2.3.4")], + ); +} + +#[test] +fn test_net_socketaddr_readable() { + assert_ser_tokens( + &"1.2.3.4:1234" + .parse::() + .unwrap() + .readable(), + &[Token::Str("1.2.3.4:1234")], + ); + assert_ser_tokens( + &"1.2.3.4:1234" + .parse::() + .unwrap() + .readable(), + &[Token::Str("1.2.3.4:1234")], + ); + assert_ser_tokens( + &"[::1]:1234" + .parse::() + .unwrap() + .readable(), + &[Token::Str("[::1]:1234")], + ); +} + +#[test] +fn test_net_ipv4addr_compact() { + assert_ser_tokens( + &net::Ipv4Addr::from(*b"1234").compact(), + &seq![ Token::Tuple { len: 4 }, b"1234".iter().copied().map(Token::U8), Token::TupleEnd, ], - } - test_net_ipv6addr_compact { - net::Ipv6Addr::from(*b"1234567890123456") => &seq![ + ); +} + +#[test] +fn test_net_ipv6addr_compact() { + assert_ser_tokens( + &net::Ipv6Addr::from(*b"1234567890123456").compact(), + &seq![ Token::Tuple { len: 16 }, b"1234567890123456".iter().copied().map(Token::U8), Token::TupleEnd, ], - } - test_net_ipaddr_compact { - net::IpAddr::from(*b"1234") => &seq![ - Token::NewtypeVariant { name: "IpAddr", variant: "V4" }, + ); +} +#[test] +fn test_net_ipaddr_compact() { + assert_ser_tokens( + &net::IpAddr::from(*b"1234").compact(), + &seq![ + Token::NewtypeVariant { + name: "IpAddr", + variant: "V4" + }, Token::Tuple { len: 4 }, b"1234".iter().copied().map(Token::U8), Token::TupleEnd, ], - } - test_net_socketaddr_compact { - net::SocketAddr::from((*b"1234567890123456", 1234)) => &seq![ - Token::NewtypeVariant { name: "SocketAddr", variant: "V6" }, + ); +} +#[test] +fn test_net_socketaddr_compact() { + assert_ser_tokens( + &net::SocketAddr::from((*b"1234567890123456", 1234)).compact(), + &seq![ + Token::NewtypeVariant { + name: "SocketAddr", + variant: "V6" + }, Token::Tuple { len: 2 }, - Token::Tuple { len: 16 }, b"1234567890123456".iter().copied().map(Token::U8), Token::TupleEnd, - Token::U16(1234), Token::TupleEnd, ], - net::SocketAddrV4::new(net::Ipv4Addr::from(*b"1234"), 1234) => &seq![ + ); + assert_ser_tokens( + &net::SocketAddrV4::new(net::Ipv4Addr::from(*b"1234"), 1234).compact(), + &seq![ Token::Tuple { len: 2 }, - Token::Tuple { len: 4 }, b"1234".iter().copied().map(Token::U8), Token::TupleEnd, - Token::U16(1234), Token::TupleEnd, ], - net::SocketAddrV6::new(net::Ipv6Addr::from(*b"1234567890123456"), 1234, 0, 0) => &seq![ + ); + assert_ser_tokens( + &net::SocketAddrV6::new(net::Ipv6Addr::from(*b"1234567890123456"), 1234, 0, 0).compact(), + &seq![ Token::Tuple { len: 2 }, - Token::Tuple { len: 16 }, b"1234567890123456".iter().copied().map(Token::U8), Token::TupleEnd, - Token::U16(1234), Token::TupleEnd, ], - } + ); } #[cfg(feature = "unstable")] -declare_tests! { - test_never_result { - Ok::(0) => &[ - Token::NewtypeVariant { name: "Result", variant: "Ok" }, +#[test] +fn test_never_result() { + assert_ser_tokens( + &Ok::(0), + &[ + Token::NewtypeVariant { + name: "Result", + variant: "Ok", + }, Token::U8(0), ], - } + ); } #[test]