use tatara_lisp::{Atom, Sexp};
pub const CAIXA_DIALETO_WIRE_PACOTE: &str = "Pacote";
pub const CAIXA_DIALETO_WIRE_MOLDE: &str = "Molde";
pub const CAIXA_DIALETO_WIRE_MOLDE_POSICIONAL: &str = "MoldePosicional";
pub const CAIXA_DIALETO_WIRE_DESCONHECIDO: &str = "Desconhecido";
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, gen_platform::IsVariant)]
pub enum CaixaDialeto {
Pacote,
Molde,
MoldePosicional,
Desconhecido,
}
impl CaixaDialeto {
pub const ALL: &'static [Self] = &[
Self::Pacote,
Self::Molde,
Self::MoldePosicional,
Self::Desconhecido,
];
#[must_use]
pub const fn as_str(self) -> &'static str {
match self {
Self::Pacote => CAIXA_DIALETO_WIRE_PACOTE,
Self::Molde => CAIXA_DIALETO_WIRE_MOLDE,
Self::MoldePosicional => CAIXA_DIALETO_WIRE_MOLDE_POSICIONAL,
Self::Desconhecido => CAIXA_DIALETO_WIRE_DESCONHECIDO,
}
}
pub const WIRE_NAMES: &'static [&'static str] = &[
CAIXA_DIALETO_WIRE_PACOTE,
CAIXA_DIALETO_WIRE_MOLDE,
CAIXA_DIALETO_WIRE_MOLDE_POSICIONAL,
CAIXA_DIALETO_WIRE_DESCONHECIDO,
];
#[must_use]
pub fn from_wire(s: &str) -> Option<Self> {
match s {
CAIXA_DIALETO_WIRE_PACOTE => Some(Self::Pacote),
CAIXA_DIALETO_WIRE_MOLDE => Some(Self::Molde),
CAIXA_DIALETO_WIRE_MOLDE_POSICIONAL => Some(Self::MoldePosicional),
CAIXA_DIALETO_WIRE_DESCONHECIDO => Some(Self::Desconhecido),
_ => None,
}
}
#[must_use]
pub const fn palavra_canonica(self) -> &'static str {
match self {
Self::Pacote => "defcaixa",
Self::Molde | Self::MoldePosicional => "defmolde",
Self::Desconhecido => "?",
}
}
#[must_use]
pub const fn consumidor(self) -> &'static str {
match self {
Self::Pacote => "caixa-core / feira",
Self::Molde | Self::MoldePosicional => "pleme-doc-gen",
Self::Desconhecido => "nobody known",
}
}
#[must_use]
pub const fn descricao(self) -> &'static str {
match self {
Self::Pacote => "tatara-lisp package manifest (:nome :versao :kind :deps …)",
Self::Molde => "repo-surface declaration (:name :ecosystem :package {…} …)",
Self::MoldePosicional => {
"repo-surface declaration, positional name (defcaixa <nome> :kind …)"
}
Self::Desconhecido => "unrecognised — matches no known defcaixa schema",
}
}
#[must_use]
pub const fn is_molde_family(self) -> bool {
self.is_molde() || self.is_molde_posicional()
}
}
impl std::fmt::Display for CaixaDialeto {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str(self.as_str())
}
}
impl AsRef<str> for CaixaDialeto {
fn as_ref(&self) -> &str {
self.as_str()
}
}
impl TryFrom<&str> for CaixaDialeto {
type Error = ();
fn try_from(s: &str) -> Result<Self, Self::Error> {
Self::from_wire(s).ok_or(())
}
}
impl std::str::FromStr for CaixaDialeto {
type Err = ();
fn from_str(s: &str) -> Result<Self, Self::Err> {
<Self as TryFrom<&str>>::try_from(s)
}
}
impl From<CaixaDialeto> for &'static str {
fn from(dialeto: CaixaDialeto) -> &'static str {
dialeto.as_str()
}
}
impl From<&CaixaDialeto> for &'static str {
fn from(dialeto: &CaixaDialeto) -> &'static str {
dialeto.as_str()
}
}
impl From<CaixaDialeto> for String {
fn from(dialeto: CaixaDialeto) -> String {
dialeto.as_str().to_owned()
}
}
impl From<&CaixaDialeto> for String {
fn from(dialeto: &CaixaDialeto) -> String {
dialeto.as_str().to_owned()
}
}
impl From<CaixaDialeto> for std::borrow::Cow<'static, str> {
fn from(dialeto: CaixaDialeto) -> std::borrow::Cow<'static, str> {
std::borrow::Cow::Borrowed(dialeto.as_str())
}
}
impl From<&CaixaDialeto> for std::borrow::Cow<'static, str> {
fn from(dialeto: &CaixaDialeto) -> std::borrow::Cow<'static, str> {
std::borrow::Cow::Borrowed(dialeto.as_str())
}
}
impl From<CaixaDialeto> for Box<str> {
fn from(dialeto: CaixaDialeto) -> Box<str> {
Box::<str>::from(dialeto.as_str())
}
}
impl From<&CaixaDialeto> for Box<str> {
fn from(dialeto: &CaixaDialeto) -> Box<str> {
Box::<str>::from(dialeto.as_str())
}
}
impl From<CaixaDialeto> for std::sync::Arc<str> {
fn from(dialeto: CaixaDialeto) -> std::sync::Arc<str> {
std::sync::Arc::<str>::from(dialeto.as_str())
}
}
impl From<&CaixaDialeto> for std::sync::Arc<str> {
fn from(dialeto: &CaixaDialeto) -> std::sync::Arc<str> {
std::sync::Arc::<str>::from(dialeto.as_str())
}
}
impl From<CaixaDialeto> for std::rc::Rc<str> {
fn from(dialeto: CaixaDialeto) -> std::rc::Rc<str> {
std::rc::Rc::<str>::from(dialeto.as_str())
}
}
impl From<&CaixaDialeto> for std::rc::Rc<str> {
fn from(dialeto: &CaixaDialeto) -> std::rc::Rc<str> {
std::rc::Rc::<str>::from(dialeto.as_str())
}
}
impl AsRef<[u8]> for CaixaDialeto {
fn as_ref(&self) -> &[u8] {
self.as_str().as_bytes()
}
}
impl From<CaixaDialeto> for Vec<u8> {
fn from(dialeto: CaixaDialeto) -> Vec<u8> {
dialeto.as_str().as_bytes().to_vec()
}
}
impl From<&CaixaDialeto> for Vec<u8> {
fn from(dialeto: &CaixaDialeto) -> Vec<u8> {
dialeto.as_str().as_bytes().to_vec()
}
}
impl TryFrom<&[u8]> for CaixaDialeto {
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 CaixaDialeto {
type Error = ();
fn try_from(bytes: Vec<u8>) -> Result<Self, Self::Error> {
<Self as TryFrom<&[u8]>>::try_from(bytes.as_slice())
}
}
#[derive(Debug, Clone, PartialEq, Eq, thiserror::Error)]
pub enum DialetoError {
#[error("source has no top-level form")]
Vazio,
#[error("top-level form is not a list — a manifest is `(defcaixa …)`")]
NaoEhLista,
#[error(
"top-level form is headed by `{encontrado}`, not `defcaixa` or `defmolde` \
(a manifest's first form must be the declaration itself)"
)]
CabecaErrada { encontrado: String },
#[error("manifest does not parse as tatara-lisp: {0}")]
Leitura(String),
}
impl DialetoError {
#[must_use]
pub fn cabeca_errada(encontrado: &str) -> Self {
Self::CabecaErrada {
encontrado: encontrado.to_string(),
}
}
#[must_use]
pub fn leitura(reason: impl Into<String>) -> Self {
Self::Leitura(reason.into())
}
}
pub fn classify(src: &str) -> Result<CaixaDialeto, DialetoError> {
let forms = tatara_lisp::read(src).map_err(|e| DialetoError::leitura(e.to_string()))?;
let first = forms.first().ok_or(DialetoError::Vazio)?;
classify_form(first)
}
pub fn classify_form(form: &Sexp) -> Result<CaixaDialeto, DialetoError> {
let list = form.as_list().ok_or(DialetoError::NaoEhLista)?;
let head = list
.first()
.and_then(Sexp::as_symbol)
.ok_or(DialetoError::NaoEhLista)?;
match head {
"defmolde" => {
return Ok(if starts_with_positional_name(&list[1..]) {
CaixaDialeto::MoldePosicional
} else {
CaixaDialeto::Molde
});
}
"defcaixa" => {}
other => {
return Err(DialetoError::cabeca_errada(other));
}
}
let args = &list[1..];
if starts_with_positional_name(args) {
return Ok(CaixaDialeto::MoldePosicional);
}
let keys = top_level_keywords(args);
let has = |k: &str| keys.iter().any(|s| s == k);
if has("nome") {
return Ok(CaixaDialeto::Pacote);
}
if has("name") || has("ecosystem") || has("package") {
return Ok(CaixaDialeto::Molde);
}
Ok(CaixaDialeto::Desconhecido)
}
fn starts_with_positional_name(args: &[Sexp]) -> bool {
matches!(args.first(), Some(Sexp::Atom(Atom::Symbol(_))))
}
fn top_level_keywords(args: &[Sexp]) -> Vec<String> {
let mut out = Vec::new();
let mut i = 0;
while i < args.len() {
if let Sexp::Atom(Atom::Keyword(k)) = &args[i] {
out.push(k.clone());
i += 2;
} else {
i += 1;
}
}
out
}
#[cfg(test)]
mod tests {
use super::*;
const PACOTE: &str = r#"
(defcaixa
:nome "checkout"
:versao "0.1.0"
:kind Servico
:deps ((:nome "caixa-teia" :versao "^0.1")))
"#;
const MOLDE: &str = r#"
(defcaixa
:name "base64"
:kind :Biblioteca
:ecosystem :rust-single-crate
:package {:name "base64" :version "0.22.1"}
:workflows [:auto-release])
"#;
const MOLDE_POSICIONAL: &str = r#"
(defcaixa todoku-go
:kind :Biblioteca
:ecosystem :go
:package {:name "todoku-go" :version "0.3.0"})
"#;
#[test]
fn the_package_dialect_is_recognised() {
assert_eq!(classify(PACOTE), Ok(CaixaDialeto::Pacote));
}
#[test]
fn the_repo_surface_dialect_is_recognised() {
assert_eq!(classify(MOLDE), Ok(CaixaDialeto::Molde));
}
#[test]
fn the_positional_arity_is_recognised() {
assert_eq!(
classify(MOLDE_POSICIONAL),
Ok(CaixaDialeto::MoldePosicional)
);
}
#[test]
fn defmolde_classifies_without_inference() {
let src = r#"(defmolde :name "x" :kind :Biblioteca :ecosystem :go)"#;
assert_eq!(classify(src), Ok(CaixaDialeto::Molde));
let pos = r"(defmolde todoku-go :kind :Biblioteca :ecosystem :go)";
assert_eq!(classify(pos), Ok(CaixaDialeto::MoldePosicional));
}
#[test]
fn a_nested_nome_does_not_make_a_repo_surface_look_like_a_package() {
let src = r#"
(defcaixa
:name "x"
:ecosystem :rust-single-crate
:deps ((:nome "inner" :versao "^0.1")))
"#;
assert_eq!(classify(src), Ok(CaixaDialeto::Molde));
}
#[test]
fn a_keyword_in_value_position_is_not_a_slot() {
let src = r#"(defcaixa :kind :Biblioteca :name "x")"#;
assert_eq!(classify(src), Ok(CaixaDialeto::Molde));
}
#[test]
fn an_unrecognised_defcaixa_is_reported_not_guessed() {
let src = r#"(defcaixa :licenca "MIT")"#;
assert_eq!(classify(src), Ok(CaixaDialeto::Desconhecido));
}
#[test]
fn a_form_that_is_not_a_manifest_is_an_error_not_a_dialect() {
assert_eq!(
classify("(defflake :nome \"x\")"),
Err(DialetoError::cabeca_errada("defflake"))
);
assert_eq!(classify(""), Err(DialetoError::Vazio));
}
#[test]
fn every_dialect_names_its_consumer_and_its_canonical_keyword() {
for &d in CaixaDialeto::ALL {
assert!(!d.descricao().is_empty(), "{d}");
assert!(!d.consumidor().is_empty(), "{d}");
}
assert_eq!(CaixaDialeto::Pacote.palavra_canonica(), "defcaixa");
assert_eq!(CaixaDialeto::Molde.palavra_canonica(), "defmolde");
assert_ne!(
CaixaDialeto::Pacote.palavra_canonica(),
CaixaDialeto::Molde.palavra_canonica(),
"the two dialects must not share a canonical keyword — that IS the defect"
);
}
#[test]
fn caixa_dialeto_all_enumerates_every_variant_exactly_once() {
assert_eq!(
CaixaDialeto::ALL.len(),
4,
"ALL must list every arm exactly once; a fifth arm added \
without extending ALL fails this pin — extend ALL alongside \
the new variant"
);
let mut seen: Vec<CaixaDialeto> = Vec::new();
for &d in CaixaDialeto::ALL {
assert!(
!seen.contains(&d),
"ALL contains a duplicate arm: {d}. Every variant appears \
exactly once — a duplicate would double-count in every \
iteration consumer"
);
seen.push(d);
}
for variant in [
CaixaDialeto::Pacote,
CaixaDialeto::Molde,
CaixaDialeto::MoldePosicional,
CaixaDialeto::Desconhecido,
] {
let coverage_probe = match variant {
CaixaDialeto::Pacote
| CaixaDialeto::Molde
| CaixaDialeto::MoldePosicional
| CaixaDialeto::Desconhecido => variant,
};
assert!(
CaixaDialeto::ALL.contains(&coverage_probe),
"ALL is missing variant {coverage_probe} — extend the slice"
);
}
}
#[test]
fn caixa_dialeto_all_is_const_and_matches_iteration_count() {
const ALL: &[CaixaDialeto] = CaixaDialeto::ALL;
assert_eq!(ALL.len(), CaixaDialeto::ALL.len());
#[allow(clippy::iter_count)]
let iterated = ALL.iter().count();
assert_eq!(iterated, CaixaDialeto::ALL.len());
}
#[test]
fn caixa_dialeto_all_covers_every_variant_by_display_probe() {
for &d in CaixaDialeto::ALL {
let display_form = d.to_string();
assert!(
!display_form.is_empty(),
"Display must render a non-empty byte-string for every \
arm; empty: {d:?}"
);
assert!(!d.palavra_canonica().is_empty(), "{d}");
assert!(!d.consumidor().is_empty(), "{d}");
assert!(!d.descricao().is_empty(), "{d}");
}
}
#[test]
fn caixa_dialeto_as_str_returns_pascal_case_variant_name() {
for (variant, expected) in [
(CaixaDialeto::Pacote, "Pacote"),
(CaixaDialeto::Molde, "Molde"),
(CaixaDialeto::MoldePosicional, "MoldePosicional"),
(CaixaDialeto::Desconhecido, "Desconhecido"),
] {
assert_eq!(
variant.as_str(),
expected,
"CaixaDialeto::{variant:?}.as_str() must return the \
canonical `PascalCase` variant-name byte-string; drift here \
splits the census-facing text from the substrate \
primitive every downstream consumer will read"
);
}
}
#[test]
fn caixa_dialeto_wire_names_covers_every_arm() {
assert_eq!(
CaixaDialeto::WIRE_NAMES.len(),
CaixaDialeto::ALL.len(),
"CaixaDialeto::WIRE_NAMES.len() must byte-equal \
CaixaDialeto::ALL.len() — a mismatch means the roster and \
the enum's arm-set have drifted; downstream consumers that \
fan through both will silently disagree on the accepted \
arm-set"
);
for &variant in CaixaDialeto::ALL {
let wire = variant.as_str();
assert!(
CaixaDialeto::WIRE_NAMES.contains(&wire),
"CaixaDialeto::{variant:?}.as_str() = {wire:?} must be \
a member of CaixaDialeto::WIRE_NAMES — the emitter and \
the roster have drifted out of lockstep"
);
}
for tag in CaixaDialeto::WIRE_NAMES {
let first = tag.chars().next().unwrap_or_else(|| {
panic!(
"CaixaDialeto::WIRE_NAMES entry {tag:?} must be a \
non-empty `PascalCase` variant-name byte-string"
)
});
assert!(
first.is_ascii_uppercase(),
"CaixaDialeto::WIRE_NAMES entry {tag:?} must open with \
an uppercase ASCII byte (matching the substrate-wide \
`PascalCase` convention) — an entry opening with a \
lowercase byte would collide the roster with any \
hypothetical peer lowercase-kebab wire-form axis a \
downstream consumer might disambiguate against"
);
}
assert_eq!(
CaixaDialeto::WIRE_NAMES,
&[
CAIXA_DIALETO_WIRE_PACOTE,
CAIXA_DIALETO_WIRE_MOLDE,
CAIXA_DIALETO_WIRE_MOLDE_POSICIONAL,
CAIXA_DIALETO_WIRE_DESCONHECIDO,
],
"CaixaDialeto::WIRE_NAMES must enumerate every arm's wire-\
form tag exactly once, in variant declaration order \
(Pacote → Molde → MoldePosicional → Desconhecido)"
);
for (&variant, tag) in CaixaDialeto::ALL.iter().zip(CaixaDialeto::WIRE_NAMES) {
assert_eq!(
CaixaDialeto::from_wire(tag),
Some(variant),
"CaixaDialeto::from_wire({tag:?}) must round-trip back \
to CaixaDialeto::{variant:?} — emitter and parser have \
drifted off the paired CAIXA_DIALETO_WIRE_* const family"
);
}
}
#[test]
fn caixa_dialeto_display_routes_through_as_str_helper() {
for &variant in CaixaDialeto::ALL {
assert_eq!(
variant.to_string(),
variant.as_str(),
"CaixaDialeto::{variant:?} Display must route through \
CaixaDialeto::as_str (single source of truth: the \
lifted per-arm `PascalCase` variant-name byte-string)"
);
}
}
#[test]
fn caixa_dialeto_as_ref_str_routes_through_as_str_accessor() {
for &variant in CaixaDialeto::ALL {
assert_eq!(
<CaixaDialeto as AsRef<str>>::as_ref(&variant),
variant.as_str(),
"AsRef<str> impl on CaixaDialeto::{variant:?} must \
byte-equal CaixaDialeto::as_str on the same instance \
— divergence signals a silent detour off the \
substrate-primitive accessor"
);
}
}
#[test]
fn caixa_dialeto_as_ref_str_routes_through_display_via_shared_accessor() {
for &variant in CaixaDialeto::ALL {
let via_as_ref: &str = <CaixaDialeto 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_dialeto_is_molde_family_returns_true_on_molde_and_positional_arms() {
assert!(
CaixaDialeto::Molde.is_molde_family(),
"CaixaDialeto::Molde.is_molde_family() must return true — \
Molde is the primary `defmolde` arm"
);
assert!(
CaixaDialeto::MoldePosicional.is_molde_family(),
"CaixaDialeto::MoldePosicional.is_molde_family() must return \
true — MoldePosicional is the positional-arity form of the \
same `defmolde` declaration Molde carries"
);
}
#[test]
fn caixa_dialeto_is_molde_family_returns_false_on_pacote_and_desconhecido_arms() {
assert!(
!CaixaDialeto::Pacote.is_molde_family(),
"CaixaDialeto::Pacote.is_molde_family() must return false — \
Pacote is the `defcaixa` tatara-lisp package manifest, not \
the `defmolde` repo-surface declaration"
);
assert!(
!CaixaDialeto::Desconhecido.is_molde_family(),
"CaixaDialeto::Desconhecido.is_molde_family() must return \
false — the residue arm names no known declaration; it is \
not silently promoted into the `defmolde` family"
);
}
#[test]
fn caixa_dialeto_is_molde_family_agrees_with_palavra_canonica_defmolde_projection() {
for &d in CaixaDialeto::ALL {
let via_palavra_canonica = d.palavra_canonica() == "defmolde";
let via_is_molde_family = d.is_molde_family();
assert_eq!(
via_is_molde_family, via_palavra_canonica,
"CaixaDialeto::{d:?}.is_molde_family() ({via_is_molde_family}) \
must agree with CaixaDialeto::{d:?}.palavra_canonica() == \
\"defmolde\" ({via_palavra_canonica}) — a split between the \
typed predicate and the sibling keyword projection would let \
a future arm addition land at one path and drift at the other, \
which is exactly the drift this pin refuses"
);
}
}
#[test]
fn caixa_dialeto_is_molde_family_is_const_fn() {
const ARMS: [(CaixaDialeto, bool); 4] = [
(CaixaDialeto::Pacote, CaixaDialeto::Pacote.is_molde_family()),
(CaixaDialeto::Molde, CaixaDialeto::Molde.is_molde_family()),
(
CaixaDialeto::MoldePosicional,
CaixaDialeto::MoldePosicional.is_molde_family(),
),
(
CaixaDialeto::Desconhecido,
CaixaDialeto::Desconhecido.is_molde_family(),
),
];
assert_eq!(
ARMS,
[
(CaixaDialeto::Pacote, false),
(CaixaDialeto::Molde, true),
(CaixaDialeto::MoldePosicional, true),
(CaixaDialeto::Desconhecido, false),
],
"CaixaDialeto::is_molde_family() must evaluate in const context \
for every arm and land on the {{false, true, true, false}} \
partition — a future accidental downgrade to non-`const` \
would trip the const-context array-initializer here"
);
}
#[test]
fn caixa_dialeto_as_str_is_const_fn() {
const PACOTE: &str = CaixaDialeto::Pacote.as_str();
const MOLDE: &str = CaixaDialeto::Molde.as_str();
const MOLDE_POSICIONAL: &str = CaixaDialeto::MoldePosicional.as_str();
const DESCONHECIDO: &str = CaixaDialeto::Desconhecido.as_str();
assert_eq!(PACOTE, "Pacote");
assert_eq!(MOLDE, "Molde");
assert_eq!(MOLDE_POSICIONAL, "MoldePosicional");
assert_eq!(DESCONHECIDO, "Desconhecido");
}
#[test]
fn caixa_dialeto_is_variant_predicates_partition_the_arm_set() {
for (idx, &variant) in CaixaDialeto::ALL.iter().enumerate() {
let observed = [
variant.is_pacote(),
variant.is_molde(),
variant.is_molde_posicional(),
variant.is_desconhecido(),
];
let mut expected = [false; 4];
expected[idx] = true;
assert_eq!(
observed, expected,
"CaixaDialeto::{variant:?} at ALL[{idx}] is_* predicates \
must fire only on their own arm lane (identity diagonal); \
got {observed:?}",
);
}
}
#[test]
fn caixa_dialeto_is_variant_predicates_are_const_fn() {
const { assert!(CaixaDialeto::Pacote.is_pacote()) };
const { assert!(CaixaDialeto::Molde.is_molde()) };
const { assert!(CaixaDialeto::MoldePosicional.is_molde_posicional()) };
const { assert!(CaixaDialeto::Desconhecido.is_desconhecido()) };
}
#[test]
fn caixa_dialeto_from_wire_accepts_every_as_str_output() {
for &variant in CaixaDialeto::ALL {
let wire = variant.as_str();
let parsed = CaixaDialeto::from_wire(wire).unwrap_or_else(|| {
panic!(
"CaixaDialeto::from_wire({wire:?}) must accept every \
CaixaDialeto::as_str output — got None for the \
wire byte-string of {variant:?}"
)
});
assert_eq!(
parsed, variant,
"CaixaDialeto::from_wire(CaixaDialeto::{variant:?}.as_str()) \
must return CaixaDialeto::{variant:?} — the (as_str, \
from_wire) pair must form a total round-trip on the \
closed four-arm CaixaDialeto arm-set"
);
}
}
#[test]
fn caixa_dialeto_from_wire_rejects_unknown_byte_strings() {
for bad in [
"",
" ",
"pacote",
"PACOTE",
"molde",
"MoldePositional",
"desconhecido",
"Unknown",
"defcaixa",
"defmolde",
"?",
"caixa-core / feira",
"pleme-doc-gen",
"nobody known",
"Pacote ",
" Pacote",
] {
assert!(
CaixaDialeto::from_wire(bad).is_none(),
"CaixaDialeto::from_wire({bad:?}) must return None — the \
parser's accept-set is exactly the four CaixaDialeto::as_str \
outputs; a widening would silently split the parser's \
accept-set from the emitter's arm-set"
);
}
}
#[test]
fn cabeca_errada_ctor_matches_struct_literal_wrap() {
assert_eq!(
DialetoError::cabeca_errada("defflake"),
DialetoError::CabecaErrada {
encontrado: "defflake".to_string(),
},
"DialetoError::cabeca_errada must byte-equal the pre-lift \
open-coded struct-literal — a drift here means the ctor \
stopped being a substrate primitive for the wrong-head \
fallthrough site"
);
}
#[test]
fn cabeca_errada_routes_encontrado_verbatim_across_boundary_inputs() {
for encontrado in [
"",
"defflake",
"def-molde",
"defcaixa ",
" defcaixa",
"μdefcaixa",
"\u{00A0}defcaixa",
"\u{3000}defcaixa",
"def\u{2028}caixa",
] {
let via_ctor = DialetoError::cabeca_errada(encontrado);
let via_literal = DialetoError::CabecaErrada {
encontrado: encontrado.to_string(),
};
assert_eq!(
via_ctor, via_literal,
"DialetoError::cabeca_errada({encontrado:?}) must byte- \
equal the open-coded struct-literal on the same input — \
a drift here would let the ctor silently normalize / \
truncate the head symbol before it reached the \
CabecaErrada envelope"
);
let DialetoError::CabecaErrada { encontrado: routed } = via_ctor else {
panic!(
"DialetoError::cabeca_errada must construct the \
CabecaErrada arm — got a different variant on \
input {encontrado:?}"
);
};
assert_eq!(
routed, encontrado,
"DialetoError::cabeca_errada must route the input \
{encontrado:?} verbatim into the encontrado field — \
any wrapper-side truncation / normalization surfaces \
here rather than at a downstream diagnostic shape drift"
);
}
}
#[test]
fn classify_form_wrong_head_routes_through_cabeca_errada_ctor() {
for head in ["defflake", "deffoobar", "defcaixaz", "let", "defmoldez"] {
let src = format!("({head} :nome \"x\")");
let observed = classify(&src);
let via_ctor = Err(DialetoError::cabeca_errada(head));
assert_eq!(
observed, via_ctor,
"classify({src:?}) must return the same Err shape as \
DialetoError::cabeca_errada({head:?}) — a drift here \
means the wire-up de-lifted its wrong-head fallthrough \
arm off the substrate primitive"
);
}
}
#[test]
fn leitura_ctor_matches_tuple_literal_wrap_on_str_binding() {
let reason: &str = "unclosed paren at 1:12";
assert_eq!(
DialetoError::leitura(reason),
DialetoError::Leitura(reason.to_string()),
"DialetoError::leitura must byte-equal the pre-lift open-coded \
tuple-newtype wrap — a drift here means the ctor stopped \
being a substrate primitive for the tatara-lisp-reader \
fallthrough site"
);
}
#[test]
fn leitura_ctor_matches_tuple_literal_wrap_on_string_binding() {
let reason: String = String::from("read: unexpected EOF at 3:1");
let via_ctor = DialetoError::leitura(reason.clone());
let via_literal = DialetoError::Leitura(reason.clone());
assert_eq!(
via_ctor, via_literal,
"DialetoError::leitura must byte-equal the pre-lift open-coded \
tuple-newtype wrap on the same owned-String fixture — a drift \
here would let the ctor silently reshape the reader reason \
before it reached the Leitura envelope"
);
let DialetoError::Leitura(routed) = via_ctor else {
panic!(
"DialetoError::leitura must construct the Leitura arm — \
got a different variant on input {reason:?}"
);
};
assert_eq!(
routed, reason,
"DialetoError::leitura must route the input {reason:?} \
verbatim into the tuple-newtype payload — any wrapper-side \
truncation / normalization surfaces here rather than at a \
downstream diagnostic shape drift"
);
}
#[test]
fn leitura_routes_reason_verbatim_across_boundary_inputs() {
for reason in [
"",
"unclosed paren at 1:12",
"unexpected token ')'",
"read: eof",
" leading whitespace",
"trailing whitespace ",
"μnicode reason",
"\u{00A0}NBSP-prefixed reason",
"\u{3000}ideographic-space reason",
"reason\u{2028}with-line-separator",
] {
let via_ctor = DialetoError::leitura(reason);
let via_literal = DialetoError::Leitura(reason.to_string());
assert_eq!(
via_ctor, via_literal,
"DialetoError::leitura({reason:?}) must byte-equal the \
open-coded tuple-newtype wrap on the same input — a \
drift here would let the ctor silently normalize / \
truncate the reader reason before it reached the \
Leitura envelope"
);
let DialetoError::Leitura(routed) = via_ctor else {
panic!(
"DialetoError::leitura must construct the Leitura \
arm — got a different variant on input {reason:?}"
);
};
assert_eq!(
routed, reason,
"DialetoError::leitura must route the input {reason:?} \
verbatim into the tuple-newtype payload — any \
wrapper-side truncation / normalization surfaces here \
rather than at a downstream diagnostic shape drift"
);
}
}
#[test]
fn classify_reader_error_routes_through_leitura_ctor() {
for src in [
"(defcaixa :nome \"x\"",
"defcaixa :nome \"x\")",
"(defcaixa :nome \"unterminated",
] {
let observed = classify(src);
let Err(DialetoError::Leitura(reason)) = observed.clone() else {
panic!(
"classify({src:?}) must return the Leitura arm — got \
{observed:?}"
);
};
let via_ctor: Result<CaixaDialeto, DialetoError> =
Err(DialetoError::leitura(reason.clone()));
assert_eq!(
observed, via_ctor,
"classify({src:?}) must return the same Err shape as \
DialetoError::leitura({reason:?}) — a drift here means \
the wire-up de-lifted its tatara-lisp-reader fallthrough \
arm off the substrate primitive"
);
}
}
#[test]
fn caixa_dialeto_try_from_str_routes_through_from_wire_accessor() {
for &variant in CaixaDialeto::ALL {
let wire = variant.as_str();
let via_try_from: CaixaDialeto = <CaixaDialeto as TryFrom<&str>>::try_from(wire)
.unwrap_or_else(|()| {
panic!(
"CaixaDialeto::try_from({wire:?}) must accept every \
CaixaDialeto::as_str output — got Err(()) for the \
wire byte-string of {variant:?}"
)
});
let via_from_wire: CaixaDialeto = CaixaDialeto::from_wire(wire).unwrap_or_else(|| {
panic!(
"CaixaDialeto::from_wire({wire:?}) must accept every \
CaixaDialeto::as_str output — got None for the wire \
byte-string of {variant:?}"
)
});
assert_eq!(
via_try_from, variant,
"CaixaDialeto::try_from(CaixaDialeto::{variant:?}.as_str()) \
must return CaixaDialeto::{variant:?} — the trait-idiomatic \
reverse projection must land on the same arm the method-named \
from_wire resolver does",
);
assert_eq!(
via_try_from, via_from_wire,
"CaixaDialeto::try_from({wire:?}) ({via_try_from:?}) must \
byte-equal CaixaDialeto::from_wire({wire:?}) ({via_from_wire:?}) \
on the same input — divergence signals a silent detour off the \
shared substrate-primitive resolver",
);
assert_eq!(
<CaixaDialeto as TryFrom<&str>>::try_from(wire).ok(),
CaixaDialeto::from_wire(wire),
"the Result::ok() projection of TryFrom<&str> must byte-equal \
the sibling from_wire Option<Self> output on {wire:?} — the \
two accessors must share the same accept-set and typed \
outcome per arm",
);
}
}
#[test]
fn caixa_dialeto_try_from_str_rejects_unknown_byte_strings() {
for bad in [
"",
" ",
"pacote",
"PACOTE",
"molde",
"MoldePositional",
"desconhecido",
"Unknown",
"defcaixa",
"defmolde",
"?",
"caixa-core / feira",
"pleme-doc-gen",
"nobody known",
"Pacote ",
" Pacote",
] {
assert_eq!(
<CaixaDialeto as TryFrom<&str>>::try_from(bad),
Err(()),
"CaixaDialeto::try_from({bad:?}) must return Err(()) — the \
trait-idiomatic parser's accept-set is exactly the four \
CaixaDialeto::as_str outputs; a widening would silently \
split the trait-idiomatic reverse-projection axis from the \
sibling from_wire resolver's arm-set"
);
}
}
#[test]
fn caixa_dialeto_from_str_routes_through_try_from_str_impl() {
use std::str::FromStr;
for &variant in CaixaDialeto::ALL {
let wire = variant.as_str();
assert_eq!(
<CaixaDialeto as FromStr>::from_str(wire),
Ok(variant),
"FromStr impl on CaixaDialeto must round-trip \
CaixaDialeto::{variant:?}.as_str() = {wire:?} back to \
Ok(CaixaDialeto::{variant:?}) — divergence from \
CaixaDialeto::try_from signals a silent detour off the \
paired reverse-projection trait impl"
);
assert_eq!(
<CaixaDialeto as FromStr>::from_str(wire).ok(),
CaixaDialeto::from_wire(wire),
"FromStr ok()-projection on {wire:?} must byte-equal \
CaixaDialeto::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<CaixaDialeto, ()> = wire.parse();
assert_eq!(
via_parse,
Ok(variant),
"`{wire:?}`.parse::<CaixaDialeto>() must resolve to \
Ok(CaixaDialeto::{variant:?}) — divergence signals \
the stdlib `.parse()` short-form has drifted from the \
lifted `FromStr::from_str` impl"
);
}
}
#[test]
fn caixa_dialeto_from_str_rejects_unknown_byte_strings() {
use std::str::FromStr;
let rejected: &[&str] = &[
"",
" ",
"pacote",
"PACOTE",
"molde",
"MoldePositional",
"desconhecido",
"Unknown",
"defcaixa",
"defmolde",
"?",
"caixa-core / feira",
"pleme-doc-gen",
"nobody known",
"Pacote ",
" Pacote",
"Pacote\n",
"\"Pacote\"",
];
for &input in rejected {
assert_eq!(
<CaixaDialeto as FromStr>::from_str(input),
Err(()),
"FromStr impl on CaixaDialeto must reject unknown \
byte-string {input:?} — divergence signals a silent \
accept-set widening past the four lifted \
crate::render::CAIXA_DIALETO_WIRE_* wire constants"
);
assert_eq!(
<CaixaDialeto as FromStr>::from_str(input).ok(),
CaixaDialeto::from_wire(input),
"FromStr ok()-projection on {input:?} must byte-equal \
CaixaDialeto::from_wire on the same input — \
divergence signals the FromStr trait path has drifted \
off the substrate-primitive accessor"
);
let via_parse: Result<CaixaDialeto, ()> = input.parse();
assert_eq!(
via_parse,
Err(()),
"`{input:?}`.parse::<CaixaDialeto>() 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_dialeto_from_into_static_str_routes_through_as_str_accessor() {
const PACOTE: &str = CaixaDialeto::Pacote.as_str();
const MOLDE: &str = CaixaDialeto::Molde.as_str();
const MOLDE_POSICIONAL: &str = CaixaDialeto::MoldePosicional.as_str();
const DESCONHECIDO: &str = CaixaDialeto::Desconhecido.as_str();
for &variant in CaixaDialeto::ALL {
let via_trait: &'static str = <&'static str as From<CaixaDialeto>>::from(variant);
let via_method: &'static str = variant.as_str();
assert_eq!(
via_trait, via_method,
"From<CaixaDialeto> for &'static str impl must round-trip \
CaixaDialeto::{variant:?} to the same `PascalCase` byte-string \
CaixaDialeto::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 CaixaDialeto::{variant:?} must \
byte-equal CaixaDialeto::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!(
[PACOTE, MOLDE, MOLDE_POSICIONAL, DESCONHECIDO],
["Pacote", "Molde", "MoldePosicional", "Desconhecido"],
"const-context CaixaDialeto::as_str must resolve to the four \
`PascalCase` variant-name byte-strings — 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<CaixaDialeto> for &'static str impl carries by \
construction"
);
}
#[test]
fn caixa_dialeto_from_into_static_str_and_as_str_partition_the_emit_set() {
for &variant in CaixaDialeto::ALL {
let via_trait: &'static str = <&'static str as From<CaixaDialeto>>::from(variant);
let via_method: &'static str = variant.as_str();
assert_eq!(
via_trait, via_method,
"From<CaixaDialeto> for &'static str and \
CaixaDialeto::as_str must resolve identically on \
CaixaDialeto::{variant:?} — divergence signals the \
two forward-projection paths have drifted onto different \
emit-sets"
);
}
for &variant in CaixaDialeto::ALL {
let emitted: &'static str = variant.into();
let re_parsed: Result<CaixaDialeto, ()> =
<CaixaDialeto as TryFrom<&str>>::try_from(emitted);
assert_eq!(
re_parsed,
Ok(variant),
"trait-idiomatic axis pair must round-trip \
CaixaDialeto::{variant:?} through `.into::<&'static \
str>()` and back through `TryFrom<&str>` — a break signals \
the forward-emit and reverse-parse axes have drifted onto \
different vocabularies"
);
}
}
#[test]
fn caixa_dialeto_is_molde_family_routes_through_is_variant_derived_predicates() {
for &d in CaixaDialeto::ALL {
let via_derived = d.is_molde() || d.is_molde_posicional();
let via_is_molde_family = d.is_molde_family();
assert_eq!(
via_is_molde_family, via_derived,
"CaixaDialeto::{d:?}.is_molde_family() ({via_is_molde_family}) \
must byte-equal the composed derived predicates \
is_molde() || is_molde_posicional() ({via_derived}) — a \
split between the composed predicate and its derived \
building blocks would let a future arm rename land at one \
path and drift at the other, which is exactly the drift \
the IsVariant lift refuses"
);
}
}
#[test]
fn caixa_dialeto_from_borrowed_into_static_str_routes_through_as_str_accessor() {
const PACOTE: &str = CaixaDialeto::Pacote.as_str();
const MOLDE: &str = CaixaDialeto::Molde.as_str();
const MOLDE_POSICIONAL: &str = CaixaDialeto::MoldePosicional.as_str();
const DESCONHECIDO: &str = CaixaDialeto::Desconhecido.as_str();
for variant in CaixaDialeto::ALL {
let via_trait: &'static str = <&'static str as From<&CaixaDialeto>>::from(variant);
let via_method: &'static str = variant.as_str();
assert_eq!(
via_trait, via_method,
"From<&CaixaDialeto> for &'static str impl must round-trip \
&CaixaDialeto::{variant:?} to the same `PascalCase` byte-\
string CaixaDialeto::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 &CaixaDialeto::{variant:?} must \
byte-equal CaixaDialeto::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!(
[PACOTE, MOLDE, MOLDE_POSICIONAL, DESCONHECIDO],
["Pacote", "Molde", "MoldePosicional", "Desconhecido"],
"const-context CaixaDialeto::as_str must resolve to the four \
`PascalCase` variant-name byte-strings — the borrowed-input \
From<&CaixaDialeto> for &'static str impl inherits its \
`'static` lifetime promise from the same accessor the owned-\
input sibling routes through"
);
}
#[test]
fn caixa_dialeto_from_owned_and_borrowed_into_static_str_agree_on_every_arm() {
for &variant in CaixaDialeto::ALL {
let owned: &'static str = <&'static str as From<CaixaDialeto>>::from(variant);
let borrowed: &'static str = <&'static str as From<&CaixaDialeto>>::from(&variant);
assert_eq!(
owned, borrowed,
"From<CaixaDialeto> and From<&CaixaDialeto> for &'static str \
must resolve identically on CaixaDialeto::{variant:?} — \
divergence signals the owned-input and borrowed-input \
forward-projection paths have drifted onto different \
emit-sets"
);
}
let via_iter: Vec<&'static str> = CaixaDialeto::ALL.iter().map(Into::into).collect();
let via_method: Vec<&'static str> = CaixaDialeto::ALL.iter().map(|d| d.as_str()).collect();
assert_eq!(
via_iter, via_method,
"`.iter().map(Into::into)` over CaixaDialeto::ALL must byte-\
equal `.iter().map(|d| d.as_str())` on every arm — the \
borrowed-input `From<&CaixaDialeto> for &'static str` axis \
is what makes the `.iter().map(Into::into)` shape route \
through the substrate-primitive `CaixaDialeto::as_str` \
accessor rather than through a per-call-site `.copied()` / \
dereference detour"
);
for &variant in CaixaDialeto::ALL {
let borrowed: &'static str = <&'static str as From<&CaixaDialeto>>::from(&variant);
let re_parsed: Result<CaixaDialeto, ()> =
<CaixaDialeto as TryFrom<&str>>::try_from(borrowed);
assert_eq!(
re_parsed,
Ok(variant),
"trait-idiomatic borrowed-input round-trip must project \
&CaixaDialeto::{variant:?} through \
`<&'static str>::from(&variant)` and back through \
`TryFrom<&str>` — a break signals the borrowed-input \
forward-emit axis and the reverse-parse axis have \
drifted onto different vocabularies"
);
}
}
#[test]
fn caixa_dialeto_from_into_owned_string_routes_through_as_str_accessor() {
for &variant in CaixaDialeto::ALL {
let via_trait: String = <String as From<CaixaDialeto>>::from(variant);
let via_method: &'static str = variant.as_str();
assert_eq!(
via_trait.as_str(),
via_method,
"From<CaixaDialeto> for String impl must round-trip \
CaixaDialeto::{variant:?} to the same `PascalCase` \
arm-string CaixaDialeto::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 CaixaDialeto::{variant:?} must \
byte-equal CaixaDialeto::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_dialeto_from_into_owned_string_and_static_str_agree_on_every_arm() {
for &variant in CaixaDialeto::ALL {
let owned_string: String = <String as From<CaixaDialeto>>::from(variant);
let owned_static: &'static str = <&'static str as From<CaixaDialeto>>::from(variant);
assert_eq!(
owned_string.as_str(),
owned_static,
"From<CaixaDialeto> for String and From<CaixaDialeto> for \
&'static str must resolve identically on \
CaixaDialeto::{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<CaixaDialeto> for String must byte-equal \
CaixaDialeto::to_string on CaixaDialeto::{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> = CaixaDialeto::ALL
.iter()
.copied()
.map(String::from)
.collect();
let via_method: Vec<String> = CaixaDialeto::ALL
.iter()
.map(|d| d.as_str().to_owned())
.collect();
assert_eq!(
via_iter, via_method,
"`.iter().copied().map(String::from)` over CaixaDialeto::ALL \
must byte-equal `.iter().map(|d| d.as_str().to_owned())` on \
every arm — the owned-`String` `From<CaixaDialeto> for \
String` axis is what makes the `String::from` composition \
route through the substrate-primitive `CaixaDialeto::as_str` \
accessor rather than through a per-call-site `.to_owned()` / \
`String::from(dialeto.as_str())` detour"
);
for &variant in CaixaDialeto::ALL {
let emitted: String = variant.into();
let re_parsed: Result<CaixaDialeto, ()> =
<CaixaDialeto as TryFrom<&str>>::try_from(emitted.as_str());
assert_eq!(
re_parsed,
Ok(variant),
"trait-idiomatic owned-`String` forward-projection + \
reverse-projection axis pair must round-trip \
CaixaDialeto::{variant:?} through `.into::<String>()` \
and back through `TryFrom<&str>` on the owned-`String`'s \
String::as_str borrow — a break signals the owned-\
`String` forward-emit and reverse-parse axes have \
drifted onto different vocabularies (unlike the peer \
CaixaKind axis pair, CaixaDialeto's forward emit and \
reverse parse share one PascalCase vocabulary by \
construction, so the round-trip composes directly)"
);
}
}
#[test]
fn caixa_dialeto_from_into_borrowed_owned_string_routes_through_as_str_accessor() {
for &variant in CaixaDialeto::ALL {
let via_trait: String = <String as From<&CaixaDialeto>>::from(&variant);
let via_method: &'static str = variant.as_str();
assert_eq!(
via_trait.as_str(),
via_method,
"From<&CaixaDialeto> for String impl must round-trip \
&CaixaDialeto::{variant:?} to the same `PascalCase` \
arm-string CaixaDialeto::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 &CaixaDialeto::{variant:?} must \
byte-equal CaixaDialeto::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_dialeto_from_into_borrowed_owned_string_agrees_with_paired_axes_on_every_arm() {
for &dialeto in CaixaDialeto::ALL {
let borrowed_string: String = <String as From<&CaixaDialeto>>::from(&dialeto);
let owned_string: String = <String as From<CaixaDialeto>>::from(dialeto);
let borrowed_static: &'static str =
<&'static str as From<&CaixaDialeto>>::from(&dialeto);
let owned_static: &'static str = <&'static str as From<CaixaDialeto>>::from(dialeto);
assert_eq!(
borrowed_string, owned_string,
"From<&CaixaDialeto> for String and From<CaixaDialeto> \
for String must resolve identically on \
CaixaDialeto::{dialeto:?} — 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<&CaixaDialeto> for String and From<&CaixaDialeto> \
for &'static str must resolve identically on \
CaixaDialeto::{dialeto:?} — 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<&CaixaDialeto> for String and From<CaixaDialeto> \
for &'static str must resolve identically on \
CaixaDialeto::{dialeto:?} — 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 = dialeto.to_string();
assert_eq!(
borrowed_string, via_to_string,
"From<&CaixaDialeto> for String must byte-equal \
CaixaDialeto::to_string on CaixaDialeto::{dialeto:?} — \
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> = CaixaDialeto::ALL.iter().map(String::from).collect();
let via_method: Vec<String> = CaixaDialeto::ALL
.iter()
.map(|d| d.as_str().to_owned())
.collect();
assert_eq!(
via_iter, via_method,
"`.iter().map(String::from)` over CaixaDialeto::ALL — a \
call site whose iteration axis holds `&CaixaDialeto` by \
construction — must byte-equal `.iter().map(|d| \
d.as_str().to_owned())` on every arm — the borrowed-input \
owned-`String` `From<&CaixaDialeto> for String` axis is \
what makes the `String::from` composition route through \
the substrate-primitive `CaixaDialeto::as_str` accessor \
without a spurious `Copy` deref (which would only be \
reachable through the owned-input `From<CaixaDialeto> for \
String` axis by first calling `.copied()` on the iterator)"
);
for &variant in CaixaDialeto::ALL {
let emitted: String = (&variant).into();
let re_parsed: Result<CaixaDialeto, ()> =
<CaixaDialeto as TryFrom<&str>>::try_from(emitted.as_str());
assert_eq!(
re_parsed,
Ok(variant),
"trait-idiomatic borrowed-input owned-`String` \
forward-projection + reverse-projection axis pair \
must round-trip &CaixaDialeto::{variant:?} through \
`.into::<String>()` on the borrowed-input surface and \
back through `TryFrom<&str>` on the owned-`String`'s \
String::as_str borrow — a break signals the \
borrowed-input owned-`String` forward-emit and \
reverse-parse axes have drifted onto different \
vocabularies (unlike the peer CaixaKind axis pair, \
CaixaDialeto's forward emit and reverse parse share \
one PascalCase vocabulary by construction, so the \
round-trip composes directly)"
);
}
}
#[test]
fn caixa_dialeto_from_into_static_cow_str_routes_through_as_str_accessor() {
for &variant in CaixaDialeto::ALL {
let via_trait: std::borrow::Cow<'static, str> =
<std::borrow::Cow<'static, str> as From<CaixaDialeto>>::from(variant);
let via_method: &'static str = variant.as_str();
assert_eq!(
via_trait.as_ref(),
via_method,
"From<CaixaDialeto> for Cow<'static, str> impl must \
round-trip CaixaDialeto::{variant:?} to the same \
PascalCase byte-string CaixaDialeto::as_str returns \
— divergence signals a silent detour off the \
substrate-primitive accessor"
);
assert!(
matches!(via_trait, std::borrow::Cow::Borrowed(_)),
"From<CaixaDialeto> for Cow<'static, str> impl must \
land on the zero-alloc Cow::Borrowed arm on \
CaixaDialeto::{variant:?} — a Cow::Owned outcome \
signals the projection has silently allocated where \
the substrate-primitive CaixaDialeto::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 \
CaixaDialeto::{variant:?} must byte-equal \
CaixaDialeto::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 \
CaixaDialeto::{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_dialeto_from_into_static_cow_str_agrees_with_paired_axes_on_every_arm() {
for &variant in CaixaDialeto::ALL {
let via_cow: std::borrow::Cow<'static, str> =
<std::borrow::Cow<'static, str> as From<CaixaDialeto>>::from(variant);
let via_static: &'static str = <&'static str as From<CaixaDialeto>>::from(variant);
let via_string: String = <String as From<CaixaDialeto>>::from(variant);
assert_eq!(
via_cow.as_ref(),
via_static,
"From<CaixaDialeto> for Cow<'static, str> and \
From<CaixaDialeto> for &'static str must resolve \
identically on CaixaDialeto::{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<CaixaDialeto> for Cow<'static, str> and \
From<CaixaDialeto> for String must resolve \
identically on CaixaDialeto::{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<CaixaDialeto> for Cow<'static, str> must \
byte-equal CaixaDialeto::to_string on \
CaixaDialeto::{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>> = CaixaDialeto::ALL
.iter()
.copied()
.map(std::borrow::Cow::from)
.collect();
let via_method: Vec<std::borrow::Cow<'static, str>> = CaixaDialeto::ALL
.iter()
.map(|d| std::borrow::Cow::Borrowed(d.as_str()))
.collect();
assert_eq!(
via_iter, via_method,
"`.iter().copied().map(Cow::from)` over \
CaixaDialeto::ALL must byte-equal `.iter().map(|d| \
Cow::Borrowed(d.as_str()))` on every arm — the \
trait-idiomatic `From<CaixaDialeto> for Cow<'static, \
str>` axis is what makes the `Cow::from` composition \
route through the substrate-primitive \
CaixaDialeto::as_str accessor rather than a per-call-\
site open-code"
);
for cow in &via_iter {
assert!(
matches!(cow, std::borrow::Cow::Borrowed(_)),
"`.iter().copied().map(Cow::from)` over \
CaixaDialeto::ALL must land on the zero-alloc \
Cow::Borrowed arm on every element — a Cow::Owned \
outcome signals the pipe has silently allocated \
where the substrate-primitive \
CaixaDialeto::as_str `&'static str` return makes \
the borrowed arm the type-correct projection"
);
}
for &variant in CaixaDialeto::ALL {
let via_cow: std::borrow::Cow<'static, str> =
<std::borrow::Cow<'static, str> as From<CaixaDialeto>>::from(variant);
let re_parsed: Result<CaixaDialeto, ()> =
<CaixaDialeto as TryFrom<&str>>::try_from(via_cow.as_ref());
assert_eq!(
re_parsed,
Ok(variant),
"trait-idiomatic Cow<'static, str> forward-projection \
+ reverse-projection axis pair must round-trip \
CaixaDialeto::{variant:?} through `.into::<Cow<\
'static, str>>()` on the owned-input surface and \
back through `TryFrom<&str>` on the projection's \
Cow::as_ref borrow — a break signals the \
Cow<'static, str> forward-emit and reverse-parse \
axes have drifted onto different vocabularies \
(unlike the peer CaixaKind axis pair, CaixaDialeto's \
forward emit and reverse parse share one PascalCase \
vocabulary by construction, so the round-trip \
composes directly)"
);
}
}
#[test]
fn caixa_dialeto_from_borrowed_into_static_cow_str_routes_through_as_str_accessor() {
for &variant in CaixaDialeto::ALL {
let via_trait: std::borrow::Cow<'static, str> =
<std::borrow::Cow<'static, str> as From<&CaixaDialeto>>::from(&variant);
let via_method: &'static str = variant.as_str();
assert_eq!(
via_trait.as_ref(),
via_method,
"From<&CaixaDialeto> for Cow<'static, str> impl must \
round-trip &CaixaDialeto::{variant:?} to the same \
PascalCase byte-string CaixaDialeto::as_str returns \
— divergence signals a silent detour off the \
substrate-primitive accessor"
);
assert!(
matches!(via_trait, std::borrow::Cow::Borrowed(_)),
"From<&CaixaDialeto> for Cow<'static, str> impl must \
land on the zero-alloc Cow::Borrowed arm on \
&CaixaDialeto::{variant:?} — a Cow::Owned outcome \
signals the projection has silently allocated where \
the substrate-primitive CaixaDialeto::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 \
&CaixaDialeto::{variant:?} must byte-equal \
CaixaDialeto::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"
);
assert!(
matches!(via_into, std::borrow::Cow::Borrowed(_)),
"Into<Cow<'static, str>>::into on \
&CaixaDialeto::{variant:?} must land on the \
zero-alloc Cow::Borrowed arm — the blanket-derived \
Into shape on the borrowed-input surface must \
resolve to the same Cow::Borrowed dispatch as the \
explicit From impl"
);
}
}
#[test]
#[allow(
clippy::too_many_lines,
reason = "cross-axis partition pin folds four return-shape paths \
(borrowed-input Cow<'static, str>, owned-input Cow<'static, str>, \
borrowed-input &'static str, borrowed-input String) plus the \
ToString-through-Display witness plus a `.iter().map(Cow::from)` \
pipe witness with zero-alloc discriminator plus a direct \
round-trip witness through TryFrom<&str> over four typed \
variants; the linear per-axis repetition is exactly what the \
fold is pinning — a helper would hide the shape it locks"
)]
fn caixa_dialeto_from_borrowed_into_static_cow_str_agrees_with_paired_axes_on_every_arm() {
for &variant in CaixaDialeto::ALL {
let via_borrowed_cow: std::borrow::Cow<'static, str> =
<std::borrow::Cow<'static, str> as From<&CaixaDialeto>>::from(&variant);
let via_owned_cow: std::borrow::Cow<'static, str> =
<std::borrow::Cow<'static, str> as From<CaixaDialeto>>::from(variant);
let via_borrowed_static: &'static str =
<&'static str as From<&CaixaDialeto>>::from(&variant);
let via_borrowed_string: String = <String as From<&CaixaDialeto>>::from(&variant);
assert_eq!(
via_borrowed_cow.as_ref(),
via_owned_cow.as_ref(),
"From<&CaixaDialeto> for Cow<'static, str> and \
From<CaixaDialeto> for Cow<'static, str> must \
resolve identically on CaixaDialeto::{variant:?} — \
divergence signals the borrowed-input and \
owned-input Cow<'static, str> return-shape paths \
have drifted onto different emit-sets"
);
assert_eq!(
via_borrowed_cow.as_ref(),
via_borrowed_static,
"From<&CaixaDialeto> for Cow<'static, str> and \
From<&CaixaDialeto> for &'static str must resolve \
identically on CaixaDialeto::{variant:?} — \
divergence signals the borrowed-input Cow<'static, \
str> and borrowed-input &'static str return-shape \
paths have drifted onto different emit-sets"
);
assert_eq!(
via_borrowed_cow.as_ref(),
via_borrowed_string.as_str(),
"From<&CaixaDialeto> for Cow<'static, str> and \
From<&CaixaDialeto> for String must resolve \
identically on CaixaDialeto::{variant:?} — \
divergence signals the borrowed-input Cow<'static, \
str> and borrowed-input String return-shape paths \
have drifted onto different emit-sets"
);
let via_to_string: String = variant.to_string();
assert_eq!(
via_borrowed_cow.as_ref(),
via_to_string.as_str(),
"From<&CaixaDialeto> for Cow<'static, str> must \
byte-equal CaixaDialeto::to_string on \
CaixaDialeto::{variant:?} — divergence signals the \
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>> = CaixaDialeto::ALL
.iter()
.map(std::borrow::Cow::from)
.collect();
let via_method: Vec<std::borrow::Cow<'static, str>> = CaixaDialeto::ALL
.iter()
.map(|d| std::borrow::Cow::Borrowed(d.as_str()))
.collect();
assert_eq!(
via_iter, via_method,
"`.iter().map(Cow::from)` over CaixaDialeto::ALL must \
byte-equal `.iter().map(|d| Cow::Borrowed(d.as_str()))` \
on every arm — the trait-idiomatic `From<&CaixaDialeto> \
for Cow<'static, str>` axis is what makes the \
`Cow::from` composition on the borrowed-iteration axis \
route through the substrate-primitive \
CaixaDialeto::as_str accessor without a spurious Copy \
deref"
);
for cow in &via_iter {
assert!(
matches!(cow, std::borrow::Cow::Borrowed(_)),
"`.iter().map(Cow::from)` over CaixaDialeto::ALL \
must land on the zero-alloc Cow::Borrowed arm on \
every element — a Cow::Owned outcome signals the \
borrowed-iteration pipe has silently allocated \
where the substrate-primitive CaixaDialeto::as_str \
`&'static str` return makes the borrowed arm the \
type-correct projection"
);
}
for &variant in CaixaDialeto::ALL {
let via_cow: std::borrow::Cow<'static, str> =
<std::borrow::Cow<'static, str> as From<&CaixaDialeto>>::from(&variant);
let re_parsed: Result<CaixaDialeto, ()> =
<CaixaDialeto as TryFrom<&str>>::try_from(via_cow.as_ref());
assert_eq!(
re_parsed,
Ok(variant),
"trait-idiomatic borrowed-input Cow<'static, str> \
forward-projection + reverse-projection axis pair \
must round-trip &CaixaDialeto::{variant:?} through \
`.into::<Cow<'static, str>>()` on the borrowed-input \
surface and back through `TryFrom<&str>` on the \
projection's Cow::as_ref borrow — a break signals \
the borrowed-input Cow<'static, str> forward-emit \
and reverse-parse axes have drifted onto different \
vocabularies (unlike the peer CaixaKind axis pair, \
CaixaDialeto's forward emit and reverse parse share \
one PascalCase vocabulary by construction, so the \
round-trip composes directly)"
);
}
}
#[test]
fn caixa_dialeto_from_into_box_str_routes_through_as_str_accessor() {
for &variant in CaixaDialeto::ALL {
let via_trait: Box<str> = <Box<str> as From<CaixaDialeto>>::from(variant);
let via_method: &'static str = variant.as_str();
assert_eq!(
via_trait.as_ref(),
via_method,
"From<CaixaDialeto> for Box<str> impl must round-trip \
CaixaDialeto::{variant:?} to the same PascalCase \
byte-string CaixaDialeto::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 CaixaDialeto::{variant:?} must \
byte-equal CaixaDialeto::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_dialeto_from_borrowed_into_box_str_routes_through_as_str_accessor() {
for &variant in CaixaDialeto::ALL {
let via_trait: Box<str> = <Box<str> as From<&CaixaDialeto>>::from(&variant);
let via_method: &'static str = variant.as_str();
assert_eq!(
via_trait.as_ref(),
via_method,
"From<&CaixaDialeto> for Box<str> impl must round-trip \
&CaixaDialeto::{variant:?} to the same PascalCase \
byte-string CaixaDialeto::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 &CaixaDialeto::{variant:?} \
must byte-equal CaixaDialeto::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>> = CaixaDialeto::ALL.iter().map(Box::<str>::from).collect();
let via_accessor: Vec<&'static str> =
CaixaDialeto::ALL.iter().map(|d| d.as_str()).collect();
assert_eq!(
via_pipe.len(),
via_accessor.len(),
"CaixaDialeto::ALL.iter().map(Box::<str>::from) pipe must \
preserve arity against the paired CaixaDialeto::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,
"CaixaDialeto::ALL.iter().map(Box::<str>::from) pipe \
must byte-equal the paired \
CaixaDialeto::ALL.iter().map(|d| d.as_str()) pipe on \
every arm — divergence signals the borrowed-input \
`From<&CaixaDialeto> for Box<str>` axis has silently \
detoured off the substrate-primitive accessor"
);
}
}
#[test]
fn caixa_dialeto_from_into_arc_str_routes_through_as_str_accessor() {
for &variant in CaixaDialeto::ALL {
let via_trait: std::sync::Arc<str> =
<std::sync::Arc<str> as From<CaixaDialeto>>::from(variant);
let via_method: &'static str = variant.as_str();
assert_eq!(
via_trait.as_ref(),
via_method,
"From<CaixaDialeto> for std::sync::Arc<str> impl must \
round-trip CaixaDialeto::{variant:?} to the same \
PascalCase byte-string CaixaDialeto::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 CaixaDialeto::\
{variant:?} must byte-equal CaixaDialeto::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<CaixaDialeto>>::from(variant);
assert_eq!(
via_trait.as_ref(),
owned_static,
"From<CaixaDialeto> for std::sync::Arc<str> and \
From<CaixaDialeto> for &'static str must resolve \
identically on CaixaDialeto::{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<CaixaDialeto>>::from(variant);
assert_eq!(
via_trait.as_ref(),
owned_string.as_str(),
"From<CaixaDialeto> for std::sync::Arc<str> and \
From<CaixaDialeto> for String must resolve identically \
on CaixaDialeto::{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<CaixaDialeto>>::from(variant);
assert_eq!(
via_trait.as_ref(),
owned_cow.as_ref(),
"From<CaixaDialeto> for std::sync::Arc<str> and \
From<CaixaDialeto> for Cow<'static, str> must resolve \
identically on CaixaDialeto::{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<CaixaDialeto>>::from(variant);
assert_eq!(
via_trait.as_ref(),
owned_box.as_ref(),
"From<CaixaDialeto> for std::sync::Arc<str> and \
From<CaixaDialeto> for Box<str> must resolve identically \
on CaixaDialeto::{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 \
CaixaDialeto::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_dialeto_from_borrowed_into_arc_str_routes_through_as_str_accessor() {
for &variant in CaixaDialeto::ALL {
let via_trait: std::sync::Arc<str> =
<std::sync::Arc<str> as From<&CaixaDialeto>>::from(&variant);
let via_method: &'static str = variant.as_str();
assert_eq!(
via_trait.as_ref(),
via_method,
"From<&CaixaDialeto> for std::sync::Arc<str> impl must \
round-trip &CaixaDialeto::{variant:?} to the same \
PascalCase byte-string CaixaDialeto::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 &CaixaDialeto::\
{variant:?} must byte-equal CaixaDialeto::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<CaixaDialeto>>::from(variant);
assert_eq!(
via_trait, owned_arc,
"From<&CaixaDialeto> for std::sync::Arc<str> and \
From<CaixaDialeto> for std::sync::Arc<str> must resolve \
identically on CaixaDialeto::{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<&CaixaDialeto>>::from(&variant);
assert_eq!(
via_trait.as_ref(),
borrowed_static,
"From<&CaixaDialeto> for std::sync::Arc<str> and \
From<&CaixaDialeto> for &'static str must resolve \
identically on CaixaDialeto::{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<&CaixaDialeto>>::from(&variant);
assert_eq!(
via_trait.as_ref(),
borrowed_string.as_str(),
"From<&CaixaDialeto> for std::sync::Arc<str> and \
From<&CaixaDialeto> for String must resolve identically \
on CaixaDialeto::{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<&CaixaDialeto>>::from(&variant);
assert_eq!(
via_trait.as_ref(),
borrowed_cow.as_ref(),
"From<&CaixaDialeto> for std::sync::Arc<str> and \
From<&CaixaDialeto> for Cow<'static, str> must resolve \
identically on CaixaDialeto::{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<&CaixaDialeto>>::from(&variant);
assert_eq!(
via_trait.as_ref(),
borrowed_box.as_ref(),
"From<&CaixaDialeto> for std::sync::Arc<str> and \
From<&CaixaDialeto> for Box<str> must resolve \
identically on CaixaDialeto::{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>> = CaixaDialeto::ALL
.iter()
.map(std::sync::Arc::<str>::from)
.collect();
let via_method: Vec<std::sync::Arc<str>> = CaixaDialeto::ALL
.iter()
.map(|d| std::sync::Arc::<str>::from(d.as_str()))
.collect();
assert_eq!(
via_iter, via_method,
"`.iter().map(std::sync::Arc::<str>::from)` over \
CaixaDialeto::ALL — a call site whose iteration axis holds \
`&CaixaDialeto` by construction — must byte-equal \
`.iter().map(|d| std::sync::Arc::<str>::from(d.as_str()))` \
on every arm — the borrowed-input std::sync::Arc<str> \
`From<&CaixaDialeto> for std::sync::Arc<str>` axis is what \
makes the `std::sync::Arc::<str>::from` composition route \
through the substrate-primitive `CaixaDialeto::as_str` \
accessor without a spurious `Copy` deref (which would only \
be reachable through the owned-input \
`From<CaixaDialeto> for std::sync::Arc<str>` axis by first \
calling `.copied()` on the iterator)"
);
}
#[test]
fn caixa_dialeto_from_into_rc_str_routes_through_as_str_accessor() {
for &variant in CaixaDialeto::ALL {
let via_trait: std::rc::Rc<str> =
<std::rc::Rc<str> as From<CaixaDialeto>>::from(variant);
let via_method: &'static str = variant.as_str();
assert_eq!(
via_trait.as_ref(),
via_method,
"From<CaixaDialeto> for std::rc::Rc<str> impl must \
round-trip CaixaDialeto::{variant:?} to the same \
PascalCase byte-string CaixaDialeto::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 CaixaDialeto::\
{variant:?} must byte-equal CaixaDialeto::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<CaixaDialeto>>::from(variant);
assert_eq!(
via_trait.as_ref(),
owned_static,
"From<CaixaDialeto> for std::rc::Rc<str> and \
From<CaixaDialeto> for &'static str must resolve \
identically on CaixaDialeto::{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<CaixaDialeto>>::from(variant);
assert_eq!(
via_trait.as_ref(),
owned_string.as_str(),
"From<CaixaDialeto> for std::rc::Rc<str> and \
From<CaixaDialeto> for String must resolve identically \
on CaixaDialeto::{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<CaixaDialeto>>::from(variant);
assert_eq!(
via_trait.as_ref(),
owned_cow.as_ref(),
"From<CaixaDialeto> for std::rc::Rc<str> and \
From<CaixaDialeto> for Cow<'static, str> must resolve \
identically on CaixaDialeto::{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<CaixaDialeto>>::from(variant);
assert_eq!(
via_trait.as_ref(),
owned_box.as_ref(),
"From<CaixaDialeto> for std::rc::Rc<str> and \
From<CaixaDialeto> for Box<str> must resolve identically \
on CaixaDialeto::{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<CaixaDialeto>>::from(variant);
assert_eq!(
via_trait.as_ref(),
owned_arc.as_ref(),
"From<CaixaDialeto> for std::rc::Rc<str> and \
From<CaixaDialeto> for std::sync::Arc<str> must resolve \
identically on CaixaDialeto::{variant:?} — divergence \
signals the owned-input std::rc::Rc<str> and \
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 CaixaDialeto::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_dialeto_from_borrowed_into_rc_str_routes_through_as_str_accessor() {
for &variant in CaixaDialeto::ALL {
let via_trait: std::rc::Rc<str> =
<std::rc::Rc<str> as From<&CaixaDialeto>>::from(&variant);
let via_method: &'static str = variant.as_str();
assert_eq!(
via_trait.as_ref(),
via_method,
"From<&CaixaDialeto> for std::rc::Rc<str> impl must \
round-trip &CaixaDialeto::{variant:?} to the same \
PascalCase byte-string CaixaDialeto::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 &CaixaDialeto::\
{variant:?} must byte-equal CaixaDialeto::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<CaixaDialeto>>::from(variant);
assert_eq!(
via_trait, owned_rc,
"From<&CaixaDialeto> for std::rc::Rc<str> and \
From<CaixaDialeto> for std::rc::Rc<str> must resolve \
identically on CaixaDialeto::{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<&CaixaDialeto>>::from(&variant);
assert_eq!(
via_trait.as_ref(),
borrowed_static,
"From<&CaixaDialeto> for std::rc::Rc<str> and \
From<&CaixaDialeto> for &'static str must resolve \
identically on CaixaDialeto::{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<&CaixaDialeto>>::from(&variant);
assert_eq!(
via_trait.as_ref(),
borrowed_string.as_str(),
"From<&CaixaDialeto> for std::rc::Rc<str> and \
From<&CaixaDialeto> for String must resolve identically \
on CaixaDialeto::{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<&CaixaDialeto>>::from(&variant);
assert_eq!(
via_trait.as_ref(),
borrowed_cow.as_ref(),
"From<&CaixaDialeto> for std::rc::Rc<str> and \
From<&CaixaDialeto> for Cow<'static, str> must resolve \
identically on CaixaDialeto::{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<&CaixaDialeto>>::from(&variant);
assert_eq!(
via_trait.as_ref(),
borrowed_box.as_ref(),
"From<&CaixaDialeto> for std::rc::Rc<str> and \
From<&CaixaDialeto> for Box<str> must resolve \
identically on CaixaDialeto::{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<&CaixaDialeto>>::from(&variant);
assert_eq!(
via_trait.as_ref(),
borrowed_arc.as_ref(),
"From<&CaixaDialeto> for std::rc::Rc<str> and \
From<&CaixaDialeto> for std::sync::Arc<str> must \
resolve identically on CaixaDialeto::{variant:?} — \
divergence signals the borrowed-input std::rc::Rc<str> \
and std::sync::Arc<str> return-shape paths have drifted \
onto different emit-sets"
);
}
let via_iter: Vec<std::rc::Rc<str>> = CaixaDialeto::ALL
.iter()
.map(std::rc::Rc::<str>::from)
.collect();
let via_method: Vec<std::rc::Rc<str>> = CaixaDialeto::ALL
.iter()
.map(|d| std::rc::Rc::<str>::from(d.as_str()))
.collect();
assert_eq!(
via_iter, via_method,
"`.iter().map(std::rc::Rc::<str>::from)` over \
CaixaDialeto::ALL — a call site whose iteration axis holds \
`&CaixaDialeto` by construction — must byte-equal \
`.iter().map(|d| std::rc::Rc::<str>::from(d.as_str()))` \
on every arm — the borrowed-input std::rc::Rc<str> \
`From<&CaixaDialeto> for std::rc::Rc<str>` axis is what \
makes the `std::rc::Rc::<str>::from` composition route \
through the substrate-primitive `CaixaDialeto::as_str` \
accessor without a spurious `Copy` deref (which would only \
be reachable through the owned-input \
`From<CaixaDialeto> for std::rc::Rc<str>` axis by first \
calling `.copied()` on the iterator)"
);
}
#[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 CaixaDialeto::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_dialeto_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 CaixaDialeto::ALL {
let via_trait: &[u8] = <CaixaDialeto 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 CaixaDialeto impl must byte-equal \
CaixaDialeto::as_str().as_bytes() on CaixaDialeto::\
{variant:?} — divergence signals a silent detour off \
the substrate-primitive accessor"
);
let str_view_ref: &str = <CaixaDialeto as AsRef<str>>::as_ref(&variant);
assert_eq!(
via_trait,
str_view_ref.as_bytes(),
"AsRef<[u8]> for CaixaDialeto and AsRef<str> for \
CaixaDialeto must resolve to byte-equal byte-tails \
on CaixaDialeto::{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 CaixaDialeto and \
<CaixaDialeto as std::fmt::Display>::to_string must \
resolve to byte-equal byte-tails on CaixaDialeto::\
{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<CaixaDialeto>>::from(variant);
assert_eq!(
via_trait,
owned_static.as_bytes(),
"AsRef<[u8]> for CaixaDialeto and From<CaixaDialeto> \
for &'static str must resolve to byte-equal byte-\
tails on CaixaDialeto::{variant:?}"
);
let owned_string: String = <String as From<CaixaDialeto>>::from(variant);
assert_eq!(
via_trait,
owned_string.as_bytes(),
"AsRef<[u8]> for CaixaDialeto and From<CaixaDialeto> \
for String must resolve to byte-equal byte-tails on \
CaixaDialeto::{variant:?}"
);
let owned_cow: std::borrow::Cow<'static, str> =
<std::borrow::Cow<'static, str> as From<CaixaDialeto>>::from(variant);
assert_eq!(
via_trait,
owned_cow.as_bytes(),
"AsRef<[u8]> for CaixaDialeto and From<CaixaDialeto> \
for Cow<'static, str> must resolve to byte-equal \
byte-tails on CaixaDialeto::{variant:?}"
);
let owned_box: Box<str> = <Box<str> as From<CaixaDialeto>>::from(variant);
assert_eq!(
via_trait,
owned_box.as_bytes(),
"AsRef<[u8]> for CaixaDialeto and From<CaixaDialeto> \
for Box<str> must resolve to byte-equal byte-tails \
on CaixaDialeto::{variant:?}"
);
let owned_arc: std::sync::Arc<str> =
<std::sync::Arc<str> as From<CaixaDialeto>>::from(variant);
assert_eq!(
via_trait,
owned_arc.as_bytes(),
"AsRef<[u8]> for CaixaDialeto and From<CaixaDialeto> \
for std::sync::Arc<str> must resolve to byte-equal \
byte-tails on CaixaDialeto::{variant:?}"
);
let owned_rc_str: std::rc::Rc<str> =
<std::rc::Rc<str> as From<CaixaDialeto>>::from(variant);
assert_eq!(
via_trait,
owned_rc_str.as_bytes(),
"AsRef<[u8]> for CaixaDialeto and From<CaixaDialeto> \
for std::rc::Rc<str> must resolve to byte-equal \
byte-tails on CaixaDialeto::{variant:?}"
);
}
for &variant in CaixaDialeto::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 \
CaixaDialeto::{variant:?} must yield the same byte-\
tail CaixaDialeto::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 \
&CaixaDialeto::{variant:?} must yield the same byte-\
tail CaixaDialeto::as_str().as_bytes() returns — the \
borrowed-input surface must resolve to the same \
as_str dispatch"
);
}
for &variant in CaixaDialeto::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(dialeto)`-shape composition on \
CaixaDialeto::{variant:?} must fold the same byte-\
tail CaixaDialeto::as_str().as_bytes() returns — the \
shape a future per-caixa BLAKE3 content-address \
closure composes to fold a `:dialect` classification \
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(&dialeto)`-shape composition on \
&CaixaDialeto::{variant:?} must fold the same byte-\
tail CaixaDialeto::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 extended \
onto CaixaDialeto here as the second peer on the \
substrate-wide byte-owned Vec<u8>-output projection \
family (after the sibling first-mover CaixaKind, \
b245fd6), 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_dialeto_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 CaixaDialeto::ALL {
let via_owned_from: Vec<u8> = <Vec<u8> as From<CaixaDialeto>>::from(variant);
let via_borrowed_from: Vec<u8> = <Vec<u8> as From<&CaixaDialeto>>::from(&variant);
let via_method_bytes: Vec<u8> = variant.as_str().as_bytes().to_vec();
assert_eq!(
via_owned_from, via_method_bytes,
"From<CaixaDialeto> for Vec<u8> impl must byte-equal \
CaixaDialeto::as_str().as_bytes().to_vec() on \
CaixaDialeto::{variant:?} — divergence signals a \
silent detour off the substrate-primitive accessor"
);
assert_eq!(
via_borrowed_from, via_method_bytes,
"From<&CaixaDialeto> for Vec<u8> impl must byte-equal \
CaixaDialeto::as_str().as_bytes().to_vec() on \
CaixaDialeto::{variant:?} — divergence signals a \
silent detour off the substrate-primitive accessor"
);
assert_eq!(
via_owned_from, via_borrowed_from,
"From<CaixaDialeto> for Vec<u8> and From<&CaixaDialeto> \
for Vec<u8> must byte-equal each other on \
CaixaDialeto::{variant:?} — divergence signals the \
owned-input and borrowed-input paths have drifted off \
the same substrate-primitive as_str accessor"
);
let borrowed_bytes: &[u8] = <CaixaDialeto as AsRef<[u8]>>::as_ref(&variant);
assert_eq!(
via_owned_from,
borrowed_bytes.to_vec(),
"From<CaixaDialeto> for Vec<u8> and AsRef<[u8]> for \
CaixaDialeto must resolve to byte-equal byte-tails on \
CaixaDialeto::{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<CaixaDialeto>>::from(variant);
assert_eq!(
via_owned_from,
owned_string.into_bytes(),
"From<CaixaDialeto> for Vec<u8> and \
String::from(dialeto).into_bytes() must resolve to \
byte-equal byte-tails on CaixaDialeto::{variant:?}"
);
let owned_cow: std::borrow::Cow<'static, str> =
<std::borrow::Cow<'static, str> as From<CaixaDialeto>>::from(variant);
assert_eq!(
via_owned_from,
owned_cow.as_bytes().to_vec(),
"From<CaixaDialeto> for Vec<u8> and From<CaixaDialeto> \
for Cow<'static, str> must resolve to byte-equal \
byte-tails on CaixaDialeto::{variant:?}"
);
let owned_box: Box<str> = <Box<str> as From<CaixaDialeto>>::from(variant);
assert_eq!(
via_owned_from,
owned_box.as_bytes().to_vec(),
"From<CaixaDialeto> for Vec<u8> and From<CaixaDialeto> \
for Box<str> must resolve to byte-equal byte-tails on \
CaixaDialeto::{variant:?}"
);
let owned_arc: std::sync::Arc<str> =
<std::sync::Arc<str> as From<CaixaDialeto>>::from(variant);
assert_eq!(
via_owned_from,
owned_arc.as_bytes().to_vec(),
"From<CaixaDialeto> for Vec<u8> and From<CaixaDialeto> \
for std::sync::Arc<str> must resolve to byte-equal \
byte-tails on CaixaDialeto::{variant:?}"
);
let owned_rc_str: std::rc::Rc<str> =
<std::rc::Rc<str> as From<CaixaDialeto>>::from(variant);
assert_eq!(
via_owned_from,
owned_rc_str.as_bytes().to_vec(),
"From<CaixaDialeto> for Vec<u8> and From<CaixaDialeto> \
for std::rc::Rc<str> must resolve to byte-equal \
byte-tails on CaixaDialeto::{variant:?}"
);
}
for &variant in CaixaDialeto::ALL {
let via_generic_owned = generic_owned_bytes_sink(variant);
let variant_ref: &CaixaDialeto = &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 \
CaixaDialeto::{variant:?} must yield the same byte-\
tail CaixaDialeto::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 \
&CaixaDialeto::{variant:?} must yield the same byte-\
tail CaixaDialeto::as_str().as_bytes().to_vec() \
returns — the borrowed-input surface must resolve to \
the same as_str dispatch"
);
}
for &variant in CaixaDialeto::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(dialeto)`-shape composition on \
CaixaDialeto::{variant:?} must fold the same byte-\
tail CaixaDialeto::as_str().as_bytes() returns"
);
let mut borrowed_sink = MockOwnedByteSink::new();
let variant_ref: &CaixaDialeto = &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(&dialeto)`-shape composition on \
&CaixaDialeto::{variant:?} must fold the same byte-\
tail CaixaDialeto::as_str().as_bytes() returns — the \
borrowed-input surface must resolve to the same \
as_str dispatch"
);
}
}
#[test]
fn caixa_dialeto_try_from_bytes_routes_through_from_wire_accessor() {
for &variant in CaixaDialeto::ALL {
let wire_bytes: &[u8] = variant.as_str().as_bytes();
assert_eq!(
<CaixaDialeto as TryFrom<&[u8]>>::try_from(wire_bytes),
Ok(variant),
"TryFrom<&[u8]> impl on CaixaDialeto must round-trip \
CaixaDialeto::{variant:?}.as_str().as_bytes() back to \
Ok(CaixaDialeto::{variant:?}) — divergence from \
CaixaDialeto::from_wire signals a silent detour off \
the substrate-primitive accessor"
);
assert_eq!(
<CaixaDialeto as TryFrom<&[u8]>>::try_from(wire_bytes).ok(),
CaixaDialeto::from_wire(variant.as_str()),
"TryFrom<&[u8]> ok()-projection on \
CaixaDialeto::{variant:?}.as_str().as_bytes() must \
byte-equal CaixaDialeto::from_wire on the paired &str \
input"
);
let via_str: Result<CaixaDialeto, ()> =
<CaixaDialeto as TryFrom<&str>>::try_from(variant.as_str());
let via_bytes: Result<CaixaDialeto, ()> =
<CaixaDialeto as TryFrom<&[u8]>>::try_from(wire_bytes);
assert_eq!(
via_bytes, via_str,
"TryFrom<&[u8]> and TryFrom<&str> reverse-projection \
axes on CaixaDialeto must agree on \
CaixaDialeto::{variant:?} — divergence signals the \
byte-view and str-view reverse paths have drifted off \
the same substrate-primitive from_wire accessor"
);
}
}
#[test]
fn caixa_dialeto_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!(
<CaixaDialeto as TryFrom<&[u8]>>::try_from(input),
Err(()),
"TryFrom<&[u8]> impl on CaixaDialeto 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" ",
b"pacote",
b"PACOTE",
b"molde",
b"MoldePositional",
b"desconhecido",
b"Unknown",
b"defcaixa",
b"defmolde",
b"?",
b"caixa-core / feira",
b"pleme-doc-gen",
b"nobody known",
b"Pacote ",
b" Pacote",
b"Pacote\n",
b"\"Pacote\"",
];
for &input in unknown_wire_rejected {
assert_eq!(
<CaixaDialeto as TryFrom<&[u8]>>::try_from(input),
Err(()),
"TryFrom<&[u8]> impl on CaixaDialeto must reject the \
valid-UTF-8-but-unknown-wire byte-string {input:?} \
with Err(()) — silent acceptance signals an accept-\
set widening off the paired CaixaDialeto::from_wire \
resolver"
);
if let Ok(s) = std::str::from_utf8(input) {
assert_eq!(
<CaixaDialeto as TryFrom<&[u8]>>::try_from(input),
<CaixaDialeto as TryFrom<&str>>::try_from(s),
"TryFrom<&[u8]> and TryFrom<&str> reverse-\
projection axes on CaixaDialeto 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_dialeto_try_from_vec_bytes_routes_through_borrowed_byte_view_axis() {
for &variant in CaixaDialeto::ALL {
let wire_bytes: Vec<u8> = variant.as_str().as_bytes().to_vec();
assert_eq!(
<CaixaDialeto as TryFrom<Vec<u8>>>::try_from(wire_bytes.clone()),
Ok(variant),
"TryFrom<Vec<u8>> impl on CaixaDialeto must round-trip \
CaixaDialeto::{variant:?}.as_str().as_bytes().to_vec() \
back to Ok(CaixaDialeto::{variant:?}) — divergence from \
the sibling TryFrom<&[u8]> axis signals a silent detour \
off the substrate-primitive from_wire accessor"
);
let via_owned: Result<CaixaDialeto, ()> =
<CaixaDialeto as TryFrom<Vec<u8>>>::try_from(wire_bytes.clone());
let via_borrowed: Result<CaixaDialeto, ()> =
<CaixaDialeto 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 CaixaDialeto must agree on \
CaixaDialeto::{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<CaixaDialeto, ()> =
<CaixaDialeto as TryFrom<&str>>::try_from(variant.as_str());
assert_eq!(
via_owned, via_str,
"TryFrom<Vec<u8>> and TryFrom<&str> reverse-projection \
axes on CaixaDialeto must agree on \
CaixaDialeto::{variant:?} — divergence signals the \
byte-owned and str-view reverse paths have drifted \
off the same substrate-primitive from_wire accessor"
);
let owned_forward: Vec<u8> = <Vec<u8> as From<CaixaDialeto>>::from(variant);
let borrowed_forward: Vec<u8> = <Vec<u8> as From<&CaixaDialeto>>::from(&variant);
assert_eq!(
owned_forward, wire_bytes,
"From<CaixaDialeto> for Vec<u8> forward projection on \
CaixaDialeto::{variant:?} must byte-equal \
variant.as_str().as_bytes().to_vec() — divergence \
signals the paired forward pair drifted off the \
substrate-primitive as_str accessor"
);
assert_eq!(
borrowed_forward, wire_bytes,
"From<&CaixaDialeto> for Vec<u8> forward projection on \
&CaixaDialeto::{variant:?} must byte-equal \
variant.as_str().as_bytes().to_vec() — divergence \
signals the paired forward pair drifted off the \
substrate-primitive as_str accessor"
);
assert_eq!(
<CaixaDialeto as TryFrom<Vec<u8>>>::try_from(owned_forward.clone()),
Ok(variant),
"Four-corner round-trip on CaixaDialeto::{variant:?} \
through From<CaixaDialeto> for Vec<u8> then \
TryFrom<Vec<u8>> for CaixaDialeto must return \
Ok(variant) — divergence signals the byte-owned \
forward pair and the byte-owned reverse axis have \
drifted apart"
);
assert_eq!(
<CaixaDialeto as TryFrom<Vec<u8>>>::try_from(borrowed_forward),
Ok(variant),
"Four-corner round-trip on CaixaDialeto::{variant:?} \
through From<&CaixaDialeto> for Vec<u8> then \
TryFrom<Vec<u8>> for CaixaDialeto must return \
Ok(variant) — divergence signals the borrowed-input \
forward corner and the owned-input reverse corner \
have drifted apart"
);
}
}
#[test]
fn caixa_dialeto_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!(
<CaixaDialeto as TryFrom<Vec<u8>>>::try_from(owned),
Err(()),
"TryFrom<Vec<u8>> impl on CaixaDialeto 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!(
<CaixaDialeto as TryFrom<Vec<u8>>>::try_from(input.to_vec()),
<CaixaDialeto as TryFrom<&[u8]>>::try_from(input),
"TryFrom<Vec<u8>> and TryFrom<&[u8]> reverse-projection \
axes on CaixaDialeto 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" ",
b"pacote",
b"PACOTE",
b"molde",
b"MoldePositional",
b"desconhecido",
b"Unknown",
b"defcaixa",
b"defmolde",
b"?",
b"caixa-core / feira",
b"pleme-doc-gen",
b"nobody known",
b"Pacote ",
b" Pacote",
b"Pacote\n",
b"\"Pacote\"",
];
for &input in unknown_wire_rejected {
let owned: Vec<u8> = input.to_vec();
assert_eq!(
<CaixaDialeto as TryFrom<Vec<u8>>>::try_from(owned),
Err(()),
"TryFrom<Vec<u8>> impl on CaixaDialeto must reject the \
valid-UTF-8-but-unknown-wire byte-string {input:?} \
with Err(()) — silent acceptance signals an accept-\
set widening off the paired CaixaDialeto::from_wire \
resolver"
);
assert_eq!(
<CaixaDialeto as TryFrom<Vec<u8>>>::try_from(input.to_vec()),
<CaixaDialeto as TryFrom<&[u8]>>::try_from(input),
"TryFrom<Vec<u8>> and TryFrom<&[u8]> reverse-projection \
axes on CaixaDialeto 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"
);
}
}
}