use super::*;
use alloc::vec;
use alloc::vec::Vec;
#[test]
fn clamp_size_hint_none_is_zero() {
assert_eq!(clamp_size_hint(None), 0);
}
#[test]
fn clamp_size_hint_small_passes_through() {
assert_eq!(clamp_size_hint(Some(10)), 10);
assert_eq!(clamp_size_hint(Some(MAX_PREALLOC_HINT)), MAX_PREALLOC_HINT);
}
#[test]
fn clamp_size_hint_caps_large_values() {
assert_eq!(clamp_size_hint(Some(usize::MAX)), MAX_PREALLOC_HINT);
assert_eq!(
clamp_size_hint(Some(MAX_PREALLOC_HINT + 1)),
MAX_PREALLOC_HINT
);
}
#[derive(serde::Serialize, serde::Deserialize)]
struct SeqI64Holder(#[serde(with = "proto_seq")] Vec<i64>);
#[test]
fn proto_seq_int64_serializes_as_quoted_strings() {
let h = SeqI64Holder(vec![1, -2, i64::MAX]);
let json = serde_json::to_string(&h).unwrap();
assert_eq!(json, r#"["1","-2","9223372036854775807"]"#);
}
#[test]
fn proto_seq_int64_deserializes_quoted_and_unquoted() {
let h: SeqI64Holder = serde_json::from_str(r#"["1","-2","42"]"#).unwrap();
assert_eq!(h.0, vec![1, -2, 42]);
let h: SeqI64Holder = serde_json::from_str(r#"[1,-2,42]"#).unwrap();
assert_eq!(h.0, vec![1, -2, 42]);
}
#[test]
fn proto_seq_int64_null_is_empty() {
let h: SeqI64Holder = serde_json::from_str("null").unwrap();
assert_eq!(h.0, Vec::<i64>::new());
}
#[test]
fn proto_seq_rejects_null_element() {
let result: Result<SeqI64Holder, _> = serde_json::from_str(r#"[1,null,2]"#);
assert!(result.is_err(), "null element must be rejected");
}
#[test]
fn proto_map_rejects_null_value() {
let result: Result<MapI32I64Holder, _> = serde_json::from_str(r#"{"1":null}"#);
assert!(result.is_err(), "null map value must be rejected");
}
#[derive(serde::Serialize, serde::Deserialize)]
struct SeqF64Holder(#[serde(with = "proto_seq")] Vec<f64>);
#[test]
fn proto_seq_float_nan_inf_as_strings() {
let h = SeqF64Holder(vec![1.5, f64::NAN, f64::INFINITY, f64::NEG_INFINITY]);
let json = serde_json::to_string(&h).unwrap();
assert_eq!(json, r#"[1.5,"NaN","Infinity","-Infinity"]"#);
let back: SeqF64Holder = serde_json::from_str(&json).unwrap();
assert_eq!(back.0[0], 1.5);
assert!(back.0[1].is_nan());
assert_eq!(back.0[2], f64::INFINITY);
assert_eq!(back.0[3], f64::NEG_INFINITY);
}
#[derive(serde::Serialize, serde::Deserialize)]
struct SeqBytesHolder(#[serde(with = "proto_seq")] Vec<Vec<u8>>);
#[test]
fn proto_seq_bytes_as_base64() {
let h = SeqBytesHolder(vec![vec![0xDE, 0xAD], vec![]]);
let json = serde_json::to_string(&h).unwrap();
assert_eq!(json, r#"["3q0=",""]"#);
let back: SeqBytesHolder = serde_json::from_str(&json).unwrap();
assert_eq!(back.0, vec![vec![0xDE, 0xAD], vec![]]);
}
#[derive(serde::Serialize, serde::Deserialize)]
struct MapI32I64Holder(#[serde(with = "proto_map")] crate::__private::HashMap<i32, i64>);
#[test]
fn proto_map_int64_value_quoted() {
let mut m = crate::__private::HashMap::default();
m.insert(1i32, 42i64);
m.insert(2i32, i64::MAX);
let h = MapI32I64Holder(m);
let json = serde_json::to_string(&h).unwrap();
assert!(
json == r#"{"1":"42","2":"9223372036854775807"}"#
|| json == r#"{"2":"9223372036854775807","1":"42"}"#,
"got: {json}"
);
}
#[test]
fn proto_map_int64_value_deserializes_quoted() {
let h: MapI32I64Holder = serde_json::from_str(r#"{"1":"42","2":"-7"}"#).unwrap();
assert_eq!(h.0[&1], 42);
assert_eq!(h.0[&2], -7);
}
#[test]
fn proto_map_null_is_empty() {
let h: MapI32I64Holder = serde_json::from_str("null").unwrap();
assert!(h.0.is_empty());
}
#[derive(serde::Serialize, serde::Deserialize)]
struct MapBoolF64Holder(#[serde(with = "proto_map")] crate::__private::HashMap<bool, f64>);
#[test]
fn proto_map_bool_key_float_nan_value() {
let mut m = crate::__private::HashMap::default();
m.insert(true, f64::NAN);
let h = MapBoolF64Holder(m);
let json = serde_json::to_string(&h).unwrap();
assert_eq!(json, r#"{"true":"NaN"}"#);
let back: MapBoolF64Holder = serde_json::from_str(&json).unwrap();
assert!(back.0[&true].is_nan());
}
#[derive(serde::Serialize, serde::Deserialize)]
struct SeqEnumHolder(#[serde(with = "proto_seq")] Vec<crate::EnumValue<Color>>);
#[test]
fn proto_seq_enum_value_roundtrip() {
let h = SeqEnumHolder(vec![
crate::EnumValue::Known(Color::Red),
crate::EnumValue::Known(Color::Blue),
crate::EnumValue::Unknown(99),
]);
let json = serde_json::to_string(&h).unwrap();
assert_eq!(json, r#"["RED","BLUE",99]"#);
let back: SeqEnumHolder = serde_json::from_str(&json).unwrap();
assert_eq!(back.0, h.0);
}
#[test]
fn proto_seq_enum_value_accepts_names_and_ints() {
let h: SeqEnumHolder = serde_json::from_str(r#"["GREEN",0,42]"#).unwrap();
assert_eq!(h.0[0], crate::EnumValue::Known(Color::Green));
assert_eq!(h.0[1], crate::EnumValue::Known(Color::Red)); assert_eq!(h.0[2], crate::EnumValue::Unknown(42));
}
#[test]
fn proto_seq_enum_value_rejects_null_element() {
let result: Result<SeqEnumHolder, _> = serde_json::from_str(r#"["RED",null,"BLUE"]"#);
assert!(result.is_err(), "null element must be rejected");
}
#[derive(serde::Serialize, serde::Deserialize)]
struct MapStrEnumHolder(
#[serde(with = "proto_map")]
crate::__private::HashMap<alloc::string::String, crate::EnumValue<Color>>,
);
#[test]
fn proto_map_enum_value_roundtrip() {
let mut m = crate::__private::HashMap::default();
m.insert("a".into(), crate::EnumValue::Known(Color::Green));
m.insert("b".into(), crate::EnumValue::Unknown(-1));
let h = MapStrEnumHolder(m);
let json = serde_json::to_string(&h).unwrap();
let back: MapStrEnumHolder = serde_json::from_str(&json).unwrap();
assert_eq!(back.0, h.0);
}
#[test]
fn proto_map_enum_value_rejects_null_value() {
let result: Result<MapStrEnumHolder, _> = serde_json::from_str(r#"{"a":null}"#);
assert!(result.is_err(), "null map value must be rejected");
}
fn json_roundtrip_int64(original: i64) -> i64 {
let serialized = serde_json::to_string(&SerdeInt64(original)).unwrap();
let recovered: SerdeInt64 = serde_json::from_str(&serialized).unwrap();
recovered.0
}
#[derive(serde::Serialize, serde::Deserialize)]
struct SerdeInt64(#[serde(with = "int64")] i64);
#[derive(serde::Serialize, serde::Deserialize)]
struct SerdeUint64(#[serde(with = "uint64")] u64);
#[derive(serde::Serialize, serde::Deserialize)]
struct SerdeFloat(#[serde(with = "float")] f32);
#[derive(serde::Serialize, serde::Deserialize)]
struct SerdeDouble(#[serde(with = "double")] f64);
#[derive(serde::Serialize, serde::Deserialize)]
struct SerdeBytes(#[serde(with = "bytes")] Vec<u8>);
#[test]
fn int64_serializes_as_quoted_string() {
let json = serde_json::to_string(&SerdeInt64(9007199254740993)).unwrap();
assert_eq!(json, r#""9007199254740993""#);
}
#[test]
fn int64_roundtrip_boundary_values() {
for v in [i64::MAX, i64::MIN, 0, -1, 9007199254740993] {
assert_eq!(json_roundtrip_int64(v), v, "roundtrip failed for {v}");
}
}
#[test]
fn int64_deserializes_from_quoted_string() {
let val: SerdeInt64 = serde_json::from_str(r#""-9007199254740993""#).unwrap();
assert_eq!(val.0, -9007199254740993i64);
}
#[test]
fn int64_deserializes_exact_float_notation_strings() {
#[rustfmt::skip]
let cases: &[(&str, i64)] = &[
(r#""9007199254740993.0""#, 9007199254740993),
(r#""9.007199254740993e15""#, 9007199254740993),
(r#""1200e-2""#, 12),
];
for &(json, expected) in cases {
let val: SerdeInt64 = serde_json::from_str(json).unwrap();
assert_eq!(val.0, expected, "input: {json}");
}
}
#[test]
fn int64_deserializes_exact_negative_float_notation_string() {
let val: SerdeInt64 = serde_json::from_str(r#""-9007199254740993.0""#).unwrap();
assert_eq!(val.0, -9007199254740993i64);
}
#[test]
fn int64_deserializes_safe_unquoted_float_notation() {
let cases: &[(&str, i64)] = &[
("4503599627370495.0", 4503599627370495),
("4.503599627370495e15", 4503599627370495),
("-4503599627370495.0", -4503599627370495),
("-4.503599627370495e15", -4503599627370495),
];
for &(json, expected) in cases {
let val: SerdeInt64 = serde_json::from_str(json).unwrap();
assert_eq!(val.0, expected, "input: {json}");
}
}
#[test]
fn int64_rejects_unsafe_unquoted_float_notation() {
let cases: &[&str] = &[
"4503599627370496.0",
"9007199254740991.0",
"9007199254740992.0",
"9007199254740993.0",
"9.007199254740993e15",
"-4503599627370496.0",
"-9007199254740991.0",
"-9007199254740992.0",
"-9007199254740993.0",
"-9.007199254740993e15",
];
for &json in cases {
assert!(
serde_json::from_str::<SerdeInt64>(json).is_err(),
"input should reject: {json}"
);
}
}
#[test]
fn uint64_serializes_as_quoted_string() {
let json = serde_json::to_string(&SerdeUint64(u64::MAX)).unwrap();
assert_eq!(json, r#""18446744073709551615""#);
}
#[test]
fn uint64_deserializes_from_quoted_string() {
let val: SerdeUint64 = serde_json::from_str(r#""18446744073709551615""#).unwrap();
assert_eq!(val.0, u64::MAX);
}
#[test]
fn uint64_deserializes_exact_float_notation_string() {
let val: SerdeUint64 = serde_json::from_str(r#""18446744073709551615.0""#).unwrap();
assert_eq!(val.0, u64::MAX);
}
#[test]
fn uint64_deserializes_safe_unquoted_float_notation() {
let val: SerdeUint64 = serde_json::from_str("4503599627370495.0").unwrap();
assert_eq!(val.0, 4503599627370495);
}
#[test]
fn uint64_rejects_unsafe_unquoted_float_notation() {
let cases: &[&str] = &[
"4503599627370496.0",
"9007199254740991.0",
"9007199254740992.0",
"9007199254740993.0",
"9.007199254740993e15",
];
for &json in cases {
assert!(
serde_json::from_str::<SerdeUint64>(json).is_err(),
"input should reject: {json}"
);
}
}
#[test]
fn float_serializes_special_values_as_strings() {
#[rustfmt::skip]
let cases: &[(f32, &str)] = &[
(f32::NAN, r#""NaN""#),
(f32::INFINITY, r#""Infinity""#),
(f32::NEG_INFINITY, r#""-Infinity""#),
];
for &(value, expected_json) in cases {
let json = serde_json::to_string(&SerdeFloat(value)).unwrap();
assert_eq!(json, expected_json, "value: {value}");
}
}
#[test]
fn float_serializes_finite_as_number() {
let json = serde_json::to_string(&SerdeFloat(1.5)).unwrap();
assert!(!json.starts_with('"'));
}
#[test]
fn float_deserializes_nan_string() {
let val: SerdeFloat = serde_json::from_str(r#""NaN""#).unwrap();
assert!(val.0.is_nan());
}
#[test]
fn float_deserializes_infinity_string() {
let val: SerdeFloat = serde_json::from_str(r#""Infinity""#).unwrap();
assert_eq!(val.0, f32::INFINITY);
}
#[test]
fn float_deserializes_neg_infinity_string() {
let val: SerdeFloat = serde_json::from_str(r#""-Infinity""#).unwrap();
assert_eq!(val.0, f32::NEG_INFINITY);
}
#[test]
fn double_serializes_nan_as_string() {
let json = serde_json::to_string(&SerdeDouble(f64::NAN)).unwrap();
assert_eq!(json, r#""NaN""#);
}
#[test]
fn double_serializes_infinity_as_string() {
let json = serde_json::to_string(&SerdeDouble(f64::INFINITY)).unwrap();
assert_eq!(json, r#""Infinity""#);
}
#[test]
fn double_finite_roundtrip() {
let val: SerdeDouble = serde_json::from_str("2.5").unwrap();
assert!((val.0 - 2.5).abs() < 1e-10);
}
#[test]
fn bytes_serializes_as_base64() {
let json = serde_json::to_string(&SerdeBytes(vec![0xde, 0xad, 0xbe, 0xef])).unwrap();
assert_eq!(json, r#""3q2+7w==""#);
}
#[test]
fn bytes_deserializes_all_base64_dialects() {
const EXPECTED: &[u8] = &[0xde, 0xad, 0xbe, 0xef];
#[rustfmt::skip]
let inputs: &[&str] = &[
r#""3q2+7w==""#, r#""3q2-7w==""#, r#""3q2+7w""#, ];
for json in inputs {
let val: SerdeBytes = serde_json::from_str(json).unwrap();
assert_eq!(val.0, EXPECTED, "input: {json}");
}
}
#[test]
fn bytes_roundtrip_empty() {
let json = serde_json::to_string(&SerdeBytes(vec![])).unwrap();
let val: SerdeBytes = serde_json::from_str(&json).unwrap();
assert_eq!(val.0, Vec::<u8>::new());
}
#[test]
fn bytes_rejects_invalid_base64() {
assert!(serde_json::from_str::<SerdeBytes>(r#""!!! not base64 !!!""#).is_err());
}
#[test]
fn bytes_url_safe_with_trailing_bits() {
let val: SerdeBytes = serde_json::from_str(r#""-_""#).unwrap();
assert_eq!(val.0, vec![0xFB]);
}
#[test]
fn bytes_url_safe_padded_with_trailing_bits() {
let val: SerdeBytes = serde_json::from_str(r#""-_==""#).unwrap();
assert_eq!(val.0, vec![0xFB]);
}
#[test]
fn base64_decode_buffer_estimate_cannot_overflow_at_any_length() {
for len in [0, 1, 4, usize::MAX / 2, usize::MAX - 1, usize::MAX] {
let needed = len / 4 * 3 + len % 4 * 3 / 4;
let estimate = base64::decoded_len_estimate(len);
assert!(
estimate >= needed,
"estimate {estimate} below the {needed} bytes that {len} characters decode to"
);
}
}
#[test]
fn int64_rejects_non_numeric_string() {
assert!(serde_json::from_str::<SerdeInt64>(r#""abc""#).is_err());
}
#[test]
fn int64_rejects_overflow_string() {
assert!(serde_json::from_str::<SerdeInt64>(r#""99999999999999999999""#).is_err());
}
#[test]
fn int64_rejects_inexact_exponential_string() {
assert!(serde_json::from_str::<SerdeInt64>(r#""1e-1""#).is_err());
}
#[test]
fn int64_rejects_significand_overflow_string() {
assert!(
serde_json::from_str::<SerdeInt64>(r#""9999999999999999999999999999999999999999""#)
.is_err()
);
}
#[test]
fn int64_rejects_huge_exponent_string() {
assert!(serde_json::from_str::<SerdeInt64>(r#""1e9999999999""#).is_err());
}
#[test]
fn integer_helpers_deserialize_large_rescaled_significands() {
macro_rules! assert_rescaled {
($holder:ty, $values:expr) => {
for value in $values {
for zeros in [20, 38, 39, 80, 1_000] {
for fraction in ["", ".000"] {
let json = format!(r#""{value}{}{fraction}e-{zeros}""#, "0".repeat(zeros));
let parsed = serde_json::from_str::<$holder>(&json)
.unwrap_or_else(|err| panic!("input {json}: {err}"));
assert_eq!(parsed.0, value, "input: {json}");
}
}
}
};
}
assert_rescaled!(SerdeInt32, [0, 1, -1, 1_200, i32::MIN, i32::MAX]);
assert_rescaled!(
SerdeInt64,
[0, 1, -1, 1_200, 9_007_199_254_740_993, i64::MIN, i64::MAX]
);
assert_rescaled!(SerdeUint32, [0, 1, 1_200, u32::MAX]);
assert_rescaled!(SerdeUint64, [0, 1, 1_200, 9_007_199_254_740_993, u64::MAX]);
}
#[test]
fn exact_decimal_integers_normalize_trailing_zeros() {
let zeros = "0".repeat(80);
let cases = [
(format!("100{zeros}e-82"), Some(1)),
(format!("100{zeros}e-81"), Some(10)),
(format!("100{zeros}e-80"), Some(100)),
(format!("100{zeros}E-82"), Some(1)),
(format!("-100{zeros}.000e-82"), Some(-1)),
(format!("+100{zeros}.000e-82"), Some(1)),
(format!("000100{zeros}e-82"), Some(1)),
("100.5e1".to_string(), Some(1_005)),
("100.5".to_string(), None),
(format!("100{zeros}e-83"), None),
(format!("100{zeros}1e-83"), None),
(format!("100{zeros}.1e-82"), None),
(format!("100{zeros}e1"), None),
(format!("x{zeros}e-80"), None),
(format!("100{zeros}e-8x"), None),
(format!("100{zeros}e-82e0"), None),
(format!("100{zeros}.0.0e-82"), None),
(format!("100{zeros}e{}", i64::MAX), None),
(format!("100{zeros}e{}", i64::MIN), None),
(format!("{zeros}e{}", i64::MAX), Some(0)),
(format!("-{zeros}.000e{}", i64::MIN), Some(0)),
];
for (input, expected) in cases {
assert_eq!(parse_exact_decimal_int(&input), expected, "input: {input}");
}
}
#[test]
fn integer_helpers_reject_rescaled_out_of_range_values() {
let zeros = "0".repeat(80);
for value in ["2147483648", "-2147483649"] {
let json = format!(r#""{value}{zeros}e-80""#);
assert!(serde_json::from_str::<SerdeInt32>(&json).is_err());
}
for value in ["9223372036854775808", "-9223372036854775809"] {
let json = format!(r#""{value}{zeros}e-80""#);
assert!(serde_json::from_str::<SerdeInt64>(&json).is_err());
}
for value in ["4294967296", "-1"] {
let json = format!(r#""{value}{zeros}e-80""#);
assert!(serde_json::from_str::<SerdeUint32>(&json).is_err());
}
for value in ["18446744073709551616", "-1"] {
let json = format!(r#""{value}{zeros}e-80""#);
assert!(serde_json::from_str::<SerdeUint64>(&json).is_err());
}
}
#[test]
fn uint64_rejects_negative_string() {
assert!(serde_json::from_str::<SerdeUint64>(r#""-1""#).is_err());
}
#[test]
fn float_rejects_unknown_string() {
assert!(serde_json::from_str::<SerdeFloat>(r#""not-a-float""#).is_err());
}
#[test]
fn double_rejects_unknown_string() {
assert!(serde_json::from_str::<SerdeDouble>(r#""not-a-double""#).is_err());
}
#[test]
fn skip_if_numeric_predicates() {
assert!(skip_if::is_zero_i32(&0));
assert!(!skip_if::is_zero_i32(&1));
assert!(skip_if::is_zero_i64(&0));
assert!(!skip_if::is_zero_i64(&-1));
assert!(skip_if::is_zero_u32(&0));
assert!(skip_if::is_zero_u64(&0));
}
#[test]
fn skip_if_float_only_omits_positive_zero() {
assert!(skip_if::is_zero_f32(&0.0));
for value in [
-0.0,
f32::from_bits(1),
-f32::from_bits(1),
1.0,
-1.0,
f32::MAX,
f32::MIN,
f32::INFINITY,
f32::NEG_INFINITY,
f32::NAN,
] {
assert!(!skip_if::is_zero_f32(&value), "value: {value:?}");
}
}
#[test]
fn skip_if_double_only_omits_positive_zero() {
assert!(skip_if::is_zero_f64(&0.0));
for value in [
-0.0,
f64::from_bits(1),
-f64::from_bits(1),
1.0,
-1.0,
f64::MAX,
f64::MIN,
f64::INFINITY,
f64::NEG_INFINITY,
f64::NAN,
] {
assert!(!skip_if::is_zero_f64(&value), "value: {value:?}");
}
}
#[test]
fn skip_if_bool_predicates() {
assert!(skip_if::is_false(&false));
assert!(!skip_if::is_false(&true));
}
#[test]
fn skip_if_string_and_bytes_predicates() {
assert!(skip_if::is_empty_str(""));
assert!(!skip_if::is_empty_str("x"));
assert!(skip_if::is_empty_bytes(&[]));
assert!(!skip_if::is_empty_bytes(&[1u8]));
assert!(skip_if::is_empty_vec::<i32>(&[]));
assert!(!skip_if::is_empty_vec(&[1]));
}
#[test]
fn nullable_seed_returns_none_for_null() {
let seed = NullableDeserializeSeed(DefaultDeserializeSeed::<i32>::new());
let result: Option<i32> =
serde::de::DeserializeSeed::deserialize(seed, serde_json::Value::Null).unwrap();
assert_eq!(result, None);
}
#[test]
fn nullable_seed_returns_some_for_value() {
let seed = NullableDeserializeSeed(DefaultDeserializeSeed::<i32>::new());
let result: Option<i32> =
serde::de::DeserializeSeed::deserialize(seed, serde_json::Value::Number(42.into()))
.unwrap();
assert_eq!(result, Some(42));
}
#[test]
fn nullable_seed_with_custom_seed_returns_none_for_null() {
struct Int64Seed;
impl<'de> serde::de::DeserializeSeed<'de> for Int64Seed {
type Value = i64;
fn deserialize<D: serde::Deserializer<'de>>(self, d: D) -> Result<i64, D::Error> {
int64::deserialize(d)
}
}
let seed = NullableDeserializeSeed(Int64Seed);
let result: Option<i64> =
serde::de::DeserializeSeed::deserialize(seed, serde_json::Value::Null).unwrap();
assert_eq!(result, None);
}
#[test]
fn nullable_seed_with_custom_seed_returns_some_for_string() {
struct Int64Seed;
impl<'de> serde::de::DeserializeSeed<'de> for Int64Seed {
type Value = i64;
fn deserialize<D: serde::Deserializer<'de>>(self, d: D) -> Result<i64, D::Error> {
int64::deserialize(d)
}
}
let seed = NullableDeserializeSeed(Int64Seed);
let result: Option<i64> =
serde::de::DeserializeSeed::deserialize(seed, serde_json::Value::String("123".to_string()))
.unwrap();
assert_eq!(result, Some(123));
}
#[test]
fn default_seed_deserializes_string() {
let seed = DefaultDeserializeSeed::<alloc::string::String>::new();
let result: alloc::string::String = serde::de::DeserializeSeed::deserialize(
seed,
serde_json::Value::String("hello".to_string()),
)
.unwrap();
assert_eq!(result, "hello");
}
#[derive(Debug, Default, PartialEq)]
struct NullAccepting(i32);
impl<'de> serde::Deserialize<'de> for NullAccepting {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct V;
impl<'de> serde::de::Visitor<'de> for V {
type Value = NullAccepting;
fn expecting(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
f.write_str("integer or null")
}
fn visit_unit<E>(self) -> Result<NullAccepting, E> {
Ok(NullAccepting(-1))
}
fn visit_i64<E>(self, v: i64) -> Result<NullAccepting, E> {
Ok(NullAccepting(v as i32))
}
fn visit_u64<E>(self, v: u64) -> Result<NullAccepting, E> {
Ok(NullAccepting(v as i32))
}
}
d.deserialize_any(V)
}
}
#[test]
fn message_field_always_present_forwards_null() {
let mf: crate::MessageField<NullAccepting> = serde_json::from_str("null").unwrap();
assert!(
mf.is_unset(),
"default MessageField should be unset for null"
);
#[derive(Debug, serde::Deserialize)]
struct Wrapper {
#[serde(deserialize_with = "message_field_always_present")]
#[serde(default)]
val: crate::MessageField<NullAccepting>,
}
let w: Wrapper = serde_json::from_str(r#"{"val": null}"#).unwrap();
assert!(
!w.val.is_unset(),
"always_present should set the field for null"
);
assert_eq!(
w.val.as_option(),
Some(&NullAccepting(-1)),
"null should produce sentinel value"
);
}
#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug, Default)]
enum Color {
#[default]
Red,
Green,
Blue,
}
impl serde::Serialize for Color {
fn serialize<S: serde::Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
s.serialize_str(crate::Enumeration::proto_name(self))
}
}
impl<'de> serde::Deserialize<'de> for Color {
fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
struct V;
impl serde::de::Visitor<'_> for V {
type Value = Color;
fn expecting(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
f.write_str("a string, integer, or null for Color")
}
fn visit_str<E: serde::de::Error>(self, v: &str) -> Result<Color, E> {
<Color as crate::Enumeration>::from_proto_name(v).ok_or_else(|| {
serde::de::Error::invalid_value(
serde::de::Unexpected::Str(v),
&"a known enum variant name",
)
})
}
fn visit_i64<E: serde::de::Error>(self, v: i64) -> Result<Color, E> {
<Color as crate::Enumeration>::from_i32(v as i32)
.ok_or_else(|| serde::de::Error::custom("unknown"))
}
fn visit_u64<E: serde::de::Error>(self, v: u64) -> Result<Color, E> {
<Color as crate::Enumeration>::from_i32(v as i32)
.ok_or_else(|| serde::de::Error::custom("unknown"))
}
fn visit_unit<E: serde::de::Error>(self) -> Result<Color, E> {
Ok(Color::default())
}
}
d.deserialize_any(V)
}
}
impl crate::Enumeration for Color {
fn from_i32(v: i32) -> Option<Self> {
match v {
0 => Some(Color::Red),
1 => Some(Color::Green),
2 => Some(Color::Blue),
_ => None,
}
}
fn to_i32(&self) -> i32 {
*self as i32
}
fn proto_name(&self) -> &'static str {
match self {
Color::Red => "RED",
Color::Green => "GREEN",
Color::Blue => "BLUE",
}
}
fn from_proto_name(name: &str) -> Option<Self> {
match name {
"RED" => Some(Color::Red),
"GREEN" => Some(Color::Green),
"BLUE" => Some(Color::Blue),
_ => None,
}
}
}
#[test]
fn repeated_enum_deserializes_known_values() {
let json = r#"["RED","GREEN","BLUE"]"#;
let result: Vec<crate::EnumValue<Color>> =
repeated_enum::deserialize(&mut serde_json::Deserializer::from_str(json)).unwrap();
assert_eq!(result.len(), 3);
assert_eq!(result[0], crate::EnumValue::Known(Color::Red));
assert_eq!(result[1], crate::EnumValue::Known(Color::Green));
assert_eq!(result[2], crate::EnumValue::Known(Color::Blue));
}
#[test]
fn repeated_enum_rejects_unknown_by_default() {
let json = r#"["RED","PURPLE","BLUE"]"#;
let result: Result<Vec<crate::EnumValue<Color>>, _> =
repeated_enum::deserialize(&mut serde_json::Deserializer::from_str(json));
assert!(result.is_err());
}
#[test]
fn repeated_enum_skips_unknown_when_lenient() {
use crate::json::{with_json_parse_options, JsonParseOptions};
let opts = JsonParseOptions {
ignore_unknown_enum_values: true,
..Default::default()
};
let json = r#"["RED","PURPLE","BLUE"]"#;
let result: Vec<crate::EnumValue<Color>> = with_json_parse_options(&opts, || {
repeated_enum::deserialize(&mut serde_json::Deserializer::from_str(json)).unwrap()
});
assert_eq!(result.len(), 2);
assert_eq!(result[0], crate::EnumValue::Known(Color::Red));
assert_eq!(result[1], crate::EnumValue::Known(Color::Blue));
}
#[test]
fn repeated_enum_null_returns_empty_vec() {
let result: Vec<crate::EnumValue<Color>> =
repeated_enum::deserialize(&mut serde_json::Deserializer::from_str("null")).unwrap();
assert!(result.is_empty());
}
#[derive(Debug, PartialEq)]
struct List<T>(Vec<T>);
impl<T> From<Vec<T>> for List<T> {
fn from(v: Vec<T>) -> Self {
List(v)
}
}
#[test]
fn repeated_enum_modules_deserialize_into_a_custom_list() {
let json = r#"["RED","BLUE"]"#;
let open: List<crate::EnumValue<Color>> =
repeated_enum::deserialize(&mut serde_json::Deserializer::from_str(json)).unwrap();
assert_eq!(
open,
List(vec![
crate::EnumValue::Known(Color::Red),
crate::EnumValue::Known(Color::Blue)
])
);
let closed: List<Color> =
repeated_closed_enum::deserialize(&mut serde_json::Deserializer::from_str(json)).unwrap();
assert_eq!(closed, List(vec![Color::Red, Color::Blue]));
}
#[test]
fn streaming_enum_collections_preserve_ordinary_null_behavior() {
for source in ["null", "[]", "[null]", "[1,null,0]"] {
let ordinary: Vec<crate::EnumValue<Color>> =
repeated_enum::deserialize(&mut serde_json::Deserializer::from_str(source)).unwrap();
let streaming: Vec<crate::EnumValue<Color>> =
enum_list::open::deserialize(&mut serde_json::Deserializer::from_str(source)).unwrap();
assert_eq!(ordinary, streaming);
}
for source in ["[null]", "[1,null]"] {
let ordinary: Result<Vec<Color>, _> =
repeated_closed_enum::deserialize(&mut serde_json::Deserializer::from_str(source));
let streaming: Result<Vec<Color>, _> =
enum_list::closed::deserialize(&mut serde_json::Deserializer::from_str(source));
assert!(ordinary.is_err());
assert!(streaming.is_err());
}
#[cfg(feature = "std")]
crate::json::with_json_parse_options(
&crate::json::JsonParseOptions::new().ignore_unknown_enum_values(true),
|| {
let source = r#"[null,"UNKNOWN",1]"#;
let ordinary: Vec<crate::EnumValue<Color>> =
repeated_enum::deserialize(&mut serde_json::Deserializer::from_str(source))
.unwrap();
let streaming: Vec<crate::EnumValue<Color>> =
enum_list::open::deserialize(&mut serde_json::Deserializer::from_str(source))
.unwrap();
assert_eq!(ordinary, streaming);
assert_eq!(streaming.len(), 2);
},
);
}
#[test]
fn map_enum_deserializes_known_values() {
let json = r#"{"a":"RED","b":"GREEN"}"#;
let result: crate::__private::HashMap<alloc::string::String, crate::EnumValue<Color>> =
map_enum::deserialize(&mut serde_json::Deserializer::from_str(json)).unwrap();
assert_eq!(result.len(), 2);
assert_eq!(result["a"], crate::EnumValue::Known(Color::Red));
assert_eq!(result["b"], crate::EnumValue::Known(Color::Green));
}
#[test]
fn map_enum_rejects_unknown_by_default() {
let json = r#"{"a":"RED","b":"PURPLE"}"#;
let result: Result<
crate::__private::HashMap<alloc::string::String, crate::EnumValue<Color>>,
_,
> = map_enum::deserialize(&mut serde_json::Deserializer::from_str(json));
assert!(result.is_err());
}
#[test]
fn map_enum_drops_unknown_entries_when_lenient() {
use crate::json::{with_json_parse_options, JsonParseOptions};
let opts = JsonParseOptions {
ignore_unknown_enum_values: true,
..Default::default()
};
let json = r#"{"a":"RED","b":"PURPLE","c":"BLUE"}"#;
let result: crate::__private::HashMap<alloc::string::String, crate::EnumValue<Color>> =
with_json_parse_options(&opts, || {
map_enum::deserialize(&mut serde_json::Deserializer::from_str(json)).unwrap()
});
assert_eq!(result.len(), 2);
assert_eq!(result["a"], crate::EnumValue::Known(Color::Red));
assert_eq!(result["c"], crate::EnumValue::Known(Color::Blue));
}
#[test]
fn lenient_open_enum_containers_reject_malformed_values() {
use crate::json::{with_json_parse_options, JsonParseOptions};
let opts = JsonParseOptions {
ignore_unknown_enum_values: true,
..Default::default()
};
with_json_parse_options(&opts, || {
for json in ["[1.5]", "[true]", "[{}]", "[[]]", "[2147483648]"] {
let result = repeated_enum::deserialize::<Color, Vec<_>, _>(
&mut serde_json::Deserializer::from_str(json),
);
assert!(
result.is_err(),
"malformed input must remain an error: {json}"
);
}
for json in [
r#"{"a":1.5}"#,
r#"{"a":true}"#,
r#"{"a":{}}"#,
r#"{"a":[]}"#,
r#"{"a":2147483648}"#,
r#"{"a":-9999999999999}"#,
] {
let result = map_enum::deserialize::<
crate::__private::HashMap<alloc::string::String, crate::EnumValue<Color>>,
_,
>(&mut serde_json::Deserializer::from_str(json));
assert!(
result.is_err(),
"malformed input must remain an error: {json}"
);
}
for json in ["1.5", "true", "{}", "[]", "2147483648"] {
let result =
opt_enum::deserialize::<Color, _>(&mut serde_json::Deserializer::from_str(json));
assert!(
result.is_err(),
"malformed input must remain an error: {json}"
);
}
});
}
#[test]
fn map_enum_null_returns_empty_map() {
let result: crate::__private::HashMap<alloc::string::String, crate::EnumValue<Color>> =
map_enum::deserialize(&mut serde_json::Deserializer::from_str("null")).unwrap();
assert!(result.is_empty());
}
#[derive(Debug, Default, serde::Serialize, serde::Deserialize)]
struct TestMsg {
#[serde(
rename = "optionalNestedEnum",
with = "proto_enum",
skip_serializing_if = "skip_if::is_default_enum_value",
default
)]
optional_nested_enum: crate::EnumValue<Color>,
#[serde(
rename = "repeatedNestedEnum",
with = "repeated_enum",
skip_serializing_if = "skip_if::is_empty_vec",
default
)]
repeated_nested_enum: Vec<crate::EnumValue<Color>>,
#[serde(
rename = "mapStringNestedEnum",
with = "map_enum",
skip_serializing_if = "std::collections::HashMap::is_empty",
default
)]
map_string_nested_enum:
std::collections::HashMap<alloc::string::String, crate::EnumValue<Color>>,
}
#[test]
fn conformance_singular_unknown_enum_strict_rejects() {
let json = r#"{"optionalNestedEnum": "UNKNOWN_VALUE"}"#;
let result: Result<TestMsg, _> = serde_json::from_str(json);
assert!(
result.is_err(),
"strict mode should reject unknown enum strings"
);
}
#[test]
fn conformance_singular_unknown_enum_lenient_defaults() {
use crate::json::{with_json_parse_options, JsonParseOptions};
let opts = JsonParseOptions {
ignore_unknown_enum_values: true,
..Default::default()
};
let json = r#"{"optionalNestedEnum": "UNKNOWN_VALUE"}"#;
let msg: TestMsg = with_json_parse_options(&opts, || serde_json::from_str(json).unwrap());
assert_eq!(
msg.optional_nested_enum,
crate::EnumValue::Known(Color::Red)
);
let out = serde_json::to_string(&msg).unwrap();
assert_eq!(out, "{}");
}
#[test]
fn conformance_repeated_all_unknown_lenient_produces_empty() {
use crate::json::{with_json_parse_options, JsonParseOptions};
let opts = JsonParseOptions {
ignore_unknown_enum_values: true,
..Default::default()
};
let json = r#"{"repeatedNestedEnum": ["UNKNOWN_VALUE"]}"#;
let msg: TestMsg = with_json_parse_options(&opts, || serde_json::from_str(json).unwrap());
assert!(msg.repeated_nested_enum.is_empty());
let out = serde_json::to_string(&msg).unwrap();
assert_eq!(out, "{}");
}
#[test]
fn conformance_repeated_mixed_unknown_lenient_skips() {
use crate::json::{with_json_parse_options, JsonParseOptions};
let opts = JsonParseOptions {
ignore_unknown_enum_values: true,
..Default::default()
};
let json = r#"{"repeatedNestedEnum": ["RED", "UNKNOWN_VALUE", "RED"]}"#;
let msg: TestMsg = with_json_parse_options(&opts, || serde_json::from_str(json).unwrap());
assert_eq!(msg.repeated_nested_enum.len(), 2);
assert_eq!(
msg.repeated_nested_enum[0],
crate::EnumValue::Known(Color::Red)
);
assert_eq!(
msg.repeated_nested_enum[1],
crate::EnumValue::Known(Color::Red)
);
}
#[test]
fn conformance_map_all_unknown_lenient_produces_empty() {
use crate::json::{with_json_parse_options, JsonParseOptions};
let opts = JsonParseOptions {
ignore_unknown_enum_values: true,
..Default::default()
};
let json = r#"{"mapStringNestedEnum": {"key": "UNKNOWN_VALUE"}}"#;
let msg: TestMsg = with_json_parse_options(&opts, || serde_json::from_str(json).unwrap());
assert!(msg.map_string_nested_enum.is_empty());
let out = serde_json::to_string(&msg).unwrap();
assert_eq!(out, "{}");
}
#[test]
fn conformance_map_mixed_unknown_lenient_drops_entry() {
use crate::json::{with_json_parse_options, JsonParseOptions};
let opts = JsonParseOptions {
ignore_unknown_enum_values: true,
..Default::default()
};
let json = r#"{"mapStringNestedEnum": {"key1": "RED", "key2": "UNKNOWN_VALUE"}}"#;
let msg: TestMsg = with_json_parse_options(&opts, || serde_json::from_str(json).unwrap());
assert_eq!(msg.map_string_nested_enum.len(), 1);
assert_eq!(
msg.map_string_nested_enum["key1"],
crate::EnumValue::Known(Color::Red)
);
}
#[test]
fn opt_enum_deserializes_known_value() {
let json = r#""GREEN""#;
let result: Option<crate::EnumValue<Color>> =
opt_enum::deserialize(&mut serde_json::Deserializer::from_str(json)).unwrap();
assert_eq!(result, Some(crate::EnumValue::Known(Color::Green)));
}
#[test]
fn opt_enum_deserializes_null_as_none() {
let result: Option<crate::EnumValue<Color>> =
opt_enum::deserialize(&mut serde_json::Deserializer::from_str("null")).unwrap();
assert_eq!(result, None);
}
#[test]
fn opt_enum_deserializes_integer_value() {
let result: Option<crate::EnumValue<Color>> =
opt_enum::deserialize(&mut serde_json::Deserializer::from_str("2")).unwrap();
assert_eq!(result, Some(crate::EnumValue::Known(Color::Blue)));
}
#[test]
fn opt_enum_rejects_unknown_by_default() {
let json = r#""UNKNOWN_VALUE""#;
let result: Result<Option<crate::EnumValue<Color>>, _> =
opt_enum::deserialize(&mut serde_json::Deserializer::from_str(json));
assert!(result.is_err());
}
#[test]
fn opt_enum_returns_none_for_unknown_when_lenient() {
use crate::json::{with_json_parse_options, JsonParseOptions};
let opts = JsonParseOptions {
ignore_unknown_enum_values: true,
..Default::default()
};
let json = r#""UNKNOWN_VALUE""#;
let result: Option<crate::EnumValue<Color>> = with_json_parse_options(&opts, || {
opt_enum::deserialize(&mut serde_json::Deserializer::from_str(json)).unwrap()
});
assert_eq!(result, None);
}
#[test]
fn opt_enum_known_value_when_lenient() {
use crate::json::{with_json_parse_options, JsonParseOptions};
let opts = JsonParseOptions {
ignore_unknown_enum_values: true,
..Default::default()
};
let json = r#""GREEN""#;
let result: Option<crate::EnumValue<Color>> = with_json_parse_options(&opts, || {
opt_enum::deserialize(&mut serde_json::Deserializer::from_str(json)).unwrap()
});
assert_eq!(result, Some(crate::EnumValue::Known(Color::Green)));
}
#[test]
fn opt_enum_roundtrip_some() {
let val = Some(crate::EnumValue::Known(Color::Blue));
let json = serde_json::to_value(SerdeOptEnum(val)).unwrap();
assert_eq!(json, serde_json::json!("BLUE"));
}
#[test]
fn opt_enum_roundtrip_none() {
let val: Option<crate::EnumValue<Color>> = None;
let json = serde_json::to_value(SerdeOptEnum(val)).unwrap();
assert_eq!(json, serde_json::Value::Null);
}
#[derive(serde::Serialize, serde::Deserialize)]
struct SerdeOptEnum(#[serde(with = "opt_enum")] Option<crate::EnumValue<Color>>);
#[test]
fn conformance_proto2_optional_unknown_enum_lenient_absent() {
use crate::json::{with_json_parse_options, JsonParseOptions};
let opts = JsonParseOptions {
ignore_unknown_enum_values: true,
..Default::default()
};
#[derive(Debug, Default, serde::Serialize, serde::Deserialize)]
struct Proto2Msg {
#[serde(
rename = "optionalNestedEnum",
with = "opt_enum",
skip_serializing_if = "Option::is_none",
default
)]
optional_nested_enum: Option<crate::EnumValue<Color>>,
}
let json = r#"{"optionalNestedEnum": "UNKNOWN_VALUE"}"#;
let msg: Proto2Msg = with_json_parse_options(&opts, || serde_json::from_str(json).unwrap());
assert_eq!(msg.optional_nested_enum, None);
let out = serde_json::to_string(&msg).unwrap();
assert_eq!(out, "{}");
}
#[derive(serde::Serialize, serde::Deserialize)]
struct SerdeInt32(#[serde(with = "int32")] i32);
#[test]
fn int32_serializes_as_number() {
assert_eq!(serde_json::to_string(&SerdeInt32(42)).unwrap(), "42");
}
#[test]
fn int32_deserialize_table() {
#[rustfmt::skip]
let cases: &[(&str, Option<i32>)] = &[
("42", Some(42)), (r#""42""#, Some(42)), (r#""1e2""#, Some(100)), (r#""1200e-2""#, Some(12)), ("null", Some(0)), ("1.0", Some(1)), ("-2147483648", Some(i32::MIN)), ("2147483647", Some(i32::MAX)), ("9223372036854775807", None), (r#""1e-1""#, None), (r#""1.5""#, None), ("1.5", None), ];
for &(json, expected) in cases {
let result = serde_json::from_str::<SerdeInt32>(json).map(|v| v.0);
assert_eq!(result.ok(), expected, "input: {json}");
}
}
#[derive(serde::Serialize, serde::Deserialize)]
struct SerdeUint32(#[serde(with = "uint32")] u32);
#[test]
fn uint32_serializes_as_number() {
assert_eq!(serde_json::to_string(&SerdeUint32(42)).unwrap(), "42");
}
#[test]
fn uint32_deserialize_table() {
#[rustfmt::skip]
let cases: &[(&str, Option<u32>)] = &[
("42", Some(42)), (r#""42""#, Some(42)), ("null", Some(0)), ("1.0", Some(1)), ("4294967295", Some(u32::MAX)), ("-1", None), ("18446744073709551615", None), ("1.5", None), ];
for &(json, expected) in cases {
let result = serde_json::from_str::<SerdeUint32>(json).map(|v| v.0);
assert_eq!(result.ok(), expected, "input: {json}");
}
}
#[derive(serde::Serialize, serde::Deserialize)]
struct SerdeStringKeyMap(
#[serde(with = "string_key_map")] std::collections::HashMap<i32, alloc::string::String>,
);
#[test]
fn string_key_map_serializes_keys_as_strings() {
let mut m = std::collections::HashMap::new();
m.insert(42, "hello".into());
let json = serde_json::to_string(&SerdeStringKeyMap(m)).unwrap();
assert!(json.contains(r#""42""#));
}
#[test]
fn string_key_map_deserializes_string_keys() {
let v: SerdeStringKeyMap = serde_json::from_str(r#"{"42":"hello"}"#).unwrap();
assert_eq!(v.0[&42], "hello");
}
#[test]
fn string_key_map_null_returns_empty() {
let v: SerdeStringKeyMap = serde_json::from_str("null").unwrap();
assert!(v.0.is_empty());
}
#[test]
fn string_key_map_rejects_invalid_key() {
let result = serde_json::from_str::<SerdeStringKeyMap>(r#"{"not_a_number":"v"}"#);
assert!(result.is_err());
}
#[derive(serde::Serialize, serde::Deserialize)]
struct SerdeBoolKeyMap(#[serde(with = "string_key_map")] std::collections::HashMap<bool, i32>);
#[test]
fn string_key_map_bool_keys_roundtrip() {
let mut m = std::collections::HashMap::new();
m.insert(true, 1);
m.insert(false, 0);
let json = serde_json::to_string(&SerdeBoolKeyMap(m)).unwrap();
let recovered: SerdeBoolKeyMap = serde_json::from_str(&json).unwrap();
assert_eq!(recovered.0[&true], 1);
assert_eq!(recovered.0[&false], 0);
}
#[derive(serde::Serialize, serde::Deserialize)]
struct SerdeOptInt64(#[serde(with = "opt_int64")] Option<i64>);
#[test]
fn opt_int64_some_roundtrip() {
let v = SerdeOptInt64(Some(9007199254740993));
let json = serde_json::to_string(&v).unwrap();
assert_eq!(json, r#""9007199254740993""#);
let recovered: SerdeOptInt64 = serde_json::from_str(&json).unwrap();
assert_eq!(recovered.0, Some(9007199254740993));
}
#[test]
fn opt_int64_none_roundtrip() {
let v = SerdeOptInt64(None);
let json = serde_json::to_string(&v).unwrap();
assert_eq!(json, "null");
let recovered: SerdeOptInt64 = serde_json::from_str(&json).unwrap();
assert_eq!(recovered.0, None);
}
#[derive(serde::Serialize, serde::Deserialize)]
struct SerdeOptBytes(#[serde(with = "opt_bytes")] Option<Vec<u8>>);
#[test]
fn opt_bytes_some_roundtrip() {
let v = SerdeOptBytes(Some(vec![0xde, 0xad]));
let json = serde_json::to_string(&v).unwrap();
assert_eq!(json, r#""3q0=""#);
let recovered: SerdeOptBytes = serde_json::from_str(&json).unwrap();
assert_eq!(recovered.0, Some(vec![0xde, 0xad]));
}
#[test]
fn opt_bytes_none_roundtrip() {
let v = SerdeOptBytes(None);
let json = serde_json::to_string(&v).unwrap();
assert_eq!(json, "null");
let recovered: SerdeOptBytes = serde_json::from_str(&json).unwrap();
assert_eq!(recovered.0, None);
}
#[derive(serde::Serialize, serde::Deserialize)]
struct SerdeBytesBytes(#[serde(with = "bytes")] ::bytes::Bytes);
#[derive(serde::Serialize, serde::Deserialize)]
struct SerdeOptBytesBytes(#[serde(with = "opt_bytes")] Option<::bytes::Bytes>);
#[test]
fn bytes_module_generic_over_bytes_type() {
#[rustfmt::skip]
let cases: &[(&[u8], &str)] = &[
(&[0xde, 0xad], r#""3q0=""#),
(&[], r#""""#),
(&[0xCA, 0xFE, 0xBA, 0xBE], r#""yv66vg==""#),
];
for &(raw, json) in cases {
let v = SerdeBytesBytes(::bytes::Bytes::copy_from_slice(raw));
assert_eq!(serde_json::to_string(&v).unwrap(), json, "ser {raw:?}");
let back: SerdeBytesBytes = serde_json::from_str(json).unwrap();
assert_eq!(&back.0[..], raw, "deser {json}");
}
let back: SerdeBytesBytes = serde_json::from_str("null").unwrap();
assert!(back.0.is_empty());
}
#[test]
fn opt_bytes_generic_over_bytes_type() {
let v = SerdeOptBytesBytes(Some(::bytes::Bytes::from_static(&[0x01, 0x02])));
let json = serde_json::to_string(&v).unwrap();
assert_eq!(json, r#""AQI=""#);
let back: SerdeOptBytesBytes = serde_json::from_str(&json).unwrap();
assert_eq!(back.0.as_deref(), Some(&[0x01, 0x02][..]));
let v = SerdeOptBytesBytes(None);
assert_eq!(serde_json::to_string(&v).unwrap(), "null");
let back: SerdeOptBytesBytes = serde_json::from_str("null").unwrap();
assert!(back.0.is_none());
}
#[test]
fn proto_elem_json_for_bytes_via_proto_seq() {
#[derive(serde::Serialize, serde::Deserialize)]
struct Seq(#[serde(with = "proto_seq")] Vec<::bytes::Bytes>);
let v = Seq(vec![
::bytes::Bytes::from_static(b"a"),
::bytes::Bytes::from_static(b""),
::bytes::Bytes::from_static(&[0xff]),
]);
let json = serde_json::to_string(&v).unwrap();
assert_eq!(json, r#"["YQ==","","/w=="]"#);
let back: Seq = serde_json::from_str(&json).unwrap();
assert_eq!(back.0, v.0);
let back: Seq = serde_json::from_str("null").unwrap();
assert!(back.0.is_empty());
}
#[test]
fn bytes_and_vec_produce_identical_json() {
let raw: &[u8] = &[0, 127, 128, 255];
let as_vec = SerdeBytes(raw.to_vec());
let as_bytes = SerdeBytesBytes(::bytes::Bytes::copy_from_slice(raw));
assert_eq!(
serde_json::to_string(&as_vec).unwrap(),
serde_json::to_string(&as_bytes).unwrap()
);
}
#[derive(serde::Serialize, serde::Deserialize)]
struct SerdeBool(#[serde(with = "proto_bool")] bool);
#[test]
fn proto_bool_serializes_as_bool() {
assert_eq!(serde_json::to_string(&SerdeBool(true)).unwrap(), "true");
assert_eq!(serde_json::to_string(&SerdeBool(false)).unwrap(), "false");
}
#[test]
fn proto_bool_deserializes_from_bool() {
assert!(serde_json::from_str::<SerdeBool>("true").unwrap().0);
assert!(!serde_json::from_str::<SerdeBool>("false").unwrap().0);
}
#[test]
fn proto_bool_null_is_false() {
assert!(!serde_json::from_str::<SerdeBool>("null").unwrap().0);
}
#[derive(serde::Serialize, serde::Deserialize)]
struct SerdeString(#[serde(with = "proto_string")] alloc::string::String);
#[test]
fn proto_string_roundtrip() {
let v = SerdeString("hello".into());
let json = serde_json::to_string(&v).unwrap();
assert_eq!(json, r#""hello""#);
let recovered: SerdeString = serde_json::from_str(&json).unwrap();
assert_eq!(recovered.0, "hello");
}
#[test]
fn proto_string_null_is_empty() {
let v: SerdeString = serde_json::from_str("null").unwrap();
assert_eq!(v.0, "");
}
#[derive(Clone, PartialEq, Debug, Default)]
struct MyStr(alloc::string::String);
impl From<alloc::string::String> for MyStr {
fn from(s: alloc::string::String) -> Self {
MyStr(s)
}
}
impl core::ops::Deref for MyStr {
type Target = str;
fn deref(&self) -> &str {
&self.0
}
}
impl crate::ProtoString for MyStr {
fn from_wire(payload: crate::WirePayload<'_>) -> Result<Self, crate::DecodeError> {
payload.to_str().map(|s| Self(s.into()))
}
}
impl AsRef<str> for MyStr {
fn as_ref(&self) -> &str {
&self.0
}
}
#[derive(serde::Serialize, serde::Deserialize)]
struct SerdeCustomStr(#[serde(with = "proto_string")] MyStr);
#[test]
fn proto_string_deserializes_into_custom_type() {
let recovered: SerdeCustomStr = serde_json::from_str(r#""hello""#).unwrap();
assert_eq!(recovered.0, MyStr("hello".into()));
let empty: SerdeCustomStr = serde_json::from_str("null").unwrap();
assert_eq!(empty.0, MyStr::default());
let json = serde_json::to_string(&SerdeCustomStr(MyStr("hi".into()))).unwrap();
assert_eq!(json, r#""hi""#);
}
#[derive(serde::Serialize, serde::Deserialize)]
struct SerdeClosedEnum(#[serde(with = "closed_enum")] Color);
#[test]
fn closed_enum_serializes_as_proto_name() {
let v = SerdeClosedEnum(Color::Green);
let json = serde_json::to_string(&v).unwrap();
assert_eq!(json, r#""GREEN""#);
}
#[test]
fn closed_enum_deserialize_table() {
#[rustfmt::skip]
let cases: &[(&str, Option<Color>)] = &[
(r#""GREEN""#, Some(Color::Green)), ("1", Some(Color::Green)), ("null", Some(Color::Red)), (r#""UNKNOWN_VALUE""#, None), ("99", None), ];
for &(json, expected) in cases {
let result = serde_json::from_str::<SerdeClosedEnum>(json).map(|v| v.0);
assert_eq!(result.ok(), expected, "input: {json}");
}
}
#[test]
fn closed_enum_unknown_string_error_omits_the_value() {
let err = serde_json::from_str::<SerdeClosedEnum>(r#""PURPLE""#)
.map(|v| v.0)
.unwrap_err();
assert_eq!(err.to_string(), "unknown enum name at line 1 column 8");
}
#[derive(serde::Serialize, serde::Deserialize)]
struct SerdeOptClosedEnum(#[serde(with = "opt_closed_enum")] Option<Color>);
#[test]
fn opt_closed_enum_some_roundtrip() {
let v = SerdeOptClosedEnum(Some(Color::Blue));
let json = serde_json::to_string(&v).unwrap();
assert_eq!(json, r#""BLUE""#);
let recovered: SerdeOptClosedEnum = serde_json::from_str(&json).unwrap();
assert_eq!(recovered.0, Some(Color::Blue));
}
#[test]
fn opt_closed_enum_none_roundtrip() {
let v = SerdeOptClosedEnum(None);
let json = serde_json::to_string(&v).unwrap();
assert_eq!(json, "null");
let recovered: SerdeOptClosedEnum = serde_json::from_str(&json).unwrap();
assert_eq!(recovered.0, None);
}
#[derive(serde::Serialize, serde::Deserialize)]
struct SerdeRepeatedClosedEnum(#[serde(with = "repeated_closed_enum")] Vec<Color>);
#[test]
fn repeated_closed_enum_roundtrip() {
let v = SerdeRepeatedClosedEnum(vec![Color::Red, Color::Blue]);
let json = serde_json::to_string(&v).unwrap();
assert_eq!(json, r#"["RED","BLUE"]"#);
let recovered: SerdeRepeatedClosedEnum = serde_json::from_str(&json).unwrap();
assert_eq!(recovered.0, vec![Color::Red, Color::Blue]);
}
#[test]
fn repeated_closed_enum_null_is_empty() {
let v: SerdeRepeatedClosedEnum = serde_json::from_str("null").unwrap();
assert!(v.0.is_empty());
}
#[test]
fn closed_enum_containers_reject_null_elements() {
for ignore_unknown_enum_values in [false, true] {
let opts = crate::json::JsonParseOptions {
ignore_unknown_enum_values,
..Default::default()
};
crate::json::with_json_parse_options(&opts, || {
for json in [
"[null]",
r#"[null,"ONE"]"#,
r#"["ONE",null]"#,
r#"["ZERO",null,1]"#,
r#"["UNKNOWN",null]"#,
] {
let result = repeated_closed_enum::deserialize::<BareEnum, Vec<_>, _>(
&mut serde_json::Deserializer::from_str(json),
);
assert!(
result.is_err(),
"accepted {json}, lenient={ignore_unknown_enum_values}"
);
}
for json in [
r#"{"a":null}"#,
r#"{"a":null,"b":"ONE"}"#,
r#"{"a":1,"b":null}"#,
r#"{"a":"UNKNOWN","b":null}"#,
] {
let result = map_closed_enum::deserialize::<
crate::__private::HashMap<String, BareEnum>,
_,
>(&mut serde_json::Deserializer::from_str(json));
assert!(
result.is_err(),
"accepted {json}, lenient={ignore_unknown_enum_values}"
);
}
});
}
}
#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug, Default)]
enum BareEnum {
#[default]
Zero,
One,
}
impl crate::Enumeration for BareEnum {
fn from_i32(v: i32) -> Option<Self> {
match v {
0 => Some(Self::Zero),
1 => Some(Self::One),
_ => None,
}
}
fn to_i32(&self) -> i32 {
*self as i32
}
fn proto_name(&self) -> &'static str {
match self {
Self::Zero => "ZERO",
Self::One => "ONE",
}
}
fn from_proto_name(name: &str) -> Option<Self> {
match name {
"ZERO" => Some(Self::Zero),
"ONE" => Some(Self::One),
_ => None,
}
}
}
#[test]
fn opt_closed_enum_works_without_deserialize_impl() {
#[rustfmt::skip]
let cases: &[(&str, Result<Option<BareEnum>, ()>)] = &[
(r#""ONE""#, Ok(Some(BareEnum::One))), ("1", Ok(Some(BareEnum::One))), ("null", Ok(None)), (r#""UNKNOWN""#, Err(())), (r#""""#, Err(())), ("99", Err(())), ("-1", Err(())), ("9999999999999", Err(())), ("-9999999999999", Err(())), ("18446744073709551615", Err(())), ("1.0", Err(())), ("1.5", Err(())), ("true", Err(())), (r#"{"x":1}"#, Err(())), (r#"["ONE"]"#, Err(())), ];
for &(json, ref expected) in cases {
let mut d = serde_json::Deserializer::from_str(json);
let got = opt_closed_enum::deserialize::<BareEnum, _>(&mut d).map_err(|_| ());
assert_eq!(&got, expected, "input: {json}");
}
}
#[test]
fn opt_closed_enum_unknown_string_error_omits_the_value() {
let mut d = serde_json::Deserializer::from_str(r#""PURPLE""#);
let err = opt_closed_enum::deserialize::<BareEnum, _>(&mut d).unwrap_err();
assert_eq!(err.to_string(), "unknown enum name");
}
#[test]
fn repeated_closed_enum_works_without_deserialize_impl() {
let json = r#"["ZERO","ONE",1]"#;
let mut d = serde_json::Deserializer::from_str(json);
let got = repeated_closed_enum::deserialize::<BareEnum, Vec<_>, _>(&mut d).unwrap();
assert_eq!(got, vec![BareEnum::Zero, BareEnum::One, BareEnum::One]);
}
#[test]
fn map_closed_enum_works_without_deserialize_impl() {
let json = r#"{"a":"ZERO","b":1}"#;
let mut d = serde_json::Deserializer::from_str(json);
let got =
map_closed_enum::deserialize::<crate::__private::HashMap<String, BareEnum>, _>(&mut d)
.unwrap();
assert_eq!(got.get("a"), Some(&BareEnum::Zero));
assert_eq!(got.get("b"), Some(&BareEnum::One));
}
#[test]
fn closed_enum_lenient_drops_unknown_but_rejects_malformed_values() {
let opts = crate::json::JsonParseOptions {
ignore_unknown_enum_values: true,
..Default::default()
};
crate::json::with_json_parse_options(&opts, || {
for json in [r#""UNKNOWN""#, "99", "-1"] {
let mut d = serde_json::Deserializer::from_str(json);
let opt = opt_closed_enum::deserialize::<BareEnum, _>(&mut d).unwrap();
assert_eq!(opt, None, "lenient mode should skip {json}");
}
for json in [
"1.5",
"true",
"{}",
"[]",
"9999999999999",
"-9999999999999",
"18446744073709551615",
] {
let mut d = serde_json::Deserializer::from_str(json);
assert!(
opt_closed_enum::deserialize::<BareEnum, _>(&mut d).is_err(),
"malformed input must remain an error: {json}"
);
}
let mut d = serde_json::Deserializer::from_str(r#"["", "1"]"#);
let values = repeated_closed_enum::deserialize::<BareEnum, Vec<_>, _>(&mut d).unwrap();
assert!(values.is_empty());
let mut d = serde_json::Deserializer::from_str(r#"["ZERO","UNKNOWN","ONE",99,-1]"#);
let values = repeated_closed_enum::deserialize::<BareEnum, Vec<_>, _>(&mut d).unwrap();
assert_eq!(values, vec![BareEnum::Zero, BareEnum::One]);
for json in [
"[1.5]",
"[true]",
"[{}]",
"[[]]",
"[9999999999999]",
"[-9999999999999]",
"[18446744073709551615]",
] {
let mut d = serde_json::Deserializer::from_str(json);
assert!(
repeated_closed_enum::deserialize::<BareEnum, Vec<_>, _>(&mut d).is_err(),
"malformed input must remain an error: {json}"
);
}
let mut d =
serde_json::Deserializer::from_str(r#"{"a":"ZERO","b":"UNKNOWN","c":99,"d":-1}"#);
let map =
map_closed_enum::deserialize::<crate::__private::HashMap<String, BareEnum>, _>(&mut d)
.unwrap();
assert_eq!(map.len(), 1);
assert_eq!(map.get("a"), Some(&BareEnum::Zero));
for json in [
r#"{"a":1.5}"#,
r#"{"a":true}"#,
r#"{"a":{}}"#,
r#"{"a":[]}"#,
r#"{"a":2147483648}"#,
r#"{"a":-9999999999999}"#,
] {
let mut d = serde_json::Deserializer::from_str(json);
assert!(
map_closed_enum::deserialize::<crate::__private::HashMap<String, BareEnum>, _>(
&mut d
)
.is_err(),
"malformed input must remain an error: {json}"
);
}
});
}
#[test]
fn is_default_closed_enum_zero_is_default() {
assert!(skip_if::is_default_closed_enum(&Color::Red));
}
#[test]
fn is_default_closed_enum_nonzero_is_not_default() {
assert!(!skip_if::is_default_closed_enum(&Color::Green));
}
#[derive(serde::Serialize, serde::Deserialize, Default)]
struct BytesKeyWrapper {
#[serde(with = "bytes_key_map")]
m: crate::__private::HashMap<Vec<u8>, i32>,
}
#[derive(serde::Serialize, serde::Deserialize, Default)]
struct BytesKeyInt64Wrapper {
#[serde(with = "bytes_key_map")]
m: crate::__private::HashMap<Vec<u8>, i64>,
}
#[derive(serde::Serialize, serde::Deserialize, Default)]
struct BytesKeyBytesValWrapper {
#[serde(with = "bytes_key_bytes_val_map")]
m: crate::__private::HashMap<Vec<u8>, Vec<u8>>,
}
#[test]
fn bytes_key_map_roundtrip() {
let mut m = crate::__private::HashMap::default();
m.insert(b"key1".to_vec(), 42);
let w = BytesKeyWrapper { m };
let json = serde_json::to_string(&w).unwrap();
assert_eq!(json, r#"{"m":{"a2V5MQ==":42}}"#);
let back: BytesKeyWrapper = serde_json::from_str(&json).unwrap();
assert_eq!(back.m.get(b"key1".as_slice()), Some(&42));
}
#[test]
fn bytes_key_map_rejects_null_values() {
assert!(
serde_json::from_str::<BytesKeyWrapper>(r#"{"m":{"a2V5MQ==":null}}"#).is_err(),
"null map values must be rejected"
);
}
#[test]
fn bytes_key_map_uses_protojson_for_int64_values() {
let mut m = crate::__private::HashMap::default();
m.insert(b"k".to_vec(), 5_i64);
let w = BytesKeyInt64Wrapper { m };
let json = serde_json::to_string(&w).unwrap();
assert_eq!(json, r#"{"m":{"aw==":"5"}}"#);
let back: BytesKeyInt64Wrapper = serde_json::from_str(&json).unwrap();
assert_eq!(back.m.get(b"k".as_slice()), Some(&5));
}
#[test]
fn bytes_key_bytes_val_map_roundtrip() {
let mut m = crate::__private::HashMap::default();
m.insert(b"k".to_vec(), b"v".to_vec());
let w = BytesKeyBytesValWrapper { m };
let json = serde_json::to_string(&w).unwrap();
assert_eq!(json, r#"{"m":{"aw==":"dg=="}}"#);
let back: BytesKeyBytesValWrapper = serde_json::from_str(&json).unwrap();
assert_eq!(back.m.get(b"k".as_slice()), Some(&b"v".to_vec()));
}
#[test]
fn bytes_key_maps_deserialize_null() {
let w: BytesKeyWrapper = serde_json::from_str(r#"{"m":null}"#).unwrap();
assert!(w.m.is_empty());
let w: BytesKeyBytesValWrapper = serde_json::from_str(r#"{"m":null}"#).unwrap();
assert!(w.m.is_empty());
}
#[test]
fn float_serialize_table() {
#[rustfmt::skip]
let cases: &[(f32, &str)] = &[
(0.0, "0.0"),
(1.5, "1.5"),
(-3.25, "-3.25"),
(f32::INFINITY, r#""Infinity""#),
(f32::NEG_INFINITY, r#""-Infinity""#),
(f32::NAN, r#""NaN""#),
];
for &(v, expected) in cases {
let json = serde_json::to_string(&SerdeFloat(v)).unwrap();
assert_eq!(json, expected, "f32 {v}");
}
}
#[test]
fn float_deserialize_table() {
#[rustfmt::skip]
let cases: &[(&str, Option<f32>)] = &[
("1.5", Some(1.5)),
("-3.25", Some(-3.25)),
("42", Some(42.0)),
("-7", Some(-7.0)),
(r#""Infinity""#, Some(f32::INFINITY)),
(r#""-Infinity""#, Some(f32::NEG_INFINITY)),
(r#""1.5""#, Some(1.5)),
("null", Some(0.0)),
("1e300", None),
(r#""3.5e38""#, None),
(r#""-3.5e38""#, None),
(r#""1e400""#, None),
(r#""-1e400""#, None),
(r#""3.4028235e38""#, Some(f32::MAX)),
(r#""-3.4028235e38""#, Some(-f32::MAX)),
(r#""340282356779733661637539395458142568447""#, Some(f32::MAX)),
(r#""340282356779733661637539395458142568448""#, None),
(r#""1e-45""#, Some(f32::from_bits(1))),
(r#""1e-400""#, Some(0.0)),
(r#""inf""#, None),
(r#""-INF""#, None),
(r#""infinity""#, None),
(r#""nan""#, None),
(r#""not-a-number""#,None),
];
for &(json, expected) in cases {
let result = serde_json::from_str::<SerdeFloat>(json).map(|h| h.0);
match expected {
Some(v) => assert_eq!(result.ok(), Some(v), "input: {json}"),
None => assert!(
result.is_err(),
"input: {json}, expected error got {result:?}"
),
}
}
let h: SerdeFloat = serde_json::from_str(r#""NaN""#).unwrap();
assert!(h.0.is_nan());
for json in [r#""-0.0""#, r#""-1e-400""#] {
let h: SerdeFloat = serde_json::from_str(json).unwrap();
assert!(
h.0 == 0.0 && h.0.is_sign_negative(),
"input: {json}, got {}",
h.0
);
}
}
#[test]
fn float_unquoted_rounds_through_f64_quoted_rounds_once() {
let json = "1.0000000596046448";
let unquoted: SerdeFloat = serde_json::from_str(json).unwrap();
assert_eq!(unquoted.0.to_bits(), 0x3f80_0000);
let quoted: SerdeFloat = serde_json::from_str(&format!("\"{json}\"")).unwrap();
assert_eq!(quoted.0.to_bits(), 0x3f80_0001);
for json in ["16777217", r#""16777217""#] {
let v: SerdeFloat = serde_json::from_str(json).unwrap();
assert_eq!(v.0.to_bits(), 0x4b80_0000, "input: {json}");
}
}
#[test]
fn double_serialize_table() {
#[rustfmt::skip]
let cases: &[(f64, &str)] = &[
(0.0, "0.0"),
(1.5, "1.5"),
(-3.25, "-3.25"),
(f64::INFINITY, r#""Infinity""#),
(f64::NEG_INFINITY, r#""-Infinity""#),
(f64::NAN, r#""NaN""#),
];
for &(v, expected) in cases {
let json = serde_json::to_string(&SerdeDouble(v)).unwrap();
assert_eq!(json, expected, "f64 {v}");
}
}
#[test]
fn double_deserialize_table() {
#[rustfmt::skip]
let cases: &[(&str, Option<f64>)] = &[
("1.5", Some(1.5)),
("42", Some(42.0)),
("-7", Some(-7.0)),
(r#""Infinity""#, Some(f64::INFINITY)),
(r#""-Infinity""#, Some(f64::NEG_INFINITY)),
(r#""2.5""#, Some(2.5)),
("null", Some(0.0)),
("1e308", Some(1e308)),
(r#""1e308""#, Some(1e308)),
(r#""1.7976931348623157e308""#, Some(f64::MAX)),
(r#""-1.7976931348623157e308""#, Some(-f64::MAX)),
("1e400", None),
(r#""1e400""#, None),
(r#""-1e400""#, None),
(r#""1.8e308""#, None),
(r#""5e-324""#, Some(f64::from_bits(1))),
(r#""1e-400""#, Some(0.0)),
(r#""inf""#, None),
(r#""-INF""#, None),
(r#""infinity""#, None),
(r#""nan""#, None),
(r#""garbage""#, None),
];
for &(json, expected) in cases {
let result = serde_json::from_str::<SerdeDouble>(json).map(|h| h.0);
match expected {
Some(v) => assert_eq!(result.ok(), Some(v), "input: {json}"),
None => assert!(
result.is_err(),
"input: {json}, expected error got {result:?}"
),
}
}
let h: SerdeDouble = serde_json::from_str(r#""NaN""#).unwrap();
assert!(h.0.is_nan());
for json in [r#""-0.0""#, r#""-1e-400""#] {
let h: SerdeDouble = serde_json::from_str(json).unwrap();
assert!(
h.0 == 0.0 && h.0.is_sign_negative(),
"input: {json}, got {}",
h.0
);
}
}
#[test]
fn quoted_float_overflow_rejected_in_every_field_shape() {
#[derive(serde::Deserialize)]
struct SeqF32(#[serde(with = "proto_seq")] Vec<f32>);
#[derive(serde::Deserialize)]
struct OptF32(#[serde(with = "opt_float")] Option<f32>);
#[derive(serde::Deserialize)]
struct OptF64(#[serde(with = "opt_double")] Option<f64>);
assert!(serde_json::from_str::<SeqF32>(r#"["1.5","3.5e38"]"#).is_err());
assert!(serde_json::from_str::<SeqF32>(r#"["1e400"]"#).is_err());
assert!(serde_json::from_str::<SeqF64Holder>(r#"["1e400"]"#).is_err());
assert!(serde_json::from_str::<MapBoolF64Holder>(r#"{"true":"1e400"}"#).is_err());
assert!(serde_json::from_str::<OptF32>(r#""3.5e38""#).is_err());
assert!(serde_json::from_str::<OptF32>(r#""1e400""#).is_err());
assert!(serde_json::from_str::<OptF64>(r#""1e400""#).is_err());
assert_eq!(
serde_json::from_str::<SeqF32>(r#"["1.5","-2"]"#).unwrap().0,
[1.5, -2.0]
);
assert_eq!(
serde_json::from_str::<OptF32>(r#""1.5""#).unwrap().0,
Some(1.5)
);
assert_eq!(
serde_json::from_str::<OptF64>(r#""1e308""#).unwrap().0,
Some(1e308)
);
}
#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug, Default)]
#[repr(i32)]
enum TestEnum {
#[default]
Zero = 0,
One = 1,
}
impl crate::Enumeration for TestEnum {
fn from_i32(value: i32) -> Option<Self> {
match value {
0 => Some(Self::Zero),
1 => Some(Self::One),
_ => None,
}
}
fn to_i32(&self) -> i32 {
*self as i32
}
fn proto_name(&self) -> &'static str {
match self {
Self::Zero => "ZERO",
Self::One => "ONE",
}
}
fn from_proto_name(name: &str) -> Option<Self> {
match name {
"ZERO" => Some(Self::Zero),
"ONE" => Some(Self::One),
_ => None,
}
}
}
#[test]
fn adapter_newtypes_match_their_helpers() {
assert_eq!(
serde_json::to_string(&ProtoJson(&i64::MAX)).unwrap(),
r#""9223372036854775807""#
);
assert_eq!(
serde_json::to_string(&BytesJson(&[0u8, 1][..])).unwrap(),
r#""AAE=""#
);
assert_eq!(
serde_json::to_string(&ClosedEnumJson(&TestEnum::One)).unwrap(),
r#""ONE""#
);
assert_eq!(
serde_json::to_string(&MapKeyJson(&42i64)).unwrap(),
r#""42""#
);
assert_eq!(
serde_json::to_string(&MapKeyJson(&true)).unwrap(),
r#""true""#
);
assert_eq!(
serde_json::to_string(&RepeatedJson(&[1u64, 2][..])).unwrap(),
r#"["1","2"]"#
);
assert_eq!(
serde_json::to_string(&BytesSeqJson(&[&[0u8][..], &[1, 2][..]][..])).unwrap(),
r#"["AA==","AQI="]"#
);
assert_eq!(
serde_json::to_string(&EnumSeqJson(
&[
crate::EnumValue::Known(TestEnum::One),
crate::EnumValue::Unknown(7),
][..]
))
.unwrap(),
r#"["ONE",7]"#
);
assert_eq!(
serde_json::to_string(&ClosedEnumSeqJson(&[TestEnum::Zero, TestEnum::One][..])).unwrap(),
r#"["ZERO","ONE"]"#
);
}
fn assert_fixed_json_error<T: serde::de::DeserializeOwned>(json: &str, reason: JsonValueError) {
let error = match serde_json::from_str::<T>(json) {
Err(error) => error,
Ok(_) => panic!("expected a JSON error for {json}"),
};
let text = error.to_string();
let expected = reason.to_string();
assert_eq!(text.split(" at line ").next(), Some(expected.as_str()));
}
#[test]
fn numeric_errors_omit_invalid_text_and_numbers() {
use JsonValueError::{Double, Float, Int32, Int64, Uint32, Uint64};
for json in [
r#""number-marker""#,
"-2147483649",
"2147483648",
"123456.5",
] {
assert_fixed_json_error::<SerdeInt32>(json, Int32);
}
for json in [r#""number-marker""#, "-123456", "4294967296"] {
assert_fixed_json_error::<SerdeUint32>(json, Uint32);
}
for json in [r#""number-marker""#, "9223372036854775808"] {
assert_fixed_json_error::<SerdeInt64>(json, Int64);
}
for json in [r#""number-marker""#, "-123456"] {
assert_fixed_json_error::<SerdeUint64>(json, Uint64);
}
for json in [r#""float-marker""#, "4.12345e39"] {
assert_fixed_json_error::<SerdeFloat>(json, Float);
}
assert_fixed_json_error::<SerdeInt32>("true", Int32);
assert_fixed_json_error::<SerdeFloat>("true", Float);
assert_fixed_json_error::<SerdeDouble>("true", Double);
assert_fixed_json_error::<SerdeDouble>(r#""double-marker""#, Double);
}
#[test]
fn key_and_base64_errors_omit_the_rejected_value() {
use JsonValueError::{Base64, MapKey};
assert_fixed_json_error::<MapI32I64Holder>(r#"{"key-marker":"42"}"#, MapKey);
assert_fixed_json_error::<SerdeStringKeyMap>(r#"{"key-marker":"value"}"#, MapKey);
assert_fixed_json_error::<SerdeBytes>(r#""base64!marker""#, Base64);
assert_fixed_json_error::<SerdeBytes>("123456789", Base64);
assert_fixed_json_error::<BytesKeyWrapper>(r#"{"m":{"base64!marker":1}}"#, Base64);
assert_fixed_json_error::<BytesKeyBytesValWrapper>(r#"{"m":{"base64!marker":"AA=="}}"#, Base64);
assert_fixed_json_error::<BytesKeyBytesValWrapper>(r#"{"m":{"AA==":"base64!marker"}}"#, Base64);
}