1use alloc::boxed::Box;
29use alloc::format;
30use alloc::string::String;
31use alloc::vec::Vec;
32use core::sync::atomic::{AtomicPtr, Ordering};
33use hashbrown::{HashMap, HashSet};
34
35use crate::unknown_fields::{UnknownField, UnknownFields};
36
37pub struct JsonExtEntry {
50 pub number: u32,
52 pub full_name: &'static str,
54 pub extendee: &'static str,
58 pub to_json: fn(u32, &UnknownFields) -> Result<serde_json::Value, String>,
61 pub from_json: fn(serde_json::Value, u32) -> Result<Vec<UnknownField>, String>,
66}
67
68#[deprecated(since = "0.3.0", note = "renamed to JsonExtEntry")]
71pub type ExtensionRegistryEntry = JsonExtEntry;
72
73pub struct ExtensionRegistry {
79 by_number: HashMap<&'static str, HashMap<u32, JsonExtEntry>>,
80 by_name: HashMap<&'static str, (&'static str, u32)>,
81}
82
83impl ExtensionRegistry {
84 pub fn new() -> Self {
86 Self {
87 by_number: HashMap::new(),
88 by_name: HashMap::new(),
89 }
90 }
91
92 pub fn register(&mut self, entry: JsonExtEntry) {
95 let extendee = entry.extendee;
96 let number = entry.number;
97
98 if let Some(previous) = self
99 .by_number
100 .get_mut(extendee)
101 .and_then(|entries| entries.remove(&number))
102 {
103 self.by_name.remove(previous.full_name);
104 }
105 if let Some((previous_extendee, previous_number)) = self.by_name.remove(entry.full_name) {
106 if let Some(entries) = self.by_number.get_mut(previous_extendee) {
107 entries.remove(&previous_number);
108 }
109 }
110
111 self.by_name.insert(entry.full_name, (extendee, number));
112 self.by_number
113 .entry(extendee)
114 .or_default()
115 .insert(number, entry);
116 }
117
118 pub fn by_number(&self, extendee: &str, number: u32) -> Option<&JsonExtEntry> {
120 self.by_number.get(extendee)?.get(&number)
121 }
122
123 pub fn by_name(&self, full_name: &str) -> Option<&JsonExtEntry> {
125 let key = self.by_name.get(full_name)?;
126 self.by_number.get(key.0)?.get(&key.1)
127 }
128}
129
130impl Default for ExtensionRegistry {
131 fn default() -> Self {
132 Self::new()
133 }
134}
135
136static REGISTRY: AtomicPtr<ExtensionRegistry> = AtomicPtr::new(core::ptr::null_mut());
139
140#[deprecated(since = "0.3.0", note = "use buffa::type_registry::set_type_registry")]
146pub fn set_extension_registry(reg: Box<ExtensionRegistry>) {
147 let old = REGISTRY.swap(Box::into_raw(reg), Ordering::Release);
148 if !old.is_null() {
149 let _ = old;
152 }
153}
154
155pub fn extension_registry() -> Option<&'static ExtensionRegistry> {
157 let ptr = REGISTRY.load(Ordering::Acquire);
158 if ptr.is_null() {
159 None
160 } else {
161 Some(unsafe { &*ptr })
164 }
165}
166
167pub fn serialize_extensions<S: serde::Serializer>(
176 extendee: &str,
177 fields: &UnknownFields,
178 serializer: S,
179) -> Result<S::Ok, S::Error> {
180 use serde::ser::{Error, SerializeMap};
181
182 let mut map = serializer.serialize_map(None)?;
183
184 let Some(reg) = extension_registry() else {
187 return map.end();
188 };
189 if fields.is_empty() {
190 return map.end();
191 }
192
193 let mut seen: HashSet<u32> = HashSet::with_capacity(fields.len());
197 for uf in fields.iter() {
198 if !seen.insert(uf.number) {
199 continue;
200 }
201 if let Some(entry) = reg.by_number(extendee, uf.number) {
202 let json = (entry.to_json)(uf.number, fields).map_err(S::Error::custom)?;
203 let key = format!("[{}]", entry.full_name);
204 map.serialize_entry(&key, &json)?;
205 }
206 }
207 map.end()
208}
209
210pub fn deserialize_extension_key(
224 extendee: &str,
225 key: &str,
226 value: serde_json::Value,
227) -> Option<Result<Vec<UnknownField>, String>> {
228 let name = key.strip_prefix('[')?.strip_suffix(']')?;
229 let Some(entry) = extension_registry().and_then(|r| r.by_name(name)) else {
238 if crate::json::strict_extension_keys() {
239 return Some(Err(format!("extension `{name}` not in registry")));
240 }
241 return None;
242 };
243 if entry.extendee != extendee {
244 return Some(Err(format!(
245 "extension `{name}` extends `{}`, not `{extendee}`",
246 entry.extendee
247 )));
248 }
249 Some((entry.from_json)(value, entry.number))
250}
251
252pub fn deserialize_extensions<'de, D: serde::Deserializer<'de>>(
259 extendee: &'static str,
260 deserializer: D,
261) -> Result<UnknownFields, D::Error> {
262 use serde::de::{Error, MapAccess, Visitor};
263
264 struct V {
265 extendee: &'static str,
266 }
267 impl<'de> Visitor<'de> for V {
268 type Value = UnknownFields;
269 fn expecting(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
270 f.write_str("extension map")
271 }
272 fn visit_map<M: MapAccess<'de>>(self, mut map: M) -> Result<UnknownFields, M::Error> {
273 let mut out = UnknownFields::new();
274 while let Some(key) = map.next_key::<String>()? {
275 let crate::json_helpers::buffered::BufferedValue(value) = map.next_value()?;
278 match deserialize_extension_key(self.extendee, &key, value) {
279 Some(Ok(records)) => {
280 for r in records {
281 out.push(r);
282 }
283 }
284 Some(Err(e)) => return Err(M::Error::custom(e)),
285 None => {} }
287 }
288 Ok(out)
289 }
290 }
291 deserializer.deserialize_map(V { extendee })
292}
293
294pub mod helpers {
302 use super::*;
303 use crate::extension::codecs::*;
304 use crate::extension::ExtensionCodec;
305 use crate::unknown_fields::{UnknownField, UnknownFieldData};
306
307 fn missing(n: u32) -> String {
308 format!("extension field {n}: no value present")
309 }
310
311 fn json_integer<T>(
315 v: serde_json::Value,
316 n: u32,
317 decode: fn(serde_json::Value) -> Result<T, serde_json::Error>,
318 encode: fn(T) -> UnknownFieldData,
319 ) -> Result<Vec<UnknownField>, String> {
320 if v.is_null() {
323 return Err(format!("field {n}: expected number or string"));
324 }
325 let i = decode(v).map_err(|e| format!("field {n}: {e}"))?;
326 Ok(alloc::vec![UnknownField {
327 number: n,
328 data: encode(i),
329 }])
330 }
331
332 pub fn int32_to_json(n: u32, f: &UnknownFields) -> Result<serde_json::Value, String> {
335 Int32::decode(n, f)
336 .map(|v| serde_json::json!(v))
337 .ok_or_else(|| missing(n))
338 }
339 pub fn int32_from_json(v: serde_json::Value, n: u32) -> Result<Vec<UnknownField>, String> {
340 json_integer(v, n, crate::json_helpers::int32::deserialize, |v| {
341 UnknownFieldData::Varint(v as i64 as u64)
342 })
343 }
344
345 pub fn sint32_to_json(n: u32, f: &UnknownFields) -> Result<serde_json::Value, String> {
346 Sint32::decode(n, f)
347 .map(|v| serde_json::json!(v))
348 .ok_or_else(|| missing(n))
349 }
350 pub fn sint32_from_json(v: serde_json::Value, n: u32) -> Result<Vec<UnknownField>, String> {
351 json_integer(v, n, crate::json_helpers::int32::deserialize, |v| {
352 UnknownFieldData::Varint(crate::types::zigzag_encode_i32(v) as u64)
353 })
354 }
355
356 pub fn uint32_to_json(n: u32, f: &UnknownFields) -> Result<serde_json::Value, String> {
357 Uint32::decode(n, f)
358 .map(|v| serde_json::json!(v))
359 .ok_or_else(|| missing(n))
360 }
361 pub fn uint32_from_json(v: serde_json::Value, n: u32) -> Result<Vec<UnknownField>, String> {
362 json_integer(v, n, crate::json_helpers::uint32::deserialize, |v| {
363 UnknownFieldData::Varint(v as u64)
364 })
365 }
366
367 pub fn sfixed32_to_json(n: u32, f: &UnknownFields) -> Result<serde_json::Value, String> {
368 Sfixed32::decode(n, f)
369 .map(|v| serde_json::json!(v))
370 .ok_or_else(|| missing(n))
371 }
372 pub fn sfixed32_from_json(v: serde_json::Value, n: u32) -> Result<Vec<UnknownField>, String> {
373 json_integer(v, n, crate::json_helpers::int32::deserialize, |v| {
374 UnknownFieldData::Fixed32(v as u32)
375 })
376 }
377
378 pub fn fixed32_to_json(n: u32, f: &UnknownFields) -> Result<serde_json::Value, String> {
379 Fixed32::decode(n, f)
380 .map(|v| serde_json::json!(v))
381 .ok_or_else(|| missing(n))
382 }
383 pub fn fixed32_from_json(v: serde_json::Value, n: u32) -> Result<Vec<UnknownField>, String> {
384 json_integer(
385 v,
386 n,
387 crate::json_helpers::uint32::deserialize,
388 UnknownFieldData::Fixed32,
389 )
390 }
391
392 pub fn int64_to_json(n: u32, f: &UnknownFields) -> Result<serde_json::Value, String> {
395 Int64::decode(n, f)
396 .map(|v| serde_json::Value::String(alloc::format!("{v}")))
397 .ok_or_else(|| missing(n))
398 }
399 pub fn int64_from_json(v: serde_json::Value, n: u32) -> Result<Vec<UnknownField>, String> {
400 json_integer(v, n, crate::json_helpers::int64::deserialize, |v| {
401 UnknownFieldData::Varint(v as u64)
402 })
403 }
404
405 pub fn sint64_to_json(n: u32, f: &UnknownFields) -> Result<serde_json::Value, String> {
406 Sint64::decode(n, f)
407 .map(|v| serde_json::Value::String(alloc::format!("{v}")))
408 .ok_or_else(|| missing(n))
409 }
410 pub fn sint64_from_json(v: serde_json::Value, n: u32) -> Result<Vec<UnknownField>, String> {
411 json_integer(v, n, crate::json_helpers::int64::deserialize, |v| {
412 UnknownFieldData::Varint(crate::types::zigzag_encode_i64(v))
413 })
414 }
415
416 pub fn uint64_to_json(n: u32, f: &UnknownFields) -> Result<serde_json::Value, String> {
417 Uint64::decode(n, f)
418 .map(|v| serde_json::Value::String(alloc::format!("{v}")))
419 .ok_or_else(|| missing(n))
420 }
421 pub fn uint64_from_json(v: serde_json::Value, n: u32) -> Result<Vec<UnknownField>, String> {
422 json_integer(v, n, crate::json_helpers::uint64::deserialize, |v| {
423 UnknownFieldData::Varint(v)
424 })
425 }
426
427 pub fn sfixed64_to_json(n: u32, f: &UnknownFields) -> Result<serde_json::Value, String> {
428 Sfixed64::decode(n, f)
429 .map(|v| serde_json::Value::String(alloc::format!("{v}")))
430 .ok_or_else(|| missing(n))
431 }
432 pub fn sfixed64_from_json(v: serde_json::Value, n: u32) -> Result<Vec<UnknownField>, String> {
433 json_integer(v, n, crate::json_helpers::int64::deserialize, |v| {
434 UnknownFieldData::Fixed64(v as u64)
435 })
436 }
437
438 pub fn fixed64_to_json(n: u32, f: &UnknownFields) -> Result<serde_json::Value, String> {
439 Fixed64::decode(n, f)
440 .map(|v| serde_json::Value::String(alloc::format!("{v}")))
441 .ok_or_else(|| missing(n))
442 }
443 pub fn fixed64_from_json(v: serde_json::Value, n: u32) -> Result<Vec<UnknownField>, String> {
444 json_integer(
445 v,
446 n,
447 crate::json_helpers::uint64::deserialize,
448 UnknownFieldData::Fixed64,
449 )
450 }
451
452 pub fn bool_to_json(n: u32, f: &UnknownFields) -> Result<serde_json::Value, String> {
455 Bool::decode(n, f)
456 .map(serde_json::Value::Bool)
457 .ok_or_else(|| missing(n))
458 }
459 pub fn bool_from_json(v: serde_json::Value, n: u32) -> Result<Vec<UnknownField>, String> {
460 let b = v
461 .as_bool()
462 .ok_or_else(|| format!("field {n}: expected bool"))?;
463 Ok(alloc::vec![UnknownField {
464 number: n,
465 data: UnknownFieldData::Varint(b as u64),
466 }])
467 }
468
469 pub fn string_to_json(n: u32, f: &UnknownFields) -> Result<serde_json::Value, String> {
470 StringCodec::decode(n, f)
471 .map(serde_json::Value::String)
472 .ok_or_else(|| missing(n))
473 }
474 pub fn string_from_json(v: serde_json::Value, n: u32) -> Result<Vec<UnknownField>, String> {
475 let serde_json::Value::String(s) = v else {
476 return Err(format!("field {n}: expected string"));
477 };
478 Ok(alloc::vec![UnknownField {
479 number: n,
480 data: UnknownFieldData::LengthDelimited(s.into_bytes()),
481 }])
482 }
483
484 pub fn bytes_to_json(n: u32, f: &UnknownFields) -> Result<serde_json::Value, String> {
485 use base64::Engine;
486 BytesCodec::decode(n, f)
487 .map(|b| serde_json::Value::String(base64::engine::general_purpose::STANDARD.encode(b)))
488 .ok_or_else(|| missing(n))
489 }
490 pub fn bytes_from_json(v: serde_json::Value, n: u32) -> Result<Vec<UnknownField>, String> {
491 let serde_json::Value::String(s) = v else {
492 return Err(format!("field {n}: expected base64 string"));
493 };
494 let bytes = crate::json_helpers::decode_base64(&s)
495 .map_err(|e| format!("field {n}: base64: {e}"))?;
496 Ok(alloc::vec![UnknownField {
497 number: n,
498 data: UnknownFieldData::LengthDelimited(bytes),
499 }])
500 }
501
502 pub fn float_to_json(n: u32, f: &UnknownFields) -> Result<serde_json::Value, String> {
505 Float::decode(n, f)
506 .map(|v| {
507 if v.is_nan() {
508 serde_json::Value::String("NaN".into())
509 } else if v == f32::INFINITY {
510 serde_json::Value::String("Infinity".into())
511 } else if v == f32::NEG_INFINITY {
512 serde_json::Value::String("-Infinity".into())
513 } else {
514 serde_json::json!(v)
515 }
516 })
517 .ok_or_else(|| missing(n))
518 }
519 pub fn float_from_json(v: serde_json::Value, n: u32) -> Result<Vec<UnknownField>, String> {
520 if !matches!(
523 v,
524 serde_json::Value::Number(_) | serde_json::Value::String(_)
525 ) {
526 return Err(format!("field {n}: expected number or string"));
527 }
528 let f =
529 crate::json_helpers::float::deserialize(v).map_err(|e| format!("field {n}: {e}"))?;
530 Ok(alloc::vec![UnknownField {
531 number: n,
532 data: UnknownFieldData::Fixed32(f.to_bits()),
533 }])
534 }
535
536 pub fn double_to_json(n: u32, f: &UnknownFields) -> Result<serde_json::Value, String> {
537 Double::decode(n, f)
538 .map(|v| {
539 if v.is_nan() {
540 serde_json::Value::String("NaN".into())
541 } else if v == f64::INFINITY {
542 serde_json::Value::String("Infinity".into())
543 } else if v == f64::NEG_INFINITY {
544 serde_json::Value::String("-Infinity".into())
545 } else {
546 serde_json::json!(v)
547 }
548 })
549 .ok_or_else(|| missing(n))
550 }
551 pub fn double_from_json(v: serde_json::Value, n: u32) -> Result<Vec<UnknownField>, String> {
552 if !matches!(
553 v,
554 serde_json::Value::Number(_) | serde_json::Value::String(_)
555 ) {
556 return Err(format!("field {n}: expected number or string"));
557 }
558 let f =
559 crate::json_helpers::double::deserialize(v).map_err(|e| format!("field {n}: {e}"))?;
560 Ok(alloc::vec![UnknownField {
561 number: n,
562 data: UnknownFieldData::Fixed64(f.to_bits()),
563 }])
564 }
565
566 pub fn enum_to_json<E: crate::Enumeration>(
572 n: u32,
573 f: &UnknownFields,
574 ) -> Result<serde_json::Value, String> {
575 let i = Int32::decode(n, f).ok_or_else(|| missing(n))?;
576 Ok(match E::from_i32(i) {
577 Some(e) => serde_json::Value::String(e.proto_name().into()),
578 None => serde_json::json!(i),
579 })
580 }
581
582 pub fn enum_from_json<E: crate::Enumeration>(
585 v: serde_json::Value,
586 n: u32,
587 ) -> Result<Vec<UnknownField>, String> {
588 let i = match v {
589 serde_json::Value::String(s) => {
590 E::from_proto_name(&s).map(|e| e.to_i32()).ok_or_else(|| {
591 format!(
592 "field {n}: {}",
593 crate::json_helpers::EnumJsonErrorReason::UnknownName
594 )
595 })?
596 }
597 serde_json::Value::Number(num) => num
598 .as_i64()
599 .and_then(|x| i32::try_from(x).ok())
600 .ok_or_else(|| format!("field {n}: not an i32"))?,
601 _ => return Err(format!("field {n}: expected string or number")),
602 };
603 Ok(alloc::vec![UnknownField {
604 number: n,
605 data: UnknownFieldData::Varint(i as i64 as u64),
606 }])
607 }
608
609 pub fn null_value_to_json(n: u32, f: &UnknownFields) -> Result<serde_json::Value, String> {
611 EnumI32::decode(n, f).ok_or_else(|| missing(n))?;
612 Ok(serde_json::Value::Null)
613 }
614
615 pub fn null_value_from_json(v: serde_json::Value, n: u32) -> Result<Vec<UnknownField>, String> {
617 match v {
618 serde_json::Value::Null => {}
619 serde_json::Value::String(s) if s == "NULL_VALUE" => {}
620 serde_json::Value::Number(num) if num.as_i64() == Some(0) => {}
621 _ => {
622 return Err(format!("field {n}: expected null, `NULL_VALUE`, or 0"));
623 }
624 }
625 Ok(alloc::vec![UnknownField {
626 number: n,
627 data: UnknownFieldData::Varint(0),
628 }])
629 }
630
631 pub fn message_to_json<M>(n: u32, f: &UnknownFields) -> Result<serde_json::Value, String>
638 where
639 M: crate::Message + Default + serde::Serialize,
640 {
641 let m = MessageCodec::<M>::decode(n, f).ok_or_else(|| missing(n))?;
642 serde_json::to_value(&m).map_err(|e| alloc::format!("field {n}: {e}"))
643 }
644
645 pub fn message_from_json<M>(v: serde_json::Value, n: u32) -> Result<Vec<UnknownField>, String>
647 where
648 M: crate::Message + Default + for<'de> serde::Deserialize<'de>,
649 {
650 let m: M = serde_json::from_value(v).map_err(|e| alloc::format!("field {n}: {e}"))?;
651 let bytes = m
652 .try_encode_to_vec()
653 .map_err(|e| alloc::format!("field {n}: {e}"))?;
654 Ok(alloc::vec![UnknownField {
655 number: n,
656 data: UnknownFieldData::LengthDelimited(bytes),
657 }])
658 }
659
660 fn repeated_from_array(
670 v: serde_json::Value,
671 n: u32,
672 from_one: fn(serde_json::Value, u32) -> Result<Vec<UnknownField>, String>,
673 ) -> Result<Vec<UnknownField>, String> {
674 let serde_json::Value::Array(arr) = v else {
675 return Err(format!("field {n}: expected array"));
676 };
677 let mut out = Vec::with_capacity(arr.len());
678 for elem in arr {
679 out.extend(from_one(elem, n)?);
680 }
681 Ok(out)
682 }
683
684 macro_rules! repeated_scalar {
689 ($to_name:ident, $from_name:ident, $codec:ty, $to_elem:expr, $from_one:path) => {
690 pub fn $to_name(n: u32, f: &UnknownFields) -> Result<serde_json::Value, String> {
691 let vs = Repeated::<$codec>::decode(n, f);
692 Ok(serde_json::Value::Array(
693 vs.into_iter().map($to_elem).collect(),
694 ))
695 }
696 pub fn $from_name(v: serde_json::Value, n: u32) -> Result<Vec<UnknownField>, String> {
697 repeated_from_array(v, n, $from_one)
698 }
699 };
700 }
701
702 fn f32_to_value(v: f32) -> serde_json::Value {
705 if v.is_nan() {
706 serde_json::Value::String("NaN".into())
707 } else if v == f32::INFINITY {
708 serde_json::Value::String("Infinity".into())
709 } else if v == f32::NEG_INFINITY {
710 serde_json::Value::String("-Infinity".into())
711 } else {
712 serde_json::json!(v)
713 }
714 }
715 fn f64_to_value(v: f64) -> serde_json::Value {
716 if v.is_nan() {
717 serde_json::Value::String("NaN".into())
718 } else if v == f64::INFINITY {
719 serde_json::Value::String("Infinity".into())
720 } else if v == f64::NEG_INFINITY {
721 serde_json::Value::String("-Infinity".into())
722 } else {
723 serde_json::json!(v)
724 }
725 }
726
727 repeated_scalar!(
729 repeated_int32_to_json,
730 repeated_int32_from_json,
731 Int32,
732 |v| serde_json::json!(v),
733 int32_from_json
734 );
735 repeated_scalar!(
736 repeated_sint32_to_json,
737 repeated_sint32_from_json,
738 Sint32,
739 |v| serde_json::json!(v),
740 sint32_from_json
741 );
742 repeated_scalar!(
743 repeated_uint32_to_json,
744 repeated_uint32_from_json,
745 Uint32,
746 |v| serde_json::json!(v),
747 uint32_from_json
748 );
749 repeated_scalar!(
750 repeated_sfixed32_to_json,
751 repeated_sfixed32_from_json,
752 Sfixed32,
753 |v| serde_json::json!(v),
754 sfixed32_from_json
755 );
756 repeated_scalar!(
757 repeated_fixed32_to_json,
758 repeated_fixed32_from_json,
759 Fixed32,
760 |v| serde_json::json!(v),
761 fixed32_from_json
762 );
763 repeated_scalar!(
765 repeated_int64_to_json,
766 repeated_int64_from_json,
767 Int64,
768 |v| serde_json::Value::String(alloc::format!("{v}")),
769 int64_from_json
770 );
771 repeated_scalar!(
772 repeated_sint64_to_json,
773 repeated_sint64_from_json,
774 Sint64,
775 |v| serde_json::Value::String(alloc::format!("{v}")),
776 sint64_from_json
777 );
778 repeated_scalar!(
779 repeated_uint64_to_json,
780 repeated_uint64_from_json,
781 Uint64,
782 |v| serde_json::Value::String(alloc::format!("{v}")),
783 uint64_from_json
784 );
785 repeated_scalar!(
786 repeated_sfixed64_to_json,
787 repeated_sfixed64_from_json,
788 Sfixed64,
789 |v| serde_json::Value::String(alloc::format!("{v}")),
790 sfixed64_from_json
791 );
792 repeated_scalar!(
793 repeated_fixed64_to_json,
794 repeated_fixed64_from_json,
795 Fixed64,
796 |v| serde_json::Value::String(alloc::format!("{v}")),
797 fixed64_from_json
798 );
799 repeated_scalar!(
801 repeated_bool_to_json,
802 repeated_bool_from_json,
803 Bool,
804 serde_json::Value::Bool,
805 bool_from_json
806 );
807 repeated_scalar!(
808 repeated_string_to_json,
809 repeated_string_from_json,
810 StringCodec,
811 serde_json::Value::String,
812 string_from_json
813 );
814 repeated_scalar!(
815 repeated_bytes_to_json,
816 repeated_bytes_from_json,
817 BytesCodec,
818 |b| {
819 use base64::Engine;
820 serde_json::Value::String(base64::engine::general_purpose::STANDARD.encode(b))
821 },
822 bytes_from_json
823 );
824 repeated_scalar!(
826 repeated_float_to_json,
827 repeated_float_from_json,
828 Float,
829 f32_to_value,
830 float_from_json
831 );
832 repeated_scalar!(
833 repeated_double_to_json,
834 repeated_double_from_json,
835 Double,
836 f64_to_value,
837 double_from_json
838 );
839
840 pub fn repeated_enum_to_json<E: crate::Enumeration>(
843 n: u32,
844 f: &UnknownFields,
845 ) -> Result<serde_json::Value, String> {
846 let vs = Repeated::<EnumI32>::decode(n, f);
847 Ok(serde_json::Value::Array(
848 vs.into_iter()
849 .map(|i| match E::from_i32(i) {
850 Some(e) => serde_json::Value::String(e.proto_name().into()),
851 None => serde_json::json!(i),
852 })
853 .collect(),
854 ))
855 }
856
857 pub fn repeated_enum_from_json<E: crate::Enumeration>(
859 v: serde_json::Value,
860 n: u32,
861 ) -> Result<Vec<UnknownField>, String> {
862 repeated_from_array(v, n, enum_from_json::<E>)
863 }
864
865 pub fn repeated_null_value_to_json(
867 n: u32,
868 f: &UnknownFields,
869 ) -> Result<serde_json::Value, String> {
870 let values = Repeated::<EnumI32>::decode(n, f);
871 Ok(serde_json::Value::Array(
872 values
873 .into_iter()
874 .map(|_| serde_json::Value::Null)
875 .collect(),
876 ))
877 }
878
879 pub fn repeated_null_value_from_json(
881 v: serde_json::Value,
882 n: u32,
883 ) -> Result<Vec<UnknownField>, String> {
884 repeated_from_array(v, n, null_value_from_json)
885 }
886
887 pub fn repeated_message_to_json<M>(
890 n: u32,
891 f: &UnknownFields,
892 ) -> Result<serde_json::Value, String>
893 where
894 M: crate::Message + Default + serde::Serialize,
895 {
896 let ms = Repeated::<MessageCodec<M>>::decode(n, f);
897 let mut arr = Vec::with_capacity(ms.len());
898 for m in ms {
899 arr.push(serde_json::to_value(&m).map_err(|e| alloc::format!("field {n}: {e}"))?);
900 }
901 Ok(serde_json::Value::Array(arr))
902 }
903
904 pub fn repeated_message_from_json<M>(
906 v: serde_json::Value,
907 n: u32,
908 ) -> Result<Vec<UnknownField>, String>
909 where
910 M: crate::Message + Default + for<'de> serde::Deserialize<'de>,
911 {
912 repeated_from_array(v, n, message_from_json::<M>)
913 }
914}
915
916#[cfg(test)]
919mod tests {
920 #![allow(deprecated)]
921
922 use super::helpers::*;
923 use super::*;
924 use crate::unknown_fields::{UnknownField, UnknownFieldData};
925 use alloc::vec;
926
927 fn fields_with(uf: UnknownField) -> UnknownFields {
928 let mut f = UnknownFields::new();
929 f.push(uf);
930 f
931 }
932
933 macro_rules! entry {
935 ($num:expr, $name:expr, $ext:expr) => {
936 JsonExtEntry {
937 number: $num,
938 full_name: $name,
939 extendee: $ext,
940 to_json: int32_to_json,
941 from_json: int32_from_json,
942 }
943 };
944 }
945
946 #[test]
947 fn int32_roundtrip() {
948 let f = fields_with(UnknownField {
949 number: 1,
950 data: UnknownFieldData::Varint(42),
951 });
952 let json = int32_to_json(1, &f).unwrap();
953 assert_eq!(json, serde_json::json!(42));
954 let back = int32_from_json(json, 1).unwrap();
955 assert_eq!(back.len(), 1);
956 assert_eq!(back[0].data, UnknownFieldData::Varint(42));
957 }
958
959 #[test]
960 fn int32_from_string() {
961 let back = int32_from_json(serde_json::json!("42"), 1).unwrap();
963 assert_eq!(back[0].data, UnknownFieldData::Varint(42));
964 }
965
966 #[test]
967 fn int32_negative_sign_extends() {
968 let f = fields_with(UnknownField {
969 number: 1,
970 data: UnknownFieldData::Varint((-7_i64) as u64),
971 });
972 let json = int32_to_json(1, &f).unwrap();
973 assert_eq!(json, serde_json::json!(-7));
974 let back = int32_from_json(json, 1).unwrap();
975 assert_eq!(back[0].data, UnknownFieldData::Varint((-7_i64) as u64));
976 }
977
978 #[test]
979 fn int64_stringifies() {
980 let f = fields_with(UnknownField {
981 number: 1,
982 data: UnknownFieldData::Varint(9_999_999_999),
983 });
984 let json = int64_to_json(1, &f).unwrap();
985 assert_eq!(json, serde_json::json!("9999999999"));
986 let back = int64_from_json(json, 1).unwrap();
987 assert_eq!(back[0].data, UnknownFieldData::Varint(9_999_999_999));
988 }
989
990 #[test]
991 fn integer_extensions_accept_protojson_decimal_and_exponent_forms() {
992 type FromJson =
993 fn(serde_json::Value, u32) -> Result<Vec<UnknownField>, alloc::string::String>;
994
995 let cases: [(FromJson, serde_json::Value, UnknownFieldData); 10] = [
996 (
997 int32_from_json,
998 serde_json::json!(1.0),
999 UnknownFieldData::Varint(1),
1000 ),
1001 (
1002 sint32_from_json,
1003 serde_json::json!("1.5e3"),
1004 UnknownFieldData::Varint(crate::types::zigzag_encode_i32(1_500) as u64),
1005 ),
1006 (
1007 uint32_from_json,
1008 serde_json::json!("1200e-2"),
1009 UnknownFieldData::Varint(12),
1010 ),
1011 (
1012 sfixed32_from_json,
1013 serde_json::json!("-1.5e3"),
1014 UnknownFieldData::Fixed32((-1_500_i32) as u32),
1015 ),
1016 (
1017 fixed32_from_json,
1018 serde_json::json!("1200e-2"),
1019 UnknownFieldData::Fixed32(12),
1020 ),
1021 (
1022 int64_from_json,
1023 serde_json::json!("9007199254740993.0"),
1024 UnknownFieldData::Varint(9_007_199_254_740_993),
1025 ),
1026 (
1027 sint64_from_json,
1028 serde_json::json!("-9007199254740993.0"),
1029 UnknownFieldData::Varint(crate::types::zigzag_encode_i64(-9_007_199_254_740_993)),
1030 ),
1031 (
1032 uint64_from_json,
1033 serde_json::json!("18446744073709551615.0"),
1034 UnknownFieldData::Varint(u64::MAX),
1035 ),
1036 (
1037 sfixed64_from_json,
1038 serde_json::json!("-9007199254740993.0"),
1039 UnknownFieldData::Fixed64((-9_007_199_254_740_993_i64) as u64),
1040 ),
1041 (
1042 fixed64_from_json,
1043 serde_json::json!("18446744073709551615.0"),
1044 UnknownFieldData::Fixed64(u64::MAX),
1045 ),
1046 ];
1047
1048 for (decode, json, expected) in cases {
1049 let fields = decode(json, 1).unwrap();
1050 assert_eq!(fields[0].data, expected);
1051 }
1052
1053 let repeated =
1054 repeated_int64_from_json(serde_json::json!(["1.5e3", "9007199254740993.0"]), 1)
1055 .unwrap();
1056 assert_eq!(repeated[0].data, UnknownFieldData::Varint(1_500));
1057 assert_eq!(
1058 repeated[1].data,
1059 UnknownFieldData::Varint(9_007_199_254_740_993)
1060 );
1061 }
1062
1063 #[test]
1064 fn integer_extensions_reject_unsafe_unquoted_float_forms() {
1065 for decode in [int64_from_json as fn(_, _) -> _, uint64_from_json] {
1066 assert!(decode(serde_json::json!(4_503_599_627_370_496.0), 1).is_err());
1067 }
1068 assert!(int32_from_json(serde_json::Value::Null, 1).is_err());
1071 }
1072
1073 #[test]
1074 fn sint32_zigzag_roundtrip() {
1075 let f = fields_with(UnknownField {
1077 number: 1,
1078 data: UnknownFieldData::Varint(1),
1079 });
1080 let json = sint32_to_json(1, &f).unwrap();
1081 assert_eq!(json, serde_json::json!(-1));
1082 let back = sint32_from_json(json, 1).unwrap();
1083 assert_eq!(back[0].data, UnknownFieldData::Varint(1));
1084 }
1085
1086 #[test]
1087 fn bool_roundtrip() {
1088 let f = fields_with(UnknownField {
1089 number: 1,
1090 data: UnknownFieldData::Varint(1),
1091 });
1092 assert_eq!(bool_to_json(1, &f).unwrap(), serde_json::json!(true));
1093 let back = bool_from_json(serde_json::json!(false), 1).unwrap();
1094 assert_eq!(back[0].data, UnknownFieldData::Varint(0));
1095 }
1096
1097 #[test]
1098 fn string_roundtrip() {
1099 let f = fields_with(UnknownField {
1100 number: 1,
1101 data: UnknownFieldData::LengthDelimited(b"hello".to_vec()),
1102 });
1103 assert_eq!(string_to_json(1, &f).unwrap(), serde_json::json!("hello"));
1104 let back = string_from_json(serde_json::json!("world"), 1).unwrap();
1105 assert_eq!(
1106 back[0].data,
1107 UnknownFieldData::LengthDelimited(b"world".to_vec())
1108 );
1109 }
1110
1111 #[test]
1112 fn string_to_json_reports_an_invalid_last_record_as_missing() {
1113 let mut f = fields_with(UnknownField {
1114 number: 1,
1115 data: UnknownFieldData::LengthDelimited(b"earlier".to_vec()),
1116 });
1117 f.push(UnknownField {
1118 number: 1,
1119 data: UnknownFieldData::LengthDelimited(vec![0xFF]),
1120 });
1121 assert_eq!(
1122 string_to_json(1, &f).unwrap_err(),
1123 "extension field 1: no value present"
1124 );
1125 }
1126
1127 #[test]
1128 fn bytes_base64_roundtrip() {
1129 let f = fields_with(UnknownField {
1130 number: 1,
1131 data: UnknownFieldData::LengthDelimited(vec![0xDE, 0xAD, 0xBE, 0xEF]),
1132 });
1133 let json = bytes_to_json(1, &f).unwrap();
1134 assert_eq!(json, serde_json::json!("3q2+7w=="));
1135 let back = bytes_from_json(json, 1).unwrap();
1136 assert_eq!(
1137 back[0].data,
1138 UnknownFieldData::LengthDelimited(vec![0xDE, 0xAD, 0xBE, 0xEF])
1139 );
1140 }
1141
1142 #[test]
1143 fn bytes_from_json_matches_protojson_base64_policy() {
1144 let variants = ["+w==", "+w", "-w==", "-w", "-_==", "-_"];
1145 for encoded in variants {
1146 let back = bytes_from_json(serde_json::json!(encoded), 1).unwrap();
1147 assert_eq!(
1148 back[0].data,
1149 UnknownFieldData::LengthDelimited(vec![0xFB]),
1150 "input: {encoded}"
1151 );
1152 }
1153
1154 let repeated = repeated_bytes_from_json(serde_json::json!(variants), 1).unwrap();
1155 assert_eq!(repeated.len(), variants.len());
1156 for (field, encoded) in repeated.iter().zip(variants) {
1157 assert_eq!(
1158 field.data,
1159 UnknownFieldData::LengthDelimited(vec![0xFB]),
1160 "input: {encoded}"
1161 );
1162 }
1163 }
1164
1165 #[test]
1166 fn float_special_values() {
1167 for (bits, expected) in [
1168 (f32::NAN.to_bits(), "NaN"),
1169 (f32::INFINITY.to_bits(), "Infinity"),
1170 (f32::NEG_INFINITY.to_bits(), "-Infinity"),
1171 ] {
1172 let f = fields_with(UnknownField {
1173 number: 1,
1174 data: UnknownFieldData::Fixed32(bits),
1175 });
1176 assert_eq!(float_to_json(1, &f).unwrap(), serde_json::json!(expected));
1177 }
1178 let back = float_from_json(serde_json::json!("NaN"), 1).unwrap();
1179 let UnknownFieldData::Fixed32(b) = back[0].data else {
1180 panic!()
1181 };
1182 assert!(f32::from_bits(b).is_nan());
1183 }
1184
1185 #[test]
1186 fn float_and_double_from_json_reject_out_of_range() {
1187 use serde_json::json;
1188 for v in [
1191 json!("3.5e38"),
1192 json!(3.5e38),
1193 json!("-3.5e38"),
1194 json!("1e400"),
1195 json!("inf"),
1196 json!("nan"),
1197 ] {
1198 let err = float_from_json(v.clone(), 7).unwrap_err();
1199 assert!(err.starts_with("field 7: "), "float {v}: {err}");
1200 }
1201 for v in [
1202 json!("1e400"),
1203 json!("-1e400"),
1204 json!("1.8e308"),
1205 json!("-INF"),
1206 json!("nan"),
1207 ] {
1208 let err = double_from_json(v.clone(), 7).unwrap_err();
1209 assert!(err.starts_with("field 7: "), "double {v}: {err}");
1210 }
1211 assert!(repeated_float_from_json(json!(["1.5", "3.5e38"]), 7).is_err());
1212 assert!(repeated_double_from_json(json!(["1.5", "1e400"]), 7).is_err());
1213
1214 let fixed32 = |v| match float_from_json(v, 1).unwrap()[0].data {
1215 UnknownFieldData::Fixed32(b) => f32::from_bits(b),
1216 _ => panic!("expected fixed32"),
1217 };
1218 assert_eq!(fixed32(json!("3.4028235e38")), f32::MAX);
1219 assert_eq!(fixed32(json!(-3.4028235e38_f64)), -f32::MAX);
1220 assert_eq!(fixed32(json!(1.5)), 1.5);
1221 assert_eq!(fixed32(json!(-7)), -7.0);
1222 assert_eq!(fixed32(json!("Infinity")), f32::INFINITY);
1223 let fixed64 = |v| match double_from_json(v, 1).unwrap()[0].data {
1224 UnknownFieldData::Fixed64(b) => f64::from_bits(b),
1225 _ => panic!("expected fixed64"),
1226 };
1227 assert_eq!(fixed64(json!("1.7976931348623157e308")), f64::MAX);
1228 assert_eq!(fixed64(json!("-Infinity")), f64::NEG_INFINITY);
1229 assert!(double_from_json(json!(true), 1).is_err());
1230 }
1231
1232 #[test]
1233 fn registry_lookup_both_axes() {
1234 let mut reg = ExtensionRegistry::new();
1235 reg.register(entry!(120, "pkg.ext", "pkg.Msg"));
1236 assert!(reg.by_number("pkg.Msg", 120).is_some());
1237 assert!(reg.by_number("pkg.Msg", 999).is_none());
1238 assert!(reg.by_number("other.Msg", 120).is_none());
1239 assert_eq!(reg.by_name("pkg.ext").unwrap().number, 120);
1240 assert!(reg.by_name("pkg.nonexistent").is_none());
1241 }
1242
1243 #[test]
1244 fn registry_replacement_evicts_both_conflicting_entries() {
1245 let mut reg = ExtensionRegistry::new();
1246 reg.register(entry!(120, "pkg.old", "pkg.Msg"));
1247 reg.register(entry!(121, "pkg.new", "pkg.Msg"));
1248 reg.register(entry!(120, "pkg.new", "pkg.Msg"));
1249
1250 assert!(reg.by_name("pkg.old").is_none());
1251 assert_eq!(reg.by_name("pkg.new").unwrap().number, 120);
1252 assert_eq!(reg.by_number("pkg.Msg", 120).unwrap().full_name, "pkg.new");
1253 assert!(reg.by_number("pkg.Msg", 121).is_none());
1254 }
1255
1256 #[test]
1257 fn registry_keys_the_same_number_per_extendee() {
1258 let mut reg = ExtensionRegistry::new();
1259 reg.register(entry!(120, "pkg.ext", "pkg.Msg"));
1260 reg.register(entry!(120, "other.ext", "other.Msg"));
1261
1262 assert_eq!(reg.by_number("pkg.Msg", 120).unwrap().full_name, "pkg.ext");
1264 assert_eq!(
1265 reg.by_number("other.Msg", 120).unwrap().full_name,
1266 "other.ext"
1267 );
1268
1269 reg.register(entry!(7, "pkg.ext", "other.Msg"));
1272 assert!(reg.by_number("pkg.Msg", 120).is_none());
1273 assert_eq!(reg.by_number("other.Msg", 7).unwrap().full_name, "pkg.ext");
1274 assert_eq!(reg.by_name("pkg.ext").unwrap().extendee, "other.Msg");
1275 }
1276
1277 #[test]
1278 fn deserialize_extension_key_shapes() {
1279 let _guard = crate::test_doubles::REGISTRY_TEST_LOCK.lock().unwrap();
1280 let mut reg = ExtensionRegistry::new();
1281 reg.register(entry!(120, "pkg.ext", "pkg.Msg"));
1282 set_extension_registry(Box::new(reg));
1283
1284 assert!(
1286 deserialize_extension_key("pkg.Msg", "regular_key", serde_json::json!(1)).is_none()
1287 );
1288 let result =
1290 deserialize_extension_key("pkg.Msg", "[pkg.ext]", serde_json::json!(42)).unwrap();
1291 assert_eq!(result.unwrap()[0].data, UnknownFieldData::Varint(42));
1292 let result =
1294 deserialize_extension_key("other.Msg", "[pkg.ext]", serde_json::json!(1)).unwrap();
1295 assert!(result.is_err());
1296 assert!(
1300 deserialize_extension_key("pkg.Msg", "[pkg.missing]", serde_json::json!(1)).is_none()
1301 );
1302 }
1303
1304 #[test]
1305 #[cfg(feature = "std")]
1306 fn deserialize_extension_key_strict_mode() {
1307 use crate::json::{with_json_parse_options, JsonParseOptions};
1308
1309 let _guard = crate::test_doubles::REGISTRY_TEST_LOCK.lock().unwrap();
1310 let mut reg = ExtensionRegistry::new();
1312 reg.register(entry!(120, "pkg.ext", "pkg.Msg"));
1313 set_extension_registry(Box::new(reg));
1314
1315 let strict = JsonParseOptions::new().strict_extension_keys(true);
1316
1317 with_json_parse_options(&strict, || {
1318 let result =
1320 deserialize_extension_key("pkg.Msg", "[pkg.missing]", serde_json::json!(1));
1321 let err = result.expect("Some in strict mode").unwrap_err();
1322 assert!(err.contains("not in registry"), "{err}");
1323
1324 assert!(
1327 deserialize_extension_key("pkg.Msg", "plain_key", serde_json::json!(1)).is_none()
1328 );
1329
1330 let result = deserialize_extension_key("pkg.Msg", "[pkg.ext]", serde_json::json!(42));
1332 assert_eq!(
1333 result.unwrap().unwrap()[0].data,
1334 UnknownFieldData::Varint(42)
1335 );
1336 });
1337
1338 assert!(
1340 deserialize_extension_key("pkg.Msg", "[pkg.missing]", serde_json::json!(1)).is_none()
1341 );
1342 }
1343
1344 #[test]
1345 fn deserialize_extensions_reads_serde_jsons_private_key_as_data() {
1346 let _guard = crate::test_doubles::REGISTRY_TEST_LOCK.lock().unwrap();
1347 set_extension_registry(Box::default());
1349
1350 let deep = alloc::format!("{}0{}", "[".repeat(200), "]".repeat(200));
1354 let hidden = serde_json::json!({ "$serde_json::private::RawValue": deep });
1355 let json = serde_json::json!({ "[pkg.not_registered]": hidden }).to_string();
1356 let mut d = serde_json::Deserializer::from_str(&json);
1357 let fields = deserialize_extensions("pkg.Msg", &mut d).expect("the key is data");
1358 assert!(fields.is_empty());
1359 }
1360
1361 #[test]
1362 fn serialize_extensions_via_registry() {
1363 let _guard = crate::test_doubles::REGISTRY_TEST_LOCK.lock().unwrap();
1364 let mut reg = ExtensionRegistry::new();
1365 reg.register(entry!(50, "pkg.weight", "pkg.Carrier"));
1366 set_extension_registry(Box::new(reg));
1367
1368 let mut fields = UnknownFields::new();
1369 fields.push(UnknownField {
1370 number: 50,
1371 data: UnknownFieldData::Varint(7),
1372 });
1373 fields.push(UnknownField {
1375 number: 99,
1376 data: UnknownFieldData::Varint(0),
1377 });
1378
1379 let json = serde_json::to_value(SerWrap {
1380 extendee: "pkg.Carrier",
1381 fields: &fields,
1382 })
1383 .unwrap();
1384 assert_eq!(json, serde_json::json!({"[pkg.weight]": 7}));
1385 }
1386
1387 #[test]
1388 fn serialize_extensions_deduplicates_field_numbers() {
1389 let _guard = crate::test_doubles::REGISTRY_TEST_LOCK.lock().unwrap();
1390 let mut reg = ExtensionRegistry::new();
1391 reg.register(entry!(50, "pkg.weight", "pkg.Carrier"));
1392 set_extension_registry(Box::new(reg));
1393
1394 let mut fields = UnknownFields::new();
1395 for number in 100..140 {
1396 fields.push(UnknownField {
1397 number,
1398 data: UnknownFieldData::Varint(u64::from(number)),
1399 });
1400 }
1401 fields.push(UnknownField {
1402 number: 50,
1403 data: UnknownFieldData::Varint(7),
1404 });
1405 fields.push(UnknownField {
1406 number: 50,
1407 data: UnknownFieldData::Varint(9),
1408 });
1409
1410 let json = serde_json::to_value(SerWrap {
1411 extendee: "pkg.Carrier",
1412 fields: &fields,
1413 })
1414 .unwrap();
1415 assert_eq!(json, serde_json::json!({"[pkg.weight]": 9}));
1416 }
1417
1418 struct SerWrap<'a> {
1420 extendee: &'static str,
1421 fields: &'a UnknownFields,
1422 }
1423 impl serde::Serialize for SerWrap<'_> {
1424 fn serialize<S: serde::Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
1425 serialize_extensions(self.extendee, self.fields, s)
1426 }
1427 }
1428
1429 #[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)]
1432 enum Color {
1433 Red = 0,
1434 Green = 1,
1435 Blue = 2,
1436 }
1437 impl crate::Enumeration for Color {
1438 fn from_i32(v: i32) -> Option<Self> {
1439 match v {
1440 0 => Some(Color::Red),
1441 1 => Some(Color::Green),
1442 2 => Some(Color::Blue),
1443 _ => None,
1444 }
1445 }
1446 fn to_i32(&self) -> i32 {
1447 *self as i32
1448 }
1449 fn proto_name(&self) -> &'static str {
1450 match self {
1451 Color::Red => "RED",
1452 Color::Green => "GREEN",
1453 Color::Blue => "BLUE",
1454 }
1455 }
1456 fn from_proto_name(name: &str) -> Option<Self> {
1457 match name {
1458 "RED" => Some(Color::Red),
1459 "GREEN" => Some(Color::Green),
1460 "BLUE" => Some(Color::Blue),
1461 _ => None,
1462 }
1463 }
1464 }
1465
1466 #[test]
1467 fn enum_to_json_known_variant_emits_name() {
1468 let f = fields_with(UnknownField {
1469 number: 1,
1470 data: UnknownFieldData::Varint(1), });
1472 assert_eq!(
1473 enum_to_json::<Color>(1, &f).unwrap(),
1474 serde_json::json!("GREEN")
1475 );
1476 }
1477
1478 #[test]
1479 fn enum_to_json_unknown_falls_back_to_numeric() {
1480 let f = fields_with(UnknownField {
1481 number: 1,
1482 data: UnknownFieldData::Varint(99),
1483 });
1484 assert_eq!(enum_to_json::<Color>(1, &f).unwrap(), serde_json::json!(99));
1485 }
1486
1487 #[test]
1488 fn enum_from_json_accepts_name_and_number() {
1489 let by_name = enum_from_json::<Color>(serde_json::json!("BLUE"), 1).unwrap();
1490 assert_eq!(by_name[0].data, UnknownFieldData::Varint(2));
1491 let by_num = enum_from_json::<Color>(serde_json::json!(1), 1).unwrap();
1492 assert_eq!(by_num[0].data, UnknownFieldData::Varint(1));
1493 }
1494
1495 #[test]
1496 fn enum_from_json_unknown_name_errors() {
1497 let err = enum_from_json::<Color>(serde_json::json!("PURPLE"), 1).unwrap_err();
1498 assert_eq!(err, "field 1: unknown enum name");
1499 assert!(!err.contains("PURPLE"), "{err}");
1500 }
1501
1502 #[test]
1503 fn null_value_helpers_roundtrip_and_accept_enum_forms() {
1504 let fields = fields_with(UnknownField {
1505 number: 5,
1506 data: UnknownFieldData::Varint(0),
1507 });
1508 assert_eq!(
1509 null_value_to_json(5, &fields).unwrap(),
1510 serde_json::Value::Null
1511 );
1512
1513 for value in [
1514 serde_json::Value::Null,
1515 serde_json::json!("NULL_VALUE"),
1516 serde_json::json!(0),
1517 ] {
1518 let records = null_value_from_json(value, 5).unwrap();
1519 assert_eq!(records.len(), 1);
1520 assert_eq!(records[0].data, UnknownFieldData::Varint(0));
1521 }
1522 assert!(null_value_from_json(serde_json::json!(1), 5).is_err());
1523 }
1524
1525 fn fields_from(records: Vec<UnknownField>) -> UnknownFields {
1528 let mut f = UnknownFields::new();
1529 for r in records {
1530 f.push(r);
1531 }
1532 f
1533 }
1534
1535 #[test]
1536 fn repeated_int32_roundtrip() {
1537 let json = serde_json::json!([1, -2, 3]);
1538 let records = repeated_int32_from_json(json.clone(), 5).unwrap();
1539 assert_eq!(records.len(), 3);
1540 let f = fields_from(records);
1541 assert_eq!(repeated_int32_to_json(5, &f).unwrap(), json);
1542 }
1543
1544 #[test]
1545 fn repeated_int64_stringifies_elements() {
1546 let records = repeated_int64_from_json(serde_json::json!(["7", 8]), 5).unwrap();
1547 let f = fields_from(records);
1548 assert_eq!(
1550 repeated_int64_to_json(5, &f).unwrap(),
1551 serde_json::json!(["7", "8"])
1552 );
1553 }
1554
1555 #[test]
1556 fn repeated_string_roundtrip() {
1557 let json = serde_json::json!(["a", "b", "c"]);
1558 let records = repeated_string_from_json(json.clone(), 5).unwrap();
1559 let f = fields_from(records);
1560 assert_eq!(repeated_string_to_json(5, &f).unwrap(), json);
1561 }
1562
1563 #[test]
1564 fn repeated_from_json_rejects_non_array() {
1565 let err = repeated_int32_from_json(serde_json::json!(42), 5).unwrap_err();
1566 assert!(err.contains("expected array"), "{err}");
1567 }
1568
1569 #[test]
1570 fn repeated_enum_roundtrip() {
1571 let json = serde_json::json!(["RED", "BLUE"]);
1572 let records = repeated_enum_from_json::<Color>(json.clone(), 5).unwrap();
1573 assert_eq!(records.len(), 2);
1574 let f = fields_from(records);
1575 assert_eq!(repeated_enum_to_json::<Color>(5, &f).unwrap(), json);
1576 }
1577
1578 #[test]
1579 fn repeated_null_value_helpers_roundtrip() {
1580 let json = serde_json::json!([null, null]);
1581 let records = repeated_null_value_from_json(json.clone(), 5).unwrap();
1582 assert_eq!(records.len(), 2);
1583 assert!(records
1584 .iter()
1585 .all(|record| record.data == UnknownFieldData::Varint(0)));
1586
1587 let fields = fields_from(records);
1588 assert_eq!(repeated_null_value_to_json(5, &fields).unwrap(), json);
1589 }
1590
1591 #[test]
1592 fn repeated_to_json_empty_when_no_records() {
1593 let f = UnknownFields::new();
1595 assert_eq!(
1596 repeated_int32_to_json(5, &f).unwrap(),
1597 serde_json::json!([])
1598 );
1599 }
1600
1601 #[test]
1602 fn enum_helpers_satisfy_fn_pointer_signature() {
1603 let _: fn(u32, &UnknownFields) -> Result<serde_json::Value, String> = enum_to_json::<Color>;
1606 let _: fn(serde_json::Value, u32) -> Result<Vec<UnknownField>, String> =
1607 enum_from_json::<Color>;
1608 let _: fn(u32, &UnknownFields) -> Result<serde_json::Value, String> =
1609 repeated_enum_to_json::<Color>;
1610 }
1611}