use serde::{Deserialize, Serialize};
#[derive(
Serialize, Deserialize, Debug, Clone, Copy, PartialEq, Eq, Hash, gen_platform::IsVariant,
)]
pub enum CaixaKind {
Biblioteca,
Binario,
Servico,
Supervisor,
Aplicacao,
Acao,
}
impl CaixaKind {
pub const ALL: &'static [Self] = &[
Self::Biblioteca,
Self::Binario,
Self::Servico,
Self::Supervisor,
Self::Aplicacao,
Self::Acao,
];
#[must_use]
pub const fn requires_lib(self) -> bool {
matches!(self, Self::Biblioteca)
}
#[must_use]
pub const fn requires_exe(self) -> bool {
matches!(self, Self::Binario)
}
#[must_use]
pub const fn requires_servicos(self) -> bool {
matches!(self, Self::Servico)
}
#[must_use]
pub const fn requires_children(self) -> bool {
matches!(self, Self::Supervisor)
}
#[must_use]
pub const fn requires_membros(self) -> bool {
matches!(self, Self::Aplicacao)
}
#[must_use]
pub const fn requires_ci(self) -> bool {
matches!(self, Self::Acao)
}
pub const WIRE_NAMES: &'static [&'static str] = &[
crate::render::CAIXA_KIND_WIRE_BIBLIOTECA,
crate::render::CAIXA_KIND_WIRE_BINARIO,
crate::render::CAIXA_KIND_WIRE_SERVICO,
crate::render::CAIXA_KIND_WIRE_SUPERVISOR,
crate::render::CAIXA_KIND_WIRE_APLICACAO,
crate::render::CAIXA_KIND_WIRE_ACAO,
];
pub const LABELS: &'static [&'static str] = &[
crate::render::CAIXA_KIND_LABEL_BIBLIOTECA,
crate::render::CAIXA_KIND_LABEL_BINARIO,
crate::render::CAIXA_KIND_LABEL_SERVICO,
crate::render::CAIXA_KIND_LABEL_SUPERVISOR,
crate::render::CAIXA_KIND_LABEL_APLICACAO,
crate::render::CAIXA_KIND_LABEL_ACAO,
];
#[must_use]
pub const fn wire_name(self) -> &'static str {
match self {
Self::Biblioteca => crate::render::CAIXA_KIND_WIRE_BIBLIOTECA,
Self::Binario => crate::render::CAIXA_KIND_WIRE_BINARIO,
Self::Servico => crate::render::CAIXA_KIND_WIRE_SERVICO,
Self::Supervisor => crate::render::CAIXA_KIND_WIRE_SUPERVISOR,
Self::Aplicacao => crate::render::CAIXA_KIND_WIRE_APLICACAO,
Self::Acao => crate::render::CAIXA_KIND_WIRE_ACAO,
}
}
#[must_use]
pub fn from_wire(s: &str) -> Option<Self> {
match s {
crate::render::CAIXA_KIND_WIRE_BIBLIOTECA => Some(Self::Biblioteca),
crate::render::CAIXA_KIND_WIRE_BINARIO => Some(Self::Binario),
crate::render::CAIXA_KIND_WIRE_SERVICO => Some(Self::Servico),
crate::render::CAIXA_KIND_WIRE_SUPERVISOR => Some(Self::Supervisor),
crate::render::CAIXA_KIND_WIRE_APLICACAO => Some(Self::Aplicacao),
crate::render::CAIXA_KIND_WIRE_ACAO => Some(Self::Acao),
_ => None,
}
}
#[must_use]
pub const fn as_str(self) -> &'static str {
match self {
Self::Biblioteca => crate::render::CAIXA_KIND_LABEL_BIBLIOTECA,
Self::Binario => crate::render::CAIXA_KIND_LABEL_BINARIO,
Self::Servico => crate::render::CAIXA_KIND_LABEL_SERVICO,
Self::Supervisor => crate::render::CAIXA_KIND_LABEL_SUPERVISOR,
Self::Aplicacao => crate::render::CAIXA_KIND_LABEL_APLICACAO,
Self::Acao => crate::render::CAIXA_KIND_LABEL_ACAO,
}
}
}
impl std::fmt::Display for CaixaKind {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str(self.as_str())
}
}
impl AsRef<str> for CaixaKind {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl TryFrom<&str> for CaixaKind {
type Error = ();
fn try_from(s: &str) -> Result<Self, Self::Error> {
Self::from_wire(s).ok_or(())
}
}
impl From<CaixaKind> for &'static str {
fn from(kind: CaixaKind) -> &'static str {
kind.as_str()
}
}
impl From<&CaixaKind> for &'static str {
fn from(kind: &CaixaKind) -> &'static str {
kind.as_str()
}
}
impl From<CaixaKind> for String {
fn from(kind: CaixaKind) -> String {
kind.as_str().to_owned()
}
}
impl From<&CaixaKind> for String {
fn from(kind: &CaixaKind) -> String {
kind.as_str().to_owned()
}
}
impl From<CaixaKind> for std::borrow::Cow<'static, str> {
fn from(kind: CaixaKind) -> std::borrow::Cow<'static, str> {
std::borrow::Cow::Borrowed(kind.as_str())
}
}
impl From<&CaixaKind> for std::borrow::Cow<'static, str> {
fn from(kind: &CaixaKind) -> std::borrow::Cow<'static, str> {
std::borrow::Cow::Borrowed(kind.as_str())
}
}
impl From<CaixaKind> for Box<str> {
fn from(kind: CaixaKind) -> Box<str> {
Box::<str>::from(kind.as_str())
}
}
impl From<&CaixaKind> for Box<str> {
fn from(kind: &CaixaKind) -> Box<str> {
Box::<str>::from(kind.as_str())
}
}
impl From<CaixaKind> for std::sync::Arc<str> {
fn from(kind: CaixaKind) -> std::sync::Arc<str> {
std::sync::Arc::<str>::from(kind.as_str())
}
}
impl From<&CaixaKind> for std::sync::Arc<str> {
fn from(kind: &CaixaKind) -> std::sync::Arc<str> {
std::sync::Arc::<str>::from(kind.as_str())
}
}
impl std::str::FromStr for CaixaKind {
type Err = ();
fn from_str(s: &str) -> Result<Self, Self::Err> {
<Self as TryFrom<&str>>::try_from(s)
}
}
impl From<CaixaKind> for std::rc::Rc<str> {
fn from(kind: CaixaKind) -> std::rc::Rc<str> {
std::rc::Rc::<str>::from(kind.as_str())
}
}
impl From<&CaixaKind> for std::rc::Rc<str> {
fn from(kind: &CaixaKind) -> std::rc::Rc<str> {
std::rc::Rc::<str>::from(kind.as_str())
}
}
impl AsRef<[u8]> for CaixaKind {
fn as_ref(&self) -> &[u8] {
self.as_str().as_bytes()
}
}
impl From<CaixaKind> for Vec<u8> {
fn from(kind: CaixaKind) -> Vec<u8> {
kind.as_str().as_bytes().to_vec()
}
}
impl From<&CaixaKind> for Vec<u8> {
fn from(kind: &CaixaKind) -> Vec<u8> {
kind.as_str().as_bytes().to_vec()
}
}
impl TryFrom<&[u8]> for CaixaKind {
type Error = ();
fn try_from(bytes: &[u8]) -> Result<Self, Self::Error> {
std::str::from_utf8(bytes)
.ok()
.and_then(Self::from_wire)
.ok_or(())
}
}
impl TryFrom<Vec<u8>> for CaixaKind {
type Error = ();
fn try_from(bytes: Vec<u8>) -> Result<Self, Self::Error> {
<Self as TryFrom<&[u8]>>::try_from(bytes.as_slice())
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn kind_requirements() {
assert!(CaixaKind::Biblioteca.requires_lib());
assert!(!CaixaKind::Biblioteca.requires_exe());
assert!(CaixaKind::Binario.requires_exe());
assert!(CaixaKind::Servico.requires_servicos());
assert!(CaixaKind::Supervisor.requires_children());
assert!(!CaixaKind::Servico.requires_children());
assert!(CaixaKind::Acao.requires_ci());
assert!(!CaixaKind::Servico.requires_ci());
}
#[test]
fn kind_deserializes_from_pascal_symbol() {
let v: CaixaKind = serde_json::from_str("\"Biblioteca\"").unwrap();
assert_eq!(v, CaixaKind::Biblioteca);
let v: CaixaKind = serde_json::from_str("\"Supervisor\"").unwrap();
assert_eq!(v, CaixaKind::Supervisor);
}
#[test]
fn supervisor_kind_has_canonical_name() {
assert_eq!(CaixaKind::Supervisor.as_str(), "supervisor");
}
#[test]
fn caixa_kind_as_str_returns_lifted_peer_const() {
for (variant, expected) in [
(
CaixaKind::Biblioteca,
crate::render::CAIXA_KIND_LABEL_BIBLIOTECA,
),
(CaixaKind::Binario, crate::render::CAIXA_KIND_LABEL_BINARIO),
(CaixaKind::Servico, crate::render::CAIXA_KIND_LABEL_SERVICO),
(
CaixaKind::Supervisor,
crate::render::CAIXA_KIND_LABEL_SUPERVISOR,
),
(
CaixaKind::Aplicacao,
crate::render::CAIXA_KIND_LABEL_APLICACAO,
),
(CaixaKind::Acao, crate::render::CAIXA_KIND_LABEL_ACAO),
] {
assert_eq!(
variant.as_str(),
expected,
"CaixaKind::{variant:?}.as_str() must return the lifted \
CAIXA_KIND_LABEL_* const"
);
}
}
#[test]
fn caixa_kind_display_routes_through_as_str_helper() {
for &variant in CaixaKind::ALL {
assert_eq!(
variant.to_string(),
variant.as_str(),
"CaixaKind::{variant:?} Display must route through \
CaixaKind::as_str (single source of truth: the lifted \
CAIXA_KIND_LABEL_* const)"
);
}
}
#[test]
fn caixa_kind_display_matches_as_str_and_not_serialize_wire() {
for &variant in CaixaKind::ALL {
let wire = serde_json::to_string(&variant).unwrap();
let unquoted = wire
.strip_prefix('"')
.and_then(|s| s.strip_suffix('"'))
.expect("serialized CaixaKind is a JSON string");
let display = variant.to_string();
assert_eq!(
display,
variant.as_str(),
"CaixaKind::{variant:?} Display must byte-equal as_str"
);
assert_ne!(
display, unquoted,
"CaixaKind::{variant:?} Display / as_str (lowercase Portuguese \
diagnostic form) must stay structurally distinct from the \
Serialize wire format (PascalCase tatara-lisp author surface)"
);
assert!(
unquoted.chars().next().is_some_and(char::is_uppercase),
"CaixaKind::{variant:?} wire format must open with an \
uppercase byte (PascalCase tatara-lisp author surface)"
);
assert!(
display.chars().next().is_some_and(char::is_lowercase),
"CaixaKind::{variant:?} Display / as_str must open with a \
lowercase byte (Portuguese diagnostic form)"
);
}
}
#[test]
fn caixa_kind_label_consts_pin_canonical_bytes() {
assert_eq!(crate::render::CAIXA_KIND_LABEL_BIBLIOTECA, "biblioteca");
assert_eq!(crate::render::CAIXA_KIND_LABEL_BINARIO, "binario");
assert_eq!(crate::render::CAIXA_KIND_LABEL_SERVICO, "servico");
assert_eq!(crate::render::CAIXA_KIND_LABEL_SUPERVISOR, "supervisor");
assert_eq!(crate::render::CAIXA_KIND_LABEL_APLICACAO, "aplicacao");
assert_eq!(crate::render::CAIXA_KIND_LABEL_ACAO, "acao");
}
#[test]
fn caixa_kind_is_variant_predicates_partition_the_arm_set() {
let rows: [(CaixaKind, [bool; 6]); 6] = [
(
CaixaKind::Biblioteca,
[true, false, false, false, false, false],
),
(
CaixaKind::Binario,
[false, true, false, false, false, false],
),
(
CaixaKind::Servico,
[false, false, true, false, false, false],
),
(
CaixaKind::Supervisor,
[false, false, false, true, false, false],
),
(
CaixaKind::Aplicacao,
[false, false, false, false, true, false],
),
(CaixaKind::Acao, [false, false, false, false, false, true]),
];
for (variant, expected) in rows {
let observed = [
variant.is_biblioteca(),
variant.is_binario(),
variant.is_servico(),
variant.is_supervisor(),
variant.is_aplicacao(),
variant.is_acao(),
];
assert_eq!(
observed, expected,
"CaixaKind::{variant:?} is_* predicates must partition \
the arm set (biblioteca, binario, servico, supervisor, \
aplicacao, acao); got {observed:?}"
);
}
}
#[test]
fn caixa_kind_is_variant_predicates_are_const_fn() {
const {
assert!(CaixaKind::Aplicacao.is_aplicacao());
assert!(CaixaKind::Biblioteca.is_biblioteca());
assert!(CaixaKind::Servico.is_servico());
assert!(CaixaKind::Supervisor.is_supervisor());
assert!(CaixaKind::Binario.is_binario());
assert!(CaixaKind::Acao.is_acao());
}
}
#[test]
fn caixa_kind_wire_name_returns_lifted_peer_const() {
for (variant, expected) in [
(
CaixaKind::Biblioteca,
crate::render::CAIXA_KIND_WIRE_BIBLIOTECA,
),
(CaixaKind::Binario, crate::render::CAIXA_KIND_WIRE_BINARIO),
(CaixaKind::Servico, crate::render::CAIXA_KIND_WIRE_SERVICO),
(
CaixaKind::Supervisor,
crate::render::CAIXA_KIND_WIRE_SUPERVISOR,
),
(
CaixaKind::Aplicacao,
crate::render::CAIXA_KIND_WIRE_APLICACAO,
),
(CaixaKind::Acao, crate::render::CAIXA_KIND_WIRE_ACAO),
] {
assert_eq!(
variant.wire_name(),
expected,
"CaixaKind::{variant:?}.wire_name() must return the \
lifted CAIXA_KIND_WIRE_* const"
);
}
}
#[test]
fn caixa_kind_wire_name_matches_serialize_wire_byte_string() {
for &variant in CaixaKind::ALL {
let json = serde_json::to_string(&variant).unwrap();
let unquoted = json
.strip_prefix('"')
.and_then(|s| s.strip_suffix('"'))
.expect("serialized CaixaKind is a JSON string");
assert_eq!(
variant.wire_name(),
unquoted,
"CaixaKind::{variant:?}.wire_name() must byte-equal the \
un-renamed Serialize derive's wire scalar — a mismatch \
means either the derive attributes drifted or the \
CAIXA_KIND_WIRE_* const family drifted; either way \
downstream K8s-CR round-trip through caixa_from_cr \
silently splits from the accessor-routed source of \
truth"
);
}
}
#[test]
fn caixa_kind_wire_round_trips_through_from_wire() {
for &variant in CaixaKind::ALL {
let wire = variant.wire_name();
let parsed = CaixaKind::from_wire(wire).unwrap_or_else(|| {
panic!(
"CaixaKind::from_wire({wire:?}) must accept every \
CaixaKind::wire_name output — got None for the \
wire byte-string of {variant:?}"
)
});
assert_eq!(
parsed, variant,
"CaixaKind::from_wire(CaixaKind::{variant:?}.wire_name()) \
must return CaixaKind::{variant:?} — the (wire_name, \
from_wire) pair must form a total round-trip on the \
closed six-arm CaixaKind arm-set"
);
}
}
#[test]
fn caixa_kind_from_wire_rejects_unknown_byte_strings() {
for bad in [
"",
"biblioteca",
"servico",
"aplicacao",
"ACao",
"unknown",
"actor",
"Biblioteka",
] {
assert!(
CaixaKind::from_wire(bad).is_none(),
"CaixaKind::from_wire({bad:?}) must return None — the \
parser's accept-set is exactly the six CaixaKind::wire_name \
outputs; a widening would silently split the parser's \
accept-set from the emitter's"
);
}
}
#[test]
fn caixa_kind_wire_name_is_const_fn() {
const BIBLIOTECA_WIRE: &str = CaixaKind::Biblioteca.wire_name();
const BINARIO_WIRE: &str = CaixaKind::Binario.wire_name();
const SERVICO_WIRE: &str = CaixaKind::Servico.wire_name();
const SUPERVISOR_WIRE: &str = CaixaKind::Supervisor.wire_name();
const APLICACAO_WIRE: &str = CaixaKind::Aplicacao.wire_name();
const ACAO_WIRE: &str = CaixaKind::Acao.wire_name();
assert_eq!(BIBLIOTECA_WIRE, "Biblioteca");
assert_eq!(BINARIO_WIRE, "Binario");
assert_eq!(SERVICO_WIRE, "Servico");
assert_eq!(SUPERVISOR_WIRE, "Supervisor");
assert_eq!(APLICACAO_WIRE, "Aplicacao");
assert_eq!(ACAO_WIRE, "Acao");
}
#[test]
fn caixa_kind_wire_consts_are_pairwise_distinct() {
let all = [
crate::render::CAIXA_KIND_WIRE_BIBLIOTECA,
crate::render::CAIXA_KIND_WIRE_BINARIO,
crate::render::CAIXA_KIND_WIRE_SERVICO,
crate::render::CAIXA_KIND_WIRE_SUPERVISOR,
crate::render::CAIXA_KIND_WIRE_APLICACAO,
crate::render::CAIXA_KIND_WIRE_ACAO,
];
for (i, a) in all.iter().enumerate() {
for (j, b) in all.iter().enumerate() {
if i != j {
assert_ne!(
a, b,
"CAIXA_KIND_WIRE_* consts must be pairwise \
distinct — found duplicate byte-string {a:?} \
at indices {i} and {j}"
);
}
}
}
}
#[test]
fn caixa_kind_label_consts_are_pairwise_distinct() {
let all = [
crate::render::CAIXA_KIND_LABEL_BIBLIOTECA,
crate::render::CAIXA_KIND_LABEL_BINARIO,
crate::render::CAIXA_KIND_LABEL_SERVICO,
crate::render::CAIXA_KIND_LABEL_SUPERVISOR,
crate::render::CAIXA_KIND_LABEL_APLICACAO,
crate::render::CAIXA_KIND_LABEL_ACAO,
];
for (i, a) in all.iter().enumerate() {
for (j, b) in all.iter().enumerate() {
if i != j {
assert_ne!(
a, b,
"CAIXA_KIND_LABEL_* consts must be pairwise distinct \
— found duplicate byte-string {a:?} at indices {i} \
and {j}"
);
}
}
}
}
#[test]
fn caixa_kind_all_enumerates_every_variant_exactly_once() {
let all: &[CaixaKind] = CaixaKind::ALL;
assert_eq!(
all.len(),
6,
"CaixaKind::ALL must enumerate every variant of the \
six-arm closed set (Biblioteca, Binario, Servico, \
Supervisor, Aplicacao, Acao); got {all:?}"
);
for (i, a) in all.iter().enumerate() {
for (j, b) in all.iter().enumerate() {
if i != j {
assert_ne!(
a, b,
"CaixaKind::ALL must carry every variant \
exactly once — got duplicate {a:?} at \
indices {i} and {j}"
);
}
}
}
for variant in [
CaixaKind::Biblioteca,
CaixaKind::Binario,
CaixaKind::Servico,
CaixaKind::Supervisor,
CaixaKind::Aplicacao,
CaixaKind::Acao,
] {
assert!(
all.contains(&variant),
"CaixaKind::ALL must contain {variant:?} — a future \
variant addition that grows the enum but forgets to \
grow the ALL slice silently truncates every \
downstream consumer's accept-set at the pre-addition \
boundary"
);
}
}
#[test]
fn caixa_kind_all_is_the_from_wire_accept_set() {
for &variant in CaixaKind::ALL {
let wire = variant.wire_name();
assert_eq!(
CaixaKind::from_wire(wire),
Some(variant),
"CaixaKind::from_wire(CaixaKind::{variant:?}.wire_name() = \
{wire:?}) must return Some({variant:?}) — CaixaKind::ALL \
must be a subset of the from_wire accept-set"
);
}
}
#[test]
fn caixa_kind_as_ref_str_routes_through_as_str_accessor() {
for &variant in CaixaKind::ALL {
assert_eq!(
<CaixaKind as AsRef<str>>::as_ref(&variant),
variant.as_str(),
"AsRef<str> impl on CaixaKind::{variant:?} must \
byte-equal CaixaKind::as_str on the same instance — \
divergence signals a silent detour off the substrate-\
primitive accessor"
);
}
}
#[test]
fn caixa_kind_as_ref_str_routes_through_display_via_shared_accessor() {
for &variant in CaixaKind::ALL {
let via_as_ref: &str = <CaixaKind as AsRef<str>>::as_ref(&variant);
let via_display: String = format!("{variant}");
let via_accessor: &str = variant.as_str();
assert_eq!(via_as_ref, via_accessor);
assert_eq!(via_display, via_accessor);
assert_eq!(via_as_ref, via_display.as_str());
}
}
#[test]
fn caixa_kind_try_from_str_routes_through_from_wire_accessor() {
for &variant in CaixaKind::ALL {
let wire = variant.wire_name();
assert_eq!(
<CaixaKind as TryFrom<&str>>::try_from(wire),
Ok(variant),
"TryFrom<&str> impl on CaixaKind must round-trip \
CaixaKind::{variant:?}.wire_name() = {wire:?} back to \
Ok(CaixaKind::{variant:?}) — divergence from \
CaixaKind::from_wire signals a silent detour off the \
substrate-primitive accessor"
);
assert_eq!(
<CaixaKind as TryFrom<&str>>::try_from(wire).ok(),
CaixaKind::from_wire(wire),
"TryFrom<&str> ok()-projection on {wire:?} must \
byte-equal CaixaKind::from_wire on the same input"
);
}
}
#[test]
fn caixa_kind_try_from_str_rejects_unknown_byte_strings() {
let rejected: &[&str] = &[
"",
"biblioteca",
"binario",
"servico",
"supervisor",
"aplicacao",
"acao",
"BIBLIOTECA",
"BINARIO",
"SERVICO",
"SUPERVISOR",
"APLICACAO",
"ACAO",
"biBlioteca",
"Bibliotecas",
"Servicos",
"library",
"binary",
"service",
"application",
" Biblioteca",
"Biblioteca ",
"Biblioteca\n",
"\"Biblioteca\"",
];
for &input in rejected {
assert_eq!(
<CaixaKind as TryFrom<&str>>::try_from(input),
Err(()),
"TryFrom<&str> impl on CaixaKind must reject the \
non-wire byte-string {input:?} — silent acceptance \
signals an accept-set widening off the paired \
CaixaKind::from_wire resolver"
);
}
}
#[test]
fn caixa_kind_try_from_str_and_from_wire_partition_the_accept_set() {
let candidates: &[&str] = &[
"Biblioteca",
"Binario",
"Servico",
"Supervisor",
"Aplicacao",
"Acao",
"",
"biblioteca",
"servico",
"unknown",
"biBlioteca",
"\"Biblioteca\"",
" Servico ",
];
for &input in candidates {
let via_trait: Option<CaixaKind> = <CaixaKind as TryFrom<&str>>::try_from(input).ok();
let via_method: Option<CaixaKind> = CaixaKind::from_wire(input);
assert_eq!(
via_trait, via_method,
"TryFrom<&str> and from_wire must resolve identically \
on input {input:?} — divergence signals the two reverse-\
projection paths have drifted onto different accept-sets"
);
}
}
#[test]
fn caixa_kind_from_str_routes_through_try_from_str_impl() {
use std::str::FromStr;
for &variant in CaixaKind::ALL {
let wire = variant.wire_name();
assert_eq!(
<CaixaKind as FromStr>::from_str(wire),
Ok(variant),
"FromStr impl on CaixaKind must round-trip \
CaixaKind::{variant:?}.wire_name() = {wire:?} back to \
Ok(CaixaKind::{variant:?}) — divergence from \
CaixaKind::try_from signals a silent detour off the \
paired reverse-projection trait impl"
);
assert_eq!(
<CaixaKind as FromStr>::from_str(wire).ok(),
CaixaKind::from_wire(wire),
"FromStr ok()-projection on {wire:?} must byte-equal \
CaixaKind::from_wire on the same input — divergence \
signals the two reverse-projection trait paths have \
drifted off the substrate-primitive accessor"
);
let via_parse: Result<CaixaKind, ()> = wire.parse();
assert_eq!(
via_parse,
Ok(variant),
"`{wire:?}`.parse::<CaixaKind>() must resolve to \
Ok(CaixaKind::{variant:?}) — divergence signals the \
stdlib `.parse()` short-form has drifted from the \
lifted `FromStr::from_str` impl"
);
}
}
#[test]
fn caixa_kind_from_str_rejects_unknown_byte_strings() {
use std::str::FromStr;
let rejected: &[&str] = &[
"",
"biblioteca",
"binario",
"servico",
"supervisor",
"aplicacao",
"acao",
"BIBLIOTECA",
"BINARIO",
"SERVICO",
"SUPERVISOR",
"APLICACAO",
"ACAO",
"biBlioteca",
"Bibliotecas",
"Servicos",
"library",
"binary",
"service",
"application",
" Biblioteca",
"Biblioteca ",
"Biblioteca\n",
"\"Biblioteca\"",
];
for &input in rejected {
assert_eq!(
<CaixaKind as FromStr>::from_str(input),
Err(()),
"FromStr impl on CaixaKind must reject unknown \
byte-string {input:?} — divergence from \
CaixaKind::from_wire on the same input signals a \
silent accept-set widening past the six lifted \
crate::render::CAIXA_KIND_WIRE_* wire constants"
);
assert_eq!(
<CaixaKind as FromStr>::from_str(input).ok(),
CaixaKind::from_wire(input),
"FromStr ok()-projection on {input:?} must byte-equal \
CaixaKind::from_wire on the same input — divergence \
signals the FromStr trait path has drifted off the \
substrate-primitive accessor"
);
let via_parse: Result<CaixaKind, ()> = input.parse();
assert_eq!(
via_parse,
Err(()),
"`{input:?}`.parse::<CaixaKind>() must reject the \
unknown byte-string — divergence signals the stdlib \
`.parse()` short-form has drifted from the lifted \
`FromStr::from_str` impl"
);
}
}
#[test]
fn caixa_kind_all_is_const_and_matches_iteration_count() {
const ALL: &[CaixaKind] = CaixaKind::ALL;
const LEN: usize = ALL.len();
assert_eq!(
LEN, 6,
"CaixaKind::ALL length must byte-equal the six-arm closed-set \
cardinality at const-fold time"
);
}
#[test]
fn caixa_kind_from_into_static_str_routes_through_as_str_accessor() {
const BIBLIOTECA: &str = CaixaKind::Biblioteca.as_str();
const BINARIO: &str = CaixaKind::Binario.as_str();
const SERVICO: &str = CaixaKind::Servico.as_str();
const SUPERVISOR: &str = CaixaKind::Supervisor.as_str();
const APLICACAO: &str = CaixaKind::Aplicacao.as_str();
const ACAO: &str = CaixaKind::Acao.as_str();
for &variant in CaixaKind::ALL {
let via_trait: &'static str = <&'static str as From<CaixaKind>>::from(variant);
let via_method: &'static str = variant.as_str();
assert_eq!(
via_trait, via_method,
"From<CaixaKind> for &'static str impl must round-trip \
CaixaKind::{variant:?} to the same lifted \
CAIXA_KIND_LABEL_* const CaixaKind::as_str returns — \
divergence signals a silent detour off the substrate-\
primitive accessor"
);
let via_into: &'static str = variant.into();
assert_eq!(
via_into, via_method,
"Into<&'static str>::into on CaixaKind::{variant:?} must \
byte-equal CaixaKind::as_str on the same input — the \
blanket-derived Into shape must resolve to the same \
as_str dispatch as the explicit From impl"
);
}
assert_eq!(
[BIBLIOTECA, BINARIO, SERVICO, SUPERVISOR, APLICACAO, ACAO],
[
crate::render::CAIXA_KIND_LABEL_BIBLIOTECA,
crate::render::CAIXA_KIND_LABEL_BINARIO,
crate::render::CAIXA_KIND_LABEL_SERVICO,
crate::render::CAIXA_KIND_LABEL_SUPERVISOR,
crate::render::CAIXA_KIND_LABEL_APLICACAO,
crate::render::CAIXA_KIND_LABEL_ACAO,
],
"const-context CaixaKind::as_str must resolve to the six \
lifted CAIXA_KIND_LABEL_* consts — a future accidental \
downgrade of any arm to a non-const or non-static byte-\
string breaks the `&'static str`-lifetime promise the \
paired From<CaixaKind> for &'static str impl carries by \
construction"
);
}
#[test]
fn caixa_kind_from_into_static_str_and_as_str_partition_the_emit_set() {
for &variant in CaixaKind::ALL {
let via_trait: &'static str = <&'static str as From<CaixaKind>>::from(variant);
let via_method: &'static str = variant.as_str();
let via_as_ref: &str = variant.as_ref();
let via_display: String = variant.to_string();
assert_eq!(
via_trait, via_method,
"From<CaixaKind> for &'static str and CaixaKind::as_str \
must resolve identically on CaixaKind::{variant:?} — \
divergence signals the two forward-projection paths \
have drifted onto different emit-sets"
);
assert_eq!(
via_trait, via_as_ref,
"From<CaixaKind> for &'static str and AsRef<str>::as_ref \
must resolve identically on CaixaKind::{variant:?} — \
the four-path forward-projection family (as_str, \
AsRef, Display, From<Self> for &'static str) must \
land on one lifted CAIXA_KIND_LABEL_* const per arm"
);
assert_eq!(
via_trait,
via_display.as_str(),
"From<CaixaKind> for &'static str and Display must \
resolve identically on CaixaKind::{variant:?} — the \
four-path forward-projection family (as_str, AsRef, \
Display, From<Self> for &'static str) must land on one \
lifted CAIXA_KIND_LABEL_* const per arm"
);
}
for &variant in CaixaKind::ALL {
let wire: &'static str = variant.wire_name();
let re_parsed: Result<CaixaKind, ()> = <CaixaKind as TryFrom<&str>>::try_from(wire);
assert_eq!(
re_parsed,
Ok(variant),
"trait-idiomatic reverse axis (TryFrom<&str>) must \
round-trip CaixaKind::{variant:?} through wire_name \
back to Ok(CaixaKind::{variant:?}) — a break signals \
the wire-emit and reverse-parse axes have drifted \
onto different vocabularies"
);
}
for &variant in CaixaKind::ALL {
let forward: &'static str = <&'static str as From<CaixaKind>>::from(variant);
let wire: &'static str = variant.wire_name();
assert_ne!(
forward, wire,
"forward `From<CaixaKind> for &'static str` axis \
(lowercase Portuguese label) and `wire_name` axis \
(PascalCase wire) must stay disjoint on \
CaixaKind::{variant:?} — a byte-equal collapse \
signals the two-axis split the substrate keys off has \
silently merged onto one vocabulary"
);
}
}
#[test]
fn caixa_kind_from_borrowed_into_static_str_routes_through_as_str_accessor() {
const BIBLIOTECA: &str = CaixaKind::Biblioteca.as_str();
const BINARIO: &str = CaixaKind::Binario.as_str();
const SERVICO: &str = CaixaKind::Servico.as_str();
const SUPERVISOR: &str = CaixaKind::Supervisor.as_str();
const APLICACAO: &str = CaixaKind::Aplicacao.as_str();
const ACAO: &str = CaixaKind::Acao.as_str();
for variant in CaixaKind::ALL {
let via_trait: &'static str = <&'static str as From<&CaixaKind>>::from(variant);
let via_method: &'static str = variant.as_str();
assert_eq!(
via_trait, via_method,
"From<&CaixaKind> for &'static str impl must round-trip \
&CaixaKind::{variant:?} to the same lifted \
CAIXA_KIND_LABEL_* const CaixaKind::as_str returns — \
divergence signals a silent detour off the substrate-\
primitive accessor"
);
let via_into: &'static str = variant.into();
assert_eq!(
via_into, via_method,
"Into<&'static str>::into on &CaixaKind::{variant:?} \
must byte-equal CaixaKind::as_str on the same input — \
the blanket-derived Into shape must resolve to the \
same as_str dispatch as the explicit From impl"
);
}
assert_eq!(
[BIBLIOTECA, BINARIO, SERVICO, SUPERVISOR, APLICACAO, ACAO],
[
crate::render::CAIXA_KIND_LABEL_BIBLIOTECA,
crate::render::CAIXA_KIND_LABEL_BINARIO,
crate::render::CAIXA_KIND_LABEL_SERVICO,
crate::render::CAIXA_KIND_LABEL_SUPERVISOR,
crate::render::CAIXA_KIND_LABEL_APLICACAO,
crate::render::CAIXA_KIND_LABEL_ACAO,
],
"const-context CaixaKind::as_str must resolve to the six \
lifted CAIXA_KIND_LABEL_* consts — the borrowed-input \
From<&CaixaKind> for &'static str impl inherits its \
`'static` lifetime promise from the same accessor the \
owned-input sibling routes through"
);
}
#[test]
fn caixa_kind_from_owned_and_borrowed_into_static_str_agree_on_every_arm() {
for &variant in CaixaKind::ALL {
let owned: &'static str = <&'static str as From<CaixaKind>>::from(variant);
let borrowed: &'static str = <&'static str as From<&CaixaKind>>::from(&variant);
assert_eq!(
owned, borrowed,
"From<CaixaKind> and From<&CaixaKind> for &'static str \
must resolve identically on CaixaKind::{variant:?} — \
divergence signals the owned-input and borrowed-input \
forward-projection paths have drifted onto different \
emit-sets"
);
}
let via_iter: Vec<&'static str> = CaixaKind::ALL.iter().map(Into::into).collect();
let via_method: Vec<&'static str> = CaixaKind::ALL.iter().map(|k| k.as_str()).collect();
assert_eq!(
via_iter, via_method,
"`.iter().map(Into::into)` over CaixaKind::ALL must byte-\
equal `.iter().map(|k| k.as_str())` on every arm — the \
borrowed-input `From<&CaixaKind> for &'static str` axis \
is what makes the `.iter().map(Into::into)` shape route \
through the substrate-primitive `CaixaKind::as_str` \
accessor rather than through a per-call-site `.copied()` \
/ dereference detour"
);
}
#[test]
fn caixa_kind_from_into_owned_string_routes_through_as_str_accessor() {
for &variant in CaixaKind::ALL {
let via_trait: String = <String as From<CaixaKind>>::from(variant);
let via_method: &'static str = variant.as_str();
assert_eq!(
via_trait.as_str(),
via_method,
"From<CaixaKind> for String impl must round-trip \
CaixaKind::{variant:?} to the same lifted \
CAIXA_KIND_LABEL_* const CaixaKind::as_str returns — \
divergence signals a silent detour off the substrate-\
primitive accessor"
);
let via_into: String = variant.into();
assert_eq!(
via_into.as_str(),
via_method,
"Into<String>::into on CaixaKind::{variant:?} must \
byte-equal CaixaKind::as_str on the same input — the \
blanket-derived Into shape must resolve to the same \
as_str dispatch as the explicit From impl"
);
}
}
#[test]
fn caixa_kind_from_into_owned_string_and_static_str_agree_on_every_arm() {
for &variant in CaixaKind::ALL {
let owned_string: String = <String as From<CaixaKind>>::from(variant);
let owned_static: &'static str = <&'static str as From<CaixaKind>>::from(variant);
assert_eq!(
owned_string.as_str(),
owned_static,
"From<CaixaKind> for String and From<CaixaKind> for \
&'static str must resolve identically on \
CaixaKind::{variant:?} — divergence signals the \
owned-`String` and owned-`&'static str` forward-\
projection return-type-shape paths have drifted onto \
different emit-sets"
);
let via_to_string: String = variant.to_string();
assert_eq!(
owned_string, via_to_string,
"From<CaixaKind> for String must byte-equal \
CaixaKind::to_string on CaixaKind::{variant:?} — \
divergence signals the trait-idiomatic owned-`String` \
forward-projection axis and the ToString-through-\
Display axis have drifted onto different emit-sets"
);
}
let via_iter: Vec<String> = CaixaKind::ALL.iter().copied().map(String::from).collect();
let via_method: Vec<String> = CaixaKind::ALL
.iter()
.map(|k| k.as_str().to_owned())
.collect();
assert_eq!(
via_iter, via_method,
"`.iter().copied().map(String::from)` over CaixaKind::ALL \
must byte-equal `.iter().map(|k| k.as_str().to_owned())` \
on every arm — the owned-`String` `From<CaixaKind> for \
String` axis is what makes the `String::from` composition \
route through the substrate-primitive `CaixaKind::as_str` \
accessor rather than through a per-call-site `.to_owned()` \
/ `String::from(kind.as_str())` detour"
);
for &variant in CaixaKind::ALL {
let wire: &'static str = variant.wire_name();
let re_parsed: Result<CaixaKind, ()> = <CaixaKind as TryFrom<&str>>::try_from(wire);
assert_eq!(
re_parsed,
Ok(variant),
"trait-idiomatic owned-`String` forward-projection + \
reverse-projection axis pair must round-trip \
CaixaKind::{variant:?} through wire_name and back \
through TryFrom<&str> — a break signals the wire-emit \
and reverse-parse axes have drifted onto different \
vocabularies (the owned-`String` forward emit lands on \
the lowercase Portuguese diagnostic vocabulary by \
design, so the round-trip crosses through wire_name \
rather than composing the owned-`String` emit directly)"
);
}
}
#[test]
fn caixa_kind_from_into_borrowed_owned_string_routes_through_as_str_accessor() {
for &variant in CaixaKind::ALL {
let via_trait: String = <String as From<&CaixaKind>>::from(&variant);
let via_method: &'static str = variant.as_str();
assert_eq!(
via_trait.as_str(),
via_method,
"From<&CaixaKind> for String impl must round-trip \
&CaixaKind::{variant:?} to the same lifted \
CAIXA_KIND_LABEL_* const CaixaKind::as_str returns — \
divergence signals a silent detour off the substrate-\
primitive accessor"
);
let via_into: String = (&variant).into();
assert_eq!(
via_into.as_str(),
via_method,
"Into<String>::into on &CaixaKind::{variant:?} must \
byte-equal CaixaKind::as_str on the same input — the \
blanket-derived Into shape must resolve to the same \
as_str dispatch as the explicit From impl"
);
}
}
#[test]
fn caixa_kind_from_into_borrowed_owned_string_agrees_with_paired_axes_on_every_arm() {
for &kind in CaixaKind::ALL {
let borrowed_string: String = <String as From<&CaixaKind>>::from(&kind);
let owned_string: String = <String as From<CaixaKind>>::from(kind);
let borrowed_static: &'static str = <&'static str as From<&CaixaKind>>::from(&kind);
let owned_static: &'static str = <&'static str as From<CaixaKind>>::from(kind);
assert_eq!(
borrowed_string, owned_string,
"From<&CaixaKind> for String and From<CaixaKind> for \
String must resolve identically on \
CaixaKind::{kind:?} — divergence signals the \
borrowed-input and owned-input owned-`String` \
forward-projection input-shape paths have drifted \
onto different emit-sets"
);
assert_eq!(
borrowed_string.as_str(),
borrowed_static,
"From<&CaixaKind> for String and From<&CaixaKind> for \
&'static str must resolve identically on \
CaixaKind::{kind:?} — divergence signals the \
borrowed-input `&'static str` and owned-`String` \
return-shape paths have drifted onto different \
emit-sets"
);
assert_eq!(
borrowed_string.as_str(),
owned_static,
"From<&CaixaKind> for String and From<CaixaKind> for \
&'static str must resolve identically on \
CaixaKind::{kind:?} — divergence signals a break in \
the diagonal corner of the {{Self, &Self}} × \
{{&'static str, String}} 2×2 trait-idiomatic \
projection family"
);
let via_to_string: String = kind.to_string();
assert_eq!(
borrowed_string, via_to_string,
"From<&CaixaKind> for String must byte-equal \
CaixaKind::to_string on CaixaKind::{kind:?} — \
divergence signals the trait-idiomatic borrowed-\
input owned-`String` forward-projection axis and the \
ToString-through-Display axis have drifted onto \
different emit-sets"
);
}
let via_iter: Vec<String> = CaixaKind::ALL.iter().map(String::from).collect();
let via_method: Vec<String> = CaixaKind::ALL
.iter()
.map(|k| k.as_str().to_owned())
.collect();
assert_eq!(
via_iter, via_method,
"`.iter().map(String::from)` over CaixaKind::ALL — a call \
site whose iteration axis holds `&CaixaKind` by \
construction — must byte-equal `.iter().map(|k| \
k.as_str().to_owned())` on every arm — the borrowed-\
input owned-`String` `From<&CaixaKind> for String` axis \
is what makes the `String::from` composition route \
through the substrate-primitive `CaixaKind::as_str` \
accessor without a spurious `Copy` deref (which would \
only be reachable through the owned-input `From<\
CaixaKind> for String` axis by first calling `.copied()` \
on the iterator)"
);
for &variant in CaixaKind::ALL {
let wire: &'static str = variant.wire_name();
let re_parsed: Result<CaixaKind, ()> = <CaixaKind as TryFrom<&str>>::try_from(wire);
assert_eq!(
re_parsed,
Ok(variant),
"trait-idiomatic borrowed-input owned-`String` \
forward-projection + reverse-projection axis pair \
must round-trip CaixaKind::{variant:?} through \
wire_name and back through TryFrom<&str> — a break \
signals the wire-emit and reverse-parse axes have \
drifted onto different vocabularies (the borrowed-\
input owned-`String` forward emit lands on the \
lowercase Portuguese diagnostic vocabulary by \
design, so the round-trip crosses through wire_name \
rather than composing the borrowed-input \
owned-`String` emit directly)"
);
}
}
#[test]
fn caixa_kind_from_into_static_cow_str_routes_through_as_str_accessor() {
for &variant in CaixaKind::ALL {
let via_trait: std::borrow::Cow<'static, str> =
<std::borrow::Cow<'static, str> as From<CaixaKind>>::from(variant);
let via_method: &'static str = variant.as_str();
assert_eq!(
via_trait.as_ref(),
via_method,
"From<CaixaKind> for Cow<'static, str> impl must \
round-trip CaixaKind::{variant:?} to the same lifted \
CAIXA_KIND_LABEL_* const CaixaKind::as_str returns — \
divergence signals a silent detour off the \
substrate-primitive accessor"
);
assert!(
matches!(via_trait, std::borrow::Cow::Borrowed(_)),
"From<CaixaKind> for Cow<'static, str> impl must land \
on the zero-alloc Cow::Borrowed arm on \
CaixaKind::{variant:?} — a Cow::Owned outcome \
signals the projection has silently allocated where \
the substrate-primitive CaixaKind::as_str \
`&'static str` return makes the borrowed arm the \
type-correct projection"
);
let via_into: std::borrow::Cow<'static, str> = variant.into();
assert_eq!(
via_into.as_ref(),
via_method,
"Into<Cow<'static, str>>::into on \
CaixaKind::{variant:?} must byte-equal \
CaixaKind::as_str on the same input — the blanket-\
derived Into shape must resolve to the same as_str \
dispatch as the explicit From impl"
);
assert!(
matches!(via_into, std::borrow::Cow::Borrowed(_)),
"Into<Cow<'static, str>>::into on \
CaixaKind::{variant:?} must land on the zero-alloc \
Cow::Borrowed arm — the blanket-derived Into shape \
must resolve to the same Cow::Borrowed dispatch as \
the explicit From impl"
);
}
}
#[test]
fn caixa_kind_from_into_static_cow_str_agrees_with_paired_axes_on_every_arm() {
for &variant in CaixaKind::ALL {
let via_cow: std::borrow::Cow<'static, str> =
<std::borrow::Cow<'static, str> as From<CaixaKind>>::from(variant);
let via_static: &'static str = <&'static str as From<CaixaKind>>::from(variant);
let via_string: String = <String as From<CaixaKind>>::from(variant);
assert_eq!(
via_cow.as_ref(),
via_static,
"From<CaixaKind> for Cow<'static, str> and \
From<CaixaKind> for &'static str must resolve \
identically on CaixaKind::{variant:?} — divergence \
signals the Cow<'static, str> and &'static str \
return-shape paths have drifted onto different \
emit-sets"
);
assert_eq!(
via_cow.as_ref(),
via_string.as_str(),
"From<CaixaKind> for Cow<'static, str> and \
From<CaixaKind> for String must resolve identically \
on CaixaKind::{variant:?} — divergence signals the \
Cow<'static, str> and String return-shape paths \
have drifted onto different emit-sets"
);
let via_to_string: String = variant.to_string();
assert_eq!(
via_cow.as_ref(),
via_to_string.as_str(),
"From<CaixaKind> for Cow<'static, str> must byte-\
equal CaixaKind::to_string on CaixaKind::{variant:?} \
— divergence signals the trait-idiomatic \
Cow<'static, str> forward-projection axis and the \
ToString-through-Display axis have drifted onto \
different emit-sets"
);
}
let via_iter: Vec<std::borrow::Cow<'static, str>> = CaixaKind::ALL
.iter()
.copied()
.map(std::borrow::Cow::from)
.collect();
let via_method: Vec<std::borrow::Cow<'static, str>> = CaixaKind::ALL
.iter()
.map(|k| std::borrow::Cow::Borrowed(k.as_str()))
.collect();
assert_eq!(
via_iter, via_method,
"`.iter().copied().map(Cow::from)` over CaixaKind::ALL \
must byte-equal `.iter().map(|k| \
Cow::Borrowed(k.as_str()))` on every arm — the trait-\
idiomatic `From<CaixaKind> for Cow<'static, str>` axis \
is what makes the `Cow::from` composition route through \
the substrate-primitive `CaixaKind::as_str` accessor \
with the zero-alloc Cow::Borrowed arm by construction, \
rather than a per-call-site \
`Cow::Owned(kind.to_string())` allocation"
);
for cow in &via_iter {
assert!(
matches!(cow, std::borrow::Cow::Borrowed(_)),
"every element of the .iter().copied().map(Cow::from) \
pipe over CaixaKind::ALL must land on the zero-alloc \
Cow::Borrowed arm — a Cow::Owned outcome on any arm \
signals the pipe's iteration axis has silently \
allocated where the substrate-primitive \
CaixaKind::as_str `&'static str` return makes the \
borrowed arm the type-correct projection"
);
}
}
#[test]
fn caixa_kind_from_borrowed_into_static_cow_str_routes_through_as_str_accessor() {
for &variant in CaixaKind::ALL {
let via_trait: std::borrow::Cow<'static, str> =
<std::borrow::Cow<'static, str> as From<&CaixaKind>>::from(&variant);
let via_method: &'static str = variant.as_str();
assert_eq!(
via_trait.as_ref(),
via_method,
"From<&CaixaKind> for Cow<'static, str> impl must \
round-trip &CaixaKind::{variant:?} to the same lifted \
CAIXA_KIND_LABEL_* const CaixaKind::as_str returns — \
divergence signals a silent detour off the \
substrate-primitive accessor"
);
assert!(
matches!(via_trait, std::borrow::Cow::Borrowed(_)),
"From<&CaixaKind> for Cow<'static, str> impl must land \
on the zero-alloc Cow::Borrowed arm on \
CaixaKind::{variant:?} — a Cow::Owned outcome \
signals the projection has silently allocated where \
the substrate-primitive CaixaKind::as_str \
`&'static str` return makes the borrowed arm the \
type-correct projection"
);
let via_into: std::borrow::Cow<'static, str> = (&variant).into();
assert_eq!(
via_into.as_ref(),
via_method,
"Into<Cow<'static, str>>::into on &CaixaKind::{variant:?} \
must byte-equal CaixaKind::as_str on the same input \
— the blanket-derived Into shape must resolve to the \
same as_str dispatch as the explicit From impl"
);
assert!(
matches!(via_into, std::borrow::Cow::Borrowed(_)),
"Into<Cow<'static, str>>::into on &CaixaKind::{variant:?} \
must land on the zero-alloc Cow::Borrowed arm — the \
blanket-derived Into shape must resolve to the same \
Cow::Borrowed dispatch as the explicit From impl"
);
}
}
#[test]
fn caixa_kind_from_borrowed_into_static_cow_str_agrees_with_paired_axes_on_every_arm() {
for &kind in CaixaKind::ALL {
let borrowed_cow: std::borrow::Cow<'static, str> =
<std::borrow::Cow<'static, str> as From<&CaixaKind>>::from(&kind);
let owned_cow: std::borrow::Cow<'static, str> =
<std::borrow::Cow<'static, str> as From<CaixaKind>>::from(kind);
let borrowed_static: &'static str = <&'static str as From<&CaixaKind>>::from(&kind);
let borrowed_string: String = <String as From<&CaixaKind>>::from(&kind);
assert_eq!(
borrowed_cow, owned_cow,
"From<&CaixaKind> for Cow<'static, str> and \
From<CaixaKind> for Cow<'static, str> must resolve \
identically on CaixaKind::{kind:?} — divergence \
signals the borrowed-input and owned-input \
Cow<'static, str> forward-projection input-shape \
paths have drifted onto different emit-sets"
);
assert_eq!(
borrowed_cow.as_ref(),
borrowed_static,
"From<&CaixaKind> for Cow<'static, str> and \
From<&CaixaKind> for &'static str must resolve \
identically on CaixaKind::{kind:?} — divergence \
signals the borrowed-input Cow<'static, str> and \
&'static str return-shape paths have drifted onto \
different emit-sets"
);
assert_eq!(
borrowed_cow.as_ref(),
borrowed_string.as_str(),
"From<&CaixaKind> for Cow<'static, str> and \
From<&CaixaKind> for String must resolve identically \
on CaixaKind::{kind:?} — divergence signals the \
borrowed-input Cow<'static, str> and owned-`String` \
return-shape paths have drifted onto different \
emit-sets"
);
let via_to_string: String = kind.to_string();
assert_eq!(
borrowed_cow.as_ref(),
via_to_string.as_str(),
"From<&CaixaKind> for Cow<'static, str> must byte-\
equal CaixaKind::to_string on CaixaKind::{kind:?} — \
divergence signals the trait-idiomatic borrowed-\
input Cow<'static, str> forward-projection axis and \
the ToString-through-Display axis have drifted onto \
different emit-sets"
);
}
let via_iter: Vec<std::borrow::Cow<'static, str>> =
CaixaKind::ALL.iter().map(std::borrow::Cow::from).collect();
let via_method: Vec<std::borrow::Cow<'static, str>> = CaixaKind::ALL
.iter()
.map(|k| std::borrow::Cow::Borrowed(k.as_str()))
.collect();
assert_eq!(
via_iter, via_method,
"`.iter().map(Cow::from)` over CaixaKind::ALL — a call \
site whose iteration axis holds `&CaixaKind` by \
construction — must byte-equal `.iter().map(|k| \
Cow::Borrowed(k.as_str()))` on every arm — the \
borrowed-input Cow<'static, str> `From<&CaixaKind> for \
Cow<'static, str>` axis is what makes the `Cow::from` \
composition route through the substrate-primitive \
`CaixaKind::as_str` accessor with the zero-alloc \
Cow::Borrowed arm by construction and without a spurious \
`Copy` deref (which would only be reachable through the \
owned-input `From<CaixaKind> for Cow<'static, str>` axis \
by first calling `.copied()` on the iterator)"
);
for cow in &via_iter {
assert!(
matches!(cow, std::borrow::Cow::Borrowed(_)),
"every element of the .iter().map(Cow::from) pipe \
over CaixaKind::ALL must land on the zero-alloc \
Cow::Borrowed arm — a Cow::Owned outcome on any arm \
signals the pipe's iteration axis has silently \
allocated where the substrate-primitive \
CaixaKind::as_str `&'static str` return makes the \
borrowed arm the type-correct projection"
);
}
}
#[test]
fn caixa_kind_from_into_box_str_routes_through_as_str_accessor() {
for &variant in CaixaKind::ALL {
let via_trait: Box<str> = <Box<str> as From<CaixaKind>>::from(variant);
let via_method: &'static str = variant.as_str();
assert_eq!(
via_trait.as_ref(),
via_method,
"From<CaixaKind> for Box<str> impl must round-trip \
CaixaKind::{variant:?} to the same lowercase-Portuguese \
byte-string CaixaKind::as_str returns — divergence \
signals a silent detour off the substrate-primitive \
accessor"
);
let via_into: Box<str> = variant.into();
assert_eq!(
via_into.as_ref(),
via_method,
"Into<Box<str>>::into on CaixaKind::{variant:?} must \
byte-equal CaixaKind::as_str on the same input — the \
blanket-derived Into shape must resolve to the same \
as_str dispatch as the explicit From impl"
);
}
}
#[test]
fn caixa_kind_from_borrowed_into_box_str_routes_through_as_str_accessor() {
for &variant in CaixaKind::ALL {
let via_trait: Box<str> = <Box<str> as From<&CaixaKind>>::from(&variant);
let via_method: &'static str = variant.as_str();
assert_eq!(
via_trait.as_ref(),
via_method,
"From<&CaixaKind> for Box<str> impl must round-trip \
&CaixaKind::{variant:?} to the same lowercase-\
Portuguese byte-string CaixaKind::as_str returns — \
divergence signals a silent detour off the substrate-\
primitive accessor"
);
let via_into: Box<str> = (&variant).into();
assert_eq!(
via_into.as_ref(),
via_method,
"Into<Box<str>>::into on &CaixaKind::{variant:?} must \
byte-equal CaixaKind::as_str on the same input — the \
blanket-derived Into shape on the borrowed-input \
surface must resolve to the same as_str dispatch as \
the explicit From impl"
);
}
let via_pipe: Vec<Box<str>> = CaixaKind::ALL.iter().map(Box::<str>::from).collect();
let via_accessor: Vec<&'static str> = CaixaKind::ALL.iter().map(|k| k.as_str()).collect();
assert_eq!(
via_pipe.len(),
via_accessor.len(),
"CaixaKind::ALL.iter().map(Box::<str>::from) pipe must \
preserve arity against the paired CaixaKind::as_str \
accessor — a length divergence signals the borrowed-input \
axis has silently rejected an arm"
);
for (pipe_arm, accessor_arm) in via_pipe.iter().zip(via_accessor.iter()) {
assert_eq!(
pipe_arm.as_ref(),
*accessor_arm,
"CaixaKind::ALL.iter().map(Box::<str>::from) pipe must \
byte-equal the paired CaixaKind::ALL.iter().map(|k| \
k.as_str()) pipe on every arm — divergence signals the \
borrowed-input `From<&CaixaKind> for Box<str>` axis \
has silently detoured off the substrate-primitive \
accessor"
);
}
}
#[test]
fn caixa_kind_from_into_arc_str_routes_through_as_str_accessor() {
for &variant in CaixaKind::ALL {
let via_trait: std::sync::Arc<str> =
<std::sync::Arc<str> as From<CaixaKind>>::from(variant);
let via_method: &'static str = variant.as_str();
assert_eq!(
via_trait.as_ref(),
via_method,
"From<CaixaKind> for std::sync::Arc<str> impl must round-\
trip CaixaKind::{variant:?} to the same lowercase-\
Portuguese byte-string CaixaKind::as_str returns — \
divergence signals a silent detour off the substrate-\
primitive accessor"
);
let via_into: std::sync::Arc<str> = variant.into();
assert_eq!(
via_into.as_ref(),
via_method,
"Into<std::sync::Arc<str>>::into on CaixaKind::{variant:?} \
must byte-equal CaixaKind::as_str on the same input — \
the blanket-derived Into shape must resolve to the same \
as_str dispatch as the explicit From impl"
);
let owned_static: &'static str = <&'static str as From<CaixaKind>>::from(variant);
assert_eq!(
via_trait.as_ref(),
owned_static,
"From<CaixaKind> for std::sync::Arc<str> and \
From<CaixaKind> for &'static str must resolve identically \
on CaixaKind::{variant:?} — divergence signals the owned-\
input std::sync::Arc<str> and &'static str return-shape \
paths have drifted onto different emit-sets"
);
let owned_string: String = <String as From<CaixaKind>>::from(variant);
assert_eq!(
via_trait.as_ref(),
owned_string.as_str(),
"From<CaixaKind> for std::sync::Arc<str> and \
From<CaixaKind> for String must resolve identically on \
CaixaKind::{variant:?} — divergence signals the owned-\
input std::sync::Arc<str> and owned-`String` return-shape \
paths have drifted onto different emit-sets"
);
let owned_cow: std::borrow::Cow<'static, str> =
<std::borrow::Cow<'static, str> as From<CaixaKind>>::from(variant);
assert_eq!(
via_trait.as_ref(),
owned_cow.as_ref(),
"From<CaixaKind> for std::sync::Arc<str> and \
From<CaixaKind> for Cow<'static, str> must resolve \
identically on CaixaKind::{variant:?} — divergence \
signals the owned-input std::sync::Arc<str> and \
Cow<'static, str> return-shape paths have drifted onto \
different emit-sets"
);
let owned_box: Box<str> = <Box<str> as From<CaixaKind>>::from(variant);
assert_eq!(
via_trait.as_ref(),
owned_box.as_ref(),
"From<CaixaKind> for std::sync::Arc<str> and \
From<CaixaKind> for Box<str> must resolve identically on \
CaixaKind::{variant:?} — divergence signals the owned-\
input std::sync::Arc<str> and Box<str> return-shape paths \
have drifted onto different emit-sets"
);
}
}
#[test]
#[allow(
clippy::too_many_lines,
reason = "cross-axis partition pin folds four borrowed-input \
return-shape paths (&'static str, String, Cow<'static, \
str>, Box<str>) plus the paired owned-input Arc<str> \
witness and the .iter().map(std::sync::Arc::<str>::from) \
pipe witness into one exhaustive round-trip over \
CaixaKind::ALL — the accepted line-count cost of keying \
the whole borrowed-input Arc<str> corner to the \
substrate-primitive as_str accessor at the same test-site"
)]
fn caixa_kind_from_borrowed_into_arc_str_routes_through_as_str_accessor() {
for &variant in CaixaKind::ALL {
let via_trait: std::sync::Arc<str> =
<std::sync::Arc<str> as From<&CaixaKind>>::from(&variant);
let via_method: &'static str = variant.as_str();
assert_eq!(
via_trait.as_ref(),
via_method,
"From<&CaixaKind> for std::sync::Arc<str> impl must round-\
trip &CaixaKind::{variant:?} to the same lowercase-\
Portuguese byte-string CaixaKind::as_str returns — \
divergence signals a silent detour off the substrate-\
primitive accessor"
);
let via_into: std::sync::Arc<str> = (&variant).into();
assert_eq!(
via_into.as_ref(),
via_method,
"Into<std::sync::Arc<str>>::into on &CaixaKind::\
{variant:?} must byte-equal CaixaKind::as_str on the \
same input — the blanket-derived Into shape on the \
borrowed-input surface must resolve to the same as_str \
dispatch as the explicit From impl"
);
let owned_arc: std::sync::Arc<str> =
<std::sync::Arc<str> as From<CaixaKind>>::from(variant);
assert_eq!(
via_trait, owned_arc,
"From<&CaixaKind> for std::sync::Arc<str> and \
From<CaixaKind> for std::sync::Arc<str> must resolve \
identically on CaixaKind::{variant:?} — divergence \
signals the borrowed-input and owned-input \
std::sync::Arc<str> forward-projection input-shape paths \
have drifted onto different emit-sets"
);
let borrowed_static: &'static str = <&'static str as From<&CaixaKind>>::from(&variant);
assert_eq!(
via_trait.as_ref(),
borrowed_static,
"From<&CaixaKind> for std::sync::Arc<str> and \
From<&CaixaKind> for &'static str must resolve \
identically on CaixaKind::{variant:?} — divergence \
signals the borrowed-input std::sync::Arc<str> and \
&'static str return-shape paths have drifted onto \
different emit-sets"
);
let borrowed_string: String = <String as From<&CaixaKind>>::from(&variant);
assert_eq!(
via_trait.as_ref(),
borrowed_string.as_str(),
"From<&CaixaKind> for std::sync::Arc<str> and \
From<&CaixaKind> for String must resolve identically on \
CaixaKind::{variant:?} — divergence signals the \
borrowed-input std::sync::Arc<str> and owned-`String` \
return-shape paths have drifted onto different emit-sets"
);
let borrowed_cow: std::borrow::Cow<'static, str> =
<std::borrow::Cow<'static, str> as From<&CaixaKind>>::from(&variant);
assert_eq!(
via_trait.as_ref(),
borrowed_cow.as_ref(),
"From<&CaixaKind> for std::sync::Arc<str> and \
From<&CaixaKind> for Cow<'static, str> must resolve \
identically on CaixaKind::{variant:?} — divergence \
signals the borrowed-input std::sync::Arc<str> and \
Cow<'static, str> return-shape paths have drifted onto \
different emit-sets"
);
let borrowed_box: Box<str> = <Box<str> as From<&CaixaKind>>::from(&variant);
assert_eq!(
via_trait.as_ref(),
borrowed_box.as_ref(),
"From<&CaixaKind> for std::sync::Arc<str> and \
From<&CaixaKind> for Box<str> must resolve identically \
on CaixaKind::{variant:?} — divergence signals the \
borrowed-input std::sync::Arc<str> and Box<str> return-\
shape paths have drifted onto different emit-sets"
);
}
let via_iter: Vec<std::sync::Arc<str>> = CaixaKind::ALL
.iter()
.map(std::sync::Arc::<str>::from)
.collect();
let via_method: Vec<std::sync::Arc<str>> = CaixaKind::ALL
.iter()
.map(|k| std::sync::Arc::<str>::from(k.as_str()))
.collect();
assert_eq!(
via_iter, via_method,
"`.iter().map(std::sync::Arc::<str>::from)` over \
CaixaKind::ALL — a call site whose iteration axis holds \
`&CaixaKind` by construction — must byte-equal \
`.iter().map(|k| std::sync::Arc::<str>::from(k.as_str()))` \
on every arm — the borrowed-input std::sync::Arc<str> \
`From<&CaixaKind> for std::sync::Arc<str>` axis is what \
makes the `std::sync::Arc::<str>::from` composition route \
through the substrate-primitive `CaixaKind::as_str` \
accessor without a spurious `Copy` deref (which would only \
be reachable through the owned-input \
`From<CaixaKind> for std::sync::Arc<str>` axis by first \
calling `.copied()` on the iterator)"
);
}
#[test]
fn caixa_kind_wire_names_covers_every_arm() {
assert_eq!(
CaixaKind::WIRE_NAMES.len(),
CaixaKind::ALL.len(),
"CaixaKind::WIRE_NAMES.len() must byte-equal \
CaixaKind::ALL.len() — a mismatch means the roster and \
the enum's arm-set have drifted; the two rosters \
enumerate the same closed six-arm set through different \
axes (variant vs. wire byte-string) and downstream \
consumers that fan through both will silently disagree \
on the accepted arm-set"
);
for &variant in CaixaKind::ALL {
let wire = variant.wire_name();
assert!(
CaixaKind::WIRE_NAMES.contains(&wire),
"CaixaKind::{variant:?}.wire_name() = {wire:?} must be \
a member of CaixaKind::WIRE_NAMES — the emitter and \
the roster have drifted out of lockstep"
);
}
for tag in CaixaKind::WIRE_NAMES {
let first = tag.chars().next().unwrap_or_else(|| {
panic!(
"CaixaKind::WIRE_NAMES entry {tag:?} must be a \
non-empty PascalCase byte-string"
)
});
assert!(
first.is_ascii_uppercase(),
"CaixaKind::WIRE_NAMES entry {tag:?} must open with an \
ASCII uppercase byte (PascalCase wire form) — a \
lowercase entry would collide the roster with the \
sibling CaixaKind::as_str lowercase-Portuguese label \
axis"
);
}
}
#[test]
fn caixa_kind_labels_covers_every_arm() {
assert_eq!(
CaixaKind::LABELS.len(),
CaixaKind::ALL.len(),
"CaixaKind::LABELS.len() must byte-equal \
CaixaKind::ALL.len() — a mismatch means the roster and \
the enum's arm-set have drifted; the two rosters \
enumerate the same closed six-arm set through different \
axes (variant vs. lowercase-Portuguese human-readable \
label byte-string) and downstream consumers that fan \
through both will silently disagree on the accepted \
arm-set"
);
for &variant in CaixaKind::ALL {
let label = variant.as_str();
assert!(
CaixaKind::LABELS.contains(&label),
"CaixaKind::{variant:?}.as_str() = {label:?} must be \
a member of CaixaKind::LABELS — the emitter and the \
roster have drifted out of lockstep"
);
}
for tag in CaixaKind::LABELS {
let first = tag.chars().next().unwrap_or_else(|| {
panic!(
"CaixaKind::LABELS entry {tag:?} must be a \
non-empty lowercase-Portuguese human-readable \
label byte-string"
)
});
assert!(
first.is_ascii_lowercase(),
"CaixaKind::LABELS entry {tag:?} must open with an \
ASCII lowercase byte (lowercase-Portuguese label \
form) — an uppercase entry would collide the roster \
with the sibling CaixaKind::wire_name PascalCase wire \
axis"
);
}
}
#[test]
#[allow(
clippy::too_many_lines,
reason = "cross-axis partition pin folds five owned-input \
return-shape paths (&'static str, String, Cow<'static, \
str>, Box<str>, std::sync::Arc<str>) plus the paired \
Rc<str> witness into one exhaustive round-trip over \
CaixaKind::ALL — the accepted line-count cost of keying \
the whole owned-input Rc<str> corner to the substrate-\
primitive as_str accessor at the same test-site"
)]
fn caixa_kind_from_into_rc_str_routes_through_as_str_accessor() {
for &variant in CaixaKind::ALL {
let via_trait: std::rc::Rc<str> = <std::rc::Rc<str> as From<CaixaKind>>::from(variant);
let via_method: &'static str = variant.as_str();
assert_eq!(
via_trait.as_ref(),
via_method,
"From<CaixaKind> for std::rc::Rc<str> impl must round-\
trip CaixaKind::{variant:?} to the same lowercase-\
Portuguese byte-string CaixaKind::as_str returns — \
divergence signals a silent detour off the substrate-\
primitive accessor"
);
let via_into: std::rc::Rc<str> = variant.into();
assert_eq!(
via_into.as_ref(),
via_method,
"Into<std::rc::Rc<str>>::into on CaixaKind::{variant:?} \
must byte-equal CaixaKind::as_str on the same input — \
the blanket-derived Into shape must resolve to the \
same as_str dispatch as the explicit From impl"
);
let owned_static: &'static str = <&'static str as From<CaixaKind>>::from(variant);
assert_eq!(
via_trait.as_ref(),
owned_static,
"From<CaixaKind> for std::rc::Rc<str> and \
From<CaixaKind> for &'static str must resolve \
identically on CaixaKind::{variant:?} — divergence \
signals the owned-input std::rc::Rc<str> and \
&'static str return-shape paths have drifted onto \
different emit-sets"
);
let owned_string: String = <String as From<CaixaKind>>::from(variant);
assert_eq!(
via_trait.as_ref(),
owned_string.as_str(),
"From<CaixaKind> for std::rc::Rc<str> and \
From<CaixaKind> for String must resolve identically \
on CaixaKind::{variant:?} — divergence signals the \
owned-input std::rc::Rc<str> and owned-`String` \
return-shape paths have drifted onto different emit-\
sets"
);
let owned_cow: std::borrow::Cow<'static, str> =
<std::borrow::Cow<'static, str> as From<CaixaKind>>::from(variant);
assert_eq!(
via_trait.as_ref(),
owned_cow.as_ref(),
"From<CaixaKind> for std::rc::Rc<str> and \
From<CaixaKind> for Cow<'static, str> must resolve \
identically on CaixaKind::{variant:?} — divergence \
signals the owned-input std::rc::Rc<str> and \
Cow<'static, str> return-shape paths have drifted \
onto different emit-sets"
);
let owned_box: Box<str> = <Box<str> as From<CaixaKind>>::from(variant);
assert_eq!(
via_trait.as_ref(),
owned_box.as_ref(),
"From<CaixaKind> for std::rc::Rc<str> and \
From<CaixaKind> for Box<str> must resolve identically \
on CaixaKind::{variant:?} — divergence signals the \
owned-input std::rc::Rc<str> and Box<str> return-\
shape paths have drifted onto different emit-sets"
);
let owned_arc: std::sync::Arc<str> =
<std::sync::Arc<str> as From<CaixaKind>>::from(variant);
assert_eq!(
via_trait.as_ref(),
owned_arc.as_ref(),
"From<CaixaKind> for std::rc::Rc<str> and \
From<CaixaKind> for std::sync::Arc<str> must resolve \
identically on CaixaKind::{variant:?} — divergence \
signals the owned-input single-threaded-refcounted \
std::rc::Rc<str> and atomically-refcounted \
std::sync::Arc<str> return-shape paths have drifted \
onto different emit-sets"
);
}
}
#[test]
#[allow(
clippy::too_many_lines,
reason = "cross-axis partition pin folds five borrowed-input \
return-shape paths (&'static str, String, Cow<'static, \
str>, Box<str>, std::sync::Arc<str>) plus the paired \
owned-input Rc<str> witness and the \
.iter().map(std::rc::Rc::<str>::from) pipe witness \
into one exhaustive round-trip over CaixaKind::ALL — \
the accepted line-count cost of keying the whole \
borrowed-input Rc<str> corner to the substrate-\
primitive as_str accessor at the same test-site"
)]
fn caixa_kind_from_borrowed_into_rc_str_routes_through_as_str_accessor() {
for &variant in CaixaKind::ALL {
let via_trait: std::rc::Rc<str> =
<std::rc::Rc<str> as From<&CaixaKind>>::from(&variant);
let via_method: &'static str = variant.as_str();
assert_eq!(
via_trait.as_ref(),
via_method,
"From<&CaixaKind> for std::rc::Rc<str> impl must \
round-trip &CaixaKind::{variant:?} to the same \
lowercase-Portuguese byte-string CaixaKind::as_str \
returns — divergence signals a silent detour off the \
substrate-primitive accessor"
);
let via_into: std::rc::Rc<str> = (&variant).into();
assert_eq!(
via_into.as_ref(),
via_method,
"Into<std::rc::Rc<str>>::into on &CaixaKind::\
{variant:?} must byte-equal CaixaKind::as_str on the \
same input — the blanket-derived Into shape on the \
borrowed-input surface must resolve to the same \
as_str dispatch as the explicit From impl"
);
let owned_rc: std::rc::Rc<str> = <std::rc::Rc<str> as From<CaixaKind>>::from(variant);
assert_eq!(
via_trait, owned_rc,
"From<&CaixaKind> for std::rc::Rc<str> and \
From<CaixaKind> for std::rc::Rc<str> must resolve \
identically on CaixaKind::{variant:?} — divergence \
signals the borrowed-input and owned-input \
std::rc::Rc<str> forward-projection input-shape paths \
have drifted onto different emit-sets"
);
let borrowed_static: &'static str = <&'static str as From<&CaixaKind>>::from(&variant);
assert_eq!(
via_trait.as_ref(),
borrowed_static,
"From<&CaixaKind> for std::rc::Rc<str> and \
From<&CaixaKind> for &'static str must resolve \
identically on CaixaKind::{variant:?} — divergence \
signals the borrowed-input std::rc::Rc<str> and \
&'static str return-shape paths have drifted onto \
different emit-sets"
);
let borrowed_string: String = <String as From<&CaixaKind>>::from(&variant);
assert_eq!(
via_trait.as_ref(),
borrowed_string.as_str(),
"From<&CaixaKind> for std::rc::Rc<str> and \
From<&CaixaKind> for String must resolve identically \
on CaixaKind::{variant:?} — divergence signals the \
borrowed-input std::rc::Rc<str> and owned-`String` \
return-shape paths have drifted onto different emit-\
sets"
);
let borrowed_cow: std::borrow::Cow<'static, str> =
<std::borrow::Cow<'static, str> as From<&CaixaKind>>::from(&variant);
assert_eq!(
via_trait.as_ref(),
borrowed_cow.as_ref(),
"From<&CaixaKind> for std::rc::Rc<str> and \
From<&CaixaKind> for Cow<'static, str> must resolve \
identically on CaixaKind::{variant:?} — divergence \
signals the borrowed-input std::rc::Rc<str> and \
Cow<'static, str> return-shape paths have drifted \
onto different emit-sets"
);
let borrowed_box: Box<str> = <Box<str> as From<&CaixaKind>>::from(&variant);
assert_eq!(
via_trait.as_ref(),
borrowed_box.as_ref(),
"From<&CaixaKind> for std::rc::Rc<str> and \
From<&CaixaKind> for Box<str> must resolve \
identically on CaixaKind::{variant:?} — divergence \
signals the borrowed-input std::rc::Rc<str> and \
Box<str> return-shape paths have drifted onto \
different emit-sets"
);
let borrowed_arc: std::sync::Arc<str> =
<std::sync::Arc<str> as From<&CaixaKind>>::from(&variant);
assert_eq!(
via_trait.as_ref(),
borrowed_arc.as_ref(),
"From<&CaixaKind> for std::rc::Rc<str> and \
From<&CaixaKind> for std::sync::Arc<str> must \
resolve identically on CaixaKind::{variant:?} — \
divergence signals the borrowed-input single-threaded-\
refcounted std::rc::Rc<str> and atomically-refcounted \
std::sync::Arc<str> return-shape paths have drifted \
onto different emit-sets"
);
}
let pipe: Vec<std::rc::Rc<str>> = CaixaKind::ALL
.iter()
.map(std::rc::Rc::<str>::from)
.collect();
assert_eq!(pipe.len(), CaixaKind::ALL.len());
for (i, &variant) in CaixaKind::ALL.iter().enumerate() {
assert_eq!(
pipe[i].as_ref(),
variant.as_str(),
"`.iter().map(std::rc::Rc::<str>::from)` pipe over \
CaixaKind::ALL must yield the same lowercase-\
Portuguese byte-string CaixaKind::as_str returns for \
CaixaKind::{variant:?}"
);
}
}
#[test]
#[allow(
clippy::too_many_lines,
reason = "cross-axis partition pin folds the substrate-primitive \
as_str accessor's `.as_bytes()` byte-tail plus the \
paired str-view (AsRef<str>, Display, as_str) and \
reverse-projection ({&'static str, String, Cow<'static, \
str>, Box<str>, std::sync::Arc<str>, std::rc::Rc<str>}) \
return-shape axes' `.as_bytes()` byte-tails plus a \
<T: AsRef<[u8]>>-bound-consumer witness plus a \
blake3::Hasher::update-shape byte-input surface witness \
into one exhaustive round-trip over CaixaKind::ALL — the \
accepted line-count cost of opening the byte-view axis \
keyed to the substrate-primitive as_str accessor at the \
same test-site"
)]
#[allow(
clippy::needless_borrows_for_generic_args,
reason = "the borrowed-input surface (&variant) is exercised \
deliberately: the `<T: AsRef<[u8]>>`-bound consumer and \
the `blake3::Hasher::update`-shape byte-input surface \
both accept either owned or borrowed input through the \
standard-library blanket `impl<T: ?Sized + AsRef<[u8]>> \
AsRef<[u8]> for &T`, and this pin round-trips both \
input shapes to lock the borrowed-input path load-\
bearing against a future silent regression"
)]
fn caixa_kind_as_ref_bytes_routes_through_as_str_accessor() {
fn generic_bytes_sink<T: AsRef<[u8]>>(t: T) -> Vec<u8> {
t.as_ref().to_vec()
}
struct MockHasher(Vec<u8>);
impl MockHasher {
fn new() -> Self {
Self(Vec::new())
}
fn update(&mut self, bytes: impl AsRef<[u8]>) -> &mut Self {
self.0.extend_from_slice(bytes.as_ref());
self
}
fn finalize(self) -> Vec<u8> {
self.0
}
}
for &variant in CaixaKind::ALL {
let via_trait: &[u8] = <CaixaKind as AsRef<[u8]>>::as_ref(&variant);
let via_method_bytes: &[u8] = variant.as_str().as_bytes();
assert_eq!(
via_trait, via_method_bytes,
"AsRef<[u8]> for CaixaKind impl must byte-equal \
CaixaKind::as_str().as_bytes() on CaixaKind::\
{variant:?} — divergence signals a silent detour off \
the substrate-primitive accessor"
);
let str_view_ref: &str = <CaixaKind as AsRef<str>>::as_ref(&variant);
assert_eq!(
via_trait,
str_view_ref.as_bytes(),
"AsRef<[u8]> for CaixaKind and AsRef<str> for \
CaixaKind must resolve to byte-equal byte-tails on \
CaixaKind::{variant:?} — divergence signals the \
byte-view and str-view axes have drifted off the same \
substrate-primitive as_str accessor"
);
let display_bytes = variant.to_string();
assert_eq!(
via_trait,
display_bytes.as_bytes(),
"AsRef<[u8]> for CaixaKind and \
<CaixaKind as std::fmt::Display>::to_string must \
resolve to byte-equal byte-tails on CaixaKind::\
{variant:?} — divergence signals the byte-view axis \
and the Display formatter axis have drifted off the \
same substrate-primitive as_str accessor"
);
let owned_static: &'static str = <&'static str as From<CaixaKind>>::from(variant);
assert_eq!(
via_trait,
owned_static.as_bytes(),
"AsRef<[u8]> for CaixaKind and From<CaixaKind> for \
&'static str must resolve to byte-equal byte-tails on \
CaixaKind::{variant:?}"
);
let owned_string: String = <String as From<CaixaKind>>::from(variant);
assert_eq!(
via_trait,
owned_string.as_bytes(),
"AsRef<[u8]> for CaixaKind and From<CaixaKind> for \
String must resolve to byte-equal byte-tails on \
CaixaKind::{variant:?}"
);
let owned_cow: std::borrow::Cow<'static, str> =
<std::borrow::Cow<'static, str> as From<CaixaKind>>::from(variant);
assert_eq!(
via_trait,
owned_cow.as_bytes(),
"AsRef<[u8]> for CaixaKind and From<CaixaKind> for \
Cow<'static, str> must resolve to byte-equal byte-\
tails on CaixaKind::{variant:?}"
);
let owned_box: Box<str> = <Box<str> as From<CaixaKind>>::from(variant);
assert_eq!(
via_trait,
owned_box.as_bytes(),
"AsRef<[u8]> for CaixaKind and From<CaixaKind> for \
Box<str> must resolve to byte-equal byte-tails on \
CaixaKind::{variant:?}"
);
let owned_arc: std::sync::Arc<str> =
<std::sync::Arc<str> as From<CaixaKind>>::from(variant);
assert_eq!(
via_trait,
owned_arc.as_bytes(),
"AsRef<[u8]> for CaixaKind and From<CaixaKind> for \
std::sync::Arc<str> must resolve to byte-equal byte-\
tails on CaixaKind::{variant:?}"
);
let owned_rc_str: std::rc::Rc<str> =
<std::rc::Rc<str> as From<CaixaKind>>::from(variant);
assert_eq!(
via_trait,
owned_rc_str.as_bytes(),
"AsRef<[u8]> for CaixaKind and From<CaixaKind> for \
std::rc::Rc<str> must resolve to byte-equal byte-\
tails on CaixaKind::{variant:?}"
);
let wire_bytes = variant.wire_name().as_bytes();
assert_ne!(
via_trait, wire_bytes,
"AsRef<[u8]> for CaixaKind must land on the \
lowercase-Portuguese diagnostic byte-string \
(CaixaKind::as_str), not the PascalCase wire byte-\
string (CaixaKind::wire_name) — the two-axis split \
is by design; if this fails on CaixaKind::{variant:?}, \
the byte-view axis has silently collapsed onto the \
wire axis"
);
}
for &variant in CaixaKind::ALL {
let via_generic = generic_bytes_sink(variant);
let via_borrowed_generic = generic_bytes_sink(&variant);
let via_method_bytes = variant.as_str().as_bytes().to_vec();
assert_eq!(
via_generic, via_method_bytes,
"generic `<T: AsRef<[u8]>>`-bound consumer on \
CaixaKind::{variant:?} must yield the same byte-tail \
CaixaKind::as_str().as_bytes() returns — divergence \
signals the byte-view axis fails to bridge a generic \
byte-input trait bound to the substrate-primitive \
accessor"
);
assert_eq!(
via_borrowed_generic, via_method_bytes,
"generic `<T: AsRef<[u8]>>`-bound consumer on \
&CaixaKind::{variant:?} must yield the same byte-tail \
CaixaKind::as_str().as_bytes() returns — the borrowed-
input surface must resolve to the same as_str dispatch"
);
}
for &variant in CaixaKind::ALL {
let mut owned_hasher = MockHasher::new();
owned_hasher.update(variant);
let owned_folded = owned_hasher.finalize();
assert_eq!(
owned_folded,
variant.as_str().as_bytes(),
"`hasher.update(kind)`-shape composition on \
CaixaKind::{variant:?} must fold the same byte-tail \
CaixaKind::as_str().as_bytes() returns — the shape a \
future per-caixa BLAKE3 content-address closure \
composes to fold a `:kind` discriminator byte-tag into \
the Lacre closure body"
);
let mut borrowed_hasher = MockHasher::new();
borrowed_hasher.update(&variant);
let borrowed_folded = borrowed_hasher.finalize();
assert_eq!(
borrowed_folded,
variant.as_str().as_bytes(),
"`hasher.update(&kind)`-shape composition on \
&CaixaKind::{variant:?} must fold the same byte-tail \
CaixaKind::as_str().as_bytes() returns — the borrowed-\
input surface must resolve to the same as_str dispatch"
);
}
}
#[test]
#[expect(
clippy::too_many_lines,
reason = "the byte-owned reverse-projection axis is opened here \
as the first-mover on the substrate-wide byte-owned \
Vec<u8>-output projection family, so the pin binds the \
new impl against every paired byte-view and str-view \
axis on the same enum plus a generic \
<T: Into<Vec<u8>>>-bound consumer witness and a \
std::io::Write::write_all-shape owned-byte-sink surface \
witness on both owned and borrowed input shapes to lock \
the whole family against a future silent regression"
)]
fn caixa_kind_from_into_owned_vec_bytes_routes_through_as_str_accessor() {
fn generic_owned_bytes_sink<T: Into<Vec<u8>>>(t: T) -> Vec<u8> {
t.into()
}
struct MockOwnedByteSink(Vec<u8>);
impl MockOwnedByteSink {
fn new() -> Self {
Self(Vec::new())
}
fn write_all(&mut self, bytes: impl Into<Vec<u8>>) -> &mut Self {
self.0.extend_from_slice(&bytes.into());
self
}
fn finalize(self) -> Vec<u8> {
self.0
}
}
for &variant in CaixaKind::ALL {
let via_owned_from: Vec<u8> = <Vec<u8> as From<CaixaKind>>::from(variant);
let via_borrowed_from: Vec<u8> = <Vec<u8> as From<&CaixaKind>>::from(&variant);
let via_method_bytes: Vec<u8> = variant.as_str().as_bytes().to_vec();
assert_eq!(
via_owned_from, via_method_bytes,
"From<CaixaKind> for Vec<u8> impl must byte-equal \
CaixaKind::as_str().as_bytes().to_vec() on \
CaixaKind::{variant:?} — divergence signals a silent \
detour off the substrate-primitive accessor"
);
assert_eq!(
via_borrowed_from, via_method_bytes,
"From<&CaixaKind> for Vec<u8> impl must byte-equal \
CaixaKind::as_str().as_bytes().to_vec() on \
CaixaKind::{variant:?} — divergence signals a silent \
detour off the substrate-primitive accessor"
);
assert_eq!(
via_owned_from, via_borrowed_from,
"From<CaixaKind> for Vec<u8> and \
From<&CaixaKind> for Vec<u8> must byte-equal each \
other on CaixaKind::{variant:?} — divergence signals \
the owned-input and borrowed-input paths have drifted \
off the same substrate-primitive as_str accessor"
);
let borrowed_bytes: &[u8] = <CaixaKind as AsRef<[u8]>>::as_ref(&variant);
assert_eq!(
via_owned_from,
borrowed_bytes.to_vec(),
"From<CaixaKind> for Vec<u8> and AsRef<[u8]> for \
CaixaKind must resolve to byte-equal byte-tails on \
CaixaKind::{variant:?} — divergence signals the byte-\
owned and byte-view axes have drifted off the same \
substrate-primitive as_str accessor"
);
let owned_string: String = <String as From<CaixaKind>>::from(variant);
assert_eq!(
via_owned_from,
owned_string.into_bytes(),
"From<CaixaKind> for Vec<u8> and \
String::from(kind).into_bytes() must resolve to byte-\
equal byte-tails on CaixaKind::{variant:?}"
);
let owned_cow: std::borrow::Cow<'static, str> =
<std::borrow::Cow<'static, str> as From<CaixaKind>>::from(variant);
assert_eq!(
via_owned_from,
owned_cow.as_bytes().to_vec(),
"From<CaixaKind> for Vec<u8> and \
From<CaixaKind> for Cow<'static, str> must resolve to \
byte-equal byte-tails on CaixaKind::{variant:?}"
);
let owned_box: Box<str> = <Box<str> as From<CaixaKind>>::from(variant);
assert_eq!(
via_owned_from,
owned_box.as_bytes().to_vec(),
"From<CaixaKind> for Vec<u8> and \
From<CaixaKind> for Box<str> must resolve to byte-\
equal byte-tails on CaixaKind::{variant:?}"
);
let owned_arc: std::sync::Arc<str> =
<std::sync::Arc<str> as From<CaixaKind>>::from(variant);
assert_eq!(
via_owned_from,
owned_arc.as_bytes().to_vec(),
"From<CaixaKind> for Vec<u8> and \
From<CaixaKind> for std::sync::Arc<str> must resolve \
to byte-equal byte-tails on CaixaKind::{variant:?}"
);
let owned_rc_str: std::rc::Rc<str> =
<std::rc::Rc<str> as From<CaixaKind>>::from(variant);
assert_eq!(
via_owned_from,
owned_rc_str.as_bytes().to_vec(),
"From<CaixaKind> for Vec<u8> and \
From<CaixaKind> for std::rc::Rc<str> must resolve to \
byte-equal byte-tails on CaixaKind::{variant:?}"
);
let wire_bytes = variant.wire_name().as_bytes().to_vec();
assert_ne!(
via_owned_from, wire_bytes,
"From<CaixaKind> for Vec<u8> must land on the \
lowercase-Portuguese diagnostic byte-string \
(CaixaKind::as_str), not the PascalCase wire byte-\
string (CaixaKind::wire_name) — the two-axis split \
is by design; if this fails on CaixaKind::{variant:?}, \
the byte-owned axis has silently collapsed onto the \
wire axis"
);
}
for &variant in CaixaKind::ALL {
let via_generic_owned = generic_owned_bytes_sink(variant);
let variant_ref: &CaixaKind = &variant;
let via_generic_borrowed = generic_owned_bytes_sink(variant_ref);
let via_method_bytes = variant.as_str().as_bytes().to_vec();
assert_eq!(
via_generic_owned, via_method_bytes,
"generic `<T: Into<Vec<u8>>>`-bound consumer on \
CaixaKind::{variant:?} must yield the same byte-tail \
CaixaKind::as_str().as_bytes().to_vec() returns — \
divergence signals the byte-owned axis fails to bridge \
a generic owned-byte-input trait bound to the \
substrate-primitive accessor"
);
assert_eq!(
via_generic_borrowed, via_method_bytes,
"generic `<T: Into<Vec<u8>>>`-bound consumer on \
&CaixaKind::{variant:?} must yield the same byte-tail \
CaixaKind::as_str().as_bytes().to_vec() returns — the \
borrowed-input surface must resolve to the same \
as_str dispatch"
);
}
for &variant in CaixaKind::ALL {
let mut owned_sink = MockOwnedByteSink::new();
owned_sink.write_all(variant);
let owned_folded = owned_sink.finalize();
assert_eq!(
owned_folded,
variant.as_str().as_bytes(),
"`sink.write_all(kind)`-shape composition on \
CaixaKind::{variant:?} must fold the same byte-tail \
CaixaKind::as_str().as_bytes() returns"
);
let mut borrowed_sink = MockOwnedByteSink::new();
let variant_ref: &CaixaKind = &variant;
borrowed_sink.write_all(variant_ref);
let borrowed_folded = borrowed_sink.finalize();
assert_eq!(
borrowed_folded,
variant.as_str().as_bytes(),
"`sink.write_all(&kind)`-shape composition on \
&CaixaKind::{variant:?} must fold the same byte-tail \
CaixaKind::as_str().as_bytes() returns — the borrowed-\
input surface must resolve to the same as_str dispatch"
);
}
}
#[test]
fn caixa_kind_try_from_bytes_routes_through_from_wire_accessor() {
for &variant in CaixaKind::ALL {
let wire_bytes: &[u8] = variant.wire_name().as_bytes();
assert_eq!(
<CaixaKind as TryFrom<&[u8]>>::try_from(wire_bytes),
Ok(variant),
"TryFrom<&[u8]> impl on CaixaKind must round-trip \
CaixaKind::{variant:?}.wire_name().as_bytes() back to \
Ok(CaixaKind::{variant:?}) — divergence from \
CaixaKind::from_wire signals a silent detour off the \
substrate-primitive accessor"
);
assert_eq!(
<CaixaKind as TryFrom<&[u8]>>::try_from(wire_bytes).ok(),
CaixaKind::from_wire(variant.wire_name()),
"TryFrom<&[u8]> ok()-projection on \
CaixaKind::{variant:?}.wire_name().as_bytes() must byte-\
equal CaixaKind::from_wire on the paired &str input"
);
let via_str: Result<CaixaKind, ()> =
<CaixaKind as TryFrom<&str>>::try_from(variant.wire_name());
let via_bytes: Result<CaixaKind, ()> =
<CaixaKind as TryFrom<&[u8]>>::try_from(wire_bytes);
assert_eq!(
via_bytes, via_str,
"TryFrom<&[u8]> and TryFrom<&str> reverse-projection axes \
on CaixaKind must agree on CaixaKind::{variant:?} — \
divergence signals the byte-view and str-view reverse \
paths have drifted off the same substrate-primitive \
from_wire accessor"
);
}
}
#[test]
fn caixa_kind_try_from_bytes_rejects_unknown_and_non_utf8_bytes() {
let non_utf8_rejected: &[&[u8]] = &[
&[0xFF],
&[0x80],
&[0xC3],
&[0xFF, 0xFE],
&[0xED, 0xA0, 0x80], ];
for &input in non_utf8_rejected {
assert_eq!(
<CaixaKind as TryFrom<&[u8]>>::try_from(input),
Err(()),
"TryFrom<&[u8]> impl on CaixaKind must reject the non-\
UTF-8 byte-sequence {input:?} with Err(()) — silent \
acceptance signals the UTF-8 validation path collapsed \
onto a default arm rather than the trait-idiomatic \
unit-error"
);
}
let unknown_wire_rejected: &[&[u8]] = &[
b"",
b"biblioteca",
b"binario",
b"servico",
b"supervisor",
b"aplicacao",
b"acao",
b"BIBLIOTECA",
b"biBlioteca",
b"Bibliotecas",
b"library",
b"service",
b" Biblioteca",
b"Biblioteca ",
b"Biblioteca\n",
b"\"Biblioteca\"",
];
for &input in unknown_wire_rejected {
assert_eq!(
<CaixaKind as TryFrom<&[u8]>>::try_from(input),
Err(()),
"TryFrom<&[u8]> impl on CaixaKind must reject the valid-\
UTF-8-but-unknown-wire byte-string {input:?} with \
Err(()) — silent acceptance signals an accept-set \
widening off the paired CaixaKind::from_wire resolver"
);
if let Ok(s) = std::str::from_utf8(input) {
assert_eq!(
<CaixaKind as TryFrom<&[u8]>>::try_from(input),
<CaixaKind as TryFrom<&str>>::try_from(s),
"TryFrom<&[u8]> and TryFrom<&str> reverse-projection \
axes on CaixaKind must agree on the valid-UTF-8 \
input {input:?} — divergence signals the two \
reverse paths have drifted off the same \
substrate-primitive from_wire accessor"
);
}
}
}
#[test]
fn caixa_kind_try_from_vec_bytes_routes_through_borrowed_byte_view_axis() {
for &variant in CaixaKind::ALL {
let wire_bytes: Vec<u8> = variant.wire_name().as_bytes().to_vec();
assert_eq!(
<CaixaKind as TryFrom<Vec<u8>>>::try_from(wire_bytes.clone()),
Ok(variant),
"TryFrom<Vec<u8>> impl on CaixaKind must round-trip \
CaixaKind::{variant:?}.wire_name().as_bytes().to_vec() \
back to Ok(CaixaKind::{variant:?}) — divergence from \
the sibling TryFrom<&[u8]> axis signals a silent detour \
off the substrate-primitive from_wire accessor"
);
let via_owned: Result<CaixaKind, ()> =
<CaixaKind as TryFrom<Vec<u8>>>::try_from(wire_bytes.clone());
let via_borrowed: Result<CaixaKind, ()> =
<CaixaKind as TryFrom<&[u8]>>::try_from(wire_bytes.as_slice());
assert_eq!(
via_owned, via_borrowed,
"TryFrom<Vec<u8>> and TryFrom<&[u8]> reverse-projection \
axes on CaixaKind must agree on CaixaKind::{variant:?} \
— divergence signals the owned-input and borrowed-\
input byte-view reverse paths have drifted off the \
same substrate-primitive from_wire accessor"
);
let via_str: Result<CaixaKind, ()> =
<CaixaKind as TryFrom<&str>>::try_from(variant.wire_name());
assert_eq!(
via_owned, via_str,
"TryFrom<Vec<u8>> and TryFrom<&str> reverse-projection \
axes on CaixaKind must agree on CaixaKind::{variant:?} \
— divergence signals the byte-owned and str-view \
reverse paths have drifted off the same substrate-\
primitive from_wire accessor"
);
}
}
#[test]
fn caixa_kind_try_from_vec_bytes_rejects_unknown_and_non_utf8_bytes() {
let non_utf8_rejected: &[&[u8]] = &[
&[0xFF],
&[0x80],
&[0xC3],
&[0xFF, 0xFE],
&[0xED, 0xA0, 0x80], ];
for &input in non_utf8_rejected {
let owned: Vec<u8> = input.to_vec();
assert_eq!(
<CaixaKind as TryFrom<Vec<u8>>>::try_from(owned),
Err(()),
"TryFrom<Vec<u8>> impl on CaixaKind must reject the \
non-UTF-8 byte-sequence {input:?} with Err(()) — \
silent acceptance signals the UTF-8 validation path \
collapsed onto a default arm rather than the trait-\
idiomatic unit-error"
);
assert_eq!(
<CaixaKind as TryFrom<Vec<u8>>>::try_from(input.to_vec()),
<CaixaKind as TryFrom<&[u8]>>::try_from(input),
"TryFrom<Vec<u8>> and TryFrom<&[u8]> reverse-projection \
axes on CaixaKind must agree on the non-UTF-8 input \
{input:?} — divergence signals the owned-input and \
borrowed-input byte-view reverse paths have drifted \
off the same substrate-primitive from_wire accessor"
);
}
let unknown_wire_rejected: &[&[u8]] = &[
b"",
b"biblioteca",
b"binario",
b"servico",
b"supervisor",
b"aplicacao",
b"acao",
b"BIBLIOTECA",
b"biBlioteca",
b"Bibliotecas",
b"library",
b"service",
b" Biblioteca",
b"Biblioteca ",
b"Biblioteca\n",
b"\"Biblioteca\"",
];
for &input in unknown_wire_rejected {
let owned: Vec<u8> = input.to_vec();
assert_eq!(
<CaixaKind as TryFrom<Vec<u8>>>::try_from(owned),
Err(()),
"TryFrom<Vec<u8>> impl on CaixaKind must reject the \
valid-UTF-8-but-unknown-wire byte-string {input:?} \
with Err(()) — silent acceptance signals an accept-\
set widening off the paired CaixaKind::from_wire \
resolver"
);
assert_eq!(
<CaixaKind as TryFrom<Vec<u8>>>::try_from(input.to_vec()),
<CaixaKind as TryFrom<&[u8]>>::try_from(input),
"TryFrom<Vec<u8>> and TryFrom<&[u8]> reverse-projection \
axes on CaixaKind must agree on the valid-UTF-8-but-\
unknown-wire input {input:?} — divergence signals the \
owned-input and borrowed-input byte-view reverse \
paths have drifted off the same substrate-primitive \
from_wire accessor"
);
}
}
}