1use core::marker::PhantomData;
79
80use crate::error::EncodeError;
81use crate::unknown_fields::UnknownFields;
82
83#[derive(Debug)]
94pub struct Extension<C: ExtensionCodec> {
95 number: u32,
96 extendee: &'static str,
104 default: Option<fn() -> C::Value>,
105 _codec: PhantomData<fn() -> C>,
106}
107
108impl<C: ExtensionCodec> Extension<C> {
109 #[track_caller]
152 pub const fn new(number: u32, extendee: &'static str) -> Self {
153 assert_valid_extension_field_number(number);
154 Self {
155 number,
156 extendee,
157 default: None,
158 _codec: PhantomData,
159 }
160 }
161
162 #[track_caller]
178 pub const fn with_default(
179 number: u32,
180 extendee: &'static str,
181 default: fn() -> C::Value,
182 ) -> Self {
183 assert_valid_extension_field_number(number);
184 Self {
185 number,
186 extendee,
187 default: Some(default),
188 _codec: PhantomData,
189 }
190 }
191
192 pub const fn number(&self) -> u32 {
194 self.number
195 }
196
197 pub const fn extendee(&self) -> &'static str {
199 self.extendee
200 }
201}
202
203#[track_caller]
210const fn assert_valid_extension_field_number(number: u32) {
211 assert!(number != 0, "extension field number must not be 0");
212 assert!(
213 number <= crate::message_set::MAX_TYPE_ID,
214 "extension field number must be at most i32::MAX"
215 );
216}
217
218#[track_caller]
227#[inline]
228fn assert_extendee<C: ExtensionCodec>(ext: &Extension<C>, expected: &'static str) {
229 assert_eq!(
230 ext.extendee, expected,
231 "extension at field {} extends `{}`, not `{}`",
232 ext.number, ext.extendee, expected
233 );
234}
235
236impl<C: ExtensionCodec> Clone for Extension<C> {
240 fn clone(&self) -> Self {
241 *self
242 }
243}
244impl<C: ExtensionCodec> Copy for Extension<C> {}
245
246pub trait ExtensionCodec {
250 type Value;
252 type Output;
254
255 fn decode(number: u32, fields: &UnknownFields) -> Self::Output;
257
258 fn try_encode(
279 number: u32,
280 value: Self::Value,
281 fields: &mut UnknownFields,
282 ) -> Result<(), EncodeError>;
283
284 fn encode(number: u32, value: Self::Value, fields: &mut UnknownFields) {
291 Self::try_encode(number, value, fields)
292 .unwrap_or_else(|_| crate::message::encode_size_overflow())
293 }
294}
295
296pub trait ExtensionSet {
305 const PROTO_FQN: &'static str;
326
327 fn unknown_fields(&self) -> &UnknownFields;
329 fn unknown_fields_mut(&mut self) -> &mut UnknownFields;
331
332 #[track_caller]
367 fn extension<C: ExtensionCodec>(&self, ext: &Extension<C>) -> C::Output {
368 assert_extendee(ext, Self::PROTO_FQN);
369 C::decode(ext.number, self.unknown_fields())
370 }
371
372 #[track_caller]
384 fn set_extension<C: ExtensionCodec>(&mut self, ext: &Extension<C>, value: C::Value) {
385 self.try_set_extension(ext, value)
386 .unwrap_or_else(|_| crate::message::encode_size_overflow())
387 }
388
389 #[track_caller]
408 fn try_set_extension<C: ExtensionCodec>(
409 &mut self,
410 ext: &Extension<C>,
411 value: C::Value,
412 ) -> Result<(), EncodeError> {
413 assert_extendee(ext, Self::PROTO_FQN);
414 let mut staged = UnknownFields::default();
417 C::try_encode(ext.number, value, &mut staged)?;
418 let fields = self.unknown_fields_mut();
419 fields.retain(|f| f.number != ext.number);
420 for f in staged {
421 fields.push(f);
422 }
423 Ok(())
424 }
425
426 fn has_extension<C: ExtensionCodec>(&self, ext: &Extension<C>) -> bool {
434 if ext.extendee != Self::PROTO_FQN {
435 return false;
436 }
437 self.unknown_fields().iter().any(|f| f.number == ext.number)
438 }
439
440 #[track_caller]
446 fn clear_extension<C: ExtensionCodec>(&mut self, ext: &Extension<C>) {
447 assert_extendee(ext, Self::PROTO_FQN);
448 self.unknown_fields_mut().retain(|f| f.number != ext.number);
449 }
450
451 #[must_use]
466 #[track_caller]
467 fn extension_or_default<C>(&self, ext: &Extension<C>) -> C::Value
468 where
469 C: ExtensionCodec<Output = Option<<C as ExtensionCodec>::Value>>,
470 C::Value: Default,
471 {
472 self.extension(ext)
473 .or_else(|| ext.default.map(|f| f()))
474 .unwrap_or_default()
475 }
476}
477
478pub mod codecs {
485 use core::marker::PhantomData;
486
487 use alloc::string::String;
488 use alloc::vec::Vec;
489 use bytes::Buf;
490
491 use crate::encoding::{decode_varint, encode_varint};
492 use crate::message::Message;
493 use crate::types::{
494 zigzag_decode_i32, zigzag_decode_i64, zigzag_encode_i32, zigzag_encode_i64,
495 };
496 use crate::unknown_fields::{UnknownField, UnknownFieldData, UnknownFields};
497
498 use super::ExtensionCodec;
499
500 pub trait SingularCodec {
507 type Value;
508
509 fn decode_one(data: &UnknownFieldData) -> Option<Self::Value>;
514
515 fn decode_one_ctx(
540 data: &UnknownFieldData,
541 _ctx: crate::DecodeContext<'_>,
542 ) -> Option<Self::Value> {
543 Self::decode_one(data)
544 }
545
546 fn decode_packed(bytes: &[u8], out: &mut Vec<Self::Value>);
555
556 fn try_encode_one(value: &Self::Value) -> Result<UnknownFieldData, crate::EncodeError>;
571
572 fn encode_one(value: &Self::Value) -> UnknownFieldData {
579 Self::try_encode_one(value).unwrap_or_else(|_| crate::message::encode_size_overflow())
580 }
581 }
582
583 pub trait PackableCodec: SingularCodec {
589 fn encode_packed(value: &Self::Value, buf: &mut Vec<u8>);
591 }
592
593 macro_rules! varint_codec {
598 ($name:ident, $ty:ty, |$d:ident| $decode:expr, |$e:ident| $encode:expr $(,)?) => {
599 #[doc = concat!("Codec for the `", stringify!($name), "` proto scalar type.")]
600 pub struct $name;
601
602 impl ExtensionCodec for $name {
603 type Value = $ty;
604 type Output = Option<$ty>;
605 fn decode(number: u32, fields: &UnknownFields) -> Option<$ty> {
606 fields
607 .iter()
608 .rev()
609 .filter(|f| f.number == number)
610 .find_map(|f| Self::decode_one(&f.data))
611 }
612 fn try_encode(
613 number: u32,
614 value: $ty,
615 fields: &mut UnknownFields,
616 ) -> Result<(), crate::EncodeError> {
617 fields.push(UnknownField {
618 number,
619 data: Self::try_encode_one(&value)?,
620 });
621 Ok(())
622 }
623 }
624
625 impl SingularCodec for $name {
626 type Value = $ty;
627 fn decode_one(data: &UnknownFieldData) -> Option<$ty> {
628 match *data {
629 UnknownFieldData::Varint($d) => Some($decode),
630 _ => None,
631 }
632 }
633 fn decode_packed(bytes: &[u8], out: &mut Vec<$ty>) {
634 let mut buf = bytes;
635 while buf.has_remaining() {
641 match decode_varint(&mut buf) {
642 Ok($d) => out.push($decode),
643 Err(_) => return,
644 }
645 }
646 }
647 fn try_encode_one($e: &$ty) -> Result<UnknownFieldData, crate::EncodeError> {
648 let $e = *$e;
649 Ok(UnknownFieldData::Varint($encode))
650 }
651 }
652
653 impl PackableCodec for $name {
654 fn encode_packed($e: &$ty, buf: &mut Vec<u8>) {
655 let $e = *$e;
656 encode_varint($encode, buf);
657 }
658 }
659 };
660 }
661
662 varint_codec!(Int32, i32, |v| v as i32, |v| v as i64 as u64);
666 varint_codec!(Int64, i64, |v| v as i64, |v| v as u64);
667 varint_codec!(Uint32, u32, |v| v as u32, |v| v as u64);
668 varint_codec!(Uint64, u64, |v| v, |v| v);
669 varint_codec!(
670 Sint32,
671 i32,
672 |v| zigzag_decode_i32(v as u32),
673 |v| zigzag_encode_i32(v) as u64
674 );
675 varint_codec!(
676 Sint64,
677 i64,
678 |v| zigzag_decode_i64(v),
679 |v| zigzag_encode_i64(v)
680 );
681 varint_codec!(Bool, bool, |v| v != 0, |v| v as u64);
682 pub struct EnumI32;
687 impl ExtensionCodec for EnumI32 {
689 type Value = i32;
690 type Output = Option<i32>;
691 fn decode(number: u32, fields: &UnknownFields) -> Option<i32> {
692 Int32::decode(number, fields)
693 }
694 fn try_encode(
695 number: u32,
696 value: i32,
697 fields: &mut UnknownFields,
698 ) -> Result<(), crate::EncodeError> {
699 Int32::try_encode(number, value, fields)
700 }
701 }
702 impl SingularCodec for EnumI32 {
703 type Value = i32;
704 fn decode_one(data: &UnknownFieldData) -> Option<i32> {
705 Int32::decode_one(data)
706 }
707 fn decode_packed(bytes: &[u8], out: &mut Vec<i32>) {
708 Int32::decode_packed(bytes, out)
709 }
710 fn try_encode_one(value: &i32) -> Result<UnknownFieldData, crate::EncodeError> {
711 Int32::try_encode_one(value)
712 }
713 }
714 impl PackableCodec for EnumI32 {
715 fn encode_packed(value: &i32, buf: &mut Vec<u8>) {
716 Int32::encode_packed(value, buf)
717 }
718 }
719
720 macro_rules! fixed32_codec {
725 ($name:ident, $ty:ty, |$d:ident| $decode:expr, |$e:ident| $encode:expr $(,)?) => {
726 #[doc = concat!("Codec for the `", stringify!($name), "` proto scalar type.")]
727 pub struct $name;
728
729 impl ExtensionCodec for $name {
730 type Value = $ty;
731 type Output = Option<$ty>;
732 fn decode(number: u32, fields: &UnknownFields) -> Option<$ty> {
733 fields
734 .iter()
735 .rev()
736 .filter(|f| f.number == number)
737 .find_map(|f| Self::decode_one(&f.data))
738 }
739 fn try_encode(
740 number: u32,
741 value: $ty,
742 fields: &mut UnknownFields,
743 ) -> Result<(), crate::EncodeError> {
744 fields.push(UnknownField {
745 number,
746 data: Self::try_encode_one(&value)?,
747 });
748 Ok(())
749 }
750 }
751
752 impl SingularCodec for $name {
753 type Value = $ty;
754 fn decode_one(data: &UnknownFieldData) -> Option<$ty> {
755 match *data {
756 UnknownFieldData::Fixed32($d) => Some($decode),
757 _ => None,
758 }
759 }
760 fn decode_packed(bytes: &[u8], out: &mut Vec<$ty>) {
761 let mut buf = bytes;
762 while buf.remaining() >= 4 {
763 let $d = buf.get_u32_le();
764 out.push($decode);
765 }
766 }
767 fn try_encode_one($e: &$ty) -> Result<UnknownFieldData, crate::EncodeError> {
768 let $e = *$e;
769 Ok(UnknownFieldData::Fixed32($encode))
770 }
771 }
772
773 impl PackableCodec for $name {
774 fn encode_packed($e: &$ty, buf: &mut Vec<u8>) {
775 use bytes::BufMut;
776 let $e = *$e;
777 buf.put_u32_le($encode);
778 }
779 }
780 };
781 }
782
783 macro_rules! fixed64_codec {
784 ($name:ident, $ty:ty, |$d:ident| $decode:expr, |$e:ident| $encode:expr $(,)?) => {
785 #[doc = concat!("Codec for the `", stringify!($name), "` proto scalar type.")]
786 pub struct $name;
787
788 impl ExtensionCodec for $name {
789 type Value = $ty;
790 type Output = Option<$ty>;
791 fn decode(number: u32, fields: &UnknownFields) -> Option<$ty> {
792 fields
793 .iter()
794 .rev()
795 .filter(|f| f.number == number)
796 .find_map(|f| Self::decode_one(&f.data))
797 }
798 fn try_encode(
799 number: u32,
800 value: $ty,
801 fields: &mut UnknownFields,
802 ) -> Result<(), crate::EncodeError> {
803 fields.push(UnknownField {
804 number,
805 data: Self::try_encode_one(&value)?,
806 });
807 Ok(())
808 }
809 }
810
811 impl SingularCodec for $name {
812 type Value = $ty;
813 fn decode_one(data: &UnknownFieldData) -> Option<$ty> {
814 match *data {
815 UnknownFieldData::Fixed64($d) => Some($decode),
816 _ => None,
817 }
818 }
819 fn decode_packed(bytes: &[u8], out: &mut Vec<$ty>) {
820 let mut buf = bytes;
821 while buf.remaining() >= 8 {
822 let $d = buf.get_u64_le();
823 out.push($decode);
824 }
825 }
826 fn try_encode_one($e: &$ty) -> Result<UnknownFieldData, crate::EncodeError> {
827 let $e = *$e;
828 Ok(UnknownFieldData::Fixed64($encode))
829 }
830 }
831
832 impl PackableCodec for $name {
833 fn encode_packed($e: &$ty, buf: &mut Vec<u8>) {
834 use bytes::BufMut;
835 let $e = *$e;
836 buf.put_u64_le($encode);
837 }
838 }
839 };
840 }
841
842 fixed32_codec!(Fixed32, u32, |v| v, |v| v);
843 fixed32_codec!(Sfixed32, i32, |v| v as i32, |v| v as u32);
844 fixed32_codec!(Float, f32, |v| f32::from_bits(v), |v| v.to_bits());
845 fixed64_codec!(Fixed64, u64, |v| v, |v| v);
846 fixed64_codec!(Sfixed64, i64, |v| v as i64, |v| v as u64);
847 fixed64_codec!(Double, f64, |v| f64::from_bits(v), |v| v.to_bits());
848
849 pub struct StringCodec;
859
860 impl ExtensionCodec for StringCodec {
861 type Value = String;
862 type Output = Option<String>;
863 fn decode(number: u32, fields: &UnknownFields) -> Option<String> {
864 fields
865 .iter()
866 .rev()
867 .filter(|f| f.number == number)
868 .find(|f| matches!(&f.data, UnknownFieldData::LengthDelimited(_)))
869 .and_then(|f| Self::decode_one(&f.data))
870 }
871 fn try_encode(
872 number: u32,
873 value: String,
874 fields: &mut UnknownFields,
875 ) -> Result<(), crate::EncodeError> {
876 fields.push(UnknownField {
877 number,
878 data: UnknownFieldData::LengthDelimited(value.into_bytes()),
879 });
880 Ok(())
881 }
882 }
883
884 impl SingularCodec for StringCodec {
885 type Value = String;
886 fn decode_one(data: &UnknownFieldData) -> Option<String> {
887 match data {
888 UnknownFieldData::LengthDelimited(bytes) => String::from_utf8(bytes.clone()).ok(),
889 _ => None,
890 }
891 }
892 fn decode_packed(_bytes: &[u8], _out: &mut Vec<String>) {}
893 fn try_encode_one(value: &String) -> Result<UnknownFieldData, crate::EncodeError> {
894 Ok(UnknownFieldData::LengthDelimited(
895 value.clone().into_bytes(),
896 ))
897 }
898 }
899
900 pub struct BytesCodec;
902
903 impl ExtensionCodec for BytesCodec {
904 type Value = Vec<u8>;
905 type Output = Option<Vec<u8>>;
906 fn decode(number: u32, fields: &UnknownFields) -> Option<Vec<u8>> {
907 fields
908 .iter()
909 .rev()
910 .filter(|f| f.number == number)
911 .find_map(|f| Self::decode_one(&f.data))
912 }
913 fn try_encode(
914 number: u32,
915 value: Vec<u8>,
916 fields: &mut UnknownFields,
917 ) -> Result<(), crate::EncodeError> {
918 fields.push(UnknownField {
919 number,
920 data: UnknownFieldData::LengthDelimited(value),
921 });
922 Ok(())
923 }
924 }
925
926 impl SingularCodec for BytesCodec {
927 type Value = Vec<u8>;
928 fn decode_one(data: &UnknownFieldData) -> Option<Vec<u8>> {
929 match data {
930 UnknownFieldData::LengthDelimited(bytes) => Some(bytes.clone()),
931 _ => None,
932 }
933 }
934 fn decode_packed(_bytes: &[u8], _out: &mut Vec<Vec<u8>>) {}
935 fn try_encode_one(value: &Vec<u8>) -> Result<UnknownFieldData, crate::EncodeError> {
936 Ok(UnknownFieldData::LengthDelimited(value.clone()))
937 }
938 }
939
940 pub struct MessageCodec<M>(PhantomData<fn() -> M>);
946
947 impl<M: Message + Default> ExtensionCodec for MessageCodec<M> {
948 type Value = M;
949 type Output = Option<M>;
950 fn decode(number: u32, fields: &UnknownFields) -> Option<M> {
951 let mut msg: Option<M> = None;
952 let (limit, elem) = extension_decode_cells();
953 let ctx = crate::DecodeContext::new(crate::RECURSION_LIMIT, &limit)
954 .with_element_memory(&elem);
955 for f in fields.iter().filter(|f| f.number == number) {
956 if let UnknownFieldData::LengthDelimited(bytes) = &f.data {
957 let m = msg.get_or_insert_with(M::default);
958 if m.merge(&mut &bytes[..], ctx).is_err() {
959 return None;
960 }
961 }
962 }
963 msg
964 }
965 fn try_encode(
966 number: u32,
967 value: M,
968 fields: &mut UnknownFields,
969 ) -> Result<(), crate::EncodeError> {
970 fields.push(UnknownField {
971 number,
972 data: UnknownFieldData::LengthDelimited(value.try_encode_to_vec()?),
973 });
974 Ok(())
975 }
976 }
977
978 impl<M: Message + Default> SingularCodec for MessageCodec<M> {
979 type Value = M;
980 fn decode_one(data: &UnknownFieldData) -> Option<M> {
981 match data {
982 UnknownFieldData::LengthDelimited(bytes) => {
983 let mut m = M::default();
984 m.merge_from_slice(bytes).ok()?;
985 Some(m)
986 }
987 _ => None,
988 }
989 }
990 fn decode_one_ctx(data: &UnknownFieldData, ctx: crate::DecodeContext<'_>) -> Option<M> {
991 match data {
992 UnknownFieldData::LengthDelimited(bytes) => {
993 decode_charged(ctx, |m: &mut M| m.merge(&mut &bytes[..], ctx))
994 }
995 _ => None,
996 }
997 }
998 fn decode_packed(_bytes: &[u8], _out: &mut Vec<M>) {}
999 fn try_encode_one(value: &M) -> Result<UnknownFieldData, crate::EncodeError> {
1000 Ok(UnknownFieldData::LengthDelimited(
1001 value.try_encode_to_vec()?,
1002 ))
1003 }
1004 }
1005
1006 pub struct GroupCodec<M>(PhantomData<fn() -> M>);
1023
1024 impl<M: Message + Default> ExtensionCodec for GroupCodec<M> {
1025 type Value = M;
1026 type Output = Option<M>;
1027 fn decode(number: u32, fields: &UnknownFields) -> Option<M> {
1028 let mut msg: Option<M> = None;
1029 let (limit, elem) = extension_decode_cells();
1030 let ctx = crate::DecodeContext::new(crate::RECURSION_LIMIT, &limit)
1031 .with_element_memory(&elem);
1032 for f in fields.iter().filter(|f| f.number == number) {
1033 if let UnknownFieldData::Group(inner) = &f.data {
1034 let m = msg.get_or_insert_with(M::default);
1035 let mut buf = Vec::with_capacity(inner.encoded_len());
1036 inner.write_to(&mut buf);
1037 if m.merge(&mut &buf[..], ctx).is_err() {
1038 return None;
1039 }
1040 }
1041 }
1042 msg
1043 }
1044 fn try_encode(
1045 number: u32,
1046 value: M,
1047 fields: &mut UnknownFields,
1048 ) -> Result<(), crate::EncodeError> {
1049 let bytes = value.try_encode_to_vec()?;
1050 let inner = UnknownFields::decode_from_slice(&bytes)
1053 .expect("BUG: re-decoding freshly-encoded message bytes failed");
1054 fields.push(UnknownField {
1055 number,
1056 data: UnknownFieldData::Group(inner),
1057 });
1058 Ok(())
1059 }
1060 }
1061
1062 impl<M: Message + Default> SingularCodec for GroupCodec<M> {
1063 type Value = M;
1064 fn decode_one(data: &UnknownFieldData) -> Option<M> {
1065 match data {
1066 UnknownFieldData::Group(inner) => {
1067 let mut buf = Vec::with_capacity(inner.encoded_len());
1068 inner.write_to(&mut buf);
1069 let mut m = M::default();
1070 m.merge_from_slice(&buf).ok()?;
1071 Some(m)
1072 }
1073 _ => None,
1074 }
1075 }
1076 fn decode_one_ctx(data: &UnknownFieldData, ctx: crate::DecodeContext<'_>) -> Option<M> {
1077 match data {
1078 UnknownFieldData::Group(inner) => decode_charged(ctx, |m: &mut M| {
1079 let mut buf = Vec::with_capacity(inner.encoded_len());
1080 inner.write_to(&mut buf);
1081 m.merge(&mut &buf[..], ctx)
1082 }),
1083 _ => None,
1084 }
1085 }
1086 fn decode_packed(_bytes: &[u8], _out: &mut Vec<M>) {}
1089 fn try_encode_one(value: &M) -> Result<UnknownFieldData, crate::EncodeError> {
1090 let bytes = value.try_encode_to_vec()?;
1091 let inner = UnknownFields::decode_from_slice(&bytes)
1093 .expect("BUG: re-decoding freshly-encoded message bytes failed");
1094 Ok(UnknownFieldData::Group(inner))
1095 }
1096 }
1097
1098 pub struct Repeated<C>(PhantomData<fn() -> C>);
1108
1109 impl<C: SingularCodec> ExtensionCodec for Repeated<C> {
1110 type Value = Vec<C::Value>;
1111 type Output = Vec<C::Value>;
1112 fn decode(number: u32, fields: &UnknownFields) -> Vec<C::Value> {
1113 decode_repeated::<C>(number, fields)
1114 }
1115 fn try_encode(
1116 number: u32,
1117 value: Vec<C::Value>,
1118 fields: &mut UnknownFields,
1119 ) -> Result<(), crate::EncodeError> {
1120 for v in &value {
1124 fields.push(UnknownField {
1125 number,
1126 data: C::try_encode_one(v)?,
1127 });
1128 }
1129 Ok(())
1130 }
1131 }
1132
1133 pub struct PackedRepeated<C>(PhantomData<fn() -> C>);
1144
1145 impl<C: PackableCodec> ExtensionCodec for PackedRepeated<C> {
1146 type Value = Vec<C::Value>;
1147 type Output = Vec<C::Value>;
1148 fn decode(number: u32, fields: &UnknownFields) -> Vec<C::Value> {
1149 decode_repeated::<C>(number, fields)
1150 }
1151 fn try_encode(
1152 number: u32,
1153 value: Vec<C::Value>,
1154 fields: &mut UnknownFields,
1155 ) -> Result<(), crate::EncodeError> {
1156 if value.is_empty() {
1157 return Ok(());
1158 }
1159 let mut buf = Vec::new();
1160 for v in &value {
1161 C::encode_packed(v, &mut buf);
1162 }
1163 fields.push(UnknownField {
1164 number,
1165 data: UnknownFieldData::LengthDelimited(buf),
1166 });
1167 Ok(())
1168 }
1169 }
1170
1171 fn extension_decode_cells() -> (core::cell::Cell<usize>, core::cell::Cell<usize>) {
1185 (
1186 core::cell::Cell::new(crate::DEFAULT_UNKNOWN_FIELD_LIMIT),
1187 core::cell::Cell::new(crate::DEFAULT_ELEMENT_MEMORY_LIMIT),
1188 )
1189 }
1190
1191 fn decode_charged<M: Default>(
1203 ctx: crate::DecodeContext<'_>,
1204 merge: impl FnOnce(&mut M) -> Result<(), crate::DecodeError>,
1205 ) -> Option<M> {
1206 let decoded = ctx
1207 .register_element_memory(core::mem::size_of::<M>())
1208 .and_then(|()| {
1209 let mut m = M::default();
1210 merge(&mut m)?;
1211 Ok(m)
1212 });
1213 if matches!(decoded, Err(crate::DecodeError::ElementMemoryLimitExceeded)) {
1214 ctx.exhaust_element_memory();
1215 }
1216 decoded.ok()
1217 }
1218
1219 fn decode_repeated<C: SingularCodec>(number: u32, fields: &UnknownFields) -> Vec<C::Value> {
1221 let (limit, elem) = extension_decode_cells();
1224 let ctx =
1225 crate::DecodeContext::new(crate::RECURSION_LIMIT, &limit).with_element_memory(&elem);
1226 decode_repeated_with_context::<C>(number, fields, ctx)
1227 }
1228
1229 pub(super) fn decode_repeated_with_context<C: SingularCodec>(
1239 number: u32,
1240 fields: &UnknownFields,
1241 ctx: crate::DecodeContext<'_>,
1242 ) -> Vec<C::Value> {
1243 let mut out = Vec::new();
1244 for f in fields.iter().filter(|f| f.number == number) {
1245 if let Some(v) = C::decode_one_ctx(&f.data, ctx) {
1246 out.push(v);
1247 } else if ctx.remaining_element_memory() == Some(0) {
1248 break;
1249 } else if let UnknownFieldData::LengthDelimited(bytes) = &f.data {
1250 C::decode_packed(bytes, &mut out);
1251 }
1252 }
1253 out
1254 }
1255}
1256
1257#[cfg(test)]
1262mod tests {
1263 use super::codecs::*;
1264 use super::*;
1265 use crate::unknown_fields::{UnknownField, UnknownFieldData};
1266 use alloc::string::{String, ToString};
1267 use alloc::{vec, vec::Vec};
1268
1269 const CARRIER: &str = "test.Carrier";
1273
1274 #[derive(Default)]
1275 struct Carrier {
1276 unknown: UnknownFields,
1277 }
1278 impl ExtensionSet for Carrier {
1279 const PROTO_FQN: &'static str = CARRIER;
1280 fn unknown_fields(&self) -> &UnknownFields {
1281 &self.unknown
1282 }
1283 fn unknown_fields_mut(&mut self) -> &mut UnknownFields {
1284 &mut self.unknown
1285 }
1286 }
1287
1288 fn varint(number: u32, v: u64) -> UnknownField {
1289 UnknownField {
1290 number,
1291 data: UnknownFieldData::Varint(v),
1292 }
1293 }
1294 fn fixed32(number: u32, v: u32) -> UnknownField {
1295 UnknownField {
1296 number,
1297 data: UnknownFieldData::Fixed32(v),
1298 }
1299 }
1300 fn fixed64(number: u32, v: u64) -> UnknownField {
1301 UnknownField {
1302 number,
1303 data: UnknownFieldData::Fixed64(v),
1304 }
1305 }
1306 fn ld(number: u32, data: Vec<u8>) -> UnknownField {
1307 UnknownField {
1308 number,
1309 data: UnknownFieldData::LengthDelimited(data),
1310 }
1311 }
1312 fn group(number: u32, inner: UnknownFields) -> UnknownField {
1313 UnknownField {
1314 number,
1315 data: UnknownFieldData::Group(inner),
1316 }
1317 }
1318
1319 #[test]
1322 fn extension_const_fn() {
1323 const EXT: Extension<Int32> = Extension::new(50001, CARRIER);
1324 assert_eq!(EXT.number(), 50001);
1325 assert_eq!(EXT.extendee(), CARRIER);
1326 let copy = EXT; assert_eq!(copy.number(), 50001);
1328 }
1329
1330 #[test]
1331 fn extension_with_default_const_fn() {
1332 const fn seven() -> i32 {
1335 7
1336 }
1337 const E: Extension<Int32> = Extension::with_default(1, CARRIER, seven);
1338 assert_eq!(E.number(), 1);
1339 assert_eq!(E.extendee(), CARRIER);
1340 let copy = E; assert_eq!(copy.number(), 1);
1342 }
1343
1344 #[test]
1345 fn extension_constructors_validate_field_numbers() {
1346 let valid_numbers = [
1347 1,
1348 crate::encoding::FIRST_RESERVED_FIELD_NUMBER,
1349 crate::encoding::LAST_RESERVED_FIELD_NUMBER,
1350 crate::encoding::MAX_FIELD_NUMBER,
1351 crate::encoding::MAX_FIELD_NUMBER + 1,
1352 i32::MAX as u32,
1353 ];
1354 for number in valid_numbers {
1355 assert_eq!(Extension::<Int32>::new(number, CARRIER).number(), number);
1356 assert_eq!(
1357 Extension::<Int32>::with_default(number, CARRIER, || 0).number(),
1358 number
1359 );
1360 }
1361
1362 let invalid_numbers = [0, i32::MAX as u32 + 1, u32::MAX];
1363 for number in invalid_numbers {
1364 assert!(
1365 std::panic::catch_unwind(|| Extension::<Int32>::new(number, CARRIER)).is_err(),
1366 "new accepted field number {number}"
1367 );
1368 assert!(
1369 std::panic::catch_unwind(|| {
1370 Extension::<Int32>::with_default(number, CARRIER, || 0)
1371 })
1372 .is_err(),
1373 "with_default accepted field number {number}"
1374 );
1375 }
1376 }
1377
1378 #[test]
1379 #[should_panic(expected = "extension field number must not be 0")]
1380 fn extension_number_zero_panic_names_the_rule() {
1381 let _ = Extension::<Int32>::new(0, CARRIER);
1382 }
1383
1384 #[test]
1385 #[should_panic(expected = "extension field number must be at most i32::MAX")]
1386 fn extension_number_above_i32_max_panic_names_the_rule() {
1387 let _ = Extension::<Int32>::with_default(i32::MAX as u32 + 1, CARRIER, || 0);
1388 }
1389
1390 #[test]
1395 fn extension_number_above_max_field_number_reads_message_set_item() {
1396 const TYPE_ID: u32 = i32::MAX as u32;
1397 const E: Extension<BytesCodec> = Extension::new(TYPE_ID, CARRIER);
1398 const fn empty() -> Vec<u8> {
1399 Vec::new()
1400 }
1401 const D: Extension<BytesCodec> = Extension::with_default(TYPE_ID, CARRIER, empty);
1402 let mut c = Carrier::default();
1403 c.unknown.push(ld(TYPE_ID, vec![1, 2]));
1404 assert_eq!(c.extension(&E), Some(vec![1, 2]));
1405 assert_eq!(c.extension_or_default(&D), vec![1, 2]);
1406 }
1407
1408 const WRONG: Extension<Int32> = Extension::new(1, "other.Message");
1413
1414 #[test]
1415 #[should_panic(expected = "extends `other.Message`, not `test.Carrier`")]
1416 fn extension_panics_on_extendee_mismatch() {
1417 let c = Carrier::default();
1418 let _ = c.extension(&WRONG);
1419 }
1420
1421 #[test]
1422 #[should_panic(expected = "extends `other.Message`, not `test.Carrier`")]
1423 fn set_extension_panics_on_extendee_mismatch() {
1424 let mut c = Carrier::default();
1425 c.set_extension(&WRONG, 42);
1426 }
1427
1428 #[test]
1429 #[should_panic(expected = "extends `other.Message`, not `test.Carrier`")]
1430 fn clear_extension_panics_on_extendee_mismatch() {
1431 let mut c = Carrier::default();
1432 c.clear_extension(&WRONG);
1433 }
1434
1435 #[test]
1436 #[should_panic(expected = "extends `other.Message`, not `test.Carrier`")]
1437 fn extension_or_default_panics_on_extendee_mismatch() {
1438 let c = Carrier::default();
1440 let _ = c.extension_or_default(&WRONG);
1441 }
1442
1443 #[test]
1444 fn has_extension_returns_false_on_extendee_mismatch() {
1445 let mut c = Carrier::default();
1450 c.unknown.push(varint(1, 42));
1452 assert!(!c.has_extension(&WRONG));
1453 const RIGHT: Extension<Int32> = Extension::new(1, CARRIER);
1455 assert!(c.has_extension(&RIGHT));
1456 }
1457
1458 #[test]
1461 fn extension_or_default_returns_declared_default_when_absent() {
1462 const fn seven() -> i32 {
1463 7
1464 }
1465 const E: Extension<Int32> = Extension::with_default(1, CARRIER, seven);
1466 let c = Carrier::default();
1467 assert_eq!(c.extension(&E), None);
1469 assert!(!c.has_extension(&E));
1470 assert_eq!(c.extension_or_default(&E), 7);
1472 }
1473
1474 #[test]
1475 fn extension_or_default_set_value_wins() {
1476 const fn seven() -> i32 {
1477 7
1478 }
1479 const E: Extension<Int32> = Extension::with_default(1, CARRIER, seven);
1480 let mut c = Carrier::default();
1481 c.set_extension(&E, 99);
1482 assert_eq!(c.extension_or_default(&E), 99);
1484 assert_eq!(c.extension(&E), Some(99));
1485 }
1486
1487 #[test]
1488 fn extension_or_default_falls_back_to_type_default() {
1489 const E: Extension<Int32> = Extension::new(1, CARRIER);
1491 let c = Carrier::default();
1492 assert_eq!(c.extension_or_default(&E), 0);
1493 assert_eq!(c.extension(&E), None);
1494 }
1495
1496 #[test]
1497 fn extension_or_default_string_allocates_per_call() {
1498 fn hello() -> String {
1500 String::from("hello")
1501 }
1502 const E: Extension<StringCodec> = Extension::with_default(1, CARRIER, hello);
1503 let c = Carrier::default();
1504 assert_eq!(c.extension_or_default(&E), "hello");
1505 let a = c.extension_or_default(&E);
1507 let b = c.extension_or_default(&E);
1508 assert_eq!(a, b);
1509 assert_ne!(a.as_ptr(), b.as_ptr());
1510 }
1511
1512 #[test]
1513 fn extension_or_default_bytes() {
1514 fn blob() -> Vec<u8> {
1515 alloc::vec![0xDE, 0xAD]
1516 }
1517 const E: Extension<BytesCodec> = Extension::with_default(1, CARRIER, blob);
1518 let c = Carrier::default();
1519 assert_eq!(c.extension_or_default(&E), alloc::vec![0xDE, 0xAD]);
1520 }
1521
1522 #[test]
1523 fn extension_or_default_zero_is_present_not_default() {
1524 const fn seven() -> i32 {
1526 7
1527 }
1528 const E: Extension<Int32> = Extension::with_default(1, CARRIER, seven);
1529 let mut c = Carrier::default();
1530 c.set_extension(&E, 0);
1531 assert_eq!(c.extension_or_default(&E), 0);
1532 }
1533
1534 #[test]
1537 fn singular_scalar_roundtrip() {
1538 #[rustfmt::skip]
1541 let int32_cases: &[(i32, u64)] = &[
1542 (0, 0),
1543 (42, 42),
1544 (-7, (-7_i64) as u64),
1545 ];
1546 for &(v, wire) in int32_cases {
1547 let mut c = Carrier::default();
1548 const E: Extension<Int32> = Extension::new(1, CARRIER);
1549 c.set_extension(&E, v);
1550 assert_eq!(
1551 c.unknown.iter().next().unwrap().data,
1552 UnknownFieldData::Varint(wire),
1553 "int32 {v}"
1554 );
1555 assert_eq!(c.extension(&E), Some(v), "int32 {v}");
1556 }
1557
1558 #[rustfmt::skip]
1560 let sint32_cases: &[(i32, u64)] = &[
1561 (0, 0),
1562 (-1, 1),
1563 (1, 2),
1564 (-2, 3),
1565 ];
1566 for &(v, wire) in sint32_cases {
1567 let mut c = Carrier::default();
1568 const E: Extension<Sint32> = Extension::new(1, CARRIER);
1569 c.set_extension(&E, v);
1570 assert_eq!(
1571 c.unknown.iter().next().unwrap().data,
1572 UnknownFieldData::Varint(wire),
1573 "sint32 {v}"
1574 );
1575 assert_eq!(c.extension(&E), Some(v), "sint32 {v}");
1576 }
1577
1578 let mut c = Carrier::default();
1580 const SF32: Extension<Sfixed32> = Extension::new(1, CARRIER);
1581 c.set_extension(&SF32, -1);
1582 assert_eq!(
1583 c.unknown.iter().next().unwrap().data,
1584 UnknownFieldData::Fixed32(u32::MAX)
1585 );
1586 assert_eq!(c.extension(&SF32), Some(-1));
1587
1588 const B: Extension<Bool> = Extension::new(1, CARRIER);
1590 let mut c = Carrier::default();
1591 c.unknown.push(varint(1, 7));
1592 assert_eq!(c.extension(&B), Some(true));
1593 let mut c = Carrier::default();
1594 c.set_extension(&B, true);
1595 assert_eq!(
1596 c.unknown.iter().next().unwrap().data,
1597 UnknownFieldData::Varint(1)
1598 );
1599
1600 const F: Extension<Float> = Extension::new(1, CARRIER);
1602 let mut c = Carrier::default();
1603 c.set_extension(&F, 1.5_f32);
1604 assert_eq!(c.extension(&F), Some(1.5_f32));
1605 const D: Extension<Double> = Extension::new(2, CARRIER);
1606 c.set_extension(&D, -0.25_f64);
1607 assert_eq!(c.extension(&D), Some(-0.25_f64));
1608
1609 const U: Extension<Uint32> = Extension::new(1, CARRIER);
1611 let mut c = Carrier::default();
1612 c.unknown.push(varint(1, 0x1_0000_002A)); assert_eq!(c.extension(&U), Some(0x0000_002A));
1614 }
1615
1616 #[test]
1617 fn singular_scalar_last_wins() {
1618 const E: Extension<Int32> = Extension::new(1, CARRIER);
1619 let mut c = Carrier::default();
1620 c.unknown.push(varint(1, 5));
1621 c.unknown.push(varint(1, 7));
1622 assert_eq!(c.extension(&E), Some(7));
1623 }
1624
1625 #[test]
1626 fn singular_scalar_wrong_wire_type_skipped() {
1627 const E: Extension<Int32> = Extension::new(1, CARRIER);
1628 let mut c = Carrier::default();
1629 c.unknown.push(varint(1, 5));
1630 c.unknown.push(ld(1, vec![0x00])); assert_eq!(c.extension(&E), Some(5));
1632
1633 let mut c = Carrier::default();
1635 c.unknown.push(ld(1, vec![0x00]));
1636 assert_eq!(c.extension(&E), None);
1637 }
1638
1639 #[test]
1640 fn singular_absent_returns_none() {
1641 const E: Extension<Int32> = Extension::new(1, CARRIER);
1642 let c = Carrier::default();
1643 assert_eq!(c.extension(&E), None);
1644 let mut c = Carrier::default();
1646 c.unknown.push(varint(2, 5));
1647 assert_eq!(c.extension(&E), None);
1648 }
1649
1650 #[test]
1653 fn explicit_presence_with_zero_value() {
1654 const E: Extension<Int32> = Extension::new(1, CARRIER);
1656 let mut c = Carrier::default();
1657 assert!(!c.has_extension(&E));
1658 c.set_extension(&E, 0);
1659 assert!(c.has_extension(&E));
1660 assert_eq!(c.extension(&E), Some(0));
1661 }
1662
1663 #[test]
1666 fn set_clears_prior_occurrences() {
1667 const E: Extension<Int32> = Extension::new(1, CARRIER);
1668 let mut c = Carrier::default();
1669 c.set_extension(&E, 5);
1670 c.set_extension(&E, 7);
1671 assert_eq!(c.unknown.iter().filter(|f| f.number == 1).count(), 1);
1673 assert_eq!(c.extension(&E), Some(7));
1674 }
1675
1676 #[test]
1677 fn set_preserves_other_fields() {
1678 const E: Extension<Int32> = Extension::new(1, CARRIER);
1679 let mut c = Carrier::default();
1680 c.unknown.push(varint(2, 99));
1681 c.set_extension(&E, 5);
1682 assert_eq!(c.unknown.len(), 2);
1683 assert!(c.unknown.iter().any(|f| f.number == 2));
1685 }
1686
1687 #[test]
1688 fn clear_extension() {
1689 const E: Extension<Int32> = Extension::new(1, CARRIER);
1690 let mut c = Carrier::default();
1691 c.set_extension(&E, 5);
1692 c.unknown.push(varint(2, 99));
1693 c.clear_extension(&E);
1694 assert!(!c.has_extension(&E));
1695 assert_eq!(c.unknown.len(), 1); }
1697
1698 #[test]
1701 fn string_roundtrip() {
1702 const E: Extension<StringCodec> = Extension::new(1, CARRIER);
1703 let mut c = Carrier::default();
1704 c.set_extension(&E, "hello".to_string());
1705 assert_eq!(c.extension(&E), Some("hello".to_string()));
1706 }
1707
1708 #[test]
1709 fn string_invalid_utf8_is_none() {
1710 const E: Extension<StringCodec> = Extension::new(1, CARRIER);
1711 let mut c = Carrier::default();
1712 c.unknown.push(ld(1, vec![0xFF, 0xFE]));
1713 assert_eq!(c.extension(&E), None);
1714 }
1715
1716 #[test]
1717 fn string_invalid_last_record_is_none() {
1718 const E: Extension<StringCodec> = Extension::new(1, CARRIER);
1719 let invalid = [
1720 vec![0xFF],
1721 vec![0x80],
1722 vec![0xC0, 0xAF],
1723 vec![0xC2],
1724 vec![0xE2, 0x82],
1725 vec![0xED, 0xA0, 0x80],
1726 vec![0xF4, 0x90, 0x80, 0x80],
1727 vec![b'a', 0xFF],
1728 ];
1729 for bytes in invalid {
1730 let mut c = Carrier::default();
1731 c.unknown.push(ld(1, b"earlier".to_vec()));
1732 c.unknown.push(ld(1, bytes));
1733 assert_eq!(c.extension(&E), None, "{:?}", c.unknown);
1734 }
1735 }
1736
1737 #[test]
1738 fn string_last_record_wins_over_valid_or_invalid_prior_values() {
1739 const E: Extension<StringCodec> = Extension::new(1, CARRIER);
1740 for prior in [b"earlier".to_vec(), vec![0xFF]] {
1741 for latest in ["latest", "", "\0", "caf\u{e9} \u{1F600}"] {
1742 let mut c = Carrier::default();
1743 c.unknown.push(ld(1, prior.clone()));
1744 c.unknown.push(ld(1, latest.as_bytes().to_vec()));
1745 assert_eq!(c.extension(&E).as_deref(), Some(latest));
1746 }
1747 }
1748 }
1749
1750 #[test]
1751 fn string_last_record_ignores_other_numbers_and_wire_types() {
1752 const E: Extension<StringCodec> = Extension::new(1, CARRIER);
1753 for (latest, expected) in [
1754 (b"latest".to_vec(), Some("latest")),
1755 (Vec::new(), Some("")),
1756 (vec![0xFF], None),
1757 ] {
1758 let mut c = Carrier::default();
1759 c.unknown.push(ld(1, b"earlier".to_vec()));
1760 c.unknown.push(ld(1, latest));
1761 c.unknown.push(ld(2, b"other".to_vec()));
1762 c.unknown.push(varint(1, 42));
1763 c.unknown.push(fixed32(1, 42));
1764 c.unknown.push(fixed64(1, 42));
1765 c.unknown.push(group(1, UnknownFields::new()));
1766 assert_eq!(c.extension(&E).as_deref(), expected);
1767 }
1768 }
1769
1770 #[test]
1771 fn string_invalid_last_record_uses_declared_default() {
1772 const E: Extension<StringCodec> =
1773 Extension::with_default(1, CARRIER, || "fallback".to_string());
1774 let mut c = Carrier::default();
1775 c.unknown.push(ld(1, b"earlier".to_vec()));
1776 c.unknown.push(ld(1, vec![0xFF]));
1777 assert_eq!(c.extension_or_default(&E), "fallback");
1778 }
1779
1780 #[test]
1781 fn string_absent_or_wrong_wire_type_only_is_none() {
1782 const E: Extension<StringCodec> = Extension::new(1, CARRIER);
1783 let mut c = Carrier::default();
1784 assert_eq!(c.extension(&E), None);
1785 c.unknown.push(ld(2, b"other".to_vec()));
1786 c.unknown.push(varint(1, 42));
1787 c.unknown.push(fixed32(1, 42));
1788 c.unknown.push(fixed64(1, 42));
1789 assert_eq!(c.extension(&E), None);
1790 }
1791
1792 #[test]
1793 fn bytes_roundtrip() {
1794 const E: Extension<BytesCodec> = Extension::new(1, CARRIER);
1795 let mut c = Carrier::default();
1796 c.set_extension(&E, vec![0xDE, 0xAD, 0xBE, 0xEF]);
1797 assert_eq!(c.extension(&E), Some(vec![0xDE, 0xAD, 0xBE, 0xEF]));
1798 }
1799
1800 #[test]
1803 fn repeated_scalar_unpacked() {
1804 const E: Extension<Repeated<Int32>> = Extension::new(1, CARRIER);
1805 let mut c = Carrier::default();
1806 c.unknown.push(varint(1, 1));
1807 c.unknown.push(varint(1, 2));
1808 c.unknown.push(varint(1, 3));
1809 assert_eq!(c.extension(&E), vec![1, 2, 3]);
1810 }
1811
1812 #[test]
1813 fn repeated_scalar_packed() {
1814 const E: Extension<Repeated<Int32>> = Extension::new(1, CARRIER);
1816 let mut c = Carrier::default();
1817 c.unknown.push(ld(1, vec![0x01, 0x02, 0xAC, 0x02]));
1818 assert_eq!(c.extension(&E), vec![1, 2, 300]);
1819 }
1820
1821 #[test]
1822 fn repeated_scalar_mixed_packed_unpacked() {
1823 const E: Extension<Repeated<Int32>> = Extension::new(1, CARRIER);
1824 let mut c = Carrier::default();
1825 c.unknown.push(varint(1, 1));
1826 c.unknown.push(ld(1, vec![0x02, 0x03])); c.unknown.push(varint(1, 4));
1828 assert_eq!(c.extension(&E), vec![1, 2, 3, 4]);
1829 }
1830
1831 #[test]
1832 fn repeated_scalar_fixed32_packed() {
1833 const E: Extension<Repeated<Fixed32>> = Extension::new(1, CARRIER);
1835 let mut c = Carrier::default();
1836 c.unknown.push(ld(1, vec![1, 0, 0, 0, 2, 0, 0, 0]));
1837 assert_eq!(c.extension(&E), vec![1_u32, 2_u32]);
1838 }
1839
1840 #[test]
1841 fn repeated_scalar_wrong_wire_type_skipped() {
1842 const E: Extension<Repeated<Int32>> = Extension::new(1, CARRIER);
1843 let mut c = Carrier::default();
1844 c.unknown.push(varint(1, 1));
1845 c.unknown.push(fixed32(1, 0xDEAD)); c.unknown.push(varint(1, 2));
1847 assert_eq!(c.extension(&E), vec![1, 2]);
1848 }
1849
1850 #[test]
1851 fn repeated_scalar_set_roundtrip() {
1852 const E: Extension<Repeated<Sint32>> = Extension::new(1, CARRIER);
1853 let mut c = Carrier::default();
1854 c.set_extension(&E, vec![-1, 0, 1, -100]);
1855 assert_eq!(c.extension(&E), vec![-1, 0, 1, -100]);
1856 assert_eq!(c.unknown.len(), 4);
1858 }
1859
1860 #[test]
1861 fn repeated_string() {
1862 const E: Extension<Repeated<StringCodec>> = Extension::new(1, CARRIER);
1863 let mut c = Carrier::default();
1864 c.set_extension(&E, vec!["a".to_string(), "b".to_string()]);
1865 assert_eq!(c.extension(&E), vec!["a".to_string(), "b".to_string()]);
1866 }
1867
1868 #[test]
1869 fn repeated_string_malformed_element_skipped() {
1870 const E: Extension<Repeated<StringCodec>> = Extension::new(1, CARRIER);
1871 let mut c = Carrier::default();
1872 c.unknown.push(ld(1, b"ok".to_vec()));
1873 c.unknown.push(ld(1, vec![0xFF])); c.unknown.push(ld(1, b"also ok".to_vec()));
1875 assert_eq!(
1878 c.extension(&E),
1879 vec!["ok".to_string(), "also ok".to_string()]
1880 );
1881 }
1882
1883 #[test]
1884 fn repeated_empty_set_not_present() {
1885 const E: Extension<Repeated<Int32>> = Extension::new(1, CARRIER);
1886 let mut c = Carrier::default();
1887 c.set_extension(&E, vec![]);
1888 assert!(!c.has_extension(&E));
1889 assert_eq!(c.extension(&E), Vec::<i32>::new());
1890 }
1891
1892 #[test]
1893 fn packed_repeated_set_twice_one_record() {
1894 const E: Extension<PackedRepeated<Int32>> = Extension::new(1, CARRIER);
1895 let mut c = Carrier::default();
1896 c.set_extension(&E, vec![1, 2]);
1897 c.set_extension(&E, vec![3, 4, 5]);
1898 assert_eq!(c.unknown.len(), 1);
1899 assert_eq!(c.extension(&E), vec![3, 4, 5]);
1900 }
1901
1902 #[test]
1905 fn packed_repeated_encode_one_record() {
1906 const E: Extension<PackedRepeated<Int32>> = Extension::new(1, CARRIER);
1907 let mut c = Carrier::default();
1908 c.set_extension(&E, vec![1, 2, 300]);
1909 assert_eq!(c.unknown.len(), 1);
1911 assert_eq!(
1912 c.unknown.iter().next().unwrap().data,
1913 UnknownFieldData::LengthDelimited(vec![0x01, 0x02, 0xAC, 0x02])
1914 );
1915 assert_eq!(c.extension(&E), vec![1, 2, 300]);
1917 }
1918
1919 #[test]
1920 fn packed_repeated_decode_accepts_unpacked() {
1921 const E: Extension<PackedRepeated<Int32>> = Extension::new(1, CARRIER);
1923 let mut c = Carrier::default();
1924 c.unknown.push(varint(1, 1));
1925 c.unknown.push(varint(1, 2));
1926 assert_eq!(c.extension(&E), vec![1, 2]);
1927 }
1928
1929 #[test]
1930 fn packed_repeated_empty_not_present() {
1931 const E: Extension<PackedRepeated<Int32>> = Extension::new(1, CARRIER);
1932 let mut c = Carrier::default();
1933 c.set_extension(&E, vec![]);
1934 assert!(!c.has_extension(&E));
1935 }
1936
1937 #[test]
1938 fn packed_repeated_fixed64_roundtrip() {
1939 const E: Extension<PackedRepeated<Sfixed64>> = Extension::new(1, CARRIER);
1940 let mut c = Carrier::default();
1941 c.set_extension(&E, vec![-1_i64, 0, i64::MAX]);
1942 assert_eq!(c.unknown.len(), 1);
1943 assert_eq!(c.extension(&E), vec![-1_i64, 0, i64::MAX]);
1944 }
1945
1946 #[derive(Clone, Default, PartialEq, Debug)]
1953 struct TestMsg {
1954 a: i32,
1955 b: i32,
1956 unknown: UnknownFields,
1957 }
1958
1959 impl crate::DefaultInstance for TestMsg {
1960 fn default_instance() -> &'static Self {
1961 static INST: crate::__private::OnceBox<TestMsg> = crate::__private::OnceBox::new();
1962 INST.get_or_init(|| alloc::boxed::Box::new(TestMsg::default()))
1963 }
1964 }
1965
1966 impl crate::Message for TestMsg {
1967 fn compute_size(&self, _cache: &mut crate::SizeCache) -> u32 {
1968 let mut n = 0;
1969 if self.a != 0 {
1970 n += 1 + crate::encoding::varint_len(self.a as i64 as u64);
1971 }
1972 if self.b != 0 {
1973 n += 1 + crate::encoding::varint_len(self.b as i64 as u64);
1974 }
1975 n += self.unknown.encoded_len();
1976 n as u32
1977 }
1978 fn write_to(&self, _cache: &mut crate::SizeCache, buf: &mut impl crate::EncodeSink) {
1979 use crate::encoding::encode_varint;
1980 if self.a != 0 {
1981 encode_varint(1 << 3, buf);
1982 encode_varint(self.a as i64 as u64, buf);
1983 }
1984 if self.b != 0 {
1985 encode_varint(2 << 3, buf);
1986 encode_varint(self.b as i64 as u64, buf);
1987 }
1988 self.unknown.write_to(buf);
1989 }
1990 fn merge_field(
1991 &mut self,
1992 tag: crate::encoding::Tag,
1993 buf: &mut impl bytes::Buf,
1994 _ctx: crate::DecodeContext<'_>,
1995 ) -> Result<(), crate::DecodeError> {
1996 match tag.field_number() {
1997 1 => self.a = crate::types::decode_int32(buf)?,
1998 2 => self.b = crate::types::decode_int32(buf)?,
1999 _ => crate::encoding::skip_field(tag, buf)?,
2000 }
2001 Ok(())
2002 }
2003 fn clear(&mut self) {
2004 *self = Self::default();
2005 }
2006 }
2007
2008 #[test]
2009 fn message_single_record() {
2010 const E: Extension<MessageCodec<TestMsg>> = Extension::new(1, CARRIER);
2011 let mut c = Carrier::default();
2012 c.unknown.push(ld(1, vec![0x08, 0x05]));
2014 let got = c.extension(&E).expect("decoded");
2015 assert_eq!(got.a, 5);
2016 assert_eq!(got.b, 0);
2017 }
2018
2019 #[test]
2020 fn message_split_records_merge() {
2021 const E: Extension<MessageCodec<TestMsg>> = Extension::new(1, CARRIER);
2024 let mut c = Carrier::default();
2025 c.unknown.push(ld(1, vec![0x08, 0x05])); c.unknown.push(ld(1, vec![0x10, 0x07])); let got = c.extension(&E).expect("decoded");
2028 assert_eq!(got.a, 5);
2029 assert_eq!(got.b, 7);
2030 }
2031
2032 #[test]
2033 fn message_absent_is_none() {
2034 const E: Extension<MessageCodec<TestMsg>> = Extension::new(1, CARRIER);
2035 let c = Carrier::default();
2036 assert!(c.extension(&E).is_none());
2037 }
2038
2039 #[test]
2040 fn message_malformed_is_none() {
2041 const E: Extension<MessageCodec<TestMsg>> = Extension::new(1, CARRIER);
2042 let mut c = Carrier::default();
2043 c.unknown.push(ld(1, vec![0x08, 0x80]));
2045 assert!(c.extension(&E).is_none());
2046 }
2047
2048 #[test]
2049 fn message_set_get_roundtrip() {
2050 const E: Extension<MessageCodec<TestMsg>> = Extension::new(1, CARRIER);
2051 let mut c = Carrier::default();
2052 c.set_extension(
2053 &E,
2054 TestMsg {
2055 a: 3,
2056 b: -1,
2057 unknown: UnknownFields::new(),
2058 },
2059 );
2060 let got = c.extension(&E).expect("decoded");
2061 assert_eq!(got.a, 3);
2062 assert_eq!(got.b, -1);
2063 }
2064
2065 #[derive(Debug, Default, Clone, PartialEq)]
2071 struct BudgetMsg {
2072 unknown: UnknownFields,
2073 }
2074
2075 impl crate::DefaultInstance for BudgetMsg {
2076 fn default_instance() -> &'static Self {
2077 static INST: crate::__private::OnceBox<BudgetMsg> = crate::__private::OnceBox::new();
2078 INST.get_or_init(|| alloc::boxed::Box::new(BudgetMsg::default()))
2079 }
2080 }
2081
2082 impl crate::Message for BudgetMsg {
2083 fn compute_size(&self, _cache: &mut crate::SizeCache) -> u32 {
2084 self.unknown.encoded_len() as u32
2085 }
2086 fn write_to(&self, _cache: &mut crate::SizeCache, buf: &mut impl crate::EncodeSink) {
2087 self.unknown.write_to(buf);
2088 }
2089 fn merge_field(
2090 &mut self,
2091 tag: crate::encoding::Tag,
2092 buf: &mut impl bytes::Buf,
2093 ctx: crate::DecodeContext<'_>,
2094 ) -> Result<(), crate::DecodeError> {
2095 self.unknown
2096 .push(crate::encoding::decode_unknown_field(tag, buf, ctx)?);
2097 Ok(())
2098 }
2099 fn clear(&mut self) {
2100 *self = Self::default();
2101 }
2102 }
2103
2104 fn unknowns_payload(n: usize) -> Vec<u8> {
2107 let mut v = Vec::with_capacity(n * 2);
2108 for _ in 0..n {
2109 v.push(9 << 3); v.push(0x00);
2111 }
2112 v
2113 }
2114
2115 #[test]
2121 fn message_extension_records_share_one_budget() {
2122 const E: Extension<MessageCodec<BudgetMsg>> = Extension::new(1, CARRIER);
2123
2124 let per_record = 2 * crate::DEFAULT_UNKNOWN_FIELD_LIMIT / 3;
2127 let mut c = Carrier::default();
2128 c.unknown.push(ld(1, unknowns_payload(per_record)));
2129 c.unknown.push(ld(1, unknowns_payload(per_record)));
2130
2131 assert!(
2132 c.extension(&E).is_none(),
2133 "two records totalling {} unknown fields must exhaust the shared \
2134 {} allowance",
2135 2 * per_record,
2136 crate::DEFAULT_UNKNOWN_FIELD_LIMIT
2137 );
2138
2139 let mut ok = Carrier::default();
2141 ok.unknown.push(ld(1, unknowns_payload(per_record)));
2142 assert!(ok.extension(&E).is_some());
2143 }
2144
2145 #[test]
2148 fn repeated_message_extension_elements_share_one_budget() {
2149 const E: Extension<Repeated<MessageCodec<BudgetMsg>>> = Extension::new(1, CARRIER);
2150
2151 let per_record = 2 * crate::DEFAULT_UNKNOWN_FIELD_LIMIT / 3;
2152 let mut c = Carrier::default();
2153 c.unknown.push(ld(1, unknowns_payload(per_record)));
2154 c.unknown.push(ld(1, unknowns_payload(per_record)));
2155
2156 assert_eq!(
2160 c.extension(&E).len(),
2161 1,
2162 "the second element must not get a fresh allowance"
2163 );
2164 }
2165
2166 #[test]
2167 fn repeated_message_extension_charges_each_output_message() {
2168 let mut fields = UnknownFields::new();
2169 for _ in 0..3 {
2170 fields.push(ld(1, Vec::new()));
2171 }
2172 let unknown_limit = core::cell::Cell::new(crate::DEFAULT_UNKNOWN_FIELD_LIMIT);
2173 let element_limit = core::cell::Cell::new(2 * core::mem::size_of::<TestMsg>());
2174 let ctx = crate::DecodeContext::new(crate::RECURSION_LIMIT, &unknown_limit)
2175 .with_element_memory(&element_limit);
2176
2177 let decoded = decode_repeated_with_context::<MessageCodec<TestMsg>>(1, &fields, ctx);
2178
2179 assert_eq!(decoded.len(), 2);
2180 assert_eq!(element_limit.get(), 0);
2181 }
2182
2183 #[test]
2184 fn repeated_group_extension_charges_each_output_message() {
2185 let mut fields = UnknownFields::new();
2186 for _ in 0..3 {
2187 fields.push(group(1, UnknownFields::new()));
2188 }
2189 let unknown_limit = core::cell::Cell::new(crate::DEFAULT_UNKNOWN_FIELD_LIMIT);
2190 let element_limit = core::cell::Cell::new(2 * core::mem::size_of::<TestMsg>());
2191 let ctx = crate::DecodeContext::new(crate::RECURSION_LIMIT, &unknown_limit)
2192 .with_element_memory(&element_limit);
2193
2194 let decoded = decode_repeated_with_context::<GroupCodec<TestMsg>>(1, &fields, ctx);
2195
2196 assert_eq!(decoded.len(), 2);
2197 assert_eq!(element_limit.get(), 0);
2198 }
2199
2200 #[test]
2202 fn repeated_message_extension_keeps_the_charge_of_a_malformed_element() {
2203 let mut fields = UnknownFields::new();
2204 fields.push(ld(1, vec![0x08, 0x80])); fields.push(ld(1, vec![0x08, 0x03])); let unknown_limit = core::cell::Cell::new(crate::DEFAULT_UNKNOWN_FIELD_LIMIT);
2207 let element_limit = core::cell::Cell::new(2 * core::mem::size_of::<TestMsg>());
2208 let ctx = crate::DecodeContext::new(crate::RECURSION_LIMIT, &unknown_limit)
2209 .with_element_memory(&element_limit);
2210
2211 let decoded = decode_repeated_with_context::<MessageCodec<TestMsg>>(1, &fields, ctx);
2212
2213 assert_eq!(decoded.len(), 1);
2214 assert_eq!(decoded[0].a, 3);
2215 assert_eq!(element_limit.get(), 0);
2216 }
2217
2218 #[test]
2219 fn repeated_group_extension_keeps_the_charge_of_a_malformed_element() {
2220 let mut malformed = UnknownFields::new();
2221 malformed.push(varint(0, 1)); let mut fields = UnknownFields::new();
2223 fields.push(group(1, malformed));
2224 fields.push(group(1, inner_a(3)));
2225 let unknown_limit = core::cell::Cell::new(crate::DEFAULT_UNKNOWN_FIELD_LIMIT);
2226 let element_limit = core::cell::Cell::new(2 * core::mem::size_of::<TestMsg>());
2227 let ctx = crate::DecodeContext::new(crate::RECURSION_LIMIT, &unknown_limit)
2228 .with_element_memory(&element_limit);
2229
2230 let decoded = decode_repeated_with_context::<GroupCodec<TestMsg>>(1, &fields, ctx);
2231
2232 assert_eq!(decoded.len(), 1);
2233 assert_eq!(decoded[0].a, 3);
2234 assert_eq!(element_limit.get(), 0);
2235 }
2236
2237 #[derive(Debug, Default, Clone, PartialEq)]
2241 struct ListMsg {
2242 items: Vec<u64>,
2243 }
2244
2245 impl ListMsg {
2246 const ITEM_CHARGE: usize = 64;
2247 }
2248
2249 impl crate::DefaultInstance for ListMsg {
2250 fn default_instance() -> &'static Self {
2251 static INST: crate::__private::OnceBox<ListMsg> = crate::__private::OnceBox::new();
2252 INST.get_or_init(|| alloc::boxed::Box::new(ListMsg::default()))
2253 }
2254 }
2255
2256 impl crate::Message for ListMsg {
2257 fn compute_size(&self, _cache: &mut crate::SizeCache) -> u32 {
2258 0
2259 }
2260 fn write_to(&self, _cache: &mut crate::SizeCache, _buf: &mut impl crate::EncodeSink) {}
2261 fn merge_field(
2262 &mut self,
2263 tag: crate::encoding::Tag,
2264 buf: &mut impl bytes::Buf,
2265 ctx: crate::DecodeContext<'_>,
2266 ) -> Result<(), crate::DecodeError> {
2267 if tag.field_number() == 1 {
2268 ctx.register_element_memory(Self::ITEM_CHARGE)?;
2269 self.items.push(crate::encoding::decode_varint(buf)?);
2270 Ok(())
2271 } else {
2272 crate::encoding::skip_field(tag, buf)
2273 }
2274 }
2275 fn clear(&mut self) {
2276 self.items.clear();
2277 }
2278 }
2279
2280 #[test]
2285 fn repeated_message_extension_stops_at_an_element_that_exhausts_the_budget() {
2286 let element = core::mem::size_of::<ListMsg>();
2287 assert!(element + ListMsg::ITEM_CHARGE / 2 < ListMsg::ITEM_CHARGE);
2290 let mut fields = UnknownFields::new();
2291 fields.push(ld(1, Vec::new()));
2292 fields.push(ld(1, vec![0x08, 0x01])); fields.push(ld(1, Vec::new()));
2294 let unknown_limit = core::cell::Cell::new(crate::DEFAULT_UNKNOWN_FIELD_LIMIT);
2295 let element_limit = core::cell::Cell::new(3 * element + ListMsg::ITEM_CHARGE / 2);
2296 let ctx = crate::DecodeContext::new(crate::RECURSION_LIMIT, &unknown_limit)
2297 .with_element_memory(&element_limit);
2298
2299 let decoded = decode_repeated_with_context::<MessageCodec<ListMsg>>(1, &fields, ctx);
2300
2301 assert_eq!(decoded, [ListMsg::default()]);
2302 assert_eq!(element_limit.get(), 0);
2303 }
2304
2305 #[derive(Debug, Default, Clone, PartialEq)]
2309 struct ZeroSizedMsg;
2310
2311 impl ZeroSizedMsg {
2312 const ITEM_CHARGE: usize = 64;
2313 }
2314
2315 impl crate::DefaultInstance for ZeroSizedMsg {
2316 fn default_instance() -> &'static Self {
2317 &Self
2318 }
2319 }
2320
2321 impl crate::Message for ZeroSizedMsg {
2322 fn compute_size(&self, _cache: &mut crate::SizeCache) -> u32 {
2323 0
2324 }
2325 fn write_to(&self, _cache: &mut crate::SizeCache, _buf: &mut impl crate::EncodeSink) {}
2326 fn merge_field(
2327 &mut self,
2328 tag: crate::encoding::Tag,
2329 buf: &mut impl bytes::Buf,
2330 ctx: crate::DecodeContext<'_>,
2331 ) -> Result<(), crate::DecodeError> {
2332 if tag.field_number() == 1 {
2333 ctx.register_element_memory(Self::ITEM_CHARGE)?;
2334 }
2335 crate::encoding::skip_field(tag, buf)
2336 }
2337 fn clear(&mut self) {}
2338 }
2339
2340 #[test]
2345 fn repeated_message_extension_reads_no_record_after_the_budget_is_spent() {
2346 let mut fields = UnknownFields::new();
2347 fields.push(ld(1, vec![0x08, 0x01])); fields.push(ld(1, Vec::new()));
2349 let unknown_limit = core::cell::Cell::new(crate::DEFAULT_UNKNOWN_FIELD_LIMIT);
2350 let element_limit = core::cell::Cell::new(ZeroSizedMsg::ITEM_CHARGE / 2);
2351 let ctx = crate::DecodeContext::new(crate::RECURSION_LIMIT, &unknown_limit)
2352 .with_element_memory(&element_limit);
2353
2354 let decoded = decode_repeated_with_context::<MessageCodec<ZeroSizedMsg>>(1, &fields, ctx);
2355
2356 assert_eq!(decoded, []);
2357 assert_eq!(element_limit.get(), 0);
2358 }
2359
2360 #[test]
2363 fn charging_the_remaining_element_memory_spends_the_budget() {
2364 let unknown_limit = core::cell::Cell::new(crate::DEFAULT_UNKNOWN_FIELD_LIMIT);
2365 let element_limit = core::cell::Cell::new(40);
2366 let ctx = crate::DecodeContext::new(crate::RECURSION_LIMIT, &unknown_limit)
2367 .with_element_memory(&element_limit);
2368
2369 let rest = ctx.remaining_element_memory().unwrap();
2370 ctx.register_element_memory(rest).unwrap();
2371
2372 assert_eq!(ctx.remaining_element_memory(), Some(0));
2373 }
2374
2375 #[test]
2378 fn repeated_message_extension_skips_malformed_elements_before_the_budget_is_spent() {
2379 let mut fields = UnknownFields::new();
2380 fields.push(ld(1, vec![0x08, 0x80])); fields.push(varint(1, 7)); fields.push(ld(1, vec![0x08, 0x03]));
2383 let unknown_limit = core::cell::Cell::new(crate::DEFAULT_UNKNOWN_FIELD_LIMIT);
2384 let element_limit = core::cell::Cell::new(4 * core::mem::size_of::<TestMsg>());
2385 let ctx = crate::DecodeContext::new(crate::RECURSION_LIMIT, &unknown_limit)
2386 .with_element_memory(&element_limit);
2387
2388 let decoded = decode_repeated_with_context::<MessageCodec<TestMsg>>(1, &fields, ctx);
2389
2390 assert_eq!(decoded.len(), 1);
2391 assert_eq!(decoded[0].a, 3);
2392 }
2393
2394 #[derive(Clone, PartialEq)]
2397 struct WideMsg {
2398 pad: [u8; 64 * 1024],
2399 }
2400
2401 impl Default for WideMsg {
2402 fn default() -> Self {
2403 Self {
2404 pad: [0; 64 * 1024],
2405 }
2406 }
2407 }
2408
2409 impl crate::DefaultInstance for WideMsg {
2410 fn default_instance() -> &'static Self {
2411 static INST: crate::__private::OnceBox<WideMsg> = crate::__private::OnceBox::new();
2412 INST.get_or_init(|| alloc::boxed::Box::new(WideMsg::default()))
2413 }
2414 }
2415
2416 impl crate::Message for WideMsg {
2417 fn compute_size(&self, _cache: &mut crate::SizeCache) -> u32 {
2418 0
2419 }
2420 fn write_to(&self, _cache: &mut crate::SizeCache, _buf: &mut impl crate::EncodeSink) {}
2421 fn merge_field(
2422 &mut self,
2423 tag: crate::encoding::Tag,
2424 buf: &mut impl bytes::Buf,
2425 _ctx: crate::DecodeContext<'_>,
2426 ) -> Result<(), crate::DecodeError> {
2427 crate::encoding::skip_field(tag, buf)
2428 }
2429 fn clear(&mut self) {
2430 self.pad.fill(0);
2431 }
2432 }
2433
2434 #[test]
2438 fn extension_getter_stops_repeated_messages_at_default_budget() {
2439 const MESSAGES: Extension<Repeated<MessageCodec<WideMsg>>> = Extension::new(1, CARRIER);
2440 const GROUPS: Extension<Repeated<GroupCodec<WideMsg>>> = Extension::new(2, CARRIER);
2441 let fit = crate::DEFAULT_ELEMENT_MEMORY_LIMIT / core::mem::size_of::<WideMsg>();
2442 let mut c = Carrier::default();
2443 for _ in 0..fit + 3 {
2444 c.unknown.push(ld(1, Vec::new()));
2445 c.unknown.push(group(2, UnknownFields::new()));
2446 }
2447
2448 assert_eq!(c.extension(&MESSAGES).len(), fit);
2449 assert_eq!(c.extension(&GROUPS).len(), fit);
2450 }
2451
2452 #[test]
2460 fn group_extension_records_share_one_budget() {
2461 const SINGULAR: Extension<GroupCodec<BudgetMsg>> = Extension::new(1, CARRIER);
2462 const REPEATED: Extension<Repeated<GroupCodec<BudgetMsg>>> = Extension::new(1, CARRIER);
2463
2464 let per_record = 2 * crate::DEFAULT_UNKNOWN_FIELD_LIMIT / 3;
2467 let record = || {
2468 let mut inner = UnknownFields::new();
2469 for _ in 0..per_record {
2470 inner.push(varint(9, 0));
2471 }
2472 group(1, inner)
2473 };
2474
2475 let mut c = Carrier::default();
2476 c.unknown.push(record());
2477 c.unknown.push(record());
2478
2479 assert!(
2480 c.extension(&SINGULAR).is_none(),
2481 "two group records must share one allowance"
2482 );
2483 assert_eq!(
2484 c.extension(&REPEATED).len(),
2485 1,
2486 "the repeated group form must share it too"
2487 );
2488 }
2489
2490 use crate::test_doubles::SizedMsg;
2493
2494 fn huge_msg() -> SizedMsg {
2495 SizedMsg {
2496 reported_size: crate::MAX_MESSAGE_BYTES + 1,
2497 }
2498 }
2499
2500 #[test]
2501 fn try_set_extension_over_limit_errs_and_leaves_priors() {
2502 const E: Extension<MessageCodec<SizedMsg>> = Extension::new(1, CARRIER);
2503 let mut c = Carrier::default();
2504 c.unknown.push(ld(1, vec![0x08, 0x05])); c.unknown.push(varint(7, 9)); assert_eq!(
2507 c.try_set_extension(&E, huge_msg()),
2508 Err(EncodeError::MessageTooLarge)
2509 );
2510 assert_eq!(c.unknown.iter().count(), 2);
2513 assert!(c.unknown.iter().any(|f| f.number == 1));
2514 }
2515
2516 #[test]
2517 fn try_set_extension_scalar_replaces_priors() {
2518 const E: Extension<Int32> = Extension::new(3, CARRIER);
2519 let mut c = Carrier::default();
2520 c.unknown.push(varint(3, 1));
2521 c.unknown.push(varint(3, 2));
2522 c.try_set_extension(&E, 42).expect("scalars cannot fail");
2523 assert_eq!(c.extension(&E), Some(42));
2524 assert_eq!(c.unknown.iter().filter(|f| f.number == 3).count(), 1);
2525 }
2526
2527 #[test]
2528 #[should_panic(expected = "2 GiB protobuf limit")]
2529 fn set_extension_over_limit_panics() {
2530 const E: Extension<MessageCodec<SizedMsg>> = Extension::new(1, CARRIER);
2531 let mut c = Carrier::default();
2532 c.set_extension(&E, huge_msg());
2533 }
2534
2535 #[test]
2536 fn try_set_extension_repeated_message_over_limit_errs() {
2537 const E: Extension<Repeated<MessageCodec<SizedMsg>>> = Extension::new(2, CARRIER);
2538 let mut c = Carrier::default();
2539 assert_eq!(
2540 c.try_set_extension(&E, vec![huge_msg()]),
2541 Err(EncodeError::MessageTooLarge)
2542 );
2543 assert_eq!(c.unknown.iter().count(), 0);
2544 }
2545
2546 #[test]
2547 fn message_unknown_fields_survive_roundtrip() {
2548 const E: Extension<MessageCodec<TestMsg>> = Extension::new(1, CARRIER);
2550 let mut c = Carrier::default();
2551 c.unknown.push(ld(1, vec![0x08, 0x05, 0x98, 0x06, 0x2A]));
2554 let got = c.extension(&E).expect("decoded");
2555 assert_eq!(got.a, 5);
2556 let mut inner_unk = UnknownFields::new();
2560 inner_unk.push(varint(99, 42));
2561 let msg = TestMsg {
2562 a: 5,
2563 b: 0,
2564 unknown: inner_unk,
2565 };
2566 let mut c = Carrier::default();
2567 c.set_extension(&E, msg);
2568 use crate::Message;
2570 let mut roundtrip = TestMsg::default();
2571 if let UnknownFieldData::LengthDelimited(bytes) = &c.unknown.iter().next().unwrap().data {
2572 assert!(bytes.len() > 2, "payload includes unknown-field bytes");
2575 assert!(bytes.windows(3).any(|w| w == [0x98, 0x06, 0x2A]));
2577 roundtrip.merge_from_slice(bytes).unwrap();
2579 assert_eq!(roundtrip.a, 5);
2580 } else {
2581 panic!("expected LengthDelimited");
2582 }
2583 }
2584
2585 #[test]
2586 fn repeated_message() {
2587 const E: Extension<Repeated<MessageCodec<TestMsg>>> = Extension::new(1, CARRIER);
2588 let mut c = Carrier::default();
2589 c.unknown.push(ld(1, vec![0x08, 0x01])); c.unknown.push(ld(1, vec![0x08, 0x02])); let got = c.extension(&E);
2592 assert_eq!(got.len(), 2);
2593 assert_eq!(got[0].a, 1);
2594 assert_eq!(got[1].a, 2);
2595 }
2596
2597 #[test]
2598 fn repeated_message_malformed_element_skipped() {
2599 const E: Extension<Repeated<MessageCodec<TestMsg>>> = Extension::new(1, CARRIER);
2600 let mut c = Carrier::default();
2601 c.unknown.push(ld(1, vec![0x08, 0x01])); c.unknown.push(ld(1, vec![0x08, 0x80])); c.unknown.push(ld(1, vec![0x08, 0x03])); let got = c.extension(&E);
2605 assert_eq!(got.len(), 2);
2606 assert_eq!(got[0].a, 1);
2607 assert_eq!(got[1].a, 3);
2608 }
2609
2610 fn inner_a(v: u64) -> UnknownFields {
2619 let mut inner = UnknownFields::new();
2620 inner.push(varint(1, v));
2621 inner
2622 }
2623
2624 #[test]
2625 fn group_single_record() {
2626 const E: Extension<GroupCodec<TestMsg>> = Extension::new(1, CARRIER);
2627 let mut c = Carrier::default();
2628 c.unknown.push(group(1, inner_a(5)));
2629 let got = c.extension(&E).expect("decoded");
2630 assert_eq!(got.a, 5);
2631 assert_eq!(got.b, 0);
2632 }
2633
2634 #[test]
2635 fn group_split_records_merge() {
2636 const E: Extension<GroupCodec<TestMsg>> = Extension::new(1, CARRIER);
2639 let mut c = Carrier::default();
2640 c.unknown.push(group(1, inner_a(5)));
2641 let mut inner_b = UnknownFields::new();
2642 inner_b.push(varint(2, 7));
2643 c.unknown.push(group(1, inner_b));
2644 let got = c.extension(&E).expect("decoded");
2645 assert_eq!(got.a, 5);
2646 assert_eq!(got.b, 7);
2647 }
2648
2649 #[test]
2650 fn group_absent_is_none() {
2651 const E: Extension<GroupCodec<TestMsg>> = Extension::new(1, CARRIER);
2652 let c = Carrier::default();
2653 assert!(c.extension(&E).is_none());
2654 }
2655
2656 #[test]
2657 fn group_wrong_wire_type_is_none() {
2658 const E: Extension<GroupCodec<TestMsg>> = Extension::new(1, CARRIER);
2661 let mut c = Carrier::default();
2662 c.unknown.push(ld(1, vec![0x08, 0x05]));
2663 assert!(c.extension(&E).is_none());
2664 }
2665
2666 #[test]
2667 fn group_set_get_roundtrip() {
2668 const E: Extension<GroupCodec<TestMsg>> = Extension::new(1, CARRIER);
2669 let mut c = Carrier::default();
2670 c.set_extension(
2671 &E,
2672 TestMsg {
2673 a: 3,
2674 b: -1,
2675 unknown: UnknownFields::new(),
2676 },
2677 );
2678 match &c.unknown.iter().next().unwrap().data {
2680 UnknownFieldData::Group(_) => {}
2681 other => panic!("expected Group, got {other:?}"),
2682 }
2683 let got = c.extension(&E).expect("decoded");
2684 assert_eq!(got.a, 3);
2685 assert_eq!(got.b, -1);
2686 }
2687
2688 #[test]
2689 fn group_set_empty_message() {
2690 const E: Extension<GroupCodec<TestMsg>> = Extension::new(1, CARRIER);
2693 let mut c = Carrier::default();
2694 c.set_extension(&E, TestMsg::default());
2695 assert!(c.has_extension(&E));
2696 let got = c.extension(&E).expect("decoded");
2697 assert_eq!(got, TestMsg::default());
2698 }
2699
2700 #[test]
2701 fn repeated_group() {
2702 const E: Extension<Repeated<GroupCodec<TestMsg>>> = Extension::new(1, CARRIER);
2703 let mut c = Carrier::default();
2704 c.unknown.push(group(1, inner_a(1)));
2705 c.unknown.push(group(1, inner_a(2)));
2706 let got = c.extension(&E);
2707 assert_eq!(got.len(), 2);
2708 assert_eq!(got[0].a, 1);
2709 assert_eq!(got[1].a, 2);
2710 }
2711
2712 #[test]
2713 fn repeated_group_set_get_roundtrip() {
2714 const E: Extension<Repeated<GroupCodec<TestMsg>>> = Extension::new(1, CARRIER);
2715 let mut c = Carrier::default();
2716 let msgs = vec![
2717 TestMsg {
2718 a: 10,
2719 b: 0,
2720 unknown: UnknownFields::new(),
2721 },
2722 TestMsg {
2723 a: 0,
2724 b: 20,
2725 unknown: UnknownFields::new(),
2726 },
2727 ];
2728 c.set_extension(&E, msgs.clone());
2729 assert_eq!(c.unknown.len(), 2);
2731 for f in c.unknown.iter() {
2732 assert!(matches!(f.data, UnknownFieldData::Group(_)));
2733 }
2734 assert_eq!(c.extension(&E), msgs);
2735 }
2736
2737 #[test]
2740 fn scalar_roundtrip_table() {
2741 macro_rules! rt {
2742 ($codec:ty, $v:expr) => {{
2743 const E: Extension<$codec> = Extension::new(1, CARRIER);
2744 let mut c = Carrier::default();
2745 c.set_extension(&E, $v);
2746 assert_eq!(c.extension(&E), Some($v), stringify!($codec));
2747 }};
2748 }
2749 rt!(Int64, -1_i64);
2750 rt!(Uint64, u64::MAX);
2751 rt!(Sint64, i64::MIN);
2752 rt!(Fixed32, u32::MAX);
2753 rt!(Fixed64, u64::MAX);
2754 rt!(Sfixed64, -1_i64);
2755 rt!(EnumI32, 42);
2756 }
2757
2758 #[test]
2759 fn fixed64_packed_decode_partial_tail_ignored() {
2760 const E: Extension<Repeated<Fixed64>> = Extension::new(1, CARRIER);
2762 let mut c = Carrier::default();
2763 let mut payload = 42_u64.to_le_bytes().to_vec();
2764 payload.extend_from_slice(&[0x01, 0x02, 0x03]);
2765 c.unknown.push(ld(1, payload));
2766 assert_eq!(c.extension(&E), vec![42_u64]);
2767 }
2768
2769 #[test]
2770 fn varint_packed_decode_malformed_tail_stops() {
2771 const E: Extension<Repeated<Int32>> = Extension::new(1, CARRIER);
2773 let mut c = Carrier::default();
2774 c.unknown.push(ld(1, vec![0x01, 0x80]));
2775 assert_eq!(c.extension(&E), vec![1]);
2776 }
2777
2778 #[test]
2780 fn fixed64_wrong_wire_type() {
2781 const E: Extension<Fixed64> = Extension::new(1, CARRIER);
2782 let mut c = Carrier::default();
2783 c.unknown.push(fixed64(1, 0xDEADBEEF));
2784 assert_eq!(c.extension(&E), Some(0xDEADBEEF_u64));
2785 let mut c = Carrier::default();
2786 c.unknown.push(fixed32(1, 0)); assert_eq!(c.extension(&E), None);
2788 }
2789}