From bc66aeb0d316d608e43061372d6bd400aad2d393 Mon Sep 17 00:00:00 2001 From: David Tolnay Date: Thu, 20 Jan 2022 21:43:08 -0800 Subject: [PATCH] Add tests of deserializing NonZero --- test_suite/tests/test_de.rs | 305 +++++++++++++++++++- test_suite/tests/test_de_error.rs | 446 +++++++++++++++++++++++++++++- 2 files changed, 749 insertions(+), 2 deletions(-) diff --git a/test_suite/tests/test_de.rs b/test_suite/tests/test_de.rs index 04d80850..b765449e 100644 --- a/test_suite/tests/test_de.rs +++ b/test_suite/tests/test_de.rs @@ -13,7 +13,10 @@ use std::default::Default; use std::ffi::{CStr, CString, OsString}; use std::fmt::Debug; use std::net; -use std::num::Wrapping; +use std::num::{ + NonZeroI128, NonZeroI16, NonZeroI32, NonZeroI64, NonZeroI8, NonZeroIsize, NonZeroU128, + NonZeroU16, NonZeroU32, NonZeroU64, NonZeroU8, NonZeroUsize, Wrapping, +}; use std::ops::Bound; use std::path::{Path, PathBuf}; use std::rc::{Rc, Weak as RcWeak}; @@ -510,6 +513,306 @@ fn test_usize() { test(10, &[Token::U64(10)]); } +#[test] +fn test_nonzero_i8() { + let test = |value, tokens| test(NonZeroI8::new(value).unwrap(), tokens); + + // from signed + test(-128, &[Token::I8(-128)]); + test(-128, &[Token::I16(-128)]); + test(-128, &[Token::I32(-128)]); + test(-128, &[Token::I64(-128)]); + test(127, &[Token::I8(127)]); + test(127, &[Token::I16(127)]); + test(127, &[Token::I32(127)]); + test(127, &[Token::I64(127)]); + + // from unsigned + test(1, &[Token::U8(1)]); + test(1, &[Token::U16(1)]); + test(1, &[Token::U32(1)]); + test(1, &[Token::U64(1)]); + test(127, &[Token::U8(127)]); + test(127, &[Token::U16(127)]); + test(127, &[Token::U32(127)]); + test(127, &[Token::U64(127)]); +} + +#[test] +fn test_nonzero_i16() { + let test = |value, tokens| test(NonZeroI16::new(value).unwrap(), tokens); + + // from signed + test(-128, &[Token::I8(-128)]); + test(-32768, &[Token::I16(-32768)]); + test(-32768, &[Token::I32(-32768)]); + test(-32768, &[Token::I64(-32768)]); + test(127, &[Token::I8(127)]); + test(32767, &[Token::I16(32767)]); + test(32767, &[Token::I32(32767)]); + test(32767, &[Token::I64(32767)]); + + // from unsigned + test(1, &[Token::U8(1)]); + test(1, &[Token::U16(1)]); + test(1, &[Token::U32(1)]); + test(1, &[Token::U64(1)]); + test(255, &[Token::U8(255)]); + test(32767, &[Token::U16(32767)]); + test(32767, &[Token::U32(32767)]); + test(32767, &[Token::U64(32767)]); +} + +#[test] +fn test_nonzero_i32() { + let test = |value, tokens| test(NonZeroI32::new(value).unwrap(), tokens); + + // from signed + test(-128, &[Token::I8(-128)]); + test(-32768, &[Token::I16(-32768)]); + test(-2147483648, &[Token::I32(-2147483648)]); + test(-2147483648, &[Token::I64(-2147483648)]); + test(127, &[Token::I8(127)]); + test(32767, &[Token::I16(32767)]); + test(2147483647, &[Token::I32(2147483647)]); + test(2147483647, &[Token::I64(2147483647)]); + + // from unsigned + test(1, &[Token::U8(1)]); + test(1, &[Token::U16(1)]); + test(1, &[Token::U32(1)]); + test(1, &[Token::U64(1)]); + test(255, &[Token::U8(255)]); + test(65535, &[Token::U16(65535)]); + test(2147483647, &[Token::U32(2147483647)]); + test(2147483647, &[Token::U64(2147483647)]); +} + +#[test] +fn test_nonzero_i64() { + let test = |value, tokens| test(NonZeroI64::new(value).unwrap(), tokens); + + // from signed + test(-128, &[Token::I8(-128)]); + test(-32768, &[Token::I16(-32768)]); + test(-2147483648, &[Token::I32(-2147483648)]); + test(-9223372036854775808, &[Token::I64(-9223372036854775808)]); + test(127, &[Token::I8(127)]); + test(32767, &[Token::I16(32767)]); + test(2147483647, &[Token::I32(2147483647)]); + test(9223372036854775807, &[Token::I64(9223372036854775807)]); + + // from unsigned + test(1, &[Token::U8(1)]); + test(1, &[Token::U16(1)]); + test(1, &[Token::U32(1)]); + test(1, &[Token::U64(1)]); + test(255, &[Token::U8(255)]); + test(65535, &[Token::U16(65535)]); + test(4294967295, &[Token::U32(4294967295)]); + test(9223372036854775807, &[Token::U64(9223372036854775807)]); +} + +#[test] +fn test_nonzero_i128() { + let test = |value, tokens| test(NonZeroI128::new(value).unwrap(), tokens); + + // from signed + test(-128, &[Token::I8(-128)]); + test(-32768, &[Token::I16(-32768)]); + test(-2147483648, &[Token::I32(-2147483648)]); + test(-9223372036854775808, &[Token::I64(-9223372036854775808)]); + test(127, &[Token::I8(127)]); + test(32767, &[Token::I16(32767)]); + test(2147483647, &[Token::I32(2147483647)]); + test(9223372036854775807, &[Token::I64(9223372036854775807)]); + + // from unsigned + test(1, &[Token::U8(1)]); + test(1, &[Token::U16(1)]); + test(1, &[Token::U32(1)]); + test(1, &[Token::U64(1)]); + test(255, &[Token::U8(255)]); + test(65535, &[Token::U16(65535)]); + test(4294967295, &[Token::U32(4294967295)]); + test(18446744073709551615, &[Token::U64(18446744073709551615)]); +} + +#[test] +fn test_nonzero_isize() { + let test = |value, tokens| test(NonZeroIsize::new(value).unwrap(), tokens); + + // from signed + test(-10, &[Token::I8(-10)]); + test(-10, &[Token::I16(-10)]); + test(-10, &[Token::I32(-10)]); + test(-10, &[Token::I64(-10)]); + test(10, &[Token::I8(10)]); + test(10, &[Token::I16(10)]); + test(10, &[Token::I32(10)]); + test(10, &[Token::I64(10)]); + + // from unsigned + test(1, &[Token::U8(1)]); + test(1, &[Token::U16(1)]); + test(1, &[Token::U32(1)]); + test(1, &[Token::U64(1)]); + test(10, &[Token::U8(10)]); + test(10, &[Token::U16(10)]); + test(10, &[Token::U32(10)]); + test(10, &[Token::U64(10)]); +} + +#[test] +fn test_nonzero_u8() { + let test = |value, tokens| test(NonZeroU8::new(value).unwrap(), tokens); + + // from signed + test(1, &[Token::I8(1)]); + test(1, &[Token::I16(1)]); + test(1, &[Token::I32(1)]); + test(1, &[Token::I64(1)]); + test(127, &[Token::I8(127)]); + test(255, &[Token::I16(255)]); + test(255, &[Token::I32(255)]); + test(255, &[Token::I64(255)]); + + // from unsigned + test(1, &[Token::U8(1)]); + test(1, &[Token::U16(1)]); + test(1, &[Token::U32(1)]); + test(1, &[Token::U64(1)]); + test(255, &[Token::U8(255)]); + test(255, &[Token::U16(255)]); + test(255, &[Token::U32(255)]); + test(255, &[Token::U64(255)]); +} + +#[test] +fn test_nonzero_u16() { + let test = |value, tokens| test(NonZeroU16::new(value).unwrap(), tokens); + + // from signed + test(1, &[Token::I8(1)]); + test(1, &[Token::I16(1)]); + test(1, &[Token::I32(1)]); + test(1, &[Token::I64(1)]); + test(127, &[Token::I8(127)]); + test(32767, &[Token::I16(32767)]); + test(65535, &[Token::I32(65535)]); + test(65535, &[Token::I64(65535)]); + + // from unsigned + test(1, &[Token::U8(1)]); + test(1, &[Token::U16(1)]); + test(1, &[Token::U32(1)]); + test(1, &[Token::U64(1)]); + test(255, &[Token::U8(255)]); + test(65535, &[Token::U16(65535)]); + test(65535, &[Token::U32(65535)]); + test(65535, &[Token::U64(65535)]); +} + +#[test] +fn test_nonzero_u32() { + let test = |value, tokens| test(NonZeroU32::new(value).unwrap(), tokens); + + // from signed + test(1, &[Token::I8(1)]); + test(1, &[Token::I16(1)]); + test(1, &[Token::I32(1)]); + test(1, &[Token::I64(1)]); + test(127, &[Token::I8(127)]); + test(32767, &[Token::I16(32767)]); + test(2147483647, &[Token::I32(2147483647)]); + test(4294967295, &[Token::I64(4294967295)]); + + // from unsigned + test(1, &[Token::U8(1)]); + test(1, &[Token::U16(1)]); + test(1, &[Token::U32(1)]); + test(1, &[Token::U64(1)]); + test(255, &[Token::U8(255)]); + test(65535, &[Token::U16(65535)]); + test(4294967295, &[Token::U32(4294967295)]); + test(4294967295, &[Token::U64(4294967295)]); +} + +#[test] +fn test_nonzero_u64() { + let test = |value, tokens| test(NonZeroU64::new(value).unwrap(), tokens); + + // from signed + test(1, &[Token::I8(1)]); + test(1, &[Token::I16(1)]); + test(1, &[Token::I32(1)]); + test(1, &[Token::I64(1)]); + test(127, &[Token::I8(127)]); + test(32767, &[Token::I16(32767)]); + test(2147483647, &[Token::I32(2147483647)]); + test(9223372036854775807, &[Token::I64(9223372036854775807)]); + + // from unsigned + test(1, &[Token::U8(1)]); + test(1, &[Token::U16(1)]); + test(1, &[Token::U32(1)]); + test(1, &[Token::U64(1)]); + test(255, &[Token::U8(255)]); + test(65535, &[Token::U16(65535)]); + test(4294967295, &[Token::U32(4294967295)]); + test(18446744073709551615, &[Token::U64(18446744073709551615)]); +} + +#[test] +fn test_nonzero_u128() { + let test = |value, tokens| test(NonZeroU128::new(value).unwrap(), tokens); + + // from signed + test(1, &[Token::I8(1)]); + test(1, &[Token::I16(1)]); + test(1, &[Token::I32(1)]); + test(1, &[Token::I64(1)]); + test(127, &[Token::I8(127)]); + test(32767, &[Token::I16(32767)]); + test(2147483647, &[Token::I32(2147483647)]); + test(9223372036854775807, &[Token::I64(9223372036854775807)]); + + // from unsigned + test(1, &[Token::U8(1)]); + test(1, &[Token::U16(1)]); + test(1, &[Token::U32(1)]); + test(1, &[Token::U64(1)]); + test(255, &[Token::U8(255)]); + test(65535, &[Token::U16(65535)]); + test(4294967295, &[Token::U32(4294967295)]); + test(18446744073709551615, &[Token::U64(18446744073709551615)]); +} + +#[test] +fn test_nonzero_usize() { + let test = |value, tokens| test(NonZeroUsize::new(value).unwrap(), tokens); + + // from signed + test(1, &[Token::I8(1)]); + test(1, &[Token::I16(1)]); + test(1, &[Token::I32(1)]); + test(1, &[Token::I64(1)]); + test(10, &[Token::I8(10)]); + test(10, &[Token::I16(10)]); + test(10, &[Token::I32(10)]); + test(10, &[Token::I64(10)]); + + // from unsigned + test(1, &[Token::U8(1)]); + test(1, &[Token::U16(1)]); + test(1, &[Token::U32(1)]); + test(1, &[Token::U64(1)]); + test(10, &[Token::U8(10)]); + test(10, &[Token::U16(10)]); + test(10, &[Token::U32(10)]); + test(10, &[Token::U64(10)]); +} + #[test] fn test_f32() { let test = test::; diff --git a/test_suite/tests/test_de_error.rs b/test_suite/tests/test_de_error.rs index 09b1e629..da6e7656 100644 --- a/test_suite/tests/test_de_error.rs +++ b/test_suite/tests/test_de_error.rs @@ -5,7 +5,10 @@ use serde::Deserialize; use serde_test::{assert_de_tokens_error, Token}; use std::collections::{BTreeMap, BTreeSet, HashMap, HashSet}; use std::ffi::{CStr, CString}; -use std::num::Wrapping; +use std::num::{ + NonZeroI128, NonZeroI16, NonZeroI32, NonZeroI64, NonZeroI8, NonZeroIsize, NonZeroU128, + NonZeroU16, NonZeroU32, NonZeroU64, NonZeroU8, NonZeroUsize, Wrapping, +}; use std::time::{Duration, SystemTime}; #[derive(Copy, Clone, PartialEq, Debug, Deserialize)] @@ -371,6 +374,447 @@ fn test_usize() { ); } +#[test] +fn test_nonzero_i8() { + let test = assert_de_tokens_error::; + + // from zero + test(&[Token::I8(0)], "expected a non-zero value"); + test(&[Token::I16(0)], "expected a non-zero value"); + test(&[Token::I32(0)], "expected a non-zero value"); + test(&[Token::I64(0)], "expected a non-zero value"); + test(&[Token::U8(0)], "expected a non-zero value"); + test(&[Token::U16(0)], "expected a non-zero value"); + test(&[Token::U32(0)], "expected a non-zero value"); + test(&[Token::U64(0)], "expected a non-zero value"); + + // from signed + test( + &[Token::I16(-129)], + "invalid value: integer `-129`, expected i8", + ); + test( + &[Token::I32(-129)], + "invalid value: integer `-129`, expected i8", + ); + test( + &[Token::I64(-129)], + "invalid value: integer `-129`, expected i8", + ); + test( + &[Token::I16(128)], + "invalid value: integer `128`, expected i8", + ); + test( + &[Token::I32(128)], + "invalid value: integer `128`, expected i8", + ); + test( + &[Token::I64(128)], + "invalid value: integer `128`, expected i8", + ); + + // from unsigned + test( + &[Token::U8(128)], + "invalid value: integer `128`, expected i8", + ); + test( + &[Token::U16(128)], + "invalid value: integer `128`, expected i8", + ); + test( + &[Token::U32(128)], + "invalid value: integer `128`, expected i8", + ); + test( + &[Token::U64(128)], + "invalid value: integer `128`, expected i8", + ); +} + +#[test] +fn test_nonzero_i16() { + let test = assert_de_tokens_error::; + + // from zero + test(&[Token::I8(0)], "expected a non-zero value"); + test(&[Token::I16(0)], "expected a non-zero value"); + test(&[Token::I32(0)], "expected a non-zero value"); + test(&[Token::I64(0)], "expected a non-zero value"); + test(&[Token::U8(0)], "expected a non-zero value"); + test(&[Token::U16(0)], "expected a non-zero value"); + test(&[Token::U32(0)], "expected a non-zero value"); + test(&[Token::U64(0)], "expected a non-zero value"); + + // from signed + test( + &[Token::I32(-32769)], + "invalid value: integer `-32769`, expected i16", + ); + test( + &[Token::I64(-32769)], + "invalid value: integer `-32769`, expected i16", + ); + test( + &[Token::I32(32768)], + "invalid value: integer `32768`, expected i16", + ); + test( + &[Token::I64(32768)], + "invalid value: integer `32768`, expected i16", + ); + + // from unsigned + test( + &[Token::U16(32768)], + "invalid value: integer `32768`, expected i16", + ); + test( + &[Token::U32(32768)], + "invalid value: integer `32768`, expected i16", + ); + test( + &[Token::U64(32768)], + "invalid value: integer `32768`, expected i16", + ); +} + +#[test] +fn test_nonzero_i32() { + let test = assert_de_tokens_error::; + + // from zero + test(&[Token::I8(0)], "expected a non-zero value"); + test(&[Token::I16(0)], "expected a non-zero value"); + test(&[Token::I32(0)], "expected a non-zero value"); + test(&[Token::I64(0)], "expected a non-zero value"); + test(&[Token::U8(0)], "expected a non-zero value"); + test(&[Token::U16(0)], "expected a non-zero value"); + test(&[Token::U32(0)], "expected a non-zero value"); + test(&[Token::U64(0)], "expected a non-zero value"); + + // from signed + test( + &[Token::I64(-2147483649)], + "invalid value: integer `-2147483649`, expected i32", + ); + test( + &[Token::I64(2147483648)], + "invalid value: integer `2147483648`, expected i32", + ); + + // from unsigned + test( + &[Token::U32(2147483648)], + "invalid value: integer `2147483648`, expected i32", + ); + test( + &[Token::U64(2147483648)], + "invalid value: integer `2147483648`, expected i32", + ); +} + +#[test] +fn test_nonzero_i64() { + let test = assert_de_tokens_error::; + + // from zero + test(&[Token::I8(0)], "expected a non-zero value"); + test(&[Token::I16(0)], "expected a non-zero value"); + test(&[Token::I32(0)], "expected a non-zero value"); + test(&[Token::I64(0)], "expected a non-zero value"); + test(&[Token::U8(0)], "expected a non-zero value"); + test(&[Token::U16(0)], "expected a non-zero value"); + test(&[Token::U32(0)], "expected a non-zero value"); + test(&[Token::U64(0)], "expected a non-zero value"); + + // from unsigned + test( + &[Token::U64(9223372036854775808)], + "invalid value: integer `9223372036854775808`, expected i64", + ); +} + +#[test] +fn test_nonzero_i128() { + let test = assert_de_tokens_error::; + + // from zero + test(&[Token::I8(0)], "expected a non-zero value"); + test(&[Token::I16(0)], "expected a non-zero value"); + test(&[Token::I32(0)], "expected a non-zero value"); + test(&[Token::I64(0)], "expected a non-zero value"); + test(&[Token::U8(0)], "expected a non-zero value"); + test(&[Token::U16(0)], "expected a non-zero value"); + test(&[Token::U32(0)], "expected a non-zero value"); + test(&[Token::U64(0)], "expected a non-zero value"); +} + +#[test] +fn test_nonzero_isize() { + let test = assert_de_tokens_error::; + + // from zero + test(&[Token::I8(0)], "expected a non-zero value"); + test(&[Token::I16(0)], "expected a non-zero value"); + test(&[Token::I32(0)], "expected a non-zero value"); + test(&[Token::I64(0)], "expected a non-zero value"); + test(&[Token::U8(0)], "expected a non-zero value"); + test(&[Token::U16(0)], "expected a non-zero value"); + test(&[Token::U32(0)], "expected a non-zero value"); + test(&[Token::U64(0)], "expected a non-zero value"); +} + +#[test] +fn test_nonzero_u8() { + let test = assert_de_tokens_error::; + + // from zero + test(&[Token::I8(0)], "expected a non-zero value"); + test(&[Token::I16(0)], "expected a non-zero value"); + test(&[Token::I32(0)], "expected a non-zero value"); + test(&[Token::I64(0)], "expected a non-zero value"); + test(&[Token::U8(0)], "expected a non-zero value"); + test(&[Token::U16(0)], "expected a non-zero value"); + test(&[Token::U32(0)], "expected a non-zero value"); + test(&[Token::U64(0)], "expected a non-zero value"); + + // from signed + test(&[Token::I8(-1)], "invalid value: integer `-1`, expected u8"); + test( + &[Token::I16(-1)], + "invalid value: integer `-1`, expected u8", + ); + test( + &[Token::I32(-1)], + "invalid value: integer `-1`, expected u8", + ); + test( + &[Token::I64(-1)], + "invalid value: integer `-1`, expected u8", + ); + test( + &[Token::I16(256)], + "invalid value: integer `256`, expected u8", + ); + test( + &[Token::I32(256)], + "invalid value: integer `256`, expected u8", + ); + test( + &[Token::I64(256)], + "invalid value: integer `256`, expected u8", + ); + + // from unsigned + test( + &[Token::U16(256)], + "invalid value: integer `256`, expected u8", + ); + test( + &[Token::U32(256)], + "invalid value: integer `256`, expected u8", + ); + test( + &[Token::U64(256)], + "invalid value: integer `256`, expected u8", + ); +} + +#[test] +fn test_nonzero_u16() { + let test = assert_de_tokens_error::; + + // from zero + test(&[Token::I8(0)], "expected a non-zero value"); + test(&[Token::I16(0)], "expected a non-zero value"); + test(&[Token::I32(0)], "expected a non-zero value"); + test(&[Token::I64(0)], "expected a non-zero value"); + test(&[Token::U8(0)], "expected a non-zero value"); + test(&[Token::U16(0)], "expected a non-zero value"); + test(&[Token::U32(0)], "expected a non-zero value"); + test(&[Token::U64(0)], "expected a non-zero value"); + + // from signed + test( + &[Token::I8(-1)], + "invalid value: integer `-1`, expected u16", + ); + test( + &[Token::I16(-1)], + "invalid value: integer `-1`, expected u16", + ); + test( + &[Token::I32(-1)], + "invalid value: integer `-1`, expected u16", + ); + test( + &[Token::I64(-1)], + "invalid value: integer `-1`, expected u16", + ); + test( + &[Token::I32(65536)], + "invalid value: integer `65536`, expected u16", + ); + test( + &[Token::I64(65536)], + "invalid value: integer `65536`, expected u16", + ); + + // from unsigned + test( + &[Token::U32(65536)], + "invalid value: integer `65536`, expected u16", + ); + test( + &[Token::U64(65536)], + "invalid value: integer `65536`, expected u16", + ); +} + +#[test] +fn test_nonzero_u32() { + let test = assert_de_tokens_error::; + + // from zero + test(&[Token::I8(0)], "expected a non-zero value"); + test(&[Token::I16(0)], "expected a non-zero value"); + test(&[Token::I32(0)], "expected a non-zero value"); + test(&[Token::I64(0)], "expected a non-zero value"); + test(&[Token::U8(0)], "expected a non-zero value"); + test(&[Token::U16(0)], "expected a non-zero value"); + test(&[Token::U32(0)], "expected a non-zero value"); + test(&[Token::U64(0)], "expected a non-zero value"); + + // from signed + test( + &[Token::I8(-1)], + "invalid value: integer `-1`, expected u32", + ); + test( + &[Token::I16(-1)], + "invalid value: integer `-1`, expected u32", + ); + test( + &[Token::I32(-1)], + "invalid value: integer `-1`, expected u32", + ); + test( + &[Token::I64(-1)], + "invalid value: integer `-1`, expected u32", + ); + test( + &[Token::I64(4294967296)], + "invalid value: integer `4294967296`, expected u32", + ); + + // from unsigned + test( + &[Token::U64(4294967296)], + "invalid value: integer `4294967296`, expected u32", + ); +} + +#[test] +fn test_nonzero_u64() { + let test = assert_de_tokens_error::; + + // from zero + test(&[Token::I8(0)], "expected a non-zero value"); + test(&[Token::I16(0)], "expected a non-zero value"); + test(&[Token::I32(0)], "expected a non-zero value"); + test(&[Token::I64(0)], "expected a non-zero value"); + test(&[Token::U8(0)], "expected a non-zero value"); + test(&[Token::U16(0)], "expected a non-zero value"); + test(&[Token::U32(0)], "expected a non-zero value"); + test(&[Token::U64(0)], "expected a non-zero value"); + + // from signed + test( + &[Token::I8(-1)], + "invalid value: integer `-1`, expected u64", + ); + test( + &[Token::I16(-1)], + "invalid value: integer `-1`, expected u64", + ); + test( + &[Token::I32(-1)], + "invalid value: integer `-1`, expected u64", + ); + test( + &[Token::I64(-1)], + "invalid value: integer `-1`, expected u64", + ); +} + +#[test] +fn test_nonzero_u128() { + let test = assert_de_tokens_error::; + + // from zero + test(&[Token::I8(0)], "expected a non-zero value"); + test(&[Token::I16(0)], "expected a non-zero value"); + test(&[Token::I32(0)], "expected a non-zero value"); + test(&[Token::I64(0)], "expected a non-zero value"); + test(&[Token::U8(0)], "expected a non-zero value"); + test(&[Token::U16(0)], "expected a non-zero value"); + test(&[Token::U32(0)], "expected a non-zero value"); + test(&[Token::U64(0)], "expected a non-zero value"); + + // from signed + test( + &[Token::I8(-1)], + "invalid value: integer `-1`, expected u128", + ); + test( + &[Token::I16(-1)], + "invalid value: integer `-1`, expected u128", + ); + test( + &[Token::I32(-1)], + "invalid value: integer `-1`, expected u128", + ); + test( + &[Token::I64(-1)], + "invalid value: integer `-1`, expected u128", + ); +} + +#[test] +fn test_nonzero_usize() { + let test = assert_de_tokens_error::; + + // from zero + test(&[Token::I8(0)], "expected a non-zero value"); + test(&[Token::I16(0)], "expected a non-zero value"); + test(&[Token::I32(0)], "expected a non-zero value"); + test(&[Token::I64(0)], "expected a non-zero value"); + test(&[Token::U8(0)], "expected a non-zero value"); + test(&[Token::U16(0)], "expected a non-zero value"); + test(&[Token::U32(0)], "expected a non-zero value"); + test(&[Token::U64(0)], "expected a non-zero value"); + + // from signed + test( + &[Token::I8(-1)], + "invalid value: integer `-1`, expected usize", + ); + test( + &[Token::I16(-1)], + "invalid value: integer `-1`, expected usize", + ); + test( + &[Token::I32(-1)], + "invalid value: integer `-1`, expected usize", + ); + test( + &[Token::I64(-1)], + "invalid value: integer `-1`, expected usize", + ); +} + #[test] fn test_unknown_field() { assert_de_tokens_error::(