use alloc::boxed::Box;
#[cfg(feature = "text")]
fn any_type_name(type_url: &str) -> Option<&str> {
let (_, type_name) = type_url.rsplit_once('/')?;
(!type_name.is_empty()).then_some(type_name)
}
pub const MAX_ANY_EXPANSION_DEPTH: u32 = crate::RECURSION_LIMIT;
#[cfg(all(feature = "json", feature = "std"))]
mod any_depth {
use core::cell::Cell;
std::thread_local! {
static DEPTH: Cell<u32> = const { Cell::new(0) };
}
pub(crate) fn enter(cap: u32) -> bool {
DEPTH.with(|c| {
let cur = c.get();
if cur >= cap {
return false;
}
c.set(cur + 1);
true
})
}
pub(crate) fn leave() {
DEPTH.with(|c| c.set(c.get().saturating_sub(1)));
}
}
#[cfg(all(feature = "json", not(feature = "std")))]
mod any_depth {
use core::sync::atomic::{AtomicU32, Ordering};
static DEPTH: AtomicU32 = AtomicU32::new(0);
pub(crate) fn enter(cap: u32) -> bool {
let mut cur = DEPTH.load(Ordering::Relaxed);
loop {
if cur >= cap {
return false;
}
match DEPTH.compare_exchange_weak(cur, cur + 1, Ordering::Relaxed, Ordering::Relaxed) {
Ok(_) => return true,
Err(actual) => cur = actual,
}
}
}
pub(crate) fn leave() {
let _ = DEPTH.try_update(Ordering::Relaxed, Ordering::Relaxed, |v| {
Some(v.saturating_sub(1))
});
}
}
#[cfg(feature = "json")]
#[doc(hidden)]
#[derive(Debug)]
pub struct AnyExpansionGuard(());
#[cfg(feature = "json")]
impl Drop for AnyExpansionGuard {
fn drop(&mut self) {
any_depth::leave();
}
}
#[cfg(feature = "json")]
#[doc(hidden)]
#[must_use]
pub fn enter_any_expansion() -> Option<AnyExpansionGuard> {
any_depth::enter(MAX_ANY_EXPANSION_DEPTH).then(|| AnyExpansionGuard(()))
}
const _: () = assert!(MAX_ANY_EXPANSION_DEPTH <= 128);
#[cfg(feature = "json")]
pub use crate::any_registry::JsonAnyEntry;
#[cfg(feature = "json")]
pub use crate::extension_registry::JsonExtEntry;
#[cfg(feature = "json")]
#[deprecated(since = "0.3.0", note = "renamed to JsonAnyEntry")]
pub type AnyTypeEntry = JsonAnyEntry;
#[cfg(feature = "json")]
#[deprecated(since = "0.3.0", note = "renamed to JsonExtEntry")]
pub type ExtensionRegistryEntry = JsonExtEntry;
#[cfg(feature = "text")]
pub struct TextAnyEntry {
pub type_url: &'static str,
pub text_encode: fn(&[u8], &mut crate::text::TextEncoder<'_>) -> core::fmt::Result,
pub text_merge: AnyTextMergeFn,
}
#[cfg(feature = "text")]
impl core::fmt::Debug for TextAnyEntry {
fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
f.debug_struct("TextAnyEntry")
.field("type_url", &self.type_url)
.finish_non_exhaustive()
}
}
#[cfg(feature = "text")]
pub type AnyTextMergeFn =
fn(&mut crate::text::TextDecoder<'_>) -> Result<alloc::vec::Vec<u8>, crate::text::ParseError>;
#[cfg(feature = "text")]
pub struct TextExtEntry {
pub number: u32,
pub full_name: &'static str,
pub extendee: &'static str,
pub text_encode: fn(
u32,
&crate::unknown_fields::UnknownFields,
&mut crate::text::TextEncoder<'_>,
) -> core::fmt::Result,
pub text_merge: ExtTextMergeFn,
}
#[cfg(feature = "text")]
impl core::fmt::Debug for TextExtEntry {
fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
f.debug_struct("TextExtEntry")
.field("number", &self.number)
.field("full_name", &self.full_name)
.field("extendee", &self.extendee)
.finish_non_exhaustive()
}
}
#[cfg(feature = "text")]
pub type ExtTextMergeFn =
fn(
&mut crate::text::TextDecoder<'_>,
u32,
)
-> Result<alloc::vec::Vec<crate::unknown_fields::UnknownField>, crate::text::ParseError>;
#[cfg(feature = "text")]
#[derive(Default)]
struct TextAnyMap {
entries: hashbrown::HashMap<alloc::string::String, TextAnyEntry>,
by_type_name: hashbrown::HashMap<&'static str, &'static str>,
}
#[cfg(feature = "text")]
impl TextAnyMap {
fn register(&mut self, entry: TextAnyEntry) {
if let Some(type_name) = any_type_name(entry.type_url) {
self.by_type_name.insert(type_name, entry.type_url);
}
self.entries
.insert(alloc::string::String::from(entry.type_url), entry);
}
fn lookup(&self, type_url: &str) -> Option<&TextAnyEntry> {
if let Some(entry) = self.entries.get(type_url) {
return Some(entry);
}
let type_name = any_type_name(type_url)?;
let registered_url = *self.by_type_name.get(type_name)?;
self.entries.get(registered_url)
}
}
#[cfg(feature = "text")]
#[derive(Default)]
struct TextExtMap {
by_number: hashbrown::HashMap<&'static str, hashbrown::HashMap<u32, TextExtEntry>>,
by_name: hashbrown::HashMap<&'static str, (&'static str, u32)>,
}
#[cfg(feature = "text")]
impl TextExtMap {
fn register(&mut self, entry: TextExtEntry) {
let extendee = entry.extendee;
let number = entry.number;
if let Some(previous) = self
.by_number
.get_mut(extendee)
.and_then(|entries| entries.remove(&number))
{
self.by_name.remove(previous.full_name);
}
if let Some((previous_extendee, previous_number)) = self.by_name.remove(entry.full_name) {
if let Some(entries) = self.by_number.get_mut(previous_extendee) {
entries.remove(&previous_number);
}
}
self.by_name.insert(entry.full_name, (extendee, number));
self.by_number
.entry(extendee)
.or_default()
.insert(number, entry);
}
fn by_number(&self, extendee: &str, number: u32) -> Option<&TextExtEntry> {
self.by_number.get(extendee)?.get(&number)
}
fn by_name(&self, full_name: &str) -> Option<&TextExtEntry> {
let key = self.by_name.get(full_name)?;
self.by_number.get(key.0)?.get(&key.1)
}
}
#[derive(Default)]
pub struct TypeRegistry {
#[cfg(feature = "json")]
json_any: crate::any_registry::AnyRegistry,
#[cfg(feature = "json")]
json_ext: crate::extension_registry::ExtensionRegistry,
#[cfg(feature = "text")]
text_any: TextAnyMap,
#[cfg(feature = "text")]
text_ext: TextExtMap,
}
impl TypeRegistry {
#[must_use]
pub fn new() -> Self {
Self::default()
}
#[cfg(feature = "json")]
pub fn register_json_any(&mut self, entry: JsonAnyEntry) {
self.json_any.register(entry);
}
#[cfg(feature = "json")]
pub fn register_json_ext(&mut self, entry: JsonExtEntry) {
self.json_ext.register(entry);
}
#[cfg(feature = "text")]
pub fn register_text_any(&mut self, entry: TextAnyEntry) {
self.text_any.register(entry);
}
#[cfg(feature = "text")]
pub fn register_text_ext(&mut self, entry: TextExtEntry) {
self.text_ext.register(entry);
}
#[cfg(feature = "json")]
pub fn json_any_by_url(&self, type_url: &str) -> Option<&JsonAnyEntry> {
self.json_any.lookup(type_url)
}
#[cfg(feature = "json")]
pub fn json_ext_by_number(&self, extendee: &str, number: u32) -> Option<&JsonExtEntry> {
self.json_ext.by_number(extendee, number)
}
#[cfg(feature = "json")]
pub fn json_ext_by_name(&self, full_name: &str) -> Option<&JsonExtEntry> {
self.json_ext.by_name(full_name)
}
#[cfg(feature = "text")]
pub fn text_any_by_url(&self, type_url: &str) -> Option<&TextAnyEntry> {
self.text_any.lookup(type_url)
}
#[cfg(feature = "text")]
pub fn text_ext_by_number(&self, extendee: &str, number: u32) -> Option<&TextExtEntry> {
self.text_ext.by_number(extendee, number)
}
#[cfg(feature = "text")]
pub fn text_ext_by_name(&self, full_name: &str) -> Option<&TextExtEntry> {
self.text_ext.by_name(full_name)
}
}
#[deprecated(since = "0.3.0", note = "renamed to TypeRegistry")]
pub type JsonRegistry = TypeRegistry;
impl core::fmt::Debug for TypeRegistry {
fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
f.debug_struct("TypeRegistry").finish_non_exhaustive()
}
}
#[cfg(feature = "text")]
static TEXT_ANY: core::sync::atomic::AtomicPtr<TextAnyMap> =
core::sync::atomic::AtomicPtr::new(core::ptr::null_mut());
#[cfg(feature = "text")]
static TEXT_EXT: core::sync::atomic::AtomicPtr<TextExtMap> =
core::sync::atomic::AtomicPtr::new(core::ptr::null_mut());
pub fn set_type_registry(reg: TypeRegistry) {
let TypeRegistry {
#[cfg(feature = "json")]
json_any,
#[cfg(feature = "json")]
json_ext,
#[cfg(feature = "text")]
text_any,
#[cfg(feature = "text")]
text_ext,
} = reg;
#[cfg(feature = "json")]
#[allow(deprecated)]
{
crate::any_registry::set_any_registry(Box::new(json_any));
crate::extension_registry::set_extension_registry(Box::new(json_ext));
}
#[cfg(feature = "text")]
{
use core::sync::atomic::Ordering;
TEXT_ANY.swap(Box::into_raw(Box::new(text_any)), Ordering::Release);
TEXT_EXT.swap(Box::into_raw(Box::new(text_ext)), Ordering::Release);
}
}
#[deprecated(since = "0.3.0", note = "renamed to set_type_registry")]
pub fn set_json_registry(reg: TypeRegistry) {
set_type_registry(reg);
}
#[cfg(feature = "text")]
pub(crate) fn global_text_any(type_url: &str) -> Option<&'static TextAnyEntry> {
use core::sync::atomic::Ordering;
let ptr = TEXT_ANY.load(Ordering::Acquire);
if ptr.is_null() {
return None;
}
unsafe { &*ptr }.lookup(type_url)
}
#[cfg(feature = "text")]
pub(crate) fn global_text_ext_by_number(
extendee: &str,
number: u32,
) -> Option<&'static TextExtEntry> {
use core::sync::atomic::Ordering;
let ptr = TEXT_EXT.load(Ordering::Acquire);
if ptr.is_null() {
return None;
}
unsafe { &*ptr }.by_number(extendee, number)
}
#[cfg(feature = "text")]
pub(crate) fn global_text_ext_by_name(full_name: &str) -> Option<&'static TextExtEntry> {
use core::sync::atomic::Ordering;
let ptr = TEXT_EXT.load(Ordering::Acquire);
if ptr.is_null() {
return None;
}
unsafe { &*ptr }.by_name(full_name)
}
#[cfg(feature = "text")]
#[doc(hidden)]
pub fn clear_text_registry() {
use core::sync::atomic::Ordering;
TEXT_ANY.swap(core::ptr::null_mut(), Ordering::Release);
TEXT_EXT.swap(core::ptr::null_mut(), Ordering::Release);
}
#[cfg(feature = "json")]
pub fn any_to_json<M>(bytes: &[u8]) -> Result<serde_json::Value, alloc::string::String>
where
M: crate::Message + serde::Serialize,
{
use alloc::format;
let m = M::decode_from_slice(bytes).map_err(|e| format!("{e}"))?;
serde_json::to_value(&m).map_err(|e| format!("{e}"))
}
#[cfg(feature = "json")]
pub fn any_from_json<M>(v: serde_json::Value) -> Result<alloc::vec::Vec<u8>, alloc::string::String>
where
M: crate::Message + for<'de> serde::Deserialize<'de>,
{
use alloc::format;
let m: M = serde_json::from_value(v).map_err(|e| format!("{e}"))?;
m.try_encode_to_vec().map_err(|e| format!("{e}"))
}
#[cfg(feature = "text")]
pub fn any_encode_text<M>(bytes: &[u8], enc: &mut crate::text::TextEncoder<'_>) -> core::fmt::Result
where
M: crate::Message + crate::text::TextFormat + Default,
{
let m = M::decode_from_slice(bytes).unwrap_or_default();
enc.write_map_entry(|enc| m.encode_text(enc))
}
#[cfg(feature = "text")]
pub fn any_merge_text<M>(
dec: &mut crate::text::TextDecoder<'_>,
) -> Result<alloc::vec::Vec<u8>, crate::text::ParseError>
where
M: crate::Message + crate::text::TextFormat + Default,
{
let mut m = M::default();
dec.merge_message(&mut m)?;
m.try_encode_to_vec().map_err(|_| oversized_message_error())
}
#[cfg(feature = "text")]
fn oversized_message_error() -> crate::text::ParseError {
crate::text::ParseError::new(
0,
0,
crate::text::ParseErrorKind::Internal("merged message exceeds the 2 GiB protobuf limit"),
)
}
#[cfg(feature = "text")]
pub fn repeated_message_encode_text<M>(
n: u32,
f: &crate::unknown_fields::UnknownFields,
enc: &mut crate::text::TextEncoder<'_>,
) -> core::fmt::Result
where
M: crate::Message + crate::text::TextFormat + Default,
{
use crate::extension::codecs::{MessageCodec, Repeated};
use crate::extension::ExtensionCodec;
enc.write_repeated_extension(&Repeated::<MessageCodec<M>>::decode(n, f))
}
#[cfg(feature = "text")]
pub fn repeated_group_encode_text<M>(
n: u32,
f: &crate::unknown_fields::UnknownFields,
enc: &mut crate::text::TextEncoder<'_>,
) -> core::fmt::Result
where
M: crate::Message + crate::text::TextFormat + Default,
{
use crate::extension::codecs::{GroupCodec, Repeated};
use crate::extension::ExtensionCodec;
enc.write_repeated_extension(&Repeated::<GroupCodec<M>>::decode(n, f))
}
#[cfg(feature = "text")]
pub fn repeated_message_merge_text<M>(
dec: &mut crate::text::TextDecoder<'_>,
n: u32,
) -> Result<alloc::vec::Vec<crate::unknown_fields::UnknownField>, crate::text::ParseError>
where
M: crate::Message + crate::text::TextFormat + Default,
{
let mut records = alloc::vec::Vec::new();
dec.read_repeated_into(&mut records, |dec| message_record::<M>(dec, n))?;
Ok(records)
}
#[cfg(feature = "text")]
pub fn repeated_group_merge_text<M>(
dec: &mut crate::text::TextDecoder<'_>,
n: u32,
) -> Result<alloc::vec::Vec<crate::unknown_fields::UnknownField>, crate::text::ParseError>
where
M: crate::Message + crate::text::TextFormat + Default,
{
let mut records = alloc::vec::Vec::new();
dec.read_repeated_into(&mut records, |dec| group_record::<M>(dec, n))?;
Ok(records)
}
#[cfg(feature = "text")]
pub fn message_encode_text<M>(
n: u32,
f: &crate::unknown_fields::UnknownFields,
enc: &mut crate::text::TextEncoder<'_>,
) -> core::fmt::Result
where
M: crate::Message + crate::text::TextFormat + Default,
{
use crate::extension::codecs::MessageCodec;
use crate::extension::ExtensionCodec;
let m = MessageCodec::<M>::decode(n, f).unwrap_or_default();
enc.write_map_entry(|enc| m.encode_text(enc))
}
#[cfg(feature = "text")]
pub fn message_merge_text<M>(
dec: &mut crate::text::TextDecoder<'_>,
n: u32,
) -> Result<alloc::vec::Vec<crate::unknown_fields::UnknownField>, crate::text::ParseError>
where
M: crate::Message + crate::text::TextFormat + Default,
{
Ok(alloc::vec![message_record::<M>(dec, n)?])
}
#[cfg(feature = "text")]
fn message_record<M>(
dec: &mut crate::text::TextDecoder<'_>,
n: u32,
) -> Result<crate::unknown_fields::UnknownField, crate::text::ParseError>
where
M: crate::Message + crate::text::TextFormat + Default,
{
use crate::unknown_fields::{UnknownField, UnknownFieldData};
let mut m = M::default();
dec.merge_message(&mut m)?;
let bytes = m
.try_encode_to_vec()
.map_err(|_| oversized_message_error())?;
Ok(UnknownField {
number: n,
data: UnknownFieldData::LengthDelimited(bytes),
})
}
#[cfg(feature = "text")]
pub fn group_encode_text<M>(
n: u32,
f: &crate::unknown_fields::UnknownFields,
enc: &mut crate::text::TextEncoder<'_>,
) -> core::fmt::Result
where
M: crate::Message + crate::text::TextFormat + Default,
{
use crate::extension::codecs::GroupCodec;
use crate::extension::ExtensionCodec;
let m = GroupCodec::<M>::decode(n, f).unwrap_or_default();
enc.write_map_entry(|enc| m.encode_text(enc))
}
#[cfg(feature = "text")]
pub fn group_merge_text<M>(
dec: &mut crate::text::TextDecoder<'_>,
n: u32,
) -> Result<alloc::vec::Vec<crate::unknown_fields::UnknownField>, crate::text::ParseError>
where
M: crate::Message + crate::text::TextFormat + Default,
{
Ok(alloc::vec![group_record::<M>(dec, n)?])
}
#[cfg(feature = "text")]
fn group_record<M>(
dec: &mut crate::text::TextDecoder<'_>,
n: u32,
) -> Result<crate::unknown_fields::UnknownField, crate::text::ParseError>
where
M: crate::Message + crate::text::TextFormat + Default,
{
use crate::unknown_fields::{UnknownField, UnknownFieldData, UnknownFields};
let mut m = M::default();
dec.merge_message(&mut m)?;
let bytes = m
.try_encode_to_vec()
.map_err(|_| oversized_message_error())?;
let inner = UnknownFields::decode_from_slice(&bytes).map_err(|_| {
crate::text::ParseError::new(
0,
0,
crate::text::ParseErrorKind::Internal(
"re-decoding freshly-encoded group message bytes failed",
),
)
})?;
Ok(UnknownField {
number: n,
data: UnknownFieldData::Group(inner),
})
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn default_is_empty() {
let reg = TypeRegistry::default();
#[cfg(feature = "json")]
assert!(reg.json_any_by_url("anything").is_none());
#[cfg(feature = "text")]
assert!(reg.text_any_by_url("anything").is_none());
#[cfg(not(any(feature = "json", feature = "text")))]
let _ = reg;
}
#[test]
fn debug_impl() {
let reg = TypeRegistry::new();
let s = alloc::format!("{reg:?}");
assert!(s.contains("TypeRegistry"), "{s}");
}
#[cfg(feature = "json")]
#[test]
fn refusing_any_expansion_does_not_decrement_active_depth() {
let _guards: alloc::vec::Vec<_> = (0..MAX_ANY_EXPANSION_DEPTH)
.map(|_| enter_any_expansion().expect("entry below the cap must succeed"))
.collect();
assert!(enter_any_expansion().is_none());
assert!(enter_any_expansion().is_none());
}
#[cfg(feature = "json")]
mod json {
use super::*;
use crate::any_registry::with_any_registry;
use crate::extension_registry::{extension_registry, helpers};
fn dummy_to_json(_: &[u8]) -> Result<serde_json::Value, alloc::string::String> {
Ok(serde_json::json!({"ok": true}))
}
fn dummy_from_json(
_: serde_json::Value,
) -> Result<alloc::vec::Vec<u8>, alloc::string::String> {
Ok(alloc::vec![1, 2, 3])
}
fn any_entry(url: &'static str, wkt: bool) -> JsonAnyEntry {
JsonAnyEntry {
type_url: url,
to_json: dummy_to_json,
from_json: dummy_from_json,
is_wkt: wkt,
}
}
fn ext_entry(num: u32, name: &'static str, ext: &'static str) -> JsonExtEntry {
JsonExtEntry {
number: num,
full_name: name,
extendee: ext,
to_json: helpers::int32_to_json,
from_json: helpers::int32_from_json,
}
}
#[test]
fn register_json_any_and_ext_independently() {
let mut reg = TypeRegistry::new();
reg.register_json_any(any_entry("type.googleapis.com/test.Foo", false));
reg.register_json_ext(ext_entry(100, "test.ext", "test.Foo"));
assert!(reg
.json_any_by_url("type.googleapis.com/test.Foo")
.is_some());
assert!(reg.json_ext_by_number("test.Foo", 100).is_some());
assert!(reg.json_ext_by_name("test.ext").is_some());
}
#[test]
fn set_type_registry_installs_json_halves() {
let _g = crate::test_doubles::REGISTRY_TEST_LOCK.lock().unwrap();
let mut reg = TypeRegistry::new();
reg.register_json_any(any_entry("type.googleapis.com/test.Unified", false));
reg.register_json_ext(ext_entry(200, "test.unified_ext", "test.Unified"));
set_type_registry(reg);
with_any_registry(|r| {
let r = r.expect("any registry installed");
assert!(r.lookup("type.googleapis.com/test.Unified").is_some());
});
let ext = extension_registry().expect("extension registry installed");
assert_eq!(ext.by_name("test.unified_ext").map(|e| e.number), Some(200));
crate::any_registry::clear_any_registry();
}
#[test]
#[allow(deprecated)]
fn deprecated_aliases_compile() {
let _: AnyTypeEntry = any_entry("x", false);
let _: ExtensionRegistryEntry = ext_entry(1, "a", "B");
let _: JsonRegistry = TypeRegistry::new();
let _g = crate::test_doubles::REGISTRY_TEST_LOCK.lock().unwrap();
set_json_registry(TypeRegistry::new());
crate::any_registry::clear_any_registry();
}
}
#[cfg(feature = "text")]
mod text {
use super::*;
use crate::unknown_fields::{UnknownField, UnknownFieldData, UnknownFields};
#[derive(Default, Clone, PartialEq, Debug)]
struct Inner {
n: i32,
}
impl crate::DefaultInstance for Inner {
fn default_instance() -> &'static Self {
static I: crate::__private::OnceBox<Inner> = crate::__private::OnceBox::new();
I.get_or_init(|| alloc::boxed::Box::new(Inner::default()))
}
}
impl crate::Message for Inner {
fn compute_size(&self, _cache: &mut crate::SizeCache) -> u32 {
if self.n != 0 {
1 + crate::encoding::varint_len(self.n as i64 as u64) as u32
} else {
0
}
}
fn write_to(&self, _cache: &mut crate::SizeCache, buf: &mut impl crate::EncodeSink) {
if self.n != 0 {
crate::encoding::Tag::new(1, crate::encoding::WireType::Varint).encode(buf);
crate::encoding::encode_varint(self.n as i64 as u64, buf);
}
}
fn merge_field(
&mut self,
tag: crate::encoding::Tag,
buf: &mut impl bytes::Buf,
_: crate::DecodeContext<'_>,
) -> Result<(), crate::DecodeError> {
if tag.field_number() == 1 && tag.wire_type() == crate::encoding::WireType::Varint {
self.n = crate::encoding::decode_varint(buf)? as i32;
Ok(())
} else {
crate::encoding::skip_field(tag, buf)
}
}
fn clear(&mut self) {
self.n = 0;
}
}
impl crate::text::TextFormat for Inner {
fn encode_text(&self, enc: &mut crate::text::TextEncoder<'_>) -> core::fmt::Result {
if self.n != 0 {
enc.write_field_name("n")?;
enc.write_i32(self.n)?;
}
Ok(())
}
fn merge_text(
&mut self,
dec: &mut crate::text::TextDecoder<'_>,
) -> Result<(), crate::text::ParseError> {
while let Some(name) = dec.read_field_name()? {
match name {
"n" => self.n = dec.read_i32()?,
_ => dec.skip_value()?,
}
}
Ok(())
}
}
fn fields_from(records: alloc::vec::Vec<UnknownField>) -> UnknownFields {
let mut f = UnknownFields::new();
for r in records {
f.push(r);
}
f
}
#[test]
fn message_text_roundtrip() {
let mut dec = crate::text::TextDecoder::new("f { n: 7 }");
dec.read_field_name().unwrap();
let records = message_merge_text::<Inner>(&mut dec, 50).unwrap();
assert_eq!(records.len(), 1);
assert_eq!(records[0].number, 50);
let UnknownFieldData::LengthDelimited(ref bytes) = records[0].data else {
panic!("expected LengthDelimited, got {:?}", records[0].data);
};
assert_eq!(*bytes, alloc::vec![0x08, 0x07]);
let fields = fields_from(records);
let mut s = alloc::string::String::new();
let mut enc = crate::text::TextEncoder::new(&mut s);
enc.write_extension_name("pkg.ext").unwrap();
message_encode_text::<Inner>(50, &fields, &mut enc).unwrap();
assert_eq!(s, "[pkg.ext] {n: 7}");
}
#[test]
fn group_text_roundtrip() {
let mut dec = crate::text::TextDecoder::new("f { n: 7 }");
dec.read_field_name().unwrap();
let records = group_merge_text::<Inner>(&mut dec, 121).unwrap();
assert_eq!(records.len(), 1);
assert_eq!(records[0].number, 121);
let UnknownFieldData::Group(ref inner) = records[0].data else {
panic!("expected Group, got {:?}", records[0].data);
};
let inner_vec: alloc::vec::Vec<_> = inner.iter().collect();
assert_eq!(inner_vec.len(), 1);
assert_eq!(inner_vec[0].number, 1);
assert_eq!(inner_vec[0].data, UnknownFieldData::Varint(7));
let fields = fields_from(records);
let mut s = alloc::string::String::new();
let mut enc = crate::text::TextEncoder::new(&mut s);
enc.write_extension_name("pkg.groupfield").unwrap();
group_encode_text::<Inner>(121, &fields, &mut enc).unwrap();
assert_eq!(s, "[pkg.groupfield] {n: 7}");
}
type RepeatedHelpers = (
&'static str,
fn(u32, &UnknownFields, &mut crate::text::TextEncoder<'_>) -> core::fmt::Result,
ExtTextMergeFn,
);
const REPEATED_HELPERS: [RepeatedHelpers; 2] = [
(
"pkg.rep",
repeated_message_encode_text::<Inner>,
repeated_message_merge_text::<Inner>,
),
(
"pkg.rep_group",
repeated_group_encode_text::<Inner>,
repeated_group_merge_text::<Inner>,
),
];
#[test]
fn repeated_helpers_write_a_list_after_a_name_the_caller_wrote() {
for (name, encode, merge) in REPEATED_HELPERS {
let mut dec = crate::text::TextDecoder::new("f: [{ n: 1 }, { n: 2 }]");
dec.read_field_name().unwrap();
let records = merge(&mut dec, 60).unwrap();
assert_eq!(records.len(), 2, "{name}");
for (count, expected) in [
(0, "[x]: []"),
(1, "[x]: [{n: 1}]"),
(2, "[x]: [{n: 1}, {n: 2}]"),
] {
let fields = fields_from(records[..count].to_vec());
let mut s = alloc::string::String::new();
let mut enc = crate::text::TextEncoder::new(&mut s);
enc.write_extension_name("x").unwrap();
encode(60, &fields, &mut enc).unwrap();
assert_eq!(s, expected, "{name}");
}
let fields = fields_from(records);
let mut s = alloc::string::String::new();
let mut enc = crate::text::TextEncoder::new_pretty(&mut s);
enc.write_extension_name("x").unwrap();
encode(60, &fields, &mut enc).unwrap();
assert_eq!(s, "[x]: [{\n n: 1\n}, {\n n: 2\n}]", "{name}");
}
}
fn install_repeated_entries() -> alloc::vec::Vec<UnknownField> {
let singular_merges: [ExtTextMergeFn; 2] =
[message_merge_text::<Inner>, group_merge_text::<Inner>];
let mut reg = TypeRegistry::new();
let mut records = alloc::vec::Vec::new();
for (number, ((full_name, text_encode, merge), text_merge)) in
(60..).zip(REPEATED_HELPERS.into_iter().zip(singular_merges))
{
reg.register_text_ext(TextExtEntry {
number,
full_name,
extendee: "pkg.Msg",
text_encode,
text_merge,
});
let mut dec = crate::text::TextDecoder::new("f: [{ n: 1 }, {}, { n: 2 }]");
dec.read_field_name().unwrap();
records.extend(merge(&mut dec, number).unwrap());
}
set_type_registry(reg);
records
}
const REPEATED_ENTRIES: &str = "[pkg.rep] {n: 1} [pkg.rep] {} [pkg.rep] {n: 2} \
[pkg.rep_group] {n: 1} [pkg.rep_group] {} [pkg.rep_group] {n: 2}";
#[test]
fn repeated_entries_parse_with_a_merge_that_reads_one_message() {
let _g = crate::test_doubles::REGISTRY_TEST_LOCK.lock().unwrap();
let records = install_repeated_entries();
let mut s = alloc::string::String::new();
crate::text::TextEncoder::new(&mut s)
.write_extension_fields("pkg.Msg", &fields_from(records.clone()))
.unwrap();
assert_eq!(s, REPEATED_ENTRIES);
let mut dec = crate::text::TextDecoder::new(&s);
let mut reparsed = alloc::vec::Vec::new();
while let Some(name) = dec.read_field_name().unwrap() {
reparsed.extend(dec.read_extension(name, "pkg.Msg").unwrap());
}
assert_eq!(reparsed, records);
clear_text_registry();
}
#[test]
fn repeated_helper_does_not_repeat_a_name_from_an_earlier_entry() {
let _g = crate::test_doubles::REGISTRY_TEST_LOCK.lock().unwrap();
let fields = fields_from(install_repeated_entries());
let mut s = alloc::string::String::new();
let mut enc = crate::text::TextEncoder::new(&mut s);
enc.write_extension_fields("pkg.Msg", &fields).unwrap();
enc.write_extension_name("x").unwrap();
repeated_message_encode_text::<Inner>(60, &fields, &mut enc).unwrap();
assert_eq!(
s,
alloc::format!("{REPEATED_ENTRIES} [x]: [{{n: 1}}, {{}}, {{n: 2}}]")
);
clear_text_registry();
}
fn install_custom_entry(
text_encode: fn(
u32,
&UnknownFields,
&mut crate::text::TextEncoder<'_>,
) -> core::fmt::Result,
) -> UnknownFields {
let mut reg = TypeRegistry::new();
reg.register_text_ext(TextExtEntry {
number: 60,
full_name: "pkg.custom",
extendee: "pkg.Msg",
text_encode,
text_merge: repeated_message_merge_text::<Inner>,
});
set_type_registry(reg);
let mut dec = crate::text::TextDecoder::new("f: [{ n: 1 }, { n: 2 }]");
dec.read_field_name().unwrap();
fields_from(repeated_message_merge_text::<Inner>(&mut dec, 60).unwrap())
}
#[test]
fn repeated_helper_does_not_repeat_the_name_of_an_entry_that_returned() {
fn write_no_value(
_: u32,
_: &UnknownFields,
_: &mut crate::text::TextEncoder<'_>,
) -> core::fmt::Result {
Ok(())
}
let _g = crate::test_doubles::REGISTRY_TEST_LOCK.lock().unwrap();
let fields = install_custom_entry(write_no_value);
let mut s = alloc::string::String::new();
let mut enc = crate::text::TextEncoder::new(&mut s);
enc.write_extension_fields("pkg.Msg", &fields).unwrap();
repeated_message_encode_text::<Inner>(60, &fields, &mut enc).unwrap();
assert_eq!(s, "[pkg.custom]: [{n: 1}, {n: 2}]");
clear_text_registry();
}
#[test]
fn repeated_helper_does_not_repeat_a_name_that_already_has_a_value() {
fn value_then_a_direct_call(
n: u32,
f: &UnknownFields,
enc: &mut crate::text::TextEncoder<'_>,
) -> core::fmt::Result {
message_encode_text::<Inner>(n, f, enc)?;
enc.write_extension_name("x")?;
repeated_message_encode_text::<Inner>(n, f, enc)
}
let _g = crate::test_doubles::REGISTRY_TEST_LOCK.lock().unwrap();
let fields = install_custom_entry(value_then_a_direct_call);
let mut s = alloc::string::String::new();
crate::text::TextEncoder::new(&mut s)
.write_extension_fields("pkg.Msg", &fields)
.unwrap();
assert_eq!(s, "[pkg.custom] {n: 2} [x]: [{n: 1}, {n: 2}]");
clear_text_registry();
}
#[test]
fn helpers_satisfy_fn_pointer_signature() {
let _: fn(&[u8], &mut crate::text::TextEncoder<'_>) -> core::fmt::Result =
any_encode_text::<Inner>;
let _: AnyTextMergeFn = any_merge_text::<Inner>;
let _: fn(u32, &UnknownFields, &mut crate::text::TextEncoder<'_>) -> core::fmt::Result =
message_encode_text::<Inner>;
let _: ExtTextMergeFn = message_merge_text::<Inner>;
let _: fn(u32, &UnknownFields, &mut crate::text::TextEncoder<'_>) -> core::fmt::Result =
group_encode_text::<Inner>;
let _: ExtTextMergeFn = group_merge_text::<Inner>;
}
#[test]
fn register_and_lookup_text_any() {
let mut reg = TypeRegistry::new();
reg.register_text_any(TextAnyEntry {
type_url: "type.example.com/Inner",
text_encode: any_encode_text::<Inner>,
text_merge: any_merge_text::<Inner>,
});
assert!(reg.text_any_by_url("type.example.com/Inner").is_some());
assert!(reg.text_any_by_url("custom.example/v1/Inner").is_some());
assert!(reg.text_any_by_url("type.example.com/Missing").is_none());
}
#[test]
fn text_any_lookup_falls_back_to_the_last_url_registered_for_a_name() {
let mut reg = TypeRegistry::new();
for type_url in ["type.example.com/Inner", "custom.example/v1/Inner"] {
reg.register_text_any(TextAnyEntry {
type_url,
text_encode: any_encode_text::<Inner>,
text_merge: any_merge_text::<Inner>,
});
}
let found = |url| reg.text_any_by_url(url).map(|entry| entry.type_url);
assert_eq!(
found("type.example.com/Inner"),
Some("type.example.com/Inner")
);
assert_eq!(
found("custom.example/v1/Inner"),
Some("custom.example/v1/Inner")
);
assert_eq!(
found("other.example/Inner"),
Some("custom.example/v1/Inner")
);
}
#[test]
fn register_and_lookup_text_ext_both_axes() {
let mut reg = TypeRegistry::new();
reg.register_text_ext(TextExtEntry {
number: 50,
full_name: "pkg.inner_ext",
extendee: "pkg.Carrier",
text_encode: message_encode_text::<Inner>,
text_merge: message_merge_text::<Inner>,
});
let e = reg.text_ext_by_number("pkg.Carrier", 50).unwrap();
assert_eq!(e.full_name, "pkg.inner_ext");
assert!(reg.text_ext_by_number("pkg.Carrier", 99).is_none());
assert!(reg.text_ext_by_number("other.Msg", 50).is_none());
assert_eq!(reg.text_ext_by_name("pkg.inner_ext").unwrap().number, 50);
assert!(reg.text_ext_by_name("pkg.missing").is_none());
}
#[test]
fn text_ext_replacement_evicts_both_conflicting_entries() {
let mut reg = TypeRegistry::new();
let make_entry = |number, full_name| TextExtEntry {
number,
full_name,
extendee: "pkg.Carrier",
text_encode: message_encode_text::<Inner>,
text_merge: message_merge_text::<Inner>,
};
reg.register_text_ext(make_entry(50, "pkg.old"));
reg.register_text_ext(make_entry(51, "pkg.new"));
reg.register_text_ext(make_entry(50, "pkg.new"));
assert!(reg.text_ext_by_name("pkg.old").is_none());
assert_eq!(reg.text_ext_by_name("pkg.new").unwrap().number, 50);
assert_eq!(
reg.text_ext_by_number("pkg.Carrier", 50).unwrap().full_name,
"pkg.new"
);
assert!(reg.text_ext_by_number("pkg.Carrier", 51).is_none());
}
#[test]
fn text_ext_keys_the_same_number_per_extendee() {
let mut reg = TypeRegistry::new();
let make_entry = |number, full_name, extendee| TextExtEntry {
number,
full_name,
extendee,
text_encode: message_encode_text::<Inner>,
text_merge: message_merge_text::<Inner>,
};
reg.register_text_ext(make_entry(50, "pkg.ext", "pkg.Carrier"));
reg.register_text_ext(make_entry(50, "other.ext", "other.Carrier"));
assert_eq!(
reg.text_ext_by_number("pkg.Carrier", 50).unwrap().full_name,
"pkg.ext"
);
assert_eq!(
reg.text_ext_by_number("other.Carrier", 50)
.unwrap()
.full_name,
"other.ext"
);
reg.register_text_ext(make_entry(7, "pkg.ext", "other.Carrier"));
assert!(reg.text_ext_by_number("pkg.Carrier", 50).is_none());
assert_eq!(
reg.text_ext_by_number("other.Carrier", 7)
.unwrap()
.full_name,
"pkg.ext"
);
assert_eq!(
reg.text_ext_by_name("pkg.ext").unwrap().extendee,
"other.Carrier"
);
}
#[test]
fn set_type_registry_installs_text_halves() {
let _g = crate::test_doubles::REGISTRY_TEST_LOCK.lock().unwrap();
let mut reg = TypeRegistry::new();
reg.register_text_any(TextAnyEntry {
type_url: "type.example.com/Global",
text_encode: any_encode_text::<Inner>,
text_merge: any_merge_text::<Inner>,
});
reg.register_text_ext(TextExtEntry {
number: 77,
full_name: "pkg.global_ext",
extendee: "pkg.Msg",
text_encode: message_encode_text::<Inner>,
text_merge: message_merge_text::<Inner>,
});
set_type_registry(reg);
assert!(global_text_any("type.example.com/Global").is_some());
assert!(global_text_any("type.example.com/Absent").is_none());
assert_eq!(
global_text_ext_by_name("pkg.global_ext").map(|e| e.number),
Some(77)
);
assert!(global_text_ext_by_number("pkg.Msg", 77).is_some());
clear_text_registry();
assert!(global_text_any("type.example.com/Global").is_none());
}
#[test]
fn bracketed_names_with_trivia_resolve_through_the_registry() {
let _g = crate::test_doubles::REGISTRY_TEST_LOCK.lock().unwrap();
let mut reg = TypeRegistry::new();
reg.register_text_any(TextAnyEntry {
type_url: "type.example.com/pkg.Inner",
text_encode: any_encode_text::<Inner>,
text_merge: any_merge_text::<Inner>,
});
reg.register_text_ext(TextExtEntry {
number: 77,
full_name: "pkg.trivia_ext",
extendee: "pkg.Msg",
text_encode: message_encode_text::<Inner>,
text_merge: message_merge_text::<Inner>,
});
set_type_registry(reg);
let input = "[ type.example.com / # ] is comment text\n pkg . Inner ] { n: 7 }";
let mut dec = crate::text::TextDecoder::new(input);
let name = dec.read_field_name().unwrap().unwrap();
let (url, value) = dec.read_any_expansion(name).unwrap();
assert_eq!(url, "type.example.com/pkg.Inner");
assert_eq!(value, alloc::vec![0x08, 0x07]);
let input = "[ pkg . # ] is comment text\n trivia_ext ] { n: 7 }";
let mut dec = crate::text::TextDecoder::new(input);
let name = dec.read_field_name().unwrap().unwrap();
let records = dec.read_extension(name, "pkg.Msg").unwrap();
assert_eq!(records.len(), 1);
assert_eq!(records[0].number, 77);
let mut dec = crate::text::TextDecoder::new("[ pkg . other_ext ] { n: 7 }");
let name = dec.read_field_name().unwrap().unwrap();
let err = dec.read_extension(name, "pkg.Msg").unwrap_err();
assert_eq!(err.kind, crate::text::ParseErrorKind::UnknownField);
clear_text_registry();
}
}
}