use std::collections::BTreeMap;
use figment::value::{Dict, Value};
pub trait DiscoveryLayer {
fn name(&self) -> &'static str;
fn discover(&self) -> Dict;
}
pub fn deep_merge(base: &mut Dict, overlay: Dict) {
for (key, incoming) in overlay {
match (base.get_mut(&key), incoming) {
(Some(Value::Dict(_, base_inner)), Value::Dict(_, over_inner)) => {
deep_merge(base_inner, over_inner);
}
(_, incoming) => {
base.insert(key, incoming);
}
}
}
}
#[must_use]
pub fn compose(layers: &[&dyn DiscoveryLayer]) -> Dict {
compose_with_provenance(layers).dict
}
#[must_use]
pub fn layer_names(layers: &[&dyn DiscoveryLayer]) -> Vec<&'static str> {
layers.iter().map(|layer| layer.name()).collect()
}
#[must_use]
pub fn layer_names_iter<'a>(layers: &'a [&'a dyn DiscoveryLayer]) -> LayerNamesIter<'a> {
LayerNamesIter {
inner: layers.iter(),
}
}
#[derive(Clone)]
pub struct LayerNamesIter<'a> {
inner: std::slice::Iter<'a, &'a dyn DiscoveryLayer>,
}
impl std::fmt::Debug for LayerNamesIter<'_> {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("LayerNamesIter")
.field("layers_remaining", &self.inner.len())
.finish()
}
}
impl Iterator for LayerNamesIter<'_> {
type Item = &'static str;
fn next(&mut self) -> Option<Self::Item> {
self.inner.next().map(|&layer| layer.name())
}
fn size_hint(&self) -> (usize, Option<usize>) {
self.inner.size_hint()
}
fn count(self) -> usize {
self.inner.len()
}
fn last(mut self) -> Option<Self::Item> {
self.inner.next_back().map(|&layer| layer.name())
}
fn nth(&mut self, n: usize) -> Option<Self::Item> {
self.inner.nth(n).map(|&layer| layer.name())
}
}
impl DoubleEndedIterator for LayerNamesIter<'_> {
fn next_back(&mut self) -> Option<Self::Item> {
self.inner.next_back().map(|&layer| layer.name())
}
fn nth_back(&mut self, n: usize) -> Option<Self::Item> {
self.inner.nth_back(n).map(|&layer| layer.name())
}
}
impl ExactSizeIterator for LayerNamesIter<'_> {
fn len(&self) -> usize {
self.inner.len()
}
}
impl std::iter::FusedIterator for LayerNamesIter<'_> {}
#[derive(Debug, Clone, Default, PartialEq, Eq)]
pub struct LayerAttribution {
inner: BTreeMap<Vec<String>, &'static str>,
}
impl LayerAttribution {
#[must_use]
pub fn len(&self) -> usize {
self.inner.len()
}
#[must_use]
pub fn is_empty(&self) -> bool {
self.inner.is_empty()
}
#[must_use]
pub fn layer_of(&self, path: &[&str]) -> Option<&'static str> {
self.layer_of_owned(&path.iter().map(|&s| s.to_owned()).collect::<Vec<String>>())
}
#[must_use]
pub fn layer_of_owned(&self, path: &[String]) -> Option<&'static str> {
self.inner.get(path).copied()
}
#[must_use]
pub fn iter(&self) -> LayerAttributionIter<'_> {
LayerAttributionIter {
inner: self.inner.iter(),
}
}
#[must_use]
pub fn writes_by_layer(&self) -> BTreeMap<&'static str, Vec<&[String]>> {
let mut out: BTreeMap<&'static str, Vec<&[String]>> = BTreeMap::new();
for (path, layer) in &self.inner {
out.entry(*layer).or_default().push(path.as_slice());
}
out
}
#[must_use]
pub fn writes_by_layer_iter(&self) -> LayerAttributionWritesByLayerIter<'_> {
LayerAttributionWritesByLayerIter {
inner: self.writes_by_layer().into_iter(),
}
}
#[must_use]
pub fn leaf_counts_by_layer(&self) -> BTreeMap<&'static str, usize> {
let mut out: BTreeMap<&'static str, usize> = BTreeMap::new();
for layer in self.inner.values() {
*out.entry(*layer).or_insert(0) += 1;
}
out
}
#[must_use]
pub fn leaf_counts_by_layer_iter(&self) -> LayerAttributionLeafCountsByLayerIter {
LayerAttributionLeafCountsByLayerIter {
inner: self.leaf_counts_by_layer().into_iter(),
}
}
#[must_use]
pub fn surviving_layer_names(&self) -> Vec<&'static str> {
self.surviving_layer_names_iter().collect()
}
#[must_use]
pub fn surviving_layer_names_iter(&self) -> LayerAttributionSurvivingLayerNamesIter {
use std::collections::BTreeSet;
let mut set: BTreeSet<&'static str> = BTreeSet::new();
for &layer in self.inner.values() {
set.insert(layer);
}
LayerAttributionSurvivingLayerNamesIter {
inner: set.into_iter(),
}
}
#[must_use]
pub fn subtree_iter<'a>(&'a self, prefix: &'a [String]) -> LayerAttributionSubtreeIter<'a> {
use std::ops::Bound;
LayerAttributionSubtreeIter {
inner: self
.inner
.range::<[String], _>((Bound::Included(prefix), Bound::Unbounded)),
prefix,
exhausted: false,
}
}
#[must_use]
pub fn subtree(&self, prefix: &[String]) -> LayerAttribution {
self.subtree_iter(prefix)
.map(|(p, l)| (p.to_vec(), l))
.collect()
}
#[must_use]
pub fn subtree_surviving_layer_names(&self, prefix: &[String]) -> Vec<&'static str> {
self.subtree_surviving_layer_names_iter(prefix).collect()
}
#[must_use]
pub fn subtree_surviving_layer_names_iter(
&self,
prefix: &[String],
) -> LayerAttributionSubtreeSurvivingLayerNamesIter {
use std::collections::BTreeSet;
let mut set: BTreeSet<&'static str> = BTreeSet::new();
for (_, layer) in self.subtree_iter(prefix) {
set.insert(layer);
}
LayerAttributionSubtreeSurvivingLayerNamesIter {
inner: set.into_iter(),
}
}
#[must_use]
pub fn subtree_leaf_counts_by_layer(&self, prefix: &[String]) -> BTreeMap<&'static str, usize> {
let mut out: BTreeMap<&'static str, usize> = BTreeMap::new();
for (_, layer) in self.subtree_iter(prefix) {
*out.entry(layer).or_insert(0) += 1;
}
out
}
#[must_use]
pub fn subtree_leaf_counts_by_layer_iter(
&self,
prefix: &[String],
) -> LayerAttributionSubtreeLeafCountsByLayerIter {
LayerAttributionSubtreeLeafCountsByLayerIter {
inner: self.subtree_leaf_counts_by_layer(prefix).into_iter(),
}
}
#[must_use]
pub fn subtree_writes_by_layer<'a>(
&'a self,
prefix: &'a [String],
) -> BTreeMap<&'static str, Vec<&'a [String]>> {
let mut out: BTreeMap<&'static str, Vec<&'a [String]>> = BTreeMap::new();
for (path, layer) in self.subtree_iter(prefix) {
out.entry(layer).or_default().push(path);
}
out
}
#[must_use]
pub fn subtree_writes_by_layer_iter<'a>(
&'a self,
prefix: &'a [String],
) -> LayerAttributionSubtreeWritesByLayerIter<'a> {
LayerAttributionSubtreeWritesByLayerIter {
inner: self.subtree_writes_by_layer(prefix).into_iter(),
}
}
#[must_use]
pub fn writes_of_layer<'a>(&'a self, layer: &str) -> Vec<&'a [String]> {
self.inner
.iter()
.filter_map(|(p, l)| (*l == layer).then_some(p.as_slice()))
.collect()
}
#[must_use]
pub fn writes_of_layer_iter<'a>(
&'a self,
layer: &'a str,
) -> LayerAttributionWritesOfLayerIter<'a> {
LayerAttributionWritesOfLayerIter {
inner: self.inner.iter(),
layer,
}
}
#[must_use]
pub fn leaf_count_of_layer(&self, layer: &str) -> usize {
self.inner.values().filter(|l| **l == layer).count()
}
#[must_use]
pub fn subtree_writes_of_layer<'a>(
&'a self,
prefix: &'a [String],
layer: &str,
) -> Vec<&'a [String]> {
self.subtree_iter(prefix)
.filter_map(|(p, l)| (l == layer).then_some(p))
.collect()
}
#[must_use]
pub fn subtree_writes_of_layer_iter<'a>(
&'a self,
prefix: &'a [String],
layer: &'a str,
) -> LayerAttributionSubtreeWritesOfLayerIter<'a> {
LayerAttributionSubtreeWritesOfLayerIter {
inner: self.subtree_iter(prefix),
layer,
}
}
#[must_use]
pub fn subtree_leaf_count_of_layer(&self, prefix: &[String], layer: &str) -> usize {
self.subtree_iter(prefix)
.filter(|(_, l)| *l == layer)
.count()
}
#[must_use]
pub fn dominant_layer(&self) -> Option<&'static str> {
self.leaf_counts_by_layer()
.into_iter()
.max_by(|(a_name, a_count), (b_name, b_count)| {
a_count.cmp(b_count).then_with(|| b_name.cmp(a_name))
})
.map(|(name, _)| name)
}
#[must_use]
pub fn subtree_dominant_layer(&self, prefix: &[String]) -> Option<&'static str> {
self.subtree_leaf_counts_by_layer(prefix)
.into_iter()
.max_by(|(a_name, a_count), (b_name, b_count)| {
a_count.cmp(b_count).then_with(|| b_name.cmp(a_name))
})
.map(|(name, _)| name)
}
#[must_use]
pub fn layer_ranking(&self) -> Vec<(&'static str, usize)> {
self.layer_ranking_iter().collect()
}
#[must_use]
pub fn layer_ranking_iter(&self) -> LayerAttributionLayerRankingIter {
let mut ranking: Vec<(&'static str, usize)> =
self.leaf_counts_by_layer().into_iter().collect();
ranking.sort_by(|(a_name, a_count), (b_name, b_count)| {
b_count.cmp(a_count).then_with(|| a_name.cmp(b_name))
});
LayerAttributionLayerRankingIter {
inner: ranking.into_iter(),
}
}
#[must_use]
pub fn layer_ranking_names_iter(&self) -> LayerAttributionLayerRankingNamesIter {
let names: Vec<&'static str> = self.layer_ranking_iter().map(|(n, _)| n).collect();
LayerAttributionLayerRankingNamesIter {
inner: names.into_iter(),
}
}
#[must_use]
pub fn subtree_layer_ranking(&self, prefix: &[String]) -> Vec<(&'static str, usize)> {
self.subtree_layer_ranking_iter(prefix).collect()
}
#[must_use]
pub fn subtree_layer_ranking_iter(
&self,
prefix: &[String],
) -> LayerAttributionSubtreeLayerRankingIter {
let mut ranking: Vec<(&'static str, usize)> = self
.subtree_leaf_counts_by_layer(prefix)
.into_iter()
.collect();
ranking.sort_by(|(a_name, a_count), (b_name, b_count)| {
b_count.cmp(a_count).then_with(|| a_name.cmp(b_name))
});
LayerAttributionSubtreeLayerRankingIter {
inner: ranking.into_iter(),
}
}
#[must_use]
pub fn subtree_layer_ranking_names_iter(
&self,
prefix: &[String],
) -> LayerAttributionSubtreeLayerRankingNamesIter {
let names: Vec<&'static str> = self
.subtree_layer_ranking_iter(prefix)
.map(|(n, _)| n)
.collect();
LayerAttributionSubtreeLayerRankingNamesIter {
inner: names.into_iter(),
}
}
#[must_use]
pub fn weakest_layer(&self) -> Option<&'static str> {
self.leaf_counts_by_layer()
.into_iter()
.min_by(|(a_name, a_count), (b_name, b_count)| {
a_count.cmp(b_count).then_with(|| b_name.cmp(a_name))
})
.map(|(name, _)| name)
}
#[must_use]
pub fn subtree_weakest_layer(&self, prefix: &[String]) -> Option<&'static str> {
self.subtree_leaf_counts_by_layer(prefix)
.into_iter()
.min_by(|(a_name, a_count), (b_name, b_count)| {
a_count.cmp(b_count).then_with(|| b_name.cmp(a_name))
})
.map(|(name, _)| name)
}
#[must_use]
pub fn dominant_entry(&self) -> Option<(&'static str, usize)> {
self.leaf_counts_by_layer()
.into_iter()
.max_by(|(a_name, a_count), (b_name, b_count)| {
a_count.cmp(b_count).then_with(|| b_name.cmp(a_name))
})
}
#[must_use]
pub fn subtree_dominant_entry(&self, prefix: &[String]) -> Option<(&'static str, usize)> {
self.subtree_leaf_counts_by_layer(prefix)
.into_iter()
.max_by(|(a_name, a_count), (b_name, b_count)| {
a_count.cmp(b_count).then_with(|| b_name.cmp(a_name))
})
}
#[must_use]
pub fn weakest_entry(&self) -> Option<(&'static str, usize)> {
self.leaf_counts_by_layer()
.into_iter()
.min_by(|(a_name, a_count), (b_name, b_count)| {
a_count.cmp(b_count).then_with(|| b_name.cmp(a_name))
})
}
#[must_use]
pub fn subtree_weakest_entry(&self, prefix: &[String]) -> Option<(&'static str, usize)> {
self.subtree_leaf_counts_by_layer(prefix)
.into_iter()
.min_by(|(a_name, a_count), (b_name, b_count)| {
a_count.cmp(b_count).then_with(|| b_name.cmp(a_name))
})
}
}
#[derive(Debug, Clone)]
pub struct LayerAttributionIter<'a> {
inner: std::collections::btree_map::Iter<'a, Vec<String>, &'static str>,
}
impl<'a> Iterator for LayerAttributionIter<'a> {
type Item = (&'a [String], &'static str);
fn next(&mut self) -> Option<Self::Item> {
self.inner.next().map(|(p, l)| (p.as_slice(), *l))
}
fn size_hint(&self) -> (usize, Option<usize>) {
self.inner.size_hint()
}
fn count(self) -> usize {
self.inner.count()
}
fn last(self) -> Option<Self::Item> {
self.inner.last().map(|(p, l)| (p.as_slice(), *l))
}
}
impl DoubleEndedIterator for LayerAttributionIter<'_> {
fn next_back(&mut self) -> Option<Self::Item> {
self.inner.next_back().map(|(p, l)| (p.as_slice(), *l))
}
}
impl ExactSizeIterator for LayerAttributionIter<'_> {
fn len(&self) -> usize {
self.inner.len()
}
}
impl std::iter::FusedIterator for LayerAttributionIter<'_> {}
impl<'a> IntoIterator for &'a LayerAttribution {
type Item = (&'a [String], &'static str);
type IntoIter = LayerAttributionIter<'a>;
fn into_iter(self) -> Self::IntoIter {
self.iter()
}
}
#[derive(Debug)]
pub struct LayerAttributionIntoIter {
inner: std::collections::btree_map::IntoIter<Vec<String>, &'static str>,
}
impl Iterator for LayerAttributionIntoIter {
type Item = (Vec<String>, &'static str);
fn next(&mut self) -> Option<Self::Item> {
self.inner.next()
}
fn size_hint(&self) -> (usize, Option<usize>) {
self.inner.size_hint()
}
fn count(self) -> usize {
self.inner.count()
}
fn last(mut self) -> Option<Self::Item> {
self.inner.next_back()
}
}
impl DoubleEndedIterator for LayerAttributionIntoIter {
fn next_back(&mut self) -> Option<Self::Item> {
self.inner.next_back()
}
}
impl ExactSizeIterator for LayerAttributionIntoIter {
fn len(&self) -> usize {
self.inner.len()
}
}
impl std::iter::FusedIterator for LayerAttributionIntoIter {}
impl IntoIterator for LayerAttribution {
type Item = (Vec<String>, &'static str);
type IntoIter = LayerAttributionIntoIter;
fn into_iter(self) -> Self::IntoIter {
LayerAttributionIntoIter {
inner: self.inner.into_iter(),
}
}
}
impl FromIterator<(Vec<String>, &'static str)> for LayerAttribution {
fn from_iter<I: IntoIterator<Item = (Vec<String>, &'static str)>>(iter: I) -> Self {
LayerAttribution {
inner: iter.into_iter().collect(),
}
}
}
impl Extend<(Vec<String>, &'static str)> for LayerAttribution {
fn extend<I: IntoIterator<Item = (Vec<String>, &'static str)>>(&mut self, iter: I) {
self.inner.extend(iter);
}
}
#[derive(Debug, Clone)]
pub struct LayerAttributionSubtreeIter<'a> {
inner: std::collections::btree_map::Range<'a, Vec<String>, &'static str>,
prefix: &'a [String],
exhausted: bool,
}
impl<'a> Iterator for LayerAttributionSubtreeIter<'a> {
type Item = (&'a [String], &'static str);
fn next(&mut self) -> Option<Self::Item> {
if self.exhausted {
return None;
}
match self.inner.next() {
Some((k, l)) if path_has_prefix(k, self.prefix) => Some((k.as_slice(), *l)),
_ => {
self.exhausted = true;
None
}
}
}
fn size_hint(&self) -> (usize, Option<usize>) {
if self.exhausted {
(0, Some(0))
} else {
(0, self.inner.size_hint().1)
}
}
}
impl std::iter::FusedIterator for LayerAttributionSubtreeIter<'_> {}
#[derive(Debug, Clone)]
pub struct LayerAttributionWritesOfLayerIter<'a> {
inner: std::collections::btree_map::Iter<'a, Vec<String>, &'static str>,
layer: &'a str,
}
impl<'a> Iterator for LayerAttributionWritesOfLayerIter<'a> {
type Item = &'a [String];
fn next(&mut self) -> Option<Self::Item> {
let target = self.layer;
self.inner
.find(|(_, l)| **l == target)
.map(|(p, _)| p.as_slice())
}
fn size_hint(&self) -> (usize, Option<usize>) {
(0, self.inner.size_hint().1)
}
fn last(mut self) -> Option<Self::Item> {
self.next_back()
}
}
impl DoubleEndedIterator for LayerAttributionWritesOfLayerIter<'_> {
fn next_back(&mut self) -> Option<Self::Item> {
let target = self.layer;
self.inner
.rfind(|(_, l)| **l == target)
.map(|(p, _)| p.as_slice())
}
}
impl std::iter::FusedIterator for LayerAttributionWritesOfLayerIter<'_> {}
#[derive(Debug, Clone)]
pub struct LayerAttributionSubtreeWritesOfLayerIter<'a> {
inner: LayerAttributionSubtreeIter<'a>,
layer: &'a str,
}
impl<'a> Iterator for LayerAttributionSubtreeWritesOfLayerIter<'a> {
type Item = &'a [String];
fn next(&mut self) -> Option<Self::Item> {
let target = self.layer;
self.inner.find_map(|(p, l)| (l == target).then_some(p))
}
fn size_hint(&self) -> (usize, Option<usize>) {
(0, self.inner.size_hint().1)
}
}
impl std::iter::FusedIterator for LayerAttributionSubtreeWritesOfLayerIter<'_> {}
#[derive(Debug)]
pub struct LayerAttributionSurvivingLayerNamesIter {
inner: std::collections::btree_set::IntoIter<&'static str>,
}
impl Iterator for LayerAttributionSurvivingLayerNamesIter {
type Item = &'static str;
fn next(&mut self) -> Option<Self::Item> {
self.inner.next()
}
fn size_hint(&self) -> (usize, Option<usize>) {
self.inner.size_hint()
}
fn count(self) -> usize {
self.inner.count()
}
fn last(mut self) -> Option<Self::Item> {
self.inner.next_back()
}
}
impl DoubleEndedIterator for LayerAttributionSurvivingLayerNamesIter {
fn next_back(&mut self) -> Option<Self::Item> {
self.inner.next_back()
}
}
impl ExactSizeIterator for LayerAttributionSurvivingLayerNamesIter {
fn len(&self) -> usize {
self.inner.len()
}
}
impl std::iter::FusedIterator for LayerAttributionSurvivingLayerNamesIter {}
#[derive(Debug)]
pub struct LayerAttributionSubtreeSurvivingLayerNamesIter {
inner: std::collections::btree_set::IntoIter<&'static str>,
}
impl Iterator for LayerAttributionSubtreeSurvivingLayerNamesIter {
type Item = &'static str;
fn next(&mut self) -> Option<Self::Item> {
self.inner.next()
}
fn size_hint(&self) -> (usize, Option<usize>) {
self.inner.size_hint()
}
fn count(self) -> usize {
self.inner.count()
}
fn last(mut self) -> Option<Self::Item> {
self.inner.next_back()
}
}
impl DoubleEndedIterator for LayerAttributionSubtreeSurvivingLayerNamesIter {
fn next_back(&mut self) -> Option<Self::Item> {
self.inner.next_back()
}
}
impl ExactSizeIterator for LayerAttributionSubtreeSurvivingLayerNamesIter {
fn len(&self) -> usize {
self.inner.len()
}
}
impl std::iter::FusedIterator for LayerAttributionSubtreeSurvivingLayerNamesIter {}
#[derive(Debug)]
pub struct LayerAttributionLeafCountsByLayerIter {
inner: std::collections::btree_map::IntoIter<&'static str, usize>,
}
impl Iterator for LayerAttributionLeafCountsByLayerIter {
type Item = (&'static str, usize);
fn next(&mut self) -> Option<Self::Item> {
self.inner.next()
}
fn size_hint(&self) -> (usize, Option<usize>) {
self.inner.size_hint()
}
fn count(self) -> usize {
self.inner.count()
}
fn last(mut self) -> Option<Self::Item> {
self.inner.next_back()
}
}
impl DoubleEndedIterator for LayerAttributionLeafCountsByLayerIter {
fn next_back(&mut self) -> Option<Self::Item> {
self.inner.next_back()
}
}
impl ExactSizeIterator for LayerAttributionLeafCountsByLayerIter {
fn len(&self) -> usize {
self.inner.len()
}
}
impl std::iter::FusedIterator for LayerAttributionLeafCountsByLayerIter {}
#[derive(Debug)]
pub struct LayerAttributionSubtreeLeafCountsByLayerIter {
inner: std::collections::btree_map::IntoIter<&'static str, usize>,
}
impl Iterator for LayerAttributionSubtreeLeafCountsByLayerIter {
type Item = (&'static str, usize);
fn next(&mut self) -> Option<Self::Item> {
self.inner.next()
}
fn size_hint(&self) -> (usize, Option<usize>) {
self.inner.size_hint()
}
fn count(self) -> usize {
self.inner.count()
}
fn last(mut self) -> Option<Self::Item> {
self.inner.next_back()
}
}
impl DoubleEndedIterator for LayerAttributionSubtreeLeafCountsByLayerIter {
fn next_back(&mut self) -> Option<Self::Item> {
self.inner.next_back()
}
}
impl ExactSizeIterator for LayerAttributionSubtreeLeafCountsByLayerIter {
fn len(&self) -> usize {
self.inner.len()
}
}
impl std::iter::FusedIterator for LayerAttributionSubtreeLeafCountsByLayerIter {}
#[derive(Debug, Clone)]
pub struct LayerAttributionLayerRankingIter {
inner: std::vec::IntoIter<(&'static str, usize)>,
}
impl Iterator for LayerAttributionLayerRankingIter {
type Item = (&'static str, usize);
fn next(&mut self) -> Option<Self::Item> {
self.inner.next()
}
fn size_hint(&self) -> (usize, Option<usize>) {
self.inner.size_hint()
}
fn count(self) -> usize {
self.inner.count()
}
fn last(mut self) -> Option<Self::Item> {
self.inner.next_back()
}
}
impl DoubleEndedIterator for LayerAttributionLayerRankingIter {
fn next_back(&mut self) -> Option<Self::Item> {
self.inner.next_back()
}
}
impl ExactSizeIterator for LayerAttributionLayerRankingIter {
fn len(&self) -> usize {
self.inner.len()
}
}
impl std::iter::FusedIterator for LayerAttributionLayerRankingIter {}
#[derive(Debug, Clone)]
pub struct LayerAttributionSubtreeLayerRankingIter {
inner: std::vec::IntoIter<(&'static str, usize)>,
}
impl Iterator for LayerAttributionSubtreeLayerRankingIter {
type Item = (&'static str, usize);
fn next(&mut self) -> Option<Self::Item> {
self.inner.next()
}
fn size_hint(&self) -> (usize, Option<usize>) {
self.inner.size_hint()
}
fn count(self) -> usize {
self.inner.count()
}
fn last(mut self) -> Option<Self::Item> {
self.inner.next_back()
}
}
impl DoubleEndedIterator for LayerAttributionSubtreeLayerRankingIter {
fn next_back(&mut self) -> Option<Self::Item> {
self.inner.next_back()
}
}
impl ExactSizeIterator for LayerAttributionSubtreeLayerRankingIter {
fn len(&self) -> usize {
self.inner.len()
}
}
impl std::iter::FusedIterator for LayerAttributionSubtreeLayerRankingIter {}
#[derive(Debug, Clone)]
pub struct LayerAttributionLayerRankingNamesIter {
inner: std::vec::IntoIter<&'static str>,
}
impl Iterator for LayerAttributionLayerRankingNamesIter {
type Item = &'static str;
fn next(&mut self) -> Option<Self::Item> {
self.inner.next()
}
fn size_hint(&self) -> (usize, Option<usize>) {
self.inner.size_hint()
}
fn count(self) -> usize {
self.inner.count()
}
fn last(mut self) -> Option<Self::Item> {
self.inner.next_back()
}
}
impl DoubleEndedIterator for LayerAttributionLayerRankingNamesIter {
fn next_back(&mut self) -> Option<Self::Item> {
self.inner.next_back()
}
}
impl ExactSizeIterator for LayerAttributionLayerRankingNamesIter {
fn len(&self) -> usize {
self.inner.len()
}
}
impl std::iter::FusedIterator for LayerAttributionLayerRankingNamesIter {}
#[derive(Debug, Clone)]
pub struct LayerAttributionSubtreeLayerRankingNamesIter {
inner: std::vec::IntoIter<&'static str>,
}
impl Iterator for LayerAttributionSubtreeLayerRankingNamesIter {
type Item = &'static str;
fn next(&mut self) -> Option<Self::Item> {
self.inner.next()
}
fn size_hint(&self) -> (usize, Option<usize>) {
self.inner.size_hint()
}
fn count(self) -> usize {
self.inner.count()
}
fn last(mut self) -> Option<Self::Item> {
self.inner.next_back()
}
}
impl DoubleEndedIterator for LayerAttributionSubtreeLayerRankingNamesIter {
fn next_back(&mut self) -> Option<Self::Item> {
self.inner.next_back()
}
}
impl ExactSizeIterator for LayerAttributionSubtreeLayerRankingNamesIter {
fn len(&self) -> usize {
self.inner.len()
}
}
impl std::iter::FusedIterator for LayerAttributionSubtreeLayerRankingNamesIter {}
#[derive(Debug)]
pub struct LayerAttributionWritesByLayerIter<'a> {
inner: std::collections::btree_map::IntoIter<&'static str, Vec<&'a [String]>>,
}
impl<'a> Iterator for LayerAttributionWritesByLayerIter<'a> {
type Item = (&'static str, Vec<&'a [String]>);
fn next(&mut self) -> Option<Self::Item> {
self.inner.next()
}
fn size_hint(&self) -> (usize, Option<usize>) {
self.inner.size_hint()
}
fn count(self) -> usize {
self.inner.count()
}
fn last(mut self) -> Option<Self::Item> {
self.inner.next_back()
}
}
impl DoubleEndedIterator for LayerAttributionWritesByLayerIter<'_> {
fn next_back(&mut self) -> Option<Self::Item> {
self.inner.next_back()
}
}
impl ExactSizeIterator for LayerAttributionWritesByLayerIter<'_> {
fn len(&self) -> usize {
self.inner.len()
}
}
impl std::iter::FusedIterator for LayerAttributionWritesByLayerIter<'_> {}
#[derive(Debug)]
pub struct LayerAttributionSubtreeWritesByLayerIter<'a> {
inner: std::collections::btree_map::IntoIter<&'static str, Vec<&'a [String]>>,
}
impl<'a> Iterator for LayerAttributionSubtreeWritesByLayerIter<'a> {
type Item = (&'static str, Vec<&'a [String]>);
fn next(&mut self) -> Option<Self::Item> {
self.inner.next()
}
fn size_hint(&self) -> (usize, Option<usize>) {
self.inner.size_hint()
}
fn count(self) -> usize {
self.inner.count()
}
fn last(mut self) -> Option<Self::Item> {
self.inner.next_back()
}
}
impl DoubleEndedIterator for LayerAttributionSubtreeWritesByLayerIter<'_> {
fn next_back(&mut self) -> Option<Self::Item> {
self.inner.next_back()
}
}
impl ExactSizeIterator for LayerAttributionSubtreeWritesByLayerIter<'_> {
fn len(&self) -> usize {
self.inner.len()
}
}
impl std::iter::FusedIterator for LayerAttributionSubtreeWritesByLayerIter<'_> {}
#[derive(Debug, Clone, Default, PartialEq)]
pub struct DiscoveryComposition {
pub dict: Dict,
pub attribution: LayerAttribution,
}
#[must_use]
pub fn compose_with_provenance(layers: &[&dyn DiscoveryLayer]) -> DiscoveryComposition {
let mut dict = Dict::new();
let mut attribution: BTreeMap<Vec<String>, &'static str> = BTreeMap::new();
for layer in layers {
deep_merge_attributed(
&mut dict,
layer.discover(),
&[],
&layer.name(),
&mut attribution,
false,
);
}
DiscoveryComposition {
dict,
attribution: LayerAttribution { inner: attribution },
}
}
pub(crate) fn deep_merge_attributed<A: Clone>(
base: &mut Dict,
overlay: Dict,
prefix: &[String],
mark: &A,
attribution: &mut BTreeMap<Vec<String>, A>,
on_change_only: bool,
) {
for (key, incoming) in overlay {
if on_change_only && base.get(&key) == Some(&incoming) {
continue;
}
let mut path = Vec::with_capacity(prefix.len() + 1);
path.extend_from_slice(prefix);
path.push(key.clone());
match (base.get_mut(&key), incoming) {
(Some(Value::Dict(_, base_inner)), Value::Dict(_, over_inner)) => {
deep_merge_attributed(
base_inner,
over_inner,
&path,
mark,
attribution,
on_change_only,
);
}
(_, incoming) => {
attribution.retain(|p, _| !path_has_prefix(p, &path));
attribute_leaves(&incoming, &path, mark, attribution);
base.insert(key, incoming);
}
}
}
}
fn path_has_prefix(path: &[String], prefix: &[String]) -> bool {
path.len() >= prefix.len() && path[..prefix.len()] == *prefix
}
pub(crate) fn attribute_leaves<A: Clone>(
v: &Value,
path: &[String],
mark: &A,
attribution: &mut BTreeMap<Vec<String>, A>,
) {
match v {
Value::Dict(_, inner) => {
for (k, sub) in inner {
let mut sub_path = path.to_vec();
sub_path.push(k.clone());
attribute_leaves(sub, &sub_path, mark, attribution);
}
}
_ => {
attribution.insert(path.to_vec(), mark.clone());
}
}
}
#[must_use]
pub fn contributor_names(layers: &[&dyn DiscoveryLayer]) -> Vec<&'static str> {
layers
.iter()
.filter(|layer| !layer.discover().is_empty())
.map(|layer| layer.name())
.collect()
}
#[must_use]
pub fn contributor_names_iter<'a>(
layers: &'a [&'a dyn DiscoveryLayer],
) -> ContributorNamesIter<'a> {
ContributorNamesIter {
inner: layers.iter(),
}
}
#[derive(Clone)]
pub struct ContributorNamesIter<'a> {
inner: std::slice::Iter<'a, &'a dyn DiscoveryLayer>,
}
impl std::fmt::Debug for ContributorNamesIter<'_> {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("ContributorNamesIter")
.field("layers_remaining", &self.inner.len())
.finish()
}
}
impl Iterator for ContributorNamesIter<'_> {
type Item = &'static str;
fn next(&mut self) -> Option<Self::Item> {
for &layer in self.inner.by_ref() {
if !layer.discover().is_empty() {
return Some(layer.name());
}
}
None
}
fn size_hint(&self) -> (usize, Option<usize>) {
(0, Some(self.inner.len()))
}
}
impl DoubleEndedIterator for ContributorNamesIter<'_> {
fn next_back(&mut self) -> Option<Self::Item> {
while let Some(&layer) = self.inner.next_back() {
if !layer.discover().is_empty() {
return Some(layer.name());
}
}
None
}
}
impl std::iter::FusedIterator for ContributorNamesIter<'_> {}
#[must_use]
pub fn silent_layer_names(layers: &[&dyn DiscoveryLayer]) -> Vec<&'static str> {
layers
.iter()
.filter(|layer| layer.discover().is_empty())
.map(|layer| layer.name())
.collect()
}
#[must_use]
pub fn silent_layer_names_iter<'a>(
layers: &'a [&'a dyn DiscoveryLayer],
) -> SilentLayerNamesIter<'a> {
SilentLayerNamesIter {
inner: layers.iter(),
}
}
#[derive(Clone)]
pub struct SilentLayerNamesIter<'a> {
inner: std::slice::Iter<'a, &'a dyn DiscoveryLayer>,
}
impl std::fmt::Debug for SilentLayerNamesIter<'_> {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("SilentLayerNamesIter")
.field("layers_remaining", &self.inner.len())
.finish()
}
}
impl Iterator for SilentLayerNamesIter<'_> {
type Item = &'static str;
fn next(&mut self) -> Option<Self::Item> {
for &layer in self.inner.by_ref() {
if layer.discover().is_empty() {
return Some(layer.name());
}
}
None
}
fn size_hint(&self) -> (usize, Option<usize>) {
(0, Some(self.inner.len()))
}
}
impl DoubleEndedIterator for SilentLayerNamesIter<'_> {
fn next_back(&mut self) -> Option<Self::Item> {
while let Some(&layer) = self.inner.next_back() {
if layer.discover().is_empty() {
return Some(layer.name());
}
}
None
}
}
impl std::iter::FusedIterator for SilentLayerNamesIter<'_> {}
#[must_use]
pub fn nonempty_layer_dicts(layers: &[&dyn DiscoveryLayer]) -> Vec<(&'static str, Dict)> {
layers
.iter()
.filter_map(|layer| {
let dict = layer.discover();
if dict.is_empty() {
None
} else {
Some((layer.name(), dict))
}
})
.collect()
}
#[must_use]
pub fn nonempty_layer_dicts_iter<'a>(
layers: &'a [&'a dyn DiscoveryLayer],
) -> NonemptyLayerDictsIter<'a> {
NonemptyLayerDictsIter {
inner: layers.iter(),
}
}
#[derive(Clone)]
pub struct NonemptyLayerDictsIter<'a> {
inner: std::slice::Iter<'a, &'a dyn DiscoveryLayer>,
}
impl std::fmt::Debug for NonemptyLayerDictsIter<'_> {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("NonemptyLayerDictsIter")
.field("layers_remaining", &self.inner.len())
.finish()
}
}
impl Iterator for NonemptyLayerDictsIter<'_> {
type Item = (&'static str, Dict);
fn next(&mut self) -> Option<Self::Item> {
for &layer in self.inner.by_ref() {
let dict = layer.discover();
if !dict.is_empty() {
return Some((layer.name(), dict));
}
}
None
}
fn size_hint(&self) -> (usize, Option<usize>) {
(0, Some(self.inner.len()))
}
}
impl DoubleEndedIterator for NonemptyLayerDictsIter<'_> {
fn next_back(&mut self) -> Option<Self::Item> {
while let Some(&layer) = self.inner.next_back() {
let dict = layer.discover();
if !dict.is_empty() {
return Some((layer.name(), dict));
}
}
None
}
}
impl std::iter::FusedIterator for NonemptyLayerDictsIter<'_> {}
#[must_use]
pub fn contributor_count(layers: &[&dyn DiscoveryLayer]) -> usize {
layers
.iter()
.filter(|layer| !layer.discover().is_empty())
.count()
}
#[must_use]
pub fn silent_layer_count(layers: &[&dyn DiscoveryLayer]) -> usize {
layers
.iter()
.filter(|layer| layer.discover().is_empty())
.count()
}
#[must_use]
pub fn has_contributor(layers: &[&dyn DiscoveryLayer]) -> bool {
layers.iter().any(|layer| !layer.discover().is_empty())
}
#[must_use]
pub fn has_silent_layer(layers: &[&dyn DiscoveryLayer]) -> bool {
layers.iter().any(|layer| layer.discover().is_empty())
}
#[must_use]
pub fn has_multiple_contributors(layers: &[&dyn DiscoveryLayer]) -> bool {
layers
.iter()
.filter(|layer| !layer.discover().is_empty())
.nth(1)
.is_some()
}
#[must_use]
pub fn has_multiple_silent_layers(layers: &[&dyn DiscoveryLayer]) -> bool {
layers
.iter()
.filter(|layer| layer.discover().is_empty())
.nth(1)
.is_some()
}
fn touches_path(dict: &Dict, path: &[&str]) -> bool {
let Some((head, tail)) = path.split_first() else {
return !dict.is_empty();
};
let Some(value) = dict.get(*head) else {
return false;
};
if tail.is_empty() {
return true;
}
match value {
Value::Dict(_, inner) => touches_path(inner, tail),
_ => true,
}
}
#[must_use]
pub fn contributors_at(layers: &[&dyn DiscoveryLayer], path: &[&str]) -> Vec<&'static str> {
layers
.iter()
.filter(|layer| touches_path(&layer.discover(), path))
.map(|layer| layer.name())
.collect()
}
#[must_use]
pub fn contributors_at_iter<'a>(
layers: &'a [&'a dyn DiscoveryLayer],
path: &'a [&'a str],
) -> ContributorsAtIter<'a> {
ContributorsAtIter {
inner: layers.iter(),
path,
}
}
#[derive(Clone)]
pub struct ContributorsAtIter<'a> {
inner: std::slice::Iter<'a, &'a dyn DiscoveryLayer>,
path: &'a [&'a str],
}
impl std::fmt::Debug for ContributorsAtIter<'_> {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("ContributorsAtIter")
.field("layers_remaining", &self.inner.len())
.field("path", &self.path)
.finish()
}
}
impl Iterator for ContributorsAtIter<'_> {
type Item = &'static str;
fn next(&mut self) -> Option<Self::Item> {
for &layer in self.inner.by_ref() {
if touches_path(&layer.discover(), self.path) {
return Some(layer.name());
}
}
None
}
fn size_hint(&self) -> (usize, Option<usize>) {
(0, Some(self.inner.len()))
}
}
impl DoubleEndedIterator for ContributorsAtIter<'_> {
fn next_back(&mut self) -> Option<Self::Item> {
while let Some(&layer) = self.inner.next_back() {
if touches_path(&layer.discover(), self.path) {
return Some(layer.name());
}
}
None
}
}
impl std::iter::FusedIterator for ContributorsAtIter<'_> {}
#[must_use]
pub fn silenced_at(layers: &[&dyn DiscoveryLayer], path: &[&str]) -> Vec<&'static str> {
let mut names: Vec<&'static str> = layers
.iter()
.filter(|layer| touches_path(&layer.discover(), path))
.map(|layer| layer.name())
.collect();
names.pop();
names
}
#[must_use]
pub fn silenced_at_iter<'a>(
layers: &'a [&'a dyn DiscoveryLayer],
path: &'a [&'a str],
) -> SilencedAtIter<'a> {
SilencedAtIter {
layers: layers.iter(),
path,
buffered: None,
primed: false,
}
}
#[derive(Clone)]
pub struct SilencedAtIter<'a> {
layers: std::slice::Iter<'a, &'a dyn DiscoveryLayer>,
path: &'a [&'a str],
buffered: Option<&'static str>,
primed: bool,
}
impl std::fmt::Debug for SilencedAtIter<'_> {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("SilencedAtIter")
.field("layers_remaining", &self.layers.len())
.field("path", &self.path)
.field("buffered", &self.buffered)
.field("primed", &self.primed)
.finish()
}
}
impl<'a> SilencedAtIter<'a> {
fn next_touching_name(&mut self) -> Option<&'static str> {
for &layer in self.layers.by_ref() {
if touches_path(&layer.discover(), self.path) {
return Some(layer.name());
}
}
None
}
}
impl<'a> Iterator for SilencedAtIter<'a> {
type Item = &'static str;
fn next(&mut self) -> Option<Self::Item> {
if !self.primed {
self.buffered = self.next_touching_name();
self.primed = true;
}
let lookahead = self.next_touching_name()?;
self.buffered.replace(lookahead)
}
}
impl<'a> std::iter::FusedIterator for SilencedAtIter<'a> {}
#[must_use]
pub fn decider_at(layers: &[&dyn DiscoveryLayer], path: &[&str]) -> Option<&'static str> {
layers
.iter()
.rev()
.find(|layer| touches_path(&layer.discover(), path))
.map(|layer| layer.name())
}
#[must_use]
pub fn coarsest_at(layers: &[&dyn DiscoveryLayer], path: &[&str]) -> Option<&'static str> {
layers
.iter()
.find(|layer| touches_path(&layer.discover(), path))
.map(|layer| layer.name())
}
#[must_use]
pub fn runner_up_at(layers: &[&dyn DiscoveryLayer], path: &[&str]) -> Option<&'static str> {
layers
.iter()
.rev()
.filter(|layer| touches_path(&layer.discover(), path))
.nth(1)
.map(|layer| layer.name())
}
#[must_use]
pub fn coarsest_silenced_at(layers: &[&dyn DiscoveryLayer], path: &[&str]) -> Option<&'static str> {
let mut iter = layers
.iter()
.filter(|layer| touches_path(&layer.discover(), path));
let first = iter.next()?;
iter.next()?;
Some(first.name())
}
#[must_use]
pub fn is_contested_at(layers: &[&dyn DiscoveryLayer], path: &[&str]) -> bool {
layers
.iter()
.filter(|layer| touches_path(&layer.discover(), path))
.nth(1)
.is_some()
}
#[must_use]
pub fn contributor_count_at(layers: &[&dyn DiscoveryLayer], path: &[&str]) -> usize {
layers
.iter()
.filter(|layer| touches_path(&layer.discover(), path))
.count()
}
#[must_use]
pub fn silenced_count_at(layers: &[&dyn DiscoveryLayer], path: &[&str]) -> usize {
layers
.iter()
.filter(|layer| touches_path(&layer.discover(), path))
.count()
.saturating_sub(1)
}
#[must_use]
pub fn is_touched_at(layers: &[&dyn DiscoveryLayer], path: &[&str]) -> bool {
layers
.iter()
.any(|layer| touches_path(&layer.discover(), path))
}
#[must_use]
pub fn is_multiply_silenced_at(layers: &[&dyn DiscoveryLayer], path: &[&str]) -> bool {
layers
.iter()
.filter(|layer| touches_path(&layer.discover(), path))
.nth(2)
.is_some()
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct PathContest {
pub decider: &'static str,
pub overridden: Vec<&'static str>,
}
impl PathContest {
#[must_use]
pub fn is_contested(&self) -> bool {
!self.overridden.is_empty()
}
#[must_use]
pub fn is_multiply_silenced(&self) -> bool {
self.overridden.len() >= 2
}
#[must_use]
pub fn contributor_count(&self) -> usize {
self.overridden.len() + 1
}
#[must_use]
pub fn silenced_count(&self) -> usize {
self.overridden.len()
}
#[must_use]
pub fn contributors(&self) -> Vec<&'static str> {
let mut out = Vec::with_capacity(self.overridden.len() + 1);
out.extend_from_slice(&self.overridden);
out.push(self.decider);
out
}
#[must_use]
pub fn contributors_iter(&self) -> PathContestContributorsIter<'_> {
PathContestContributorsIter {
overridden: self.overridden.iter().copied(),
decider: Some(self.decider),
}
}
#[must_use]
pub fn silenced(&self) -> &[&'static str] {
&self.overridden
}
#[must_use]
pub fn silenced_iter(&self) -> PathContestSilencedIter<'_> {
PathContestSilencedIter {
inner: self.overridden.iter().copied(),
}
}
#[must_use]
pub fn coarsest(&self) -> &'static str {
self.overridden.first().copied().unwrap_or(self.decider)
}
#[must_use]
pub fn runner_up(&self) -> Option<&'static str> {
self.overridden.last().copied()
}
#[must_use]
pub fn coarsest_silenced(&self) -> Option<&'static str> {
self.overridden.first().copied()
}
}
#[derive(Debug, Clone)]
pub struct PathContestContributorsIter<'a> {
overridden: std::iter::Copied<std::slice::Iter<'a, &'static str>>,
decider: Option<&'static str>,
}
impl Iterator for PathContestContributorsIter<'_> {
type Item = &'static str;
fn next(&mut self) -> Option<Self::Item> {
self.overridden.next().or_else(|| self.decider.take())
}
fn size_hint(&self) -> (usize, Option<usize>) {
let len = self.len();
(len, Some(len))
}
fn count(self) -> usize {
self.len()
}
fn last(mut self) -> Option<Self::Item> {
if self.decider.is_some() {
self.decider.take()
} else {
self.overridden.last()
}
}
}
impl DoubleEndedIterator for PathContestContributorsIter<'_> {
fn next_back(&mut self) -> Option<Self::Item> {
self.decider.take().or_else(|| self.overridden.next_back())
}
}
impl ExactSizeIterator for PathContestContributorsIter<'_> {
fn len(&self) -> usize {
self.overridden.len() + usize::from(self.decider.is_some())
}
}
impl std::iter::FusedIterator for PathContestContributorsIter<'_> {}
#[derive(Debug, Clone)]
pub struct PathContestSilencedIter<'a> {
inner: std::iter::Copied<std::slice::Iter<'a, &'static str>>,
}
impl Iterator for PathContestSilencedIter<'_> {
type Item = &'static str;
fn next(&mut self) -> Option<Self::Item> {
self.inner.next()
}
fn size_hint(&self) -> (usize, Option<usize>) {
self.inner.size_hint()
}
fn count(self) -> usize {
self.inner.count()
}
fn last(self) -> Option<Self::Item> {
self.inner.last()
}
fn nth(&mut self, n: usize) -> Option<Self::Item> {
self.inner.nth(n)
}
}
impl DoubleEndedIterator for PathContestSilencedIter<'_> {
fn next_back(&mut self) -> Option<Self::Item> {
self.inner.next_back()
}
fn nth_back(&mut self, n: usize) -> Option<Self::Item> {
self.inner.nth_back(n)
}
}
impl ExactSizeIterator for PathContestSilencedIter<'_> {
fn len(&self) -> usize {
self.inner.len()
}
}
impl std::iter::FusedIterator for PathContestSilencedIter<'_> {}
#[must_use]
pub fn contest_at(layers: &[&dyn DiscoveryLayer], path: &[&str]) -> Option<PathContest> {
let mut names: Vec<&'static str> = layers
.iter()
.filter(|layer| touches_path(&layer.discover(), path))
.map(|layer| layer.name())
.collect();
let decider = names.pop()?;
Some(PathContest {
decider,
overridden: names,
})
}
#[cfg(test)]
mod tests {
use super::*;
use figment::value::Value;
struct Fixed(&'static str, Dict);
impl DiscoveryLayer for Fixed {
fn name(&self) -> &'static str {
self.0
}
fn discover(&self) -> Dict {
self.1.clone()
}
}
fn dict(pairs: &[(&str, Value)]) -> Dict {
let mut d = Dict::new();
for (k, v) in pairs {
d.insert((*k).to_owned(), v.clone());
}
d
}
#[test]
fn deep_merge_overlay_wins_scalars_and_keeps_siblings() {
let mut base = dict(&[("a", Value::from(1i64)), ("b", Value::from(2i64))]);
deep_merge(
&mut base,
dict(&[("b", Value::from(20i64)), ("c", Value::from(3i64))]),
);
assert_eq!(
base.get("a"),
Some(&Value::from(1i64)),
"untouched sibling kept"
);
assert_eq!(base.get("b"), Some(&Value::from(20i64)), "overlay wins");
assert_eq!(base.get("c"), Some(&Value::from(3i64)), "new key added");
}
#[test]
fn deep_merge_recurses_into_nested_dicts() {
let mut base = dict(&[(
"breathe",
Value::from(dict(&[
("setpoint", Value::from(0.80)),
("mode", Value::from("live")),
])),
)]);
deep_merge(
&mut base,
dict(&[(
"breathe",
Value::from(dict(&[("mode", Value::from("shadow"))])),
)]),
);
let Some(Value::Dict(_, inner)) = base.get("breathe") else {
panic!("nested dict preserved");
};
assert_eq!(
inner.get("setpoint"),
Some(&Value::from(0.80)),
"sibling survives"
);
assert_eq!(
inner.get("mode"),
Some(&Value::from("shadow")),
"leaf overridden"
);
}
#[test]
fn deep_merge_dict_replaces_scalar_and_vice_versa() {
let mut base = dict(&[("x", Value::from(1i64))]);
deep_merge(
&mut base,
dict(&[("x", Value::from(dict(&[("y", Value::from(2i64))])))]),
);
assert!(
matches!(base.get("x"), Some(Value::Dict(..))),
"dict replaced scalar"
);
let mut base = dict(&[("x", Value::from(dict(&[("y", Value::from(2i64))])))]);
deep_merge(&mut base, dict(&[("x", Value::from(9i64))]));
assert_eq!(
base.get("x"),
Some(&Value::from(9i64)),
"scalar replaced dict"
);
}
#[test]
fn deep_merge_replaces_arrays_wholesale() {
let mut base = dict(&[(
"xs",
Value::from(vec![Value::from(1i64), Value::from(2i64)]),
)]);
deep_merge(
&mut base,
dict(&[("xs", Value::from(vec![Value::from(9i64)]))]),
);
let Some(Value::Array(_, arr)) = base.get("xs") else {
panic!("array value");
};
assert_eq!(arr.len(), 1, "array replaced wholesale, not concatenated");
assert_eq!(arr[0], Value::from(9i64));
}
#[test]
fn deep_merge_recurses_three_levels_preserving_each_sibling() {
let mut base = dict(&[(
"a",
Value::from(dict(&[(
"b",
Value::from(dict(&[
("keep", Value::from(1i64)),
("change", Value::from(2i64)),
])),
)])),
)]);
deep_merge(
&mut base,
dict(&[(
"a",
Value::from(dict(&[(
"b",
Value::from(dict(&[("change", Value::from(20i64))])),
)])),
)]),
);
let Some(Value::Dict(_, a)) = base.get("a") else {
panic!("a")
};
let Some(Value::Dict(_, b)) = a.get("b") else {
panic!("b")
};
assert_eq!(
b.get("keep"),
Some(&Value::from(1i64)),
"level-3 sibling survives"
);
assert_eq!(
b.get("change"),
Some(&Value::from(20i64)),
"level-3 leaf overridden"
);
}
#[test]
fn compose_specific_layer_overrides_coarse() {
let coarse = Fixed(
"platform",
dict(&[
("setpoint", Value::from(0.80)),
("floor", Value::from("256Mi")),
]),
);
let specific = Fixed("tenancy", dict(&[("setpoint", Value::from(0.70))]));
let out = compose(&[&coarse, &specific]);
assert_eq!(
out.get("setpoint"),
Some(&Value::from(0.70)),
"specific (later) wins"
);
assert_eq!(
out.get("floor"),
Some(&Value::from("256Mi")),
"coarse-only key retained"
);
}
#[test]
fn compose_empty_layer_contributes_nothing() {
let real = Fixed("cloud", dict(&[("k", Value::from(1i64))]));
let empty = Fixed("undetectable", Dict::new());
assert_eq!(
compose(&[&real, &empty]),
compose(&[&real]),
"empty axis invisible"
);
}
#[test]
fn compose_no_layers_is_empty() {
assert!(compose(&[]).is_empty());
}
#[test]
fn layer_names_in_application_order() {
let a = Fixed("platform", Dict::new());
let b = Fixed("tenancy", Dict::new());
assert_eq!(layer_names(&[&a, &b]), vec!["platform", "tenancy"]);
}
#[test]
fn layer_names_iter_collect_matches_layer_names() {
let a = Fixed("platform", dict(&[("a", Value::from(1i64))]));
let quiet = Fixed("cloud", Dict::new());
let c = Fixed("tenancy", dict(&[("c", Value::from(3i64))]));
let layers: [&dyn DiscoveryLayer; 3] = [&a, &quiet, &c];
assert_eq!(
layer_names_iter(&layers).collect::<Vec<_>>(),
layer_names(&layers),
"iter → Vec matches layer_names verbatim",
);
}
#[test]
fn layer_names_iter_empty_stack_is_empty_stream() {
let layers: [&dyn DiscoveryLayer; 0] = [];
assert!(
layer_names_iter(&layers).next().is_none(),
"no layers → no declared names",
);
}
#[test]
fn layer_names_iter_preserves_application_order() {
let a = Fixed("platform", dict(&[("a", Value::from(1i64))]));
let b = Fixed("cloud", Dict::new());
let c = Fixed("tenancy", dict(&[("c", Value::from(3i64))]));
let layers: [&dyn DiscoveryLayer; 3] = [&a, &b, &c];
assert_eq!(
layer_names_iter(&layers).collect::<Vec<_>>(),
vec!["platform", "cloud", "tenancy"],
"iter yields names coarse→specific in application order",
);
}
#[test]
fn layer_names_iter_rev_reverses_forward_walk() {
let a = Fixed("platform", dict(&[("a", Value::from(1i64))]));
let b = Fixed("cloud", Dict::new());
let c = Fixed("tenancy", dict(&[("c", Value::from(3i64))]));
let layers: [&dyn DiscoveryLayer; 3] = [&a, &b, &c];
let forward = layer_names_iter(&layers).collect::<Vec<_>>();
let reverse = layer_names_iter(&layers).rev().collect::<Vec<_>>();
assert_eq!(
reverse,
forward.iter().rev().copied().collect::<Vec<_>>(),
".rev() over the iter recovers the reverse of the forward walk",
);
}
#[test]
fn layer_names_iter_clone_yields_independent_walks() {
let a = Fixed("platform", dict(&[("a", Value::from(1i64))]));
let b = Fixed("cloud", Dict::new());
let c = Fixed("tenancy", dict(&[("c", Value::from(3i64))]));
let layers: [&dyn DiscoveryLayer; 3] = [&a, &b, &c];
let one = layer_names_iter(&layers);
let two = one.clone();
assert_eq!(
one.collect::<Vec<_>>(),
two.collect::<Vec<_>>(),
"two independent walks agree",
);
}
#[test]
fn layer_names_iter_is_fused_past_exhaustion() {
let a = Fixed("platform", Dict::new());
let layers: [&dyn DiscoveryLayer; 1] = [&a];
let mut it = layer_names_iter(&layers);
assert_eq!(it.next(), Some("platform"));
for _ in 0..4 {
assert!(it.next().is_none(), "post-exhaustion pulls stay None");
}
}
#[test]
fn layer_names_iter_exact_size_matches_layer_names_len() {
let a = Fixed("platform", dict(&[("a", Value::from(1i64))]));
let b = Fixed("cloud", Dict::new());
let c = Fixed("tenancy", dict(&[("c", Value::from(3i64))]));
let layers: [&dyn DiscoveryLayer; 3] = [&a, &b, &c];
let it = layer_names_iter(&layers);
assert_eq!(it.len(), 3, ".len() equals the layer count");
assert_eq!(
it.size_hint(),
(3, Some(3)),
".size_hint() is exact on both bounds",
);
}
#[test]
fn layer_names_iter_exact_size_shrinks_as_walk_advances() {
let a = Fixed("platform", Dict::new());
let b = Fixed("cloud", Dict::new());
let c = Fixed("tenancy", Dict::new());
let layers: [&dyn DiscoveryLayer; 3] = [&a, &b, &c];
let mut it = layer_names_iter(&layers);
assert_eq!(it.len(), 3);
let _ = it.next();
assert_eq!(it.len(), 2, "one pull ⇒ len drops by one");
let _ = it.next();
assert_eq!(it.len(), 1);
let _ = it.next();
assert_eq!(it.len(), 0, "fully drained ⇒ len is zero");
}
#[test]
fn layer_names_iter_head_short_circuits_without_full_sweep() {
let a = Fixed("platform", dict(&[("a", Value::from(1i64))]));
let b = Fixed("cloud", dict(&[("b", Value::from(2i64))]));
let c = Fixed("tenancy", dict(&[("c", Value::from(3i64))]));
let layers: [&dyn DiscoveryLayer; 3] = [&a, &b, &c];
assert_eq!(
layer_names_iter(&layers).next(),
Some("platform"),
".next() yields the first declared name without walking the rest",
);
}
#[test]
fn layer_names_iter_ignores_discover_shape() {
let a1 = Fixed("platform", dict(&[("a", Value::from(1i64))]));
let b1 = Fixed("cloud", dict(&[("b", Value::from(2i64))]));
let a2 = Fixed("platform", Dict::new());
let b2 = Fixed("cloud", Dict::new());
let contributing: [&dyn DiscoveryLayer; 2] = [&a1, &b1];
let silent: [&dyn DiscoveryLayer; 2] = [&a2, &b2];
let mixed: [&dyn DiscoveryLayer; 2] = [&a1, &b2];
assert_eq!(
layer_names_iter(&contributing).collect::<Vec<_>>(),
layer_names_iter(&silent).collect::<Vec<_>>(),
"same names on contributing and silent stacks",
);
assert_eq!(
layer_names_iter(&mixed).collect::<Vec<_>>(),
layer_names_iter(&contributing).collect::<Vec<_>>(),
"mixed stack yields the same name walk",
);
}
#[test]
fn layer_names_iter_is_partition_source_for_contributor_and_silent_iters() {
let coarse = Fixed("platform", dict(&[("a", Value::from(1i64))]));
let empty1 = Fixed("cloud", Dict::new());
let mid = Fixed("region", dict(&[("b", Value::from(2i64))]));
let empty2 = Fixed("tenancy", Dict::new());
let layers: [&dyn DiscoveryLayer; 4] = [&coarse, &empty1, &mid, &empty2];
let source: std::collections::BTreeSet<_> = layer_names_iter(&layers).collect();
let chained: std::collections::BTreeSet<_> = contributor_names_iter(&layers)
.chain(silent_layer_names_iter(&layers))
.collect();
assert_eq!(
chained, source,
"contributor_iter ⨄ silent_iter covers layer_names_iter",
);
}
#[test]
fn layer_names_iter_return_type_is_nameable_layer_names_iter() {
struct HoldsLayerNames<'a> {
iter: LayerNamesIter<'a>,
}
let a = Fixed("platform", dict(&[("a", Value::from(1i64))]));
let b = Fixed("cloud", Dict::new());
let c = Fixed("tenancy", dict(&[("c", Value::from(3i64))]));
let layers: [&dyn DiscoveryLayer; 3] = [&a, &b, &c];
let held = HoldsLayerNames {
iter: layer_names_iter(&layers),
};
let out: Vec<&'static str> = held.iter.collect();
assert_eq!(out, vec!["platform", "cloud", "tenancy"]);
}
#[test]
fn layer_names_iter_clone_preserves_static_traits() {
fn requires_full_traits<I>(_it: &I)
where
I: Iterator
+ DoubleEndedIterator
+ ExactSizeIterator
+ std::iter::FusedIterator
+ Clone,
{
}
let a = Fixed("platform", dict(&[("a", Value::from(1i64))]));
let b = Fixed("cloud", Dict::new());
let c = Fixed("tenancy", dict(&[("c", Value::from(3i64))]));
let layers: [&dyn DiscoveryLayer; 3] = [&a, &b, &c];
let it: LayerNamesIter<'_> = layer_names_iter(&layers);
requires_full_traits(&it);
assert_eq!(it.len(), 3, "ExactSizeIterator survives the sharpen");
let clone = it.clone();
let via_original: Vec<&'static str> = it.collect();
let via_clone: Vec<&'static str> = clone.collect();
assert_eq!(
via_original, via_clone,
"cloned handle walks the same declared-name stream",
);
}
#[test]
fn layer_names_iter_debug_impl_omits_layers_handle() {
let a = Fixed("platform", dict(&[("a", Value::from(1i64))]));
let b = Fixed("cloud", Dict::new());
let c = Fixed("tenancy", dict(&[("c", Value::from(3i64))]));
let layers: [&dyn DiscoveryLayer; 3] = [&a, &b, &c];
let it: LayerNamesIter<'_> = layer_names_iter(&layers);
let rendered = format!("{it:?}");
assert!(
rendered.starts_with("LayerNamesIter"),
"Debug names the concrete struct: {rendered}",
);
assert!(
rendered.contains("layers_remaining"),
"Debug reports the remaining layer count: {rendered}",
);
assert!(
rendered.contains('3'),
"Debug reports the initial cursor length: {rendered}",
);
}
#[test]
fn compose_with_provenance_attributes_each_leaf_to_its_writer() {
let a = Fixed(
"platform",
dict(&[("k1", Value::from(1i64)), ("k2", Value::from(2i64))]),
);
let b = Fixed(
"tenancy",
dict(&[("k2", Value::from(20i64)), ("k3", Value::from(3i64))]),
);
let out = compose_with_provenance(&[&a, &b]);
assert_eq!(
out.dict,
compose(&[&a, &b]),
"dict projection agrees with compose"
);
assert_eq!(out.attribution.layer_of(&["k1"]), Some("platform"));
assert_eq!(
out.attribution.layer_of(&["k2"]),
Some("tenancy"),
"later layer wins per leaf"
);
assert_eq!(out.attribution.layer_of(&["k3"]), Some("tenancy"));
assert_eq!(
out.attribution.layer_of(&["never"]),
None,
"unset paths are unattributed"
);
assert_eq!(out.attribution.len(), 3);
assert!(!out.attribution.is_empty());
}
#[test]
fn compose_with_provenance_recurses_into_nested_dicts_per_leaf() {
let a = Fixed(
"platform",
dict(&[(
"breathe",
Value::from(dict(&[
("setpoint", Value::from(0.80)),
("mode", Value::from("live")),
])),
)]),
);
let b = Fixed(
"tenancy",
dict(&[(
"breathe",
Value::from(dict(&[("mode", Value::from("shadow"))])),
)]),
);
let out = compose_with_provenance(&[&a, &b]);
assert_eq!(
out.attribution.layer_of(&["breathe", "setpoint"]),
Some("platform"),
"sibling under nested dict retains coarse writer"
);
assert_eq!(
out.attribution.layer_of(&["breathe", "mode"]),
Some("tenancy"),
"overwritten nested leaf gets the specific writer"
);
assert_eq!(out.attribution.len(), 2);
}
#[test]
fn compose_with_provenance_dict_replaces_scalar_purges_prior_attribution() {
let a = Fixed("first", dict(&[("x", Value::from(1i64))]));
let b = Fixed(
"second",
dict(&[("x", Value::from(dict(&[("y", Value::from(2i64))])))]),
);
let out = compose_with_provenance(&[&a, &b]);
assert_eq!(
out.attribution.layer_of(&["x"]),
None,
"scalar leaf attribution purged when replaced by a dict"
);
assert_eq!(out.attribution.layer_of(&["x", "y"]), Some("second"));
assert_eq!(out.attribution.len(), 1);
}
#[test]
fn compose_with_provenance_scalar_replaces_dict_purges_sub_attributions() {
let a = Fixed(
"first",
dict(&[(
"x",
Value::from(dict(&[("y", Value::from(1i64)), ("z", Value::from(2i64))])),
)]),
);
let b = Fixed("second", dict(&[("x", Value::from(99i64))]));
let out = compose_with_provenance(&[&a, &b]);
assert_eq!(
out.attribution.layer_of(&["x", "y"]),
None,
"sub-leaf attribution purged when parent replaced by scalar"
);
assert_eq!(out.attribution.layer_of(&["x", "z"]), None);
assert_eq!(
out.attribution.layer_of(&["x"]),
Some("second"),
"replacing scalar attributed at the flattened path"
);
assert_eq!(out.attribution.len(), 1);
}
#[test]
fn compose_with_provenance_arrays_replace_wholesale_and_reattribute() {
let a = Fixed(
"first",
dict(&[("xs", Value::from(vec![Value::from(1i64)]))]),
);
let b = Fixed(
"second",
dict(&[(
"xs",
Value::from(vec![Value::from(9i64), Value::from(10i64)]),
)]),
);
let out = compose_with_provenance(&[&a, &b]);
assert_eq!(out.attribution.layer_of(&["xs"]), Some("second"));
assert_eq!(out.attribution.len(), 1);
}
#[test]
fn compose_with_provenance_empty_layer_preserves_prior_attribution() {
let a = Fixed("real", dict(&[("k", Value::from(1i64))]));
let empty = Fixed("undetectable", Dict::new());
let out = compose_with_provenance(&[&a, &empty]);
assert_eq!(out.attribution.layer_of(&["k"]), Some("real"));
assert_eq!(out.attribution.len(), 1);
}
#[test]
fn compose_with_provenance_no_layers_is_empty_and_unattributed() {
let out = compose_with_provenance(&[]);
assert!(out.dict.is_empty());
assert!(out.attribution.is_empty());
assert_eq!(out.attribution.len(), 0);
}
#[test]
fn compose_with_provenance_iter_yields_lexicographic_order() {
let a = Fixed("A", dict(&[("z", Value::from(1i64))]));
let b = Fixed(
"B",
dict(&[("a", Value::from(dict(&[("y", Value::from(2i64))])))]),
);
let c = Fixed("C", dict(&[("m", Value::from(3i64))]));
let out = compose_with_provenance(&[&a, &b, &c]);
let observed: Vec<(Vec<String>, &'static str)> = out
.attribution
.iter()
.map(|(p, l)| (p.to_vec(), l))
.collect();
assert_eq!(
observed,
vec![
(vec!["a".to_owned(), "y".to_owned()], "B"),
(vec!["m".to_owned()], "C"),
(vec!["z".to_owned()], "A"),
]
);
}
#[test]
fn compose_with_provenance_dict_matches_independent_deep_merge_walk() {
let a = Fixed(
"A",
dict(&[
("outer", Value::from(dict(&[("a", Value::from(1i64))]))),
("scalar", Value::from(1i64)),
]),
);
let b = Fixed(
"B",
dict(&[
("outer", Value::from(dict(&[("b", Value::from(2i64))]))),
("scalar", Value::from(dict(&[("inner", Value::from(9i64))]))),
]),
);
let via_prov = compose_with_provenance(&[&a, &b]).dict;
let mut via_plain = Dict::new();
deep_merge(&mut via_plain, a.discover());
deep_merge(&mut via_plain, b.discover());
assert_eq!(
via_prov, via_plain,
"attributed compose dict matches independent deep_merge walk"
);
}
#[test]
fn layer_of_owned_agrees_with_layer_of_pointwise() {
let a = Fixed(
"A",
dict(&[(
"outer",
Value::from(dict(&[("a", Value::from(1i64)), ("b", Value::from(2i64))])),
)]),
);
let b = Fixed("B", dict(&[("scalar", Value::from(3i64))]));
let out = compose_with_provenance(&[&a, &b]);
for (path_slice, layer) in &out.attribution {
let borrowed: Vec<&str> = path_slice.iter().map(String::as_str).collect();
assert_eq!(
out.attribution.layer_of(&borrowed),
Some(layer),
"layer_of at {path_slice:?} must match iter()",
);
assert_eq!(
out.attribution.layer_of_owned(path_slice),
Some(layer),
"layer_of_owned at {path_slice:?} must match iter()",
);
}
let absent: [&str; 2] = ["outer", "never"];
assert_eq!(out.attribution.layer_of(&absent), None);
let absent_owned: Vec<String> = absent.iter().map(|s| (*s).to_owned()).collect();
assert_eq!(out.attribution.layer_of_owned(&absent_owned), None);
}
#[test]
fn layer_of_is_not_a_prefix_match_only_exact_leaves() {
let a = Fixed(
"A",
dict(&[("outer", Value::from(dict(&[("a", Value::from(1i64))])))]),
);
let out = compose_with_provenance(&[&a]);
assert_eq!(out.attribution.layer_of(&["outer", "a"]), Some("A"));
assert_eq!(
out.attribution.layer_of(&["outer"]),
None,
"interior nodes are not leaves and must not resolve",
);
}
#[test]
fn layer_of_owned_skips_allocation_on_owned_paths() {
let a = Fixed(
"A",
dict(&[("k1", Value::from(1i64)), ("k2", Value::from(2i64))]),
);
let b = Fixed("B", dict(&[("k3", Value::from(3i64))]));
let out = compose_with_provenance(&[&a, &b]);
let owned_paths: Vec<Vec<String>> = out
.attribution
.iter()
.map(|(path_slice, _)| path_slice.to_vec())
.collect();
for path in &owned_paths {
assert!(
out.attribution.layer_of_owned(path).is_some(),
"every iter()-sourced path must resolve on layer_of_owned",
);
}
}
fn iter_fixture() -> DiscoveryComposition {
let coarse = Fixed(
"coarse",
dict(&[
("alpha", Value::from(1i64)),
("beta", Value::from(2i64)),
(
"breathe",
Value::from(dict(&[
("mode", Value::from("live")),
("setpoint", Value::from(0.80)),
])),
),
]),
);
let mid = Fixed("mid", dict(&[("gamma", Value::from(3i64))]));
let specific = Fixed(
"specific",
dict(&[
(
"breathe",
Value::from(dict(&[("setpoint", Value::from(0.70))])),
),
("delta", Value::from(4i64)),
]),
);
compose_with_provenance(&[&coarse, &mid, &specific])
}
#[test]
fn attribution_iter_rev_reverses_forward_walk() {
let out = iter_fixture();
let forward: Vec<(Vec<String>, &'static str)> = out
.attribution
.iter()
.map(|(p, l)| (p.to_vec(), l))
.collect();
let reverse: Vec<(Vec<String>, &'static str)> = out
.attribution
.iter()
.rev()
.map(|(p, l)| (p.to_vec(), l))
.collect();
let mut expected = forward.clone();
expected.reverse();
assert_eq!(reverse, expected, "iter().rev() reverses iter() pointwise");
}
#[test]
fn attribution_iter_rev_endpoints_alias_first_and_last_key() {
let out = iter_fixture();
let forward: Vec<(Vec<String>, &'static str)> = out
.attribution
.iter()
.map(|(p, l)| (p.to_vec(), l))
.collect();
let mut back = out.attribution.iter();
let last = back.next_back().expect("non-empty");
assert_eq!(
(last.0.to_vec(), last.1),
forward.last().cloned().expect("non-empty"),
"next_back() yields the lex-last (path, layer)",
);
let front = back.next_back().expect("more than one entry");
assert_eq!(
(front.0.to_vec(), front.1),
forward[forward.len() - 2].clone(),
"successive next_back walks specific→coarse in lex order",
);
}
#[test]
fn attribution_iter_clone_yields_independent_walks() {
let out = iter_fixture();
let a = out.attribution.iter();
let b = a.clone();
let a_collected: Vec<(Vec<String>, &'static str)> =
a.map(|(p, l)| (p.to_vec(), l)).collect();
let b_collected: Vec<(Vec<String>, &'static str)> =
b.map(|(p, l)| (p.to_vec(), l)).collect();
assert_eq!(
a_collected, b_collected,
"cloned handles yield the same walk"
);
let mut left = out.attribution.iter();
let mut right = left.clone();
let l0 = left.next().expect("non-empty");
let r0 = right.next().expect("non-empty");
assert_eq!(
(l0.0.to_vec(), l0.1),
(r0.0.to_vec(), r0.1),
"both clones observe the same first entry — position is per-clone",
);
let _ = left.next();
let _ = left.next();
let r1 = right.next().expect("second entry present");
assert_eq!(
(r1.0.to_vec(), r1.1),
a_collected[1],
"right sees the second entry regardless of left's advance",
);
}
#[test]
fn attribution_iter_clone_and_rev_compose() {
let out = iter_fixture();
let base: Vec<(Vec<String>, &'static str)> = out
.attribution
.iter()
.rev()
.map(|(p, l)| (p.to_vec(), l))
.collect();
let via_clone_then_rev: Vec<(Vec<String>, &'static str)> = out
.attribution
.iter()
.clone()
.rev()
.map(|(p, l)| (p.to_vec(), l))
.collect();
let via_rev_then_clone: Vec<(Vec<String>, &'static str)> = {
let rev = out.attribution.iter().rev();
rev.clone().map(|(p, l)| (p.to_vec(), l)).collect()
};
assert_eq!(base, via_clone_then_rev);
assert_eq!(base, via_rev_then_clone);
}
#[test]
fn attribution_iter_len_matches_attribution_len_across_fixture() {
let out = iter_fixture();
assert_eq!(out.attribution.iter().len(), out.attribution.len());
}
#[test]
fn attribution_iter_size_hint_reports_exact_length() {
let out = iter_fixture();
let n = out.attribution.len();
let iter = out.attribution.iter();
assert_eq!(iter.size_hint(), (n, Some(n)));
}
#[test]
fn attribution_iter_len_decreases_by_one_per_advance() {
let out = iter_fixture();
let n = out.attribution.len();
assert!(n >= 3, "fixture is expected to be non-trivial");
let mut iter = out.attribution.iter();
for expected_remaining in (0..n).rev() {
if expected_remaining % 2 == 0 {
assert!(iter.next().is_some(), "non-empty at len {n}");
} else {
assert!(iter.next_back().is_some(), "non-empty at len {n}");
}
assert_eq!(iter.len(), expected_remaining);
}
assert!(iter.next().is_none(), "exhausted forward");
assert!(iter.next_back().is_none(), "exhausted backward");
assert_eq!(iter.len(), 0);
}
#[test]
fn attribution_iter_is_fused_past_exhaustion() {
let out = iter_fixture();
let mut iter = out.attribution.iter();
while iter.next().is_some() {}
for _ in 0..4 {
assert!(iter.next().is_none(), "fused past forward exhaustion");
assert!(
iter.next_back().is_none(),
"fused past forward exhaustion (back)"
);
assert_eq!(iter.len(), 0, "len stays 0 past fused exhaustion");
}
}
#[test]
fn attribution_iter_last_matches_lex_last_key() {
let out = iter_fixture();
let forward: Vec<(Vec<String>, &'static str)> = out
.attribution
.iter()
.map(|(p, l)| (p.to_vec(), l))
.collect();
let last = out.attribution.iter().last().map(|(p, l)| (p.to_vec(), l));
assert_eq!(last, forward.last().cloned());
}
#[test]
fn attribution_iter_named_type_carries_trait_algebra() {
fn is_iter<'a, I: Iterator<Item = (&'a [String], &'static str)>>(_: &I) {}
fn is_double_ended<'a, I: DoubleEndedIterator<Item = (&'a [String], &'static str)>>(_: &I) {
}
fn is_exact_size<'a, I: ExactSizeIterator<Item = (&'a [String], &'static str)>>(_: &I) {}
fn is_fused<'a, I: std::iter::FusedIterator<Item = (&'a [String], &'static str)>>(_: &I) {}
fn is_clone<T: Clone>(_: &T) {}
fn is_debug<T: std::fmt::Debug>(_: &T) {}
let out = iter_fixture();
let iter: LayerAttributionIter<'_> = out.attribution.iter();
is_iter(&iter);
is_double_ended(&iter);
is_exact_size(&iter);
is_fused(&iter);
is_clone(&iter);
is_debug(&iter);
}
#[test]
fn writes_by_layer_groups_leaves_under_their_writer() {
let a = Fixed(
"platform",
dict(&[("k1", Value::from(1i64)), ("k2", Value::from(2i64))]),
);
let b = Fixed(
"tenancy",
dict(&[("k2", Value::from(20i64)), ("k3", Value::from(3i64))]),
);
let out = compose_with_provenance(&[&a, &b]);
let groups = out.attribution.writes_by_layer();
let layers: Vec<&&'static str> = groups.keys().collect();
assert_eq!(
layers,
vec![&"platform", &"tenancy"],
"outer BTreeMap keys sort lex on layer name",
);
let platform = groups.get("platform").expect("platform bucket");
let tenancy = groups.get("tenancy").expect("tenancy bucket");
assert_eq!(
platform,
&vec![["k1".to_owned()].as_slice()],
"platform kept k1 only",
);
assert_eq!(
tenancy,
&vec![["k2".to_owned()].as_slice(), ["k3".to_owned()].as_slice(),],
"tenancy holds k2 (overwritten) and k3, in lex path order",
);
}
#[test]
fn writes_by_layer_partitions_leaves_by_writer() {
let a = Fixed(
"A",
dict(&[(
"outer",
Value::from(dict(&[
("keep", Value::from("k")),
("change", Value::from(1i64)),
])),
)]),
);
let b = Fixed(
"B",
dict(&[
("outer", Value::from(dict(&[("change", Value::from(9i64))]))),
("array", Value::from(vec![Value::from(0i64)])),
]),
);
let out = compose_with_provenance(&[&a, &b]);
let groups = out.attribution.writes_by_layer();
let bucket_sum: usize = groups.values().map(Vec::len).sum();
assert_eq!(bucket_sum, out.attribution.len());
let mut flattened: Vec<&[String]> = groups
.values()
.flat_map(|paths| paths.iter().copied())
.collect();
flattened.sort();
let mut iter_paths: Vec<&[String]> = out.attribution.iter().map(|(p, _)| p).collect();
iter_paths.sort();
assert_eq!(
flattened, iter_paths,
"the flattened bucket union equals iter()'s path set",
);
for (layer, paths) in &groups {
for path in paths {
assert_eq!(
out.attribution.layer_of_owned(path),
Some(*layer),
"layer_of_owned must agree with the bucket layer",
);
}
}
}
#[test]
fn writes_by_layer_empty_when_no_layers() {
let out = compose_with_provenance(&[]);
assert!(
out.attribution.writes_by_layer().is_empty(),
"no layers ⇒ no buckets",
);
}
#[test]
fn writes_by_layer_empty_layer_drops_out_of_buckets() {
let real = Fixed("real", dict(&[("k", Value::from(1i64))]));
let empty = Fixed("undetectable", Dict::new());
let out = compose_with_provenance(&[&real, &empty]);
let groups = out.attribution.writes_by_layer();
assert_eq!(groups.len(), 1);
assert!(
groups.contains_key("real"),
"the real writer keeps its bucket",
);
assert!(
!groups.contains_key("undetectable"),
"an empty-dict layer contributes no leaves, so no bucket",
);
}
#[test]
fn writes_by_layer_yields_deterministic_layer_and_path_order() {
let a = Fixed("Z", dict(&[("z", Value::from(1i64))]));
let b = Fixed(
"A",
dict(&[
("a", Value::from(dict(&[("y", Value::from(2i64))]))),
("m", Value::from(3i64)),
]),
);
let out = compose_with_provenance(&[&a, &b]);
let groups = out.attribution.writes_by_layer();
let layers: Vec<&&'static str> = groups.keys().collect();
assert_eq!(layers, vec![&"A", &"Z"]);
let a_paths = groups.get("A").expect("A bucket");
assert_eq!(
a_paths,
&vec![
["a".to_owned(), "y".to_owned()].as_slice(),
["m".to_owned()].as_slice(),
],
);
let z_paths = groups.get("Z").expect("Z bucket");
assert_eq!(z_paths, &vec![["z".to_owned()].as_slice()]);
}
#[test]
fn leaf_counts_by_layer_counts_writes_per_layer() {
let a = Fixed(
"platform",
dict(&[("k1", Value::from(1i64)), ("k2", Value::from(2i64))]),
);
let b = Fixed(
"tenancy",
dict(&[("k2", Value::from(20i64)), ("k3", Value::from(3i64))]),
);
let out = compose_with_provenance(&[&a, &b]);
let counts = out.attribution.leaf_counts_by_layer();
let layers: Vec<&&'static str> = counts.keys().collect();
assert_eq!(
layers,
vec![&"platform", &"tenancy"],
"outer BTreeMap keys sort lex on layer name",
);
assert_eq!(
counts.get("platform").copied(),
Some(1),
"platform kept k1 only",
);
assert_eq!(
counts.get("tenancy").copied(),
Some(2),
"tenancy holds k2 (overwritten) and k3",
);
}
#[test]
fn leaf_counts_by_layer_partition_count_law() {
let a = Fixed(
"A",
dict(&[(
"outer",
Value::from(dict(&[
("keep", Value::from("k")),
("change", Value::from(1i64)),
])),
)]),
);
let b = Fixed(
"B",
dict(&[
("outer", Value::from(dict(&[("change", Value::from(9i64))]))),
("array", Value::from(vec![Value::from(0i64)])),
]),
);
let out = compose_with_provenance(&[&a, &b]);
let counts = out.attribution.leaf_counts_by_layer();
let sum: usize = counts.values().sum();
assert_eq!(sum, out.attribution.len());
}
#[test]
fn leaf_counts_by_layer_agrees_with_writes_by_layer_sizes() {
let a = Fixed("Z", dict(&[("z", Value::from(1i64))]));
let b = Fixed(
"A",
dict(&[
("a", Value::from(dict(&[("y", Value::from(2i64))]))),
("m", Value::from(3i64)),
]),
);
let c = Fixed("M", dict(&[("q", Value::from(4i64))]));
let out = compose_with_provenance(&[&a, &b, &c]);
let counts = out.attribution.leaf_counts_by_layer();
let groups = out.attribution.writes_by_layer();
let counts_keys: Vec<&&'static str> = counts.keys().collect();
let groups_keys: Vec<&&'static str> = groups.keys().collect();
assert_eq!(
counts_keys, groups_keys,
"compact and wide seams share the outer key set verbatim",
);
for (layer, paths) in &groups {
assert_eq!(
counts.get(layer).copied(),
Some(paths.len()),
"leaf_counts_by_layer[{layer}] == writes_by_layer[{layer}].len()",
);
}
}
#[test]
fn leaf_counts_by_layer_empty_when_no_layers() {
let out = compose_with_provenance(&[]);
assert!(
out.attribution.leaf_counts_by_layer().is_empty(),
"no layers ⇒ no counters",
);
}
#[test]
fn leaf_counts_by_layer_empty_layer_drops_out_of_counters() {
let real = Fixed("real", dict(&[("k", Value::from(1i64))]));
let empty = Fixed("undetectable", Dict::new());
let out = compose_with_provenance(&[&real, &empty]);
let counts = out.attribution.leaf_counts_by_layer();
assert_eq!(counts.len(), 1);
assert_eq!(counts.get("real").copied(), Some(1));
assert!(
!counts.contains_key("undetectable"),
"an empty-dict layer contributes no leaves, so no counter",
);
}
#[test]
fn leaf_counts_by_layer_reflects_dict_over_scalar_reshape() {
let a = Fixed("first", dict(&[("x", Value::from(1i64))]));
let b = Fixed(
"second",
dict(&[("x", Value::from(dict(&[("y", Value::from(2i64))])))]),
);
let out = compose_with_provenance(&[&a, &b]);
let counts = out.attribution.leaf_counts_by_layer();
assert_eq!(counts.get("second").copied(), Some(1));
assert!(
!counts.contains_key("first"),
"purged scalar attribution drops A from the counters",
);
assert_eq!(counts.len(), 1);
}
#[test]
fn compose_with_provenance_dict_matches_compose_projection_across_shape_transitions() {
let a = Fixed(
"A",
dict(&[
("scalar", Value::from(1i64)),
(
"nested",
Value::from(dict(&[
("keep", Value::from("k")),
("change", Value::from("A")),
])),
),
]),
);
let b = Fixed(
"B",
dict(&[
("nested", Value::from(dict(&[("change", Value::from("B"))]))),
("array", Value::from(vec![Value::from(1i64)])),
("scalar", Value::from(dict(&[("inner", Value::from(2i64))]))),
]),
);
let c = Fixed(
"C",
dict(&[
("array", Value::from(vec![Value::from(9i64)])),
("scalar", Value::from(99i64)),
]),
);
let out = compose_with_provenance(&[&a, &b, &c]);
assert_eq!(
out.dict,
compose(&[&a, &b, &c]),
"dict projection equals plain compose across shape transitions"
);
assert_eq!(out.attribution.layer_of(&["nested", "keep"]), Some("A"));
assert_eq!(out.attribution.layer_of(&["nested", "change"]), Some("B"));
assert_eq!(out.attribution.layer_of(&["array"]), Some("C"));
assert_eq!(out.attribution.layer_of(&["scalar"]), Some("C"));
assert_eq!(out.attribution.layer_of(&["scalar", "inner"]), None);
}
fn s(x: &str) -> String {
x.to_owned()
}
fn subtree_fixture() -> DiscoveryComposition {
let coarse = Fixed(
"coarse",
dict(&[
(
"breathe",
Value::from(dict(&[
("mode", Value::from("live")),
("setpoint", Value::from(0.80)),
])),
),
("alpha", Value::from(1i64)),
]),
);
let specific = Fixed(
"specific",
dict(&[
(
"breathe",
Value::from(dict(&[("setpoint", Value::from(0.70))])),
),
("breatheZ", Value::from(9i64)),
]),
);
compose_with_provenance(&[&coarse, &specific])
}
#[test]
fn subtree_iter_at_root_prefix_matches_iter() {
let out = subtree_fixture();
let full: Vec<(Vec<String>, &'static str)> = out
.attribution
.subtree_iter(&[])
.map(|(p, l)| (p.to_vec(), l))
.collect();
let via_iter: Vec<(Vec<String>, &'static str)> = out
.attribution
.iter()
.map(|(p, l)| (p.to_vec(), l))
.collect();
assert_eq!(full, via_iter, "empty prefix ⇒ full iter, same order");
assert_eq!(
out.attribution.subtree(&[]).len(),
out.attribution.len(),
"subtree(&[]) equals self on the len() axis",
);
}
#[test]
fn subtree_iter_at_named_prefix_yields_only_that_subtree_in_lex_order() {
let out = subtree_fixture();
let prefix = vec![s("breathe")];
let observed: Vec<(Vec<String>, &'static str)> = out
.attribution
.subtree_iter(&prefix)
.map(|(p, l)| (p.to_vec(), l))
.collect();
assert_eq!(
observed,
vec![
(vec![s("breathe"), s("mode")], "coarse"),
(vec![s("breathe"), s("setpoint")], "specific"),
],
"subtree yields only breathe.* leaves in lex order",
);
}
#[test]
fn subtree_iter_stops_at_prefix_extending_sibling_key() {
let out = subtree_fixture();
let prefix = vec![s("breathe")];
let observed: Vec<Vec<String>> = out
.attribution
.subtree_iter(&prefix)
.map(|(p, _)| p.to_vec())
.collect();
assert!(
!observed.contains(&vec![s("breatheZ")]),
"prefix-extending sibling `breatheZ` is NOT a descendant of `breathe`",
);
assert_eq!(
observed.len(),
2,
"only the two `breathe.*` leaves are yielded, not `breatheZ`",
);
assert_eq!(
out.attribution.layer_of(&["breatheZ"]),
Some("specific"),
"the excluded sibling is still attributed in the parent",
);
}
#[test]
fn subtree_iter_empty_when_prefix_names_no_subtree() {
let out = subtree_fixture();
assert_eq!(
out.attribution.subtree_iter(&[s("nonexistent")]).count(),
0,
"absent prefix ⇒ empty iterator",
);
assert!(
out.attribution.subtree(&[s("nonexistent")]).is_empty(),
"absent prefix ⇒ empty projection",
);
}
#[test]
fn subtree_iter_at_exact_leaf_yields_that_leaf_only() {
let out = subtree_fixture();
let prefix = vec![s("alpha")];
let observed: Vec<(Vec<String>, &'static str)> = out
.attribution
.subtree_iter(&prefix)
.map(|(p, l)| (p.to_vec(), l))
.collect();
assert_eq!(observed, vec![(vec![s("alpha")], "coarse")]);
}
#[test]
fn subtree_agrees_with_subtree_iter_pointwise() {
let out = subtree_fixture();
let prefix = vec![s("breathe")];
let sub = out.attribution.subtree(&prefix);
let via_projection: Vec<(Vec<String>, &'static str)> =
sub.iter().map(|(p, l)| (p.to_vec(), l)).collect();
let via_iter: Vec<(Vec<String>, &'static str)> = out
.attribution
.subtree_iter(&prefix)
.map(|(p, l)| (p.to_vec(), l))
.collect();
assert_eq!(via_projection, via_iter);
assert_eq!(sub.len(), 2);
for (path, layer) in &via_iter {
assert_eq!(sub.layer_of_owned(path), Some(*layer));
assert_eq!(out.attribution.layer_of_owned(path), Some(*layer));
}
}
#[test]
fn subtree_writes_by_layer_is_subset_of_parent() {
let out = subtree_fixture();
let prefix = vec![s("breathe")];
let sub = out.attribution.subtree(&prefix);
let sub_groups = sub.writes_by_layer();
let parent_groups = out.attribution.writes_by_layer();
for (layer, sub_paths) in &sub_groups {
let parent_paths = parent_groups
.get(layer)
.expect("every subtree layer appears in the parent");
for path in sub_paths {
assert!(
parent_paths.contains(path),
"sub-bucket paths are a subset of parent-bucket paths",
);
}
}
assert!(sub_groups.contains_key("coarse"));
assert!(sub_groups.contains_key("specific"));
}
#[test]
fn subtree_leaf_counts_by_layer_composes_at_sub_altitude() {
let out = subtree_fixture();
let prefix = vec![s("breathe")];
let sub_counts = out.attribution.subtree(&prefix).leaf_counts_by_layer();
assert_eq!(sub_counts.get("coarse").copied(), Some(1));
assert_eq!(sub_counts.get("specific").copied(), Some(1));
assert_eq!(sub_counts.len(), 2);
let parent_counts = out.attribution.leaf_counts_by_layer();
for (layer, sub_count) in &sub_counts {
let parent_count = parent_counts
.get(layer)
.copied()
.expect("every subtree layer appears in the parent");
assert!(
*sub_count <= parent_count,
"sub-count for {layer} ({sub_count}) must not exceed parent count ({parent_count})",
);
}
}
#[test]
fn subtree_iter_reflects_dict_over_scalar_reshape() {
let a = Fixed("first", dict(&[("x", Value::from(1i64))]));
let b = Fixed(
"second",
dict(&[("x", Value::from(dict(&[("y", Value::from(2i64))])))]),
);
let out = compose_with_provenance(&[&a, &b]);
let observed: Vec<(Vec<String>, &'static str)> = out
.attribution
.subtree_iter(&[s("x")])
.map(|(p, l)| (p.to_vec(), l))
.collect();
assert_eq!(observed, vec![(vec![s("x"), s("y")], "second")]);
}
#[test]
fn subtree_iter_clone_yields_independent_walks() {
let out = subtree_fixture();
let prefix = vec![s("breathe")];
let a = out.attribution.subtree_iter(&prefix);
let b = a.clone();
let a_collected: Vec<(Vec<String>, &'static str)> =
a.map(|(p, l)| (p.to_vec(), l)).collect();
let b_collected: Vec<(Vec<String>, &'static str)> =
b.map(|(p, l)| (p.to_vec(), l)).collect();
assert_eq!(
a_collected, b_collected,
"cloned handles yield the same subtree walk"
);
let mut left = out.attribution.subtree_iter(&prefix);
let mut right = left.clone();
let l0 = left.next().expect("breathe.mode");
let r0 = right.next().expect("breathe.mode");
assert_eq!(
(l0.0.to_vec(), l0.1),
(r0.0.to_vec(), r0.1),
"both clones observe the same first entry",
);
let _ = left.next();
assert!(left.next().is_none(), "left is exhausted after two entries");
let r1 = right.next().expect("right still has breathe.setpoint");
assert_eq!(
(r1.0.to_vec(), r1.1),
a_collected[1],
"right's position is independent of left's",
);
}
#[test]
fn subtree_iter_clone_at_root_prefix_matches_iter_clone() {
let out = iter_fixture();
let via_subtree = out.attribution.subtree_iter(&[]);
let via_subtree_clone = via_subtree.clone();
let via_iter_clone = out.attribution.iter().clone();
let sub_collected: Vec<(Vec<String>, &'static str)> =
via_subtree.map(|(p, l)| (p.to_vec(), l)).collect();
let sub_clone_collected: Vec<(Vec<String>, &'static str)> =
via_subtree_clone.map(|(p, l)| (p.to_vec(), l)).collect();
let iter_clone_collected: Vec<(Vec<String>, &'static str)> =
via_iter_clone.map(|(p, l)| (p.to_vec(), l)).collect();
assert_eq!(sub_collected, sub_clone_collected);
assert_eq!(sub_collected, iter_clone_collected);
}
#[test]
fn subtree_iter_named_type_carries_trait_algebra() {
fn is_iter<'a, I: Iterator<Item = (&'a [String], &'static str)>>(_: &I) {}
fn is_fused<'a, I: std::iter::FusedIterator<Item = (&'a [String], &'static str)>>(_: &I) {}
fn is_clone<T: Clone>(_: &T) {}
fn is_debug<T: std::fmt::Debug>(_: &T) {}
let out = subtree_fixture();
let prefix: Vec<String> = vec![s("breathe")];
let iter: LayerAttributionSubtreeIter<'_> = out.attribution.subtree_iter(&prefix);
is_iter(&iter);
is_fused(&iter);
is_clone(&iter);
is_debug(&iter);
}
#[test]
fn subtree_iter_is_fused_past_exhaustion() {
let out = subtree_fixture();
let prefix = vec![s("breathe")];
let mut iter = out.attribution.subtree_iter(&prefix);
while iter.next().is_some() {}
for _ in 0..4 {
assert!(iter.next().is_none(), "fused past forward exhaustion");
}
}
#[test]
fn subtree_iter_stays_fused_across_absent_prefix() {
let out = subtree_fixture();
let absent = vec![s("no_such_key")];
let mut iter = out.attribution.subtree_iter(&absent);
assert!(iter.next().is_none(), "absent prefix yields empty");
for _ in 0..4 {
assert!(iter.next().is_none(), "fused past empty");
}
}
#[test]
fn subtree_iter_debug_formats() {
let out = subtree_fixture();
let prefix = vec![s("breathe")];
let iter = out.attribution.subtree_iter(&prefix);
let s_fmt = format!("{iter:?}");
assert!(
s_fmt.contains("LayerAttributionSubtreeIter"),
"Debug output names the type: {s_fmt}",
);
}
#[test]
fn subtree_iter_named_type_binds_as_struct_field() {
struct Cursor<'a> {
iter: LayerAttributionSubtreeIter<'a>,
}
impl<'a> Cursor<'a> {
fn advance(&mut self) -> Option<(&'a [String], &'static str)> {
self.iter.next()
}
}
let out = subtree_fixture();
let prefix = vec![s("breathe")];
let mut cursor = Cursor {
iter: out.attribution.subtree_iter(&prefix),
};
assert!(cursor.advance().is_some(), "first entry present");
assert!(cursor.advance().is_some(), "second entry present");
assert!(cursor.advance().is_none(), "subtree exhausted");
}
#[test]
fn subtree_surviving_layer_names_empty_prefix_equals_surviving_layer_names() {
let out = subtree_fixture();
assert_eq!(
out.attribution.subtree_surviving_layer_names(&[]),
out.attribution.surviving_layer_names(),
"empty prefix ⇒ same lex name-set as the top-level projection",
);
}
#[test]
fn subtree_surviving_layer_names_at_named_prefix_lists_writers_under_it() {
let out = subtree_fixture();
let prefix = vec![s("breathe")];
assert_eq!(
out.attribution.subtree_surviving_layer_names(&prefix),
vec!["coarse", "specific"],
);
}
#[test]
fn subtree_surviving_layer_names_agrees_with_subtree_surviving_layer_names() {
let out = subtree_fixture();
for prefix in [
vec![],
vec![s("breathe")],
vec![s("alpha")],
vec![s("nonexistent")],
] {
assert_eq!(
out.attribution.subtree_surviving_layer_names(&prefix),
out.attribution.subtree(&prefix).surviving_layer_names(),
"direct seam agrees with the subtree-then-surviving composition at {prefix:?}",
);
}
}
#[test]
fn subtree_surviving_layer_names_absent_prefix_is_empty() {
let out = subtree_fixture();
assert!(
out.attribution
.subtree_surviving_layer_names(&[s("nonexistent")])
.is_empty(),
"absent prefix ⇒ empty name-set",
);
}
#[test]
fn subtree_surviving_layer_names_at_exact_scalar_leaf_lists_only_its_writer() {
let out = subtree_fixture();
let prefix = vec![s("alpha")];
assert_eq!(
out.attribution.subtree_surviving_layer_names(&prefix),
vec!["coarse"],
);
}
#[test]
fn subtree_surviving_layer_names_stops_at_prefix_extending_sibling_key() {
let coarse = Fixed(
"coarse",
dict(&[(
"breathe",
Value::from(dict(&[("mode", Value::from("live"))])),
)]),
);
let specific_only_sibling = Fixed("specific", dict(&[("breatheZ", Value::from(9i64))]));
let out = compose_with_provenance(&[&coarse, &specific_only_sibling]);
let prefix = vec![s("breathe")];
assert_eq!(
out.attribution.subtree_surviving_layer_names(&prefix),
vec!["coarse"],
"the prefix-extending sibling's writer is NOT credited against the subtree",
);
assert_eq!(
out.attribution.surviving_layer_names(),
vec!["coarse", "specific"],
);
}
#[test]
fn subtree_surviving_layer_names_deduplicates_multi_write_writer() {
let only = Fixed(
"only",
dict(&[(
"svc",
Value::from(dict(&[
("a", Value::from(1i64)),
("b", Value::from(2i64)),
("c", Value::from(3i64)),
])),
)]),
);
let out = compose_with_provenance(&[&only]);
let prefix = vec![s("svc")];
assert_eq!(
out.attribution.subtree_surviving_layer_names(&prefix),
vec!["only"],
);
}
#[test]
fn subtree_surviving_layer_names_returns_lex_order_on_layer_name() {
let z_layer = Fixed(
"Z",
dict(&[("svc", Value::from(dict(&[("k1", Value::from(1i64))])))]),
);
let a_layer = Fixed(
"A",
dict(&[("svc", Value::from(dict(&[("k2", Value::from(2i64))])))]),
);
let out = compose_with_provenance(&[&z_layer, &a_layer]);
let prefix = vec![s("svc")];
assert_eq!(
out.attribution.subtree_surviving_layer_names(&prefix),
vec!["A", "Z"],
"lex order, not application order",
);
}
#[test]
fn subtree_surviving_layer_names_subset_of_surviving_layer_names() {
let out = subtree_fixture();
let prefix = vec![s("alpha")];
let sub_set: std::collections::BTreeSet<_> = out
.attribution
.subtree_surviving_layer_names(&prefix)
.into_iter()
.collect();
let top_set: std::collections::BTreeSet<_> = out
.attribution
.surviving_layer_names()
.into_iter()
.collect();
assert!(sub_set.is_subset(&top_set), "sub ⊆ top on every prefix");
assert!(
sub_set.len() < top_set.len(),
"the `alpha`-only subtree drops `specific` — strict subset",
);
assert!(
!sub_set.contains("specific"),
"specific has no leaf under alpha"
);
}
#[test]
fn subtree_surviving_layer_names_empty_when_no_leaves() {
let empty = compose_with_provenance(&[]);
assert!(
empty
.attribution
.subtree_surviving_layer_names(&[])
.is_empty()
);
assert!(
empty
.attribution
.subtree_surviving_layer_names(&[s("any")])
.is_empty(),
);
}
#[test]
fn subtree_surviving_layer_names_iter_collect_matches_subtree_surviving_layer_names() {
let out = subtree_fixture();
for prefix in [
vec![],
vec![s("breathe")],
vec![s("alpha")],
vec![s("nonexistent")],
] {
assert_eq!(
out.attribution
.subtree_surviving_layer_names_iter(&prefix)
.collect::<Vec<_>>(),
out.attribution.subtree_surviving_layer_names(&prefix),
"iter dual collects to the same Vec as the collecting form at {prefix:?}",
);
}
}
#[test]
fn subtree_surviving_layer_names_iter_empty_prefix_matches_surviving_layer_names_iter() {
let out = subtree_fixture();
assert_eq!(
out.attribution
.subtree_surviving_layer_names_iter(&[])
.collect::<Vec<_>>(),
out.attribution
.surviving_layer_names_iter()
.collect::<Vec<_>>(),
);
}
#[test]
fn subtree_surviving_layer_names_iter_empty_attribution_is_empty_stream() {
let empty = compose_with_provenance(&[]);
for prefix in [vec![], vec![s("any")], vec![s("nested"), s("under")]] {
let iter = empty
.attribution
.subtree_surviving_layer_names_iter(&prefix);
assert_eq!(iter.len(), 0, "empty attribution at {prefix:?}");
assert_eq!(iter.size_hint(), (0, Some(0)));
assert_eq!(
empty
.attribution
.subtree_surviving_layer_names_iter(&prefix)
.collect::<Vec<_>>(),
Vec::<&'static str>::new(),
);
}
}
#[test]
fn subtree_surviving_layer_names_iter_absent_prefix_is_empty_stream() {
let out = subtree_fixture();
let iter = out
.attribution
.subtree_surviving_layer_names_iter(&[s("nonexistent")]);
assert_eq!(iter.len(), 0);
assert_eq!(iter.size_hint(), (0, Some(0)));
assert_eq!(
out.attribution
.subtree_surviving_layer_names_iter(&[s("nonexistent")])
.collect::<Vec<_>>(),
Vec::<&'static str>::new(),
);
}
#[test]
fn subtree_surviving_layer_names_iter_len_equals_distinct_writer_count_under_subtree() {
let out = subtree_fixture();
for prefix in [vec![], vec![s("breathe")], vec![s("alpha")]] {
let iter = out.attribution.subtree_surviving_layer_names_iter(&prefix);
let expected = out.attribution.subtree_surviving_layer_names(&prefix).len();
assert_eq!(iter.len(), expected, "len at {prefix:?}");
assert_eq!(iter.size_hint(), (expected, Some(expected)));
}
}
#[test]
fn subtree_surviving_layer_names_iter_yields_lex_order_on_layer_name() {
let z_layer = Fixed(
"Z",
dict(&[("svc", Value::from(dict(&[("k1", Value::from(1i64))])))]),
);
let a_layer = Fixed(
"A",
dict(&[("svc", Value::from(dict(&[("k2", Value::from(2i64))])))]),
);
let out = compose_with_provenance(&[&z_layer, &a_layer]);
let prefix = vec![s("svc")];
assert_eq!(
out.attribution
.subtree_surviving_layer_names_iter(&prefix)
.collect::<Vec<_>>(),
vec!["A", "Z"],
"lex order, not application order",
);
}
#[test]
fn subtree_surviving_layer_names_iter_rev_matches_iter_reversed() {
let z_layer = Fixed(
"Z",
dict(&[("svc", Value::from(dict(&[("k1", Value::from(1i64))])))]),
);
let a_layer = Fixed(
"A",
dict(&[("svc", Value::from(dict(&[("k2", Value::from(2i64))])))]),
);
let m_layer = Fixed(
"M",
dict(&[("svc", Value::from(dict(&[("k3", Value::from(3i64))])))]),
);
let out = compose_with_provenance(&[&z_layer, &a_layer, &m_layer]);
let prefix = vec![s("svc")];
let forward = out.attribution.subtree_surviving_layer_names(&prefix);
let mut expected = forward.clone();
expected.reverse();
assert_eq!(
out.attribution
.subtree_surviving_layer_names_iter(&prefix)
.rev()
.collect::<Vec<_>>(),
expected,
);
}
#[test]
fn subtree_surviving_layer_names_iter_last_matches_reverse_head() {
let z_layer = Fixed(
"Z",
dict(&[("svc", Value::from(dict(&[("k1", Value::from(1i64))])))]),
);
let a_layer = Fixed(
"A",
dict(&[("svc", Value::from(dict(&[("k2", Value::from(2i64))])))]),
);
let out = compose_with_provenance(&[&z_layer, &a_layer]);
let prefix = vec![s("svc")];
assert_eq!(
out.attribution
.subtree_surviving_layer_names_iter(&prefix)
.last(),
out.attribution
.subtree_surviving_layer_names(&prefix)
.last()
.copied(),
);
}
#[test]
fn subtree_surviving_layer_names_iter_head_short_circuits_to_lex_first() {
let z_layer = Fixed(
"Z",
dict(&[("svc", Value::from(dict(&[("k1", Value::from(1i64))])))]),
);
let a_layer = Fixed(
"A",
dict(&[("svc", Value::from(dict(&[("k2", Value::from(2i64))])))]),
);
let out = compose_with_provenance(&[&z_layer, &a_layer]);
let prefix = vec![s("svc")];
assert_eq!(
out.attribution
.subtree_surviving_layer_names_iter(&prefix)
.next(),
Some("A"),
);
}
#[test]
fn subtree_surviving_layer_names_iter_dedups_multi_write_writer_under_subtree() {
let only = Fixed(
"only",
dict(&[(
"svc",
Value::from(dict(&[
("a", Value::from(1i64)),
("b", Value::from(2i64)),
("c", Value::from(3i64)),
])),
)]),
);
let out = compose_with_provenance(&[&only]);
let prefix = vec![s("svc")];
assert_eq!(
out.attribution
.subtree_surviving_layer_names_iter(&prefix)
.collect::<Vec<_>>(),
vec!["only"],
);
assert_eq!(
out.attribution
.subtree_surviving_layer_names_iter(&prefix)
.count(),
1,
);
assert_eq!(
out.attribution
.subtree_surviving_layer_names_iter(&prefix)
.len(),
1,
"ExactSizeIterator::len reads 1 despite three underlying sightings",
);
}
#[test]
fn subtree_surviving_layer_names_iter_stops_at_prefix_extending_sibling_key() {
let coarse = Fixed(
"coarse",
dict(&[(
"breathe",
Value::from(dict(&[("mode", Value::from("live"))])),
)]),
);
let specific_only_sibling = Fixed("specific", dict(&[("breatheZ", Value::from(9i64))]));
let out = compose_with_provenance(&[&coarse, &specific_only_sibling]);
let prefix = vec![s("breathe")];
assert_eq!(
out.attribution
.subtree_surviving_layer_names_iter(&prefix)
.collect::<Vec<_>>(),
vec!["coarse"],
"the prefix-extending sibling's writer is NOT credited against the subtree",
);
assert_eq!(
out.attribution
.surviving_layer_names_iter()
.collect::<Vec<_>>(),
vec!["coarse", "specific"],
);
}
#[test]
fn subtree_surviving_layer_names_iter_fused_after_exhaustion() {
let only = Fixed(
"only",
dict(&[("svc", Value::from(dict(&[("k", Value::from(1i64))])))]),
);
let out = compose_with_provenance(&[&only]);
let prefix = vec![s("svc")];
let mut iter = out.attribution.subtree_surviving_layer_names_iter(&prefix);
assert_eq!(iter.next(), Some("only"));
assert_eq!(iter.next(), None);
assert_eq!(iter.next(), None);
assert_eq!(iter.next(), None);
}
#[test]
fn contributor_names_filters_empty_layers() {
let a = Fixed("platform", dict(&[("k", Value::from(1i64))]));
let b = Fixed("undetectable", Dict::new());
let c = Fixed("tenancy", dict(&[("k", Value::from(2i64))]));
assert_eq!(
contributor_names(&[&a, &b, &c]),
vec!["platform", "tenancy"]
);
}
#[test]
fn contributor_names_preserves_application_order() {
let a = Fixed("tenancy", dict(&[("k", Value::from(1i64))]));
let b = Fixed("platform", dict(&[("k", Value::from(2i64))]));
assert_eq!(contributor_names(&[&a, &b]), vec!["tenancy", "platform"]);
}
#[test]
fn contributor_names_empty_when_all_layers_undetectable() {
let a = Fixed("a", Dict::new());
let b = Fixed("b", Dict::new());
assert!(contributor_names(&[&a, &b]).is_empty());
}
#[test]
fn contributor_names_empty_when_no_layers() {
assert!(contributor_names(&[]).is_empty());
}
#[test]
fn contributor_names_is_subset_of_layer_names() {
let a = Fixed("a", dict(&[("k", Value::from(1i64))]));
let b = Fixed("b", Dict::new());
let c = Fixed("c", dict(&[("k", Value::from(2i64))]));
let all: std::collections::BTreeSet<_> = layer_names(&[&a, &b, &c]).into_iter().collect();
let contributors: std::collections::BTreeSet<_> =
contributor_names(&[&a, &b, &c]).into_iter().collect();
assert!(
contributors.is_subset(&all),
"contributors ⊆ declared names"
);
assert_eq!(
contributors.len(),
2,
"the empty middle layer is filtered out"
);
}
#[test]
fn contributor_names_emptiness_matches_composed_emptiness() {
let a_empty = Fixed("a", Dict::new());
let b_empty = Fixed("b", Dict::new());
let empty_stack: [&dyn DiscoveryLayer; 2] = [&a_empty, &b_empty];
assert!(contributor_names(&empty_stack).is_empty());
assert!(compose(&empty_stack).is_empty());
let a = Fixed("a", dict(&[("x", Value::from(1i64))]));
let b = Fixed("b", Dict::new());
let c = Fixed("c", dict(&[("y", Value::from(2i64))]));
let stack: [&dyn DiscoveryLayer; 3] = [&a, &b, &c];
assert!(!contributor_names(&stack).is_empty());
assert!(!compose(&stack).is_empty());
}
#[test]
fn contributor_names_counts_overridden_writers_too() {
let coarse = Fixed("platform", dict(&[("setpoint", Value::from(0.80))]));
let specific = Fixed("tenancy", dict(&[("setpoint", Value::from(0.70))]));
assert_eq!(
contributor_names(&[&coarse, &specific]),
vec!["platform", "tenancy"],
"both writers show up even when specific wholly overrides coarse",
);
assert_eq!(
compose(&[&coarse, &specific]).get("setpoint"),
Some(&Value::from(0.70)),
);
}
#[test]
fn contributor_names_iter_collect_matches_contributor_names() {
let a = Fixed("platform", dict(&[("a", Value::from(1i64))]));
let quiet = Fixed("cloud", Dict::new());
let c = Fixed("tenancy", dict(&[("c", Value::from(3i64))]));
let layers: [&dyn DiscoveryLayer; 3] = [&a, &quiet, &c];
assert_eq!(
contributor_names_iter(&layers).collect::<Vec<_>>(),
contributor_names(&layers),
"iter → Vec matches contributor_names verbatim",
);
}
#[test]
fn contributor_names_iter_empty_stack_is_empty_stream() {
let layers: [&dyn DiscoveryLayer; 0] = [];
assert!(
contributor_names_iter(&layers).next().is_none(),
"no layers → no contributors",
);
}
#[test]
fn contributor_names_iter_all_undetectable_is_empty_stream() {
let a = Fixed("platform", Dict::new());
let b = Fixed("cloud", Dict::new());
let layers: [&dyn DiscoveryLayer; 2] = [&a, &b];
assert!(
contributor_names_iter(&layers).next().is_none(),
"every axis silent → the stream is empty",
);
}
#[test]
fn contributor_names_iter_preserves_application_order() {
let a = Fixed("platform", dict(&[("a", Value::from(1i64))]));
let b = Fixed("cloud", dict(&[("b", Value::from(2i64))]));
let c = Fixed("tenancy", dict(&[("c", Value::from(3i64))]));
let layers: [&dyn DiscoveryLayer; 3] = [&a, &b, &c];
assert_eq!(
contributor_names_iter(&layers).collect::<Vec<_>>(),
vec!["platform", "cloud", "tenancy"],
"iter yields names coarse→specific in application order",
);
}
#[test]
fn contributor_names_iter_rev_reverses_forward_walk() {
let a = Fixed("platform", dict(&[("a", Value::from(1i64))]));
let quiet = Fixed("cloud", Dict::new());
let c = Fixed("tenancy", dict(&[("c", Value::from(3i64))]));
let layers: [&dyn DiscoveryLayer; 3] = [&a, &quiet, &c];
let forward = contributor_names_iter(&layers).collect::<Vec<_>>();
let reverse = contributor_names_iter(&layers).rev().collect::<Vec<_>>();
assert_eq!(
reverse,
forward.iter().rev().copied().collect::<Vec<_>>(),
".rev() over the iter recovers the reverse of the forward walk",
);
}
#[test]
fn contributor_names_iter_clone_yields_independent_walks() {
let a = Fixed("platform", dict(&[("a", Value::from(1i64))]));
let quiet = Fixed("cloud", Dict::new());
let c = Fixed("tenancy", dict(&[("c", Value::from(3i64))]));
let layers: [&dyn DiscoveryLayer; 3] = [&a, &quiet, &c];
let one = contributor_names_iter(&layers);
let two = one.clone();
assert_eq!(
one.collect::<Vec<_>>(),
two.collect::<Vec<_>>(),
"two independent walks agree",
);
}
#[test]
fn contributor_names_iter_is_fused_past_exhaustion() {
let a = Fixed("platform", dict(&[("a", Value::from(1i64))]));
let layers: [&dyn DiscoveryLayer; 1] = [&a];
let mut it = contributor_names_iter(&layers);
assert_eq!(it.next(), Some("platform"));
for _ in 0..4 {
assert!(it.next().is_none(), "post-exhaustion pulls stay None");
}
}
#[test]
fn contributor_names_iter_head_short_circuits_without_full_sweep() {
let a = Fixed("platform", dict(&[("a", Value::from(1i64))]));
let b = Fixed("cloud", dict(&[("b", Value::from(2i64))]));
let c = Fixed("tenancy", dict(&[("c", Value::from(3i64))]));
let layers: [&dyn DiscoveryLayer; 3] = [&a, &b, &c];
assert_eq!(
contributor_names_iter(&layers).next(),
Some("platform"),
".next() yields the first contributor without walking the rest",
);
}
#[test]
fn contributor_names_iter_return_type_is_nameable_contributor_names_iter() {
struct HoldsContributorNames<'a> {
iter: ContributorNamesIter<'a>,
}
let a = Fixed("platform", dict(&[("a", Value::from(1i64))]));
let b = Fixed("cloud", Dict::new());
let c = Fixed("tenancy", dict(&[("c", Value::from(3i64))]));
let layers: [&dyn DiscoveryLayer; 3] = [&a, &b, &c];
let held = HoldsContributorNames {
iter: contributor_names_iter(&layers),
};
let out: Vec<&'static str> = held.iter.collect();
assert_eq!(out, vec!["platform", "tenancy"]);
}
#[test]
fn contributor_names_iter_clone_preserves_static_traits() {
fn requires_full_traits<I>(_it: &I)
where
I: Iterator + DoubleEndedIterator + std::iter::FusedIterator + Clone,
{
}
let a = Fixed("platform", dict(&[("a", Value::from(1i64))]));
let b = Fixed("cloud", Dict::new());
let c = Fixed("tenancy", dict(&[("c", Value::from(3i64))]));
let layers: [&dyn DiscoveryLayer; 3] = [&a, &b, &c];
let it: ContributorNamesIter<'_> = contributor_names_iter(&layers);
requires_full_traits(&it);
let clone = it.clone();
let via_original: Vec<&'static str> = it.collect();
let via_clone: Vec<&'static str> = clone.collect();
assert_eq!(
via_original, via_clone,
"cloned handle walks the same contributor stream",
);
}
#[test]
fn contributor_names_iter_next_back_walks_specific_to_coarse() {
let a = Fixed("platform", dict(&[("a", Value::from(1i64))]));
let quiet = Fixed("cloud", Dict::new());
let c = Fixed("tenancy", dict(&[("c", Value::from(3i64))]));
let tail_quiet = Fixed("aftermath", Dict::new());
let layers: [&dyn DiscoveryLayer; 4] = [&a, &quiet, &c, &tail_quiet];
let mut it = contributor_names_iter(&layers);
assert_eq!(
it.next_back(),
Some("tenancy"),
"tail silent 'aftermath' is skipped and 'tenancy' is the first reverse yield",
);
assert_eq!(
it.next_back(),
Some("platform"),
"mid silent 'cloud' is skipped and 'platform' is next in reverse",
);
assert!(
it.next_back().is_none(),
"both remaining cursor ends have been swept by next_back",
);
}
#[test]
fn contributor_names_iter_debug_impl_omits_layers_handle() {
let a = Fixed("platform", dict(&[("a", Value::from(1i64))]));
let b = Fixed("cloud", Dict::new());
let c = Fixed("tenancy", dict(&[("c", Value::from(3i64))]));
let layers: [&dyn DiscoveryLayer; 3] = [&a, &b, &c];
let it: ContributorNamesIter<'_> = contributor_names_iter(&layers);
let rendered = format!("{it:?}");
assert!(
rendered.starts_with("ContributorNamesIter"),
"Debug names the concrete struct: {rendered}",
);
assert!(
rendered.contains("layers_remaining"),
"Debug reports the remaining layer count: {rendered}",
);
assert!(
rendered.contains('3'),
"Debug reports the initial cursor length: {rendered}",
);
}
#[test]
fn nonempty_layer_dicts_filters_empty_layers_and_carries_the_dicts() {
let a_dict = dict(&[("k", Value::from(1i64)), ("side", Value::from("A"))]);
let c_dict = dict(&[("k", Value::from(2i64))]);
let a = Fixed("platform", a_dict.clone());
let b = Fixed("undetectable", Dict::new());
let c = Fixed("tenancy", c_dict.clone());
assert_eq!(
nonempty_layer_dicts(&[&a, &b, &c]),
vec![("platform", a_dict), ("tenancy", c_dict)],
);
}
#[test]
fn nonempty_layer_dicts_preserves_application_order() {
let a = Fixed("tenancy", dict(&[("k", Value::from(1i64))]));
let b = Fixed("platform", dict(&[("k", Value::from(2i64))]));
let names: Vec<&'static str> = nonempty_layer_dicts(&[&a, &b])
.iter()
.map(|(n, _)| *n)
.collect();
assert_eq!(names, vec!["tenancy", "platform"]);
}
#[test]
fn nonempty_layer_dicts_empty_when_no_layers() {
assert!(nonempty_layer_dicts(&[]).is_empty());
}
#[test]
fn nonempty_layer_dicts_empty_when_all_layers_undetectable() {
let a = Fixed("a", Dict::new());
let b = Fixed("b", Dict::new());
assert!(nonempty_layer_dicts(&[&a, &b]).is_empty());
}
#[test]
fn nonempty_layer_dicts_projects_to_contributor_names() {
let a = Fixed("platform", dict(&[("k", Value::from(1i64))]));
let b = Fixed("undetectable", Dict::new());
let c = Fixed("tenancy", dict(&[("k", Value::from(2i64))]));
let layers: [&dyn DiscoveryLayer; 3] = [&a, &b, &c];
let derived: Vec<&'static str> = nonempty_layer_dicts(&layers)
.into_iter()
.map(|(n, _)| n)
.collect();
assert_eq!(derived, contributor_names(&layers));
}
#[test]
fn nonempty_layer_dicts_projects_to_compose_via_deep_merge() {
let coarse = Fixed(
"platform",
dict(&[
("setpoint", Value::from(0.80)),
("floor", Value::from("256Mi")),
]),
);
let mid = Fixed("undetectable", Dict::new());
let specific = Fixed("tenancy", dict(&[("setpoint", Value::from(0.70))]));
let layers: [&dyn DiscoveryLayer; 3] = [&coarse, &mid, &specific];
let mut derived = Dict::new();
for (_, d) in nonempty_layer_dicts(&layers) {
deep_merge(&mut derived, d);
}
assert_eq!(derived, compose(&layers), "fold(deep_merge) == compose");
assert_eq!(derived.get("setpoint"), Some(&Value::from(0.70)));
assert_eq!(derived.get("floor"), Some(&Value::from("256Mi")));
}
#[test]
fn nonempty_layer_dicts_length_equals_contributor_names_length() {
let a = Fixed("a", dict(&[("k", Value::from(1i64))]));
let b = Fixed("b", Dict::new());
let c = Fixed("c", dict(&[("k", Value::from(2i64))]));
let layers: [&dyn DiscoveryLayer; 3] = [&a, &b, &c];
assert_eq!(
nonempty_layer_dicts(&layers).len(),
contributor_names(&layers).len()
);
}
#[test]
fn nonempty_layer_dicts_carries_overridden_writers_dicts_unchanged() {
let coarse_dict = dict(&[("setpoint", Value::from(0.80))]);
let specific_dict = dict(&[("setpoint", Value::from(0.70))]);
let coarse = Fixed("platform", coarse_dict.clone());
let specific = Fixed("tenancy", specific_dict.clone());
assert_eq!(
nonempty_layer_dicts(&[&coarse, &specific]),
vec![("platform", coarse_dict), ("tenancy", specific_dict)],
);
}
#[test]
fn nonempty_layer_dicts_iter_collect_matches_nonempty_layer_dicts() {
let a_dict = dict(&[("k", Value::from(1i64)), ("side", Value::from("A"))]);
let c_dict = dict(&[("k", Value::from(2i64))]);
let a = Fixed("platform", a_dict);
let quiet = Fixed("undetectable", Dict::new());
let c = Fixed("tenancy", c_dict);
let layers: [&dyn DiscoveryLayer; 3] = [&a, &quiet, &c];
assert_eq!(
nonempty_layer_dicts_iter(&layers).collect::<Vec<_>>(),
nonempty_layer_dicts(&layers),
"iter → Vec matches nonempty_layer_dicts verbatim",
);
}
#[test]
fn nonempty_layer_dicts_iter_empty_stack_is_empty_stream() {
let layers: [&dyn DiscoveryLayer; 0] = [];
assert!(
nonempty_layer_dicts_iter(&layers).next().is_none(),
"no layers → no pairs",
);
}
#[test]
fn nonempty_layer_dicts_iter_all_undetectable_is_empty_stream() {
let a = Fixed("platform", Dict::new());
let b = Fixed("cloud", Dict::new());
let layers: [&dyn DiscoveryLayer; 2] = [&a, &b];
assert!(
nonempty_layer_dicts_iter(&layers).next().is_none(),
"every axis silent → the stream is empty",
);
}
#[test]
fn nonempty_layer_dicts_iter_preserves_application_order() {
let a = Fixed("tenancy", dict(&[("k", Value::from(1i64))]));
let b = Fixed("platform", dict(&[("k", Value::from(2i64))]));
let layers: [&dyn DiscoveryLayer; 2] = [&a, &b];
let names: Vec<&'static str> = nonempty_layer_dicts_iter(&layers).map(|(n, _)| n).collect();
assert_eq!(names, vec!["tenancy", "platform"]);
}
#[test]
fn nonempty_layer_dicts_iter_rev_reverses_forward_walk() {
let a = Fixed("platform", dict(&[("a", Value::from(1i64))]));
let quiet = Fixed("cloud", Dict::new());
let c = Fixed("tenancy", dict(&[("c", Value::from(3i64))]));
let layers: [&dyn DiscoveryLayer; 3] = [&a, &quiet, &c];
let forward = nonempty_layer_dicts_iter(&layers).collect::<Vec<_>>();
let reverse = nonempty_layer_dicts_iter(&layers).rev().collect::<Vec<_>>();
assert_eq!(
reverse,
forward.iter().rev().cloned().collect::<Vec<_>>(),
".rev() over the iter recovers the reverse of the forward walk",
);
}
#[test]
fn nonempty_layer_dicts_iter_clone_yields_independent_walks() {
let a = Fixed("platform", dict(&[("a", Value::from(1i64))]));
let quiet = Fixed("cloud", Dict::new());
let c = Fixed("tenancy", dict(&[("c", Value::from(3i64))]));
let layers: [&dyn DiscoveryLayer; 3] = [&a, &quiet, &c];
let one = nonempty_layer_dicts_iter(&layers);
let two = one.clone();
assert_eq!(
one.collect::<Vec<_>>(),
two.collect::<Vec<_>>(),
"two independent walks agree",
);
}
#[test]
fn nonempty_layer_dicts_iter_is_fused_past_exhaustion() {
let a = Fixed("platform", dict(&[("k", Value::from(1i64))]));
let layers: [&dyn DiscoveryLayer; 1] = [&a];
let mut it = nonempty_layer_dicts_iter(&layers);
assert_eq!(it.next().map(|(n, _)| n), Some("platform"));
for _ in 0..4 {
assert!(it.next().is_none(), "post-exhaustion pulls stay None");
}
}
#[test]
fn nonempty_layer_dicts_iter_head_short_circuits_without_full_sweep() {
let a_dict = dict(&[("a", Value::from(1i64))]);
let b_dict = dict(&[("b", Value::from(2i64))]);
let c_dict = dict(&[("c", Value::from(3i64))]);
let a = Fixed("platform", a_dict.clone());
let b = Fixed("cloud", b_dict);
let c = Fixed("tenancy", c_dict);
let layers: [&dyn DiscoveryLayer; 3] = [&a, &b, &c];
assert_eq!(
nonempty_layer_dicts_iter(&layers).next(),
Some(("platform", a_dict)),
".next() yields the first contributor's (name, dict) without walking the rest",
);
}
#[test]
fn nonempty_layer_dicts_iter_names_project_to_contributor_names_iter() {
let a = Fixed("platform", dict(&[("a", Value::from(1i64))]));
let quiet = Fixed("cloud", Dict::new());
let c = Fixed("tenancy", dict(&[("c", Value::from(3i64))]));
let layers: [&dyn DiscoveryLayer; 3] = [&a, &quiet, &c];
let via_pair: Vec<&'static str> =
nonempty_layer_dicts_iter(&layers).map(|(n, _)| n).collect();
let via_name: Vec<&'static str> = contributor_names_iter(&layers).collect();
assert_eq!(
via_pair, via_name,
"map(first) over the pair iter recovers contributor_names_iter",
);
}
#[test]
fn nonempty_layer_dicts_iter_fold_deep_merge_matches_compose() {
let coarse = Fixed(
"platform",
dict(&[
("setpoint", Value::from(0.80)),
("floor", Value::from("256Mi")),
]),
);
let mid = Fixed("undetectable", Dict::new());
let specific = Fixed("tenancy", dict(&[("setpoint", Value::from(0.70))]));
let layers: [&dyn DiscoveryLayer; 3] = [&coarse, &mid, &specific];
let derived: Dict =
nonempty_layer_dicts_iter(&layers).fold(Dict::new(), |mut acc, (_, d)| {
deep_merge(&mut acc, d);
acc
});
assert_eq!(derived, compose(&layers), "fold(deep_merge) == compose");
assert_eq!(derived.get("setpoint"), Some(&Value::from(0.70)));
assert_eq!(derived.get("floor"), Some(&Value::from("256Mi")));
}
#[test]
fn nonempty_layer_dicts_iter_count_matches_contributor_count() {
let a = Fixed("platform", dict(&[("k", Value::from(1i64))]));
let quiet = Fixed("undetectable", Dict::new());
let c = Fixed("tenancy", dict(&[("k", Value::from(2i64))]));
let layers: [&dyn DiscoveryLayer; 3] = [&a, &quiet, &c];
assert_eq!(
nonempty_layer_dicts_iter(&layers).count(),
contributor_count(&layers),
".count() on the pair iter matches the scalar contributor_count",
);
}
#[test]
fn nonempty_layer_dicts_iter_return_type_is_nameable_nonempty_layer_dicts_iter() {
struct HoldsPairs<'a> {
iter: NonemptyLayerDictsIter<'a>,
}
let a = Fixed("platform", dict(&[("a", Value::from(1i64))]));
let quiet = Fixed("cloud", Dict::new());
let c = Fixed("tenancy", dict(&[("c", Value::from(3i64))]));
let layers: [&dyn DiscoveryLayer; 3] = [&a, &quiet, &c];
let held = HoldsPairs {
iter: nonempty_layer_dicts_iter(&layers),
};
let names: Vec<&'static str> = held.iter.map(|(n, _)| n).collect();
assert_eq!(names, vec!["platform", "tenancy"]);
}
#[test]
fn nonempty_layer_dicts_iter_clone_preserves_static_traits() {
fn requires_full_traits<I>(_it: &I)
where
I: Iterator + DoubleEndedIterator + std::iter::FusedIterator + Clone,
{
}
let a = Fixed("platform", dict(&[("a", Value::from(1i64))]));
let quiet = Fixed("cloud", Dict::new());
let c = Fixed("tenancy", dict(&[("c", Value::from(3i64))]));
let layers: [&dyn DiscoveryLayer; 3] = [&a, &quiet, &c];
let it: NonemptyLayerDictsIter<'_> = nonempty_layer_dicts_iter(&layers);
requires_full_traits(&it);
let clone = it.clone();
let via_original: Vec<(&'static str, Dict)> = it.collect();
let via_clone: Vec<(&'static str, Dict)> = clone.collect();
assert_eq!(
via_original, via_clone,
"cloned handle walks the same (name, dict) pair stream",
);
}
#[test]
fn nonempty_layer_dicts_iter_next_back_walks_specific_to_coarse() {
let a = Fixed("platform", dict(&[("a", Value::from(1i64))]));
let quiet = Fixed("cloud", Dict::new());
let c_dict = dict(&[("c", Value::from(3i64))]);
let c = Fixed("tenancy", c_dict.clone());
let tail_quiet = Fixed("aftermath", Dict::new());
let layers: [&dyn DiscoveryLayer; 4] = [&a, &quiet, &c, &tail_quiet];
let mut it = nonempty_layer_dicts_iter(&layers);
assert_eq!(
it.next_back(),
Some(("tenancy", c_dict)),
"tail silent 'aftermath' skipped; 'tenancy' is the first reverse yield",
);
assert_eq!(
it.next_back().map(|(n, _)| n),
Some("platform"),
"mid silent 'cloud' skipped; 'platform' is next in reverse",
);
assert!(
it.next_back().is_none(),
"both remaining cursor ends have been swept by next_back",
);
}
#[test]
fn nonempty_layer_dicts_iter_debug_impl_omits_layers_handle() {
let a = Fixed("platform", dict(&[("a", Value::from(1i64))]));
let b = Fixed("cloud", Dict::new());
let c = Fixed("tenancy", dict(&[("c", Value::from(3i64))]));
let layers: [&dyn DiscoveryLayer; 3] = [&a, &b, &c];
let it: NonemptyLayerDictsIter<'_> = nonempty_layer_dicts_iter(&layers);
let rendered = format!("{it:?}");
assert!(
rendered.starts_with("NonemptyLayerDictsIter"),
"Debug names the concrete struct: {rendered}",
);
assert!(
rendered.contains("layers_remaining"),
"Debug reports the remaining layer count: {rendered}",
);
assert!(
rendered.contains('3'),
"Debug reports the initial cursor length: {rendered}",
);
}
#[test]
fn surviving_layer_names_lists_layers_with_live_leaves() {
let a = Fixed(
"platform",
dict(&[("k1", Value::from(1i64)), ("k2", Value::from(2i64))]),
);
let b = Fixed(
"tenancy",
dict(&[("k2", Value::from(20i64)), ("k3", Value::from(3i64))]),
);
let out = compose_with_provenance(&[&a, &b]);
assert_eq!(
out.attribution.surviving_layer_names(),
vec!["platform", "tenancy"],
"both writers survive; result sorted lex on layer name",
);
}
#[test]
fn surviving_layer_names_lex_order_regardless_of_application_order() {
let a = Fixed("Z", dict(&[("z", Value::from(1i64))]));
let b = Fixed(
"A",
dict(&[
("a", Value::from(dict(&[("y", Value::from(2i64))]))),
("m", Value::from(3i64)),
]),
);
let out = compose_with_provenance(&[&a, &b]);
assert_eq!(
out.attribution.surviving_layer_names(),
vec!["A", "Z"],
"lex order, not application order",
);
}
#[test]
fn surviving_layer_names_drops_wholly_overridden_writer() {
let coarse = Fixed("coarse", dict(&[("setpoint", Value::from(0.80))]));
let specific = Fixed("specific", dict(&[("setpoint", Value::from(0.70))]));
let out = compose_with_provenance(&[&coarse, &specific]);
assert_eq!(
out.attribution.surviving_layer_names(),
vec!["specific"],
"wholly-overridden writer drops off the surviving axis",
);
assert_eq!(
contributor_names(&[&coarse, &specific]),
vec!["coarse", "specific"],
"pre-merge contributor_names still lists the overridden writer",
);
}
#[test]
fn surviving_layer_names_drops_writer_purged_by_dict_over_scalar() {
let a = Fixed("first", dict(&[("x", Value::from(1i64))]));
let b = Fixed(
"second",
dict(&[("x", Value::from(dict(&[("y", Value::from(2i64))])))]),
);
let out = compose_with_provenance(&[&a, &b]);
assert_eq!(
out.attribution.surviving_layer_names(),
vec!["second"],
"dict-over-scalar reshape purges A's only leaf",
);
}
#[test]
fn surviving_layer_names_empty_when_no_leaves() {
let empty = compose_with_provenance(&[]);
assert!(empty.attribution.surviving_layer_names().is_empty());
let a_empty = Fixed("a", Dict::new());
let b_empty = Fixed("b", Dict::new());
let out = compose_with_provenance(&[&a_empty, &b_empty]);
assert!(
out.attribution.surviving_layer_names().is_empty(),
"empty-only stack ⇒ no surviving writers",
);
}
#[test]
fn surviving_layer_names_agrees_with_writes_by_layer_keys() {
let a = Fixed("Z", dict(&[("z", Value::from(1i64))]));
let b = Fixed(
"A",
dict(&[
("a", Value::from(dict(&[("y", Value::from(2i64))]))),
("m", Value::from(3i64)),
]),
);
let c = Fixed("M", dict(&[("q", Value::from(4i64))]));
let out = compose_with_provenance(&[&a, &b, &c]);
let via_wide: Vec<&'static str> = out.attribution.writes_by_layer().into_keys().collect();
assert_eq!(
out.attribution.surviving_layer_names(),
via_wide,
"compact and wide seams share the outer key set verbatim",
);
assert_eq!(
out.attribution.surviving_layer_names().len(),
out.attribution.writes_by_layer().len(),
);
}
#[test]
fn surviving_layer_names_agrees_with_leaf_counts_by_layer_keys() {
let a = Fixed(
"platform",
dict(&[("k1", Value::from(1i64)), ("k2", Value::from(2i64))]),
);
let b = Fixed(
"tenancy",
dict(&[("k2", Value::from(20i64)), ("k3", Value::from(3i64))]),
);
let out = compose_with_provenance(&[&a, &b]);
let via_counts: Vec<&'static str> =
out.attribution.leaf_counts_by_layer().into_keys().collect();
assert_eq!(
out.attribution.surviving_layer_names(),
via_counts,
"compact and count seams share the outer key set verbatim",
);
assert_eq!(
out.attribution.surviving_layer_names().len(),
out.attribution.leaf_counts_by_layer().len(),
);
}
#[test]
fn surviving_layer_names_subset_of_contributor_names() {
let coarse = Fixed("coarse", dict(&[("setpoint", Value::from(0.80))]));
let specific = Fixed("specific", dict(&[("setpoint", Value::from(0.70))]));
let empty = Fixed("undetectable", Dict::new());
let layers: [&dyn DiscoveryLayer; 3] = [&coarse, &specific, &empty];
let all: std::collections::BTreeSet<_> = layer_names(&layers).into_iter().collect();
let contribs: std::collections::BTreeSet<_> =
contributor_names(&layers).into_iter().collect();
let survivors: std::collections::BTreeSet<_> = compose_with_provenance(&layers)
.attribution
.surviving_layer_names()
.into_iter()
.collect();
assert!(survivors.is_subset(&contribs), "survivors ⊆ contributors");
assert!(contribs.is_subset(&all), "contributors ⊆ declared names");
assert!(
survivors.len() < contribs.len(),
"coarse wholly overridden ⇒ strict subset on this fixture",
);
assert!(
contribs.len() < all.len(),
"the undetectable layer is filtered from contributors but not from declared names",
);
}
#[test]
fn surviving_layer_names_coincides_with_contributor_names_when_no_writer_overridden() {
let a = Fixed("A", dict(&[("k1", Value::from(1i64))]));
let b = Fixed("B", dict(&[("k2", Value::from(2i64))]));
let c = Fixed("C", dict(&[("k3", Value::from(3i64))]));
let layers: [&dyn DiscoveryLayer; 3] = [&a, &b, &c];
let contribs: std::collections::BTreeSet<_> =
contributor_names(&layers).into_iter().collect();
let survivors: std::collections::BTreeSet<_> = compose_with_provenance(&layers)
.attribution
.surviving_layer_names()
.into_iter()
.collect();
assert_eq!(
survivors, contribs,
"no writer overridden ⇒ survivors and contributors agree as sets",
);
}
#[test]
fn surviving_layer_names_iter_collect_matches_surviving_layer_names() {
let z = Fixed("Z", dict(&[("path_first", Value::from(1i64))]));
let a = Fixed(
"A",
dict(&[
("a", Value::from(dict(&[("y", Value::from(2i64))]))),
("m", Value::from(3i64)),
]),
);
let m = Fixed("M", dict(&[("q", Value::from(4i64))]));
let out = compose_with_provenance(&[&z, &a, &m]);
assert_eq!(
out.attribution
.surviving_layer_names_iter()
.collect::<Vec<_>>(),
out.attribution.surviving_layer_names(),
"iter dual collects to the same Vec as the collecting form",
);
}
#[test]
fn surviving_layer_names_iter_empty_attribution_is_empty_stream() {
let empty = compose_with_provenance(&[]);
let iter = empty.attribution.surviving_layer_names_iter();
assert_eq!(iter.len(), 0);
assert_eq!(iter.size_hint(), (0, Some(0)));
assert_eq!(
empty
.attribution
.surviving_layer_names_iter()
.collect::<Vec<_>>(),
Vec::<&'static str>::new(),
);
}
#[test]
fn surviving_layer_names_iter_len_equals_distinct_writer_count() {
let a = Fixed("platform", dict(&[("k1", Value::from(1i64))]));
let b = Fixed(
"tenancy",
dict(&[("k2", Value::from(2i64)), ("k3", Value::from(3i64))]),
);
let out = compose_with_provenance(&[&a, &b]);
let iter = out.attribution.surviving_layer_names_iter();
let expected = out.attribution.surviving_layer_names().len();
assert_eq!(iter.len(), expected);
assert_eq!(iter.size_hint(), (expected, Some(expected)));
}
#[test]
fn surviving_layer_names_iter_yields_lex_order() {
let z = Fixed("Z", dict(&[("z", Value::from(1i64))]));
let a = Fixed("A", dict(&[("a", Value::from(2i64))]));
let m = Fixed("M", dict(&[("m", Value::from(3i64))]));
let out = compose_with_provenance(&[&z, &a, &m]);
let seq: Vec<_> = out.attribution.surviving_layer_names_iter().collect();
assert_eq!(seq, vec!["A", "M", "Z"]);
}
#[test]
fn surviving_layer_names_iter_rev_matches_iter_reversed() {
let z = Fixed("Z", dict(&[("z", Value::from(1i64))]));
let a = Fixed("A", dict(&[("a", Value::from(2i64))]));
let m = Fixed("M", dict(&[("m", Value::from(3i64))]));
let out = compose_with_provenance(&[&z, &a, &m]);
let forward = out.attribution.surviving_layer_names();
let mut expected = forward.clone();
expected.reverse();
assert_eq!(
out.attribution
.surviving_layer_names_iter()
.rev()
.collect::<Vec<_>>(),
expected,
);
}
#[test]
fn surviving_layer_names_iter_last_matches_reverse_head() {
let z = Fixed("Z", dict(&[("z", Value::from(1i64))]));
let a = Fixed("A", dict(&[("a", Value::from(2i64))]));
let m = Fixed("M", dict(&[("m", Value::from(3i64))]));
let out = compose_with_provenance(&[&z, &a, &m]);
assert_eq!(
out.attribution.surviving_layer_names_iter().last(),
out.attribution.surviving_layer_names().last().copied(),
);
}
#[test]
fn surviving_layer_names_iter_head_short_circuits_to_lex_first() {
let z = Fixed("Z", dict(&[("z", Value::from(1i64))]));
let a = Fixed("A", dict(&[("a", Value::from(2i64))]));
let out = compose_with_provenance(&[&z, &a]);
assert_eq!(
out.attribution.surviving_layer_names_iter().next(),
Some("A"),
);
}
#[test]
fn surviving_layer_names_iter_dedups_duplicate_writes_at_writer_altitude() {
let a = Fixed(
"solo",
dict(&[("k1", Value::from(1i64)), ("k2", Value::from(2i64))]),
);
let out = compose_with_provenance(&[&a]);
assert_eq!(
out.attribution
.surviving_layer_names_iter()
.collect::<Vec<_>>(),
vec!["solo"],
);
assert_eq!(out.attribution.surviving_layer_names_iter().count(), 1);
}
#[test]
fn surviving_layer_names_iter_fused_after_exhaustion() {
let a = Fixed("only", dict(&[("k", Value::from(1i64))]));
let out = compose_with_provenance(&[&a]);
let mut iter = out.attribution.surviving_layer_names_iter();
assert_eq!(iter.next(), Some("only"));
assert_eq!(iter.next(), None);
assert_eq!(iter.next(), None);
assert_eq!(iter.next(), None);
}
#[test]
fn leaf_counts_by_layer_iter_collect_matches_leaf_counts_by_layer() {
let z = Fixed(
"Z",
dict(&[
("path_first", Value::from(1i64)),
("z_leaf", Value::from(9i64)),
]),
);
let a = Fixed(
"A",
dict(&[
("a", Value::from(dict(&[("y", Value::from(2i64))]))),
("m", Value::from(3i64)),
]),
);
let m = Fixed("M", dict(&[("q", Value::from(4i64))]));
let out = compose_with_provenance(&[&z, &a, &m]);
assert_eq!(
out.attribution
.leaf_counts_by_layer_iter()
.collect::<BTreeMap<_, _>>(),
out.attribution.leaf_counts_by_layer(),
"iter dual collects to the same BTreeMap as the collecting form",
);
}
#[test]
fn leaf_counts_by_layer_iter_empty_attribution_is_empty_stream() {
let empty = compose_with_provenance(&[]);
let iter = empty.attribution.leaf_counts_by_layer_iter();
assert_eq!(iter.len(), 0);
assert_eq!(iter.size_hint(), (0, Some(0)));
assert_eq!(
empty
.attribution
.leaf_counts_by_layer_iter()
.collect::<Vec<_>>(),
Vec::<(&'static str, usize)>::new(),
);
}
#[test]
fn leaf_counts_by_layer_iter_len_equals_distinct_writer_count() {
let a = Fixed("platform", dict(&[("k1", Value::from(1i64))]));
let b = Fixed(
"tenancy",
dict(&[("k2", Value::from(2i64)), ("k3", Value::from(3i64))]),
);
let out = compose_with_provenance(&[&a, &b]);
let iter = out.attribution.leaf_counts_by_layer_iter();
let expected = out.attribution.leaf_counts_by_layer().len();
assert_eq!(iter.len(), expected);
assert_eq!(iter.size_hint(), (expected, Some(expected)));
}
#[test]
fn leaf_counts_by_layer_iter_yields_lex_order_on_layer_name() {
let z = Fixed("Z", dict(&[("z", Value::from(1i64))]));
let a = Fixed(
"A",
dict(&[("a1", Value::from(2i64)), ("a2", Value::from(3i64))]),
);
let m = Fixed("M", dict(&[("m", Value::from(4i64))]));
let out = compose_with_provenance(&[&z, &a, &m]);
let seq: Vec<_> = out.attribution.leaf_counts_by_layer_iter().collect();
assert_eq!(seq, vec![("A", 2), ("M", 1), ("Z", 1)]);
}
#[test]
fn leaf_counts_by_layer_iter_next_is_first_lex_name_entry() {
let z = Fixed("Z", dict(&[("z", Value::from(1i64))]));
let a = Fixed(
"A",
dict(&[("a", Value::from(2i64)), ("b", Value::from(3i64))]),
);
let out = compose_with_provenance(&[&z, &a]);
assert_eq!(
out.attribution.leaf_counts_by_layer_iter().next(),
Some(("A", 2)),
);
}
#[test]
fn leaf_counts_by_layer_iter_next_back_is_last_lex_name_entry() {
let z = Fixed("Z", dict(&[("z", Value::from(1i64))]));
let a = Fixed(
"A",
dict(&[("a", Value::from(2i64)), ("b", Value::from(3i64))]),
);
let out = compose_with_provenance(&[&z, &a]);
let tail = out.attribution.leaf_counts_by_layer_iter().next_back();
assert_eq!(tail, Some(("Z", 1)));
assert_eq!(out.attribution.leaf_counts_by_layer_iter().last(), tail);
}
#[test]
fn leaf_counts_by_layer_iter_rev_matches_iter_reversed() {
let z = Fixed("Z", dict(&[("z", Value::from(1i64))]));
let a = Fixed("A", dict(&[("a", Value::from(2i64))]));
let m = Fixed("M", dict(&[("m", Value::from(3i64))]));
let out = compose_with_provenance(&[&z, &a, &m]);
let mut expected: Vec<(&'static str, usize)> =
out.attribution.leaf_counts_by_layer().into_iter().collect();
expected.reverse();
assert_eq!(
out.attribution
.leaf_counts_by_layer_iter()
.rev()
.collect::<Vec<_>>(),
expected,
);
}
#[test]
fn leaf_counts_by_layer_iter_names_match_surviving_layer_names_iter() {
let z = Fixed("Z", dict(&[("z", Value::from(1i64))]));
let a = Fixed(
"A",
dict(&[("a", Value::from(2i64)), ("b", Value::from(3i64))]),
);
let m = Fixed("M", dict(&[("m", Value::from(4i64))]));
let out = compose_with_provenance(&[&z, &a, &m]);
let via_counts: Vec<&'static str> = out
.attribution
.leaf_counts_by_layer_iter()
.map(|(n, _)| n)
.collect();
let via_names: Vec<&'static str> = out.attribution.surviving_layer_names_iter().collect();
assert_eq!(via_counts, via_names);
}
#[test]
fn leaf_counts_by_layer_iter_counts_sum_to_len() {
let z = Fixed("Z", dict(&[("z", Value::from(1i64))]));
let a = Fixed(
"A",
dict(&[("a", Value::from(2i64)), ("b", Value::from(3i64))]),
);
let m = Fixed("M", dict(&[("m", Value::from(4i64))]));
let out = compose_with_provenance(&[&z, &a, &m]);
let total: usize = out
.attribution
.leaf_counts_by_layer_iter()
.map(|(_, c)| c)
.sum();
assert_eq!(total, out.attribution.len());
}
#[test]
fn leaf_counts_by_layer_iter_take_short_circuits_at_lex_prefix() {
let z = Fixed("Z", dict(&[("z", Value::from(1i64))]));
let a = Fixed("A", dict(&[("a", Value::from(2i64))]));
let m = Fixed("M", dict(&[("m", Value::from(3i64))]));
let out = compose_with_provenance(&[&z, &a, &m]);
let full: Vec<(&'static str, usize)> =
out.attribution.leaf_counts_by_layer().into_iter().collect();
for k in 0..=full.len() {
let via_iter: Vec<_> = out
.attribution
.leaf_counts_by_layer_iter()
.take(k)
.collect();
assert_eq!(via_iter, full[..k].to_vec(), "top-{k} lex slice");
}
}
#[test]
fn leaf_counts_by_layer_iter_fused_after_exhaustion() {
let a = Fixed("only", dict(&[("k", Value::from(1i64))]));
let out = compose_with_provenance(&[&a]);
let mut iter = out.attribution.leaf_counts_by_layer_iter();
assert_eq!(iter.next(), Some(("only", 1)));
assert_eq!(iter.next(), None);
assert_eq!(iter.next(), None);
assert_eq!(iter.next(), None);
}
#[test]
fn writes_by_layer_iter_collect_matches_writes_by_layer() {
let z = Fixed(
"Z",
dict(&[
("path_first", Value::from(1i64)),
("z_leaf", Value::from(9i64)),
]),
);
let a = Fixed(
"A",
dict(&[
("a", Value::from(dict(&[("y", Value::from(2i64))]))),
("m", Value::from(3i64)),
]),
);
let m = Fixed("M", dict(&[("q", Value::from(4i64))]));
let out = compose_with_provenance(&[&z, &a, &m]);
assert_eq!(
out.attribution
.writes_by_layer_iter()
.collect::<BTreeMap<_, _>>(),
out.attribution.writes_by_layer(),
"iter dual collects to the same BTreeMap as the collecting form",
);
}
#[test]
fn writes_by_layer_iter_empty_attribution_is_empty_stream() {
let empty = compose_with_provenance(&[]);
let iter = empty.attribution.writes_by_layer_iter();
assert_eq!(iter.len(), 0);
assert_eq!(iter.size_hint(), (0, Some(0)));
assert!(
empty.attribution.writes_by_layer_iter().next().is_none(),
"no leaves ⇒ empty stream",
);
}
#[test]
fn writes_by_layer_iter_len_equals_distinct_writer_count() {
let a = Fixed("platform", dict(&[("k1", Value::from(1i64))]));
let b = Fixed(
"tenancy",
dict(&[("k2", Value::from(2i64)), ("k3", Value::from(3i64))]),
);
let out = compose_with_provenance(&[&a, &b]);
let iter = out.attribution.writes_by_layer_iter();
let expected = out.attribution.writes_by_layer().len();
assert_eq!(iter.len(), expected);
assert_eq!(iter.size_hint(), (expected, Some(expected)));
}
#[test]
fn writes_by_layer_iter_yields_lex_order_on_layer_name() {
let z = Fixed("Z", dict(&[("z", Value::from(1i64))]));
let a = Fixed(
"A",
dict(&[
("a", Value::from(dict(&[("y", Value::from(2i64))]))),
("m", Value::from(3i64)),
]),
);
let m = Fixed("M", dict(&[("q", Value::from(4i64))]));
let out = compose_with_provenance(&[&z, &a, &m]);
let names: Vec<&'static str> = out
.attribution
.writes_by_layer_iter()
.map(|(n, _)| n)
.collect();
assert_eq!(names, vec!["A", "M", "Z"]);
let paths_for_a: Vec<&[String]> = out
.attribution
.writes_by_layer_iter()
.find(|(n, _)| *n == "A")
.expect("A bucket")
.1;
assert_eq!(
paths_for_a,
vec![
["a".to_owned(), "y".to_owned()].as_slice(),
["m".to_owned()].as_slice(),
],
"per-bucket paths land in lex path order",
);
}
#[test]
fn writes_by_layer_iter_next_is_first_lex_name_bucket() {
let z = Fixed("Z", dict(&[("z", Value::from(1i64))]));
let a = Fixed(
"A",
dict(&[("a", Value::from(2i64)), ("b", Value::from(3i64))]),
);
let out = compose_with_provenance(&[&z, &a]);
let head = out.attribution.writes_by_layer_iter().next();
assert_eq!(
head,
Some((
"A",
vec![["a".to_owned()].as_slice(), ["b".to_owned()].as_slice(),],
)),
);
}
#[test]
fn writes_by_layer_iter_next_back_is_last_lex_name_bucket() {
let z = Fixed("Z", dict(&[("z", Value::from(1i64))]));
let a = Fixed(
"A",
dict(&[("a", Value::from(2i64)), ("b", Value::from(3i64))]),
);
let out = compose_with_provenance(&[&z, &a]);
let tail = out.attribution.writes_by_layer_iter().next_back();
assert_eq!(tail, Some(("Z", vec![["z".to_owned()].as_slice()])),);
assert_eq!(out.attribution.writes_by_layer_iter().last(), tail);
}
#[test]
fn writes_by_layer_iter_rev_matches_iter_reversed() {
let z = Fixed("Z", dict(&[("z", Value::from(1i64))]));
let a = Fixed("A", dict(&[("a", Value::from(2i64))]));
let m = Fixed("M", dict(&[("m", Value::from(3i64))]));
let out = compose_with_provenance(&[&z, &a, &m]);
let mut expected: Vec<(&'static str, Vec<&[String]>)> =
out.attribution.writes_by_layer().into_iter().collect();
expected.reverse();
assert_eq!(
out.attribution
.writes_by_layer_iter()
.rev()
.collect::<Vec<_>>(),
expected,
);
}
#[test]
fn writes_by_layer_iter_names_match_surviving_layer_names_iter() {
let z = Fixed("Z", dict(&[("z", Value::from(1i64))]));
let a = Fixed(
"A",
dict(&[("a", Value::from(2i64)), ("b", Value::from(3i64))]),
);
let m = Fixed("M", dict(&[("m", Value::from(4i64))]));
let out = compose_with_provenance(&[&z, &a, &m]);
let via_wide: Vec<&'static str> = out
.attribution
.writes_by_layer_iter()
.map(|(n, _)| n)
.collect();
let via_names: Vec<&'static str> = out.attribution.surviving_layer_names_iter().collect();
assert_eq!(via_wide, via_names);
}
#[test]
fn writes_by_layer_iter_bucket_sizes_match_leaf_counts_by_layer_iter() {
let z = Fixed("Z", dict(&[("z", Value::from(1i64))]));
let a = Fixed(
"A",
dict(&[("a", Value::from(2i64)), ("b", Value::from(3i64))]),
);
let m = Fixed("M", dict(&[("m", Value::from(4i64))]));
let out = compose_with_provenance(&[&z, &a, &m]);
let via_wide: Vec<(&'static str, usize)> = out
.attribution
.writes_by_layer_iter()
.map(|(n, ps)| (n, ps.len()))
.collect();
let via_counts: Vec<(&'static str, usize)> =
out.attribution.leaf_counts_by_layer_iter().collect();
assert_eq!(via_wide, via_counts);
}
#[test]
fn writes_by_layer_iter_paths_lens_sum_to_len() {
let z = Fixed("Z", dict(&[("z", Value::from(1i64))]));
let a = Fixed(
"A",
dict(&[("a", Value::from(2i64)), ("b", Value::from(3i64))]),
);
let m = Fixed("M", dict(&[("m", Value::from(4i64))]));
let out = compose_with_provenance(&[&z, &a, &m]);
let total: usize = out
.attribution
.writes_by_layer_iter()
.map(|(_, ps)| ps.len())
.sum();
assert_eq!(total, out.attribution.len());
}
#[test]
fn writes_by_layer_iter_fused_after_exhaustion() {
let a = Fixed("only", dict(&[("k", Value::from(1i64))]));
let out = compose_with_provenance(&[&a]);
let mut iter = out.attribution.writes_by_layer_iter();
assert_eq!(
iter.next(),
Some(("only", vec![["k".to_owned()].as_slice()])),
);
assert!(iter.next().is_none());
assert!(iter.next().is_none());
assert!(iter.next().is_none());
}
#[test]
fn subtree_writes_by_layer_iter_collect_matches_subtree_writes_by_layer() {
let out = subtree_fixture();
for prefix in [
vec![],
vec![s("breathe")],
vec![s("alpha")],
vec![s("nonexistent")],
] {
assert_eq!(
out.attribution
.subtree_writes_by_layer_iter(&prefix)
.collect::<BTreeMap<_, _>>(),
out.attribution.subtree_writes_by_layer(&prefix),
"iter dual collects to the same BTreeMap at {prefix:?}",
);
}
}
#[test]
fn subtree_writes_by_layer_iter_empty_prefix_matches_writes_by_layer_iter() {
let out = subtree_fixture();
let via_subtree: Vec<(&'static str, Vec<&[String]>)> =
out.attribution.subtree_writes_by_layer_iter(&[]).collect();
let via_top: Vec<(&'static str, Vec<&[String]>)> =
out.attribution.writes_by_layer_iter().collect();
assert_eq!(via_subtree, via_top);
}
#[test]
fn subtree_writes_by_layer_iter_missing_prefix_is_empty_stream() {
let out = subtree_fixture();
let prefix = vec![s("nonexistent")];
let iter = out.attribution.subtree_writes_by_layer_iter(&prefix);
assert_eq!(iter.len(), 0);
assert_eq!(iter.size_hint(), (0, Some(0)));
assert!(
out.attribution
.subtree_writes_by_layer_iter(&prefix)
.next()
.is_none(),
);
}
#[test]
fn subtree_writes_by_layer_iter_names_match_subtree_surviving_layer_names_iter() {
let out = subtree_fixture();
for prefix in [vec![], vec![s("breathe")], vec![s("alpha")]] {
let via_wide: Vec<&'static str> = out
.attribution
.subtree_writes_by_layer_iter(&prefix)
.map(|(n, _)| n)
.collect();
let via_names: Vec<&'static str> = out
.attribution
.subtree_surviving_layer_names_iter(&prefix)
.collect();
assert_eq!(via_wide, via_names, "at {prefix:?}");
}
}
#[test]
fn subtree_writes_by_layer_iter_bucket_sizes_match_subtree_leaf_counts_by_layer_iter() {
let out = subtree_fixture();
for prefix in [vec![], vec![s("breathe")], vec![s("alpha")]] {
let via_wide: Vec<(&'static str, usize)> = out
.attribution
.subtree_writes_by_layer_iter(&prefix)
.map(|(n, ps)| (n, ps.len()))
.collect();
let via_counts: Vec<(&'static str, usize)> = out
.attribution
.subtree_leaf_counts_by_layer_iter(&prefix)
.collect();
assert_eq!(via_wide, via_counts, "at {prefix:?}");
}
}
#[test]
fn subtree_writes_by_layer_iter_paths_lens_sum_to_subtree_iter_count() {
let out = subtree_fixture();
for prefix in [vec![], vec![s("breathe")], vec![s("alpha")]] {
let total: usize = out
.attribution
.subtree_writes_by_layer_iter(&prefix)
.map(|(_, ps)| ps.len())
.sum();
let expected = out.attribution.subtree_iter(&prefix).count();
assert_eq!(total, expected, "at {prefix:?}");
}
}
#[test]
fn subtree_leaf_counts_by_layer_iter_collect_matches_subtree_leaf_counts_by_layer() {
let out = subtree_fixture();
for prefix in [
vec![],
vec![s("breathe")],
vec![s("alpha")],
vec![s("nonexistent")],
] {
assert_eq!(
out.attribution
.subtree_leaf_counts_by_layer_iter(&prefix)
.collect::<BTreeMap<_, _>>(),
out.attribution.subtree_leaf_counts_by_layer(&prefix),
"iter dual collects to the same BTreeMap at {prefix:?}",
);
}
}
#[test]
fn subtree_leaf_counts_by_layer_iter_empty_prefix_matches_leaf_counts_by_layer_iter() {
for out in [subtree_fixture(), inversion_fixture(), layer_axis_fixture()] {
assert_eq!(
out.attribution
.subtree_leaf_counts_by_layer_iter(&[])
.collect::<Vec<_>>(),
out.attribution
.leaf_counts_by_layer_iter()
.collect::<Vec<_>>(),
);
}
}
#[test]
fn subtree_leaf_counts_by_layer_iter_empty_attribution_is_empty_stream() {
let empty = compose_with_provenance(&[]);
for prefix in [vec![], vec![s("any")], vec![s("nested"), s("under")]] {
let iter = empty.attribution.subtree_leaf_counts_by_layer_iter(&prefix);
assert_eq!(iter.len(), 0, "empty attribution at {prefix:?}");
assert_eq!(iter.size_hint(), (0, Some(0)));
assert_eq!(
empty
.attribution
.subtree_leaf_counts_by_layer_iter(&prefix)
.collect::<Vec<_>>(),
Vec::<(&'static str, usize)>::new(),
);
}
}
#[test]
fn subtree_leaf_counts_by_layer_iter_absent_prefix_is_empty_stream() {
let out = subtree_fixture();
let iter = out
.attribution
.subtree_leaf_counts_by_layer_iter(&[s("nonexistent")]);
assert_eq!(iter.len(), 0);
assert_eq!(iter.size_hint(), (0, Some(0)));
assert_eq!(
out.attribution
.subtree_leaf_counts_by_layer_iter(&[s("nonexistent")])
.collect::<Vec<_>>(),
Vec::<(&'static str, usize)>::new(),
);
}
#[test]
fn subtree_leaf_counts_by_layer_iter_len_equals_distinct_writer_count_under_subtree() {
let out = subtree_fixture();
for prefix in [vec![], vec![s("breathe")], vec![s("alpha")]] {
let iter = out.attribution.subtree_leaf_counts_by_layer_iter(&prefix);
let expected = out.attribution.subtree_leaf_counts_by_layer(&prefix).len();
assert_eq!(iter.len(), expected, "len at {prefix:?}");
assert_eq!(iter.size_hint(), (expected, Some(expected)));
}
}
#[test]
fn subtree_leaf_counts_by_layer_iter_names_match_subtree_surviving_layer_names_iter() {
let out = subtree_fixture();
for prefix in [vec![], vec![s("breathe")], vec![s("alpha")]] {
let via_counts: Vec<&'static str> = out
.attribution
.subtree_leaf_counts_by_layer_iter(&prefix)
.map(|(n, _)| n)
.collect();
let via_names: Vec<&'static str> = out
.attribution
.subtree_surviving_layer_names_iter(&prefix)
.collect();
assert_eq!(via_counts, via_names, "at {prefix:?}");
}
}
#[test]
fn subtree_leaf_counts_by_layer_iter_counts_sum_to_subtree_leaf_count() {
let out = subtree_fixture();
for prefix in [vec![], vec![s("breathe")], vec![s("alpha")]] {
let total: usize = out
.attribution
.subtree_leaf_counts_by_layer_iter(&prefix)
.map(|(_, c)| c)
.sum();
assert_eq!(
total,
out.attribution.subtree_iter(&prefix).count(),
"sum at {prefix:?}",
);
}
}
#[test]
fn subtree_leaf_counts_by_layer_iter_stops_at_prefix_extending_sibling_key() {
let out = subtree_fixture();
let global_names: std::collections::BTreeSet<&'static str> = out
.attribution
.leaf_counts_by_layer_iter()
.map(|(n, _)| n)
.collect();
let subtree_names: std::collections::BTreeSet<&'static str> = out
.attribution
.subtree_leaf_counts_by_layer_iter(&[s("breathe")])
.map(|(n, _)| n)
.collect();
assert!(
subtree_names.is_subset(&global_names),
"subtree names ⊆ global names",
);
let counts: BTreeMap<&'static str, usize> = out
.attribution
.subtree_leaf_counts_by_layer_iter(&[s("breathe")])
.collect();
assert_eq!(counts.get("specific").copied(), Some(1));
}
#[test]
fn subtree_leaf_counts_by_layer_iter_head_and_tail_track_lex_endpoints() {
let out = subtree_fixture();
for prefix in [vec![], vec![s("breathe")]] {
let head = out
.attribution
.subtree_leaf_counts_by_layer_iter(&prefix)
.next();
let expected_head = out
.attribution
.subtree_leaf_counts_by_layer(&prefix)
.into_iter()
.next();
assert_eq!(head, expected_head, "head at {prefix:?}");
let tail = out
.attribution
.subtree_leaf_counts_by_layer_iter(&prefix)
.next_back();
let expected_tail = out
.attribution
.subtree_leaf_counts_by_layer(&prefix)
.into_iter()
.next_back();
assert_eq!(tail, expected_tail, "tail at {prefix:?}");
assert_eq!(
out.attribution
.subtree_leaf_counts_by_layer_iter(&prefix)
.last(),
tail,
"overridden .last() at {prefix:?} matches .next_back()",
);
}
}
#[test]
fn subtree_leaf_counts_by_layer_iter_fused_after_exhaustion() {
let out = subtree_fixture();
for prefix in [vec![], vec![s("breathe")], vec![s("nonexistent")]] {
let mut iter = out.attribution.subtree_leaf_counts_by_layer_iter(&prefix);
while iter.next().is_some() {}
assert_eq!(iter.next(), None);
assert_eq!(iter.next(), None);
assert_eq!(iter.next(), None);
}
}
#[test]
fn silent_layer_names_lists_axes_that_returned_empty_dicts() {
let a = Fixed("platform", dict(&[("k", Value::from(1i64))]));
let b = Fixed("undetectable", Dict::new());
let c = Fixed("also-empty", Dict::new());
assert_eq!(
silent_layer_names(&[&a, &b, &c]),
vec!["undetectable", "also-empty"],
);
}
#[test]
fn silent_layer_names_preserves_application_order() {
let a = Fixed("tenancy", Dict::new());
let b = Fixed("platform", Dict::new());
assert_eq!(silent_layer_names(&[&a, &b]), vec!["tenancy", "platform"]);
}
#[test]
fn silent_layer_names_empty_when_every_layer_contributes() {
let a = Fixed("a", dict(&[("k", Value::from(1i64))]));
let b = Fixed("b", dict(&[("k", Value::from(2i64))]));
assert!(silent_layer_names(&[&a, &b]).is_empty());
}
#[test]
fn silent_layer_names_empty_when_no_layers() {
assert!(silent_layer_names(&[]).is_empty());
}
#[test]
fn silent_layer_names_covers_layer_names_when_all_undetectable() {
let a = Fixed("a", Dict::new());
let b = Fixed("b", Dict::new());
let layers: [&dyn DiscoveryLayer; 2] = [&a, &b];
assert_eq!(silent_layer_names(&layers), layer_names(&layers));
}
#[test]
fn silent_layer_names_is_subset_of_layer_names() {
let a = Fixed("a", dict(&[("k", Value::from(1i64))]));
let b = Fixed("b", Dict::new());
let c = Fixed("c", Dict::new());
let all: std::collections::BTreeSet<_> = layer_names(&[&a, &b, &c]).into_iter().collect();
let silent: std::collections::BTreeSet<_> =
silent_layer_names(&[&a, &b, &c]).into_iter().collect();
assert!(silent.is_subset(&all), "silent ⊆ declared names");
assert_eq!(silent.len(), 2, "two undetectable axes");
}
#[test]
fn silent_layer_names_disjoint_from_contributor_names() {
let a = Fixed("a", dict(&[("k", Value::from(1i64))]));
let b = Fixed("b", Dict::new());
let c = Fixed("c", dict(&[("k", Value::from(2i64))]));
let d = Fixed("d", Dict::new());
let layers: [&dyn DiscoveryLayer; 4] = [&a, &b, &c, &d];
let contribs: std::collections::BTreeSet<_> =
contributor_names(&layers).into_iter().collect();
let silent: std::collections::BTreeSet<_> =
silent_layer_names(&layers).into_iter().collect();
assert!(
contribs.is_disjoint(&silent),
"contributor and silent projections share no elements",
);
}
#[test]
fn silent_layer_names_partitions_layer_names_disjointly() {
let a = Fixed("platform", dict(&[("k", Value::from(1i64))]));
let b = Fixed("undetectable", Dict::new());
let c = Fixed("tenancy", dict(&[("k", Value::from(2i64))]));
let d = Fixed("also-empty", Dict::new());
let layers: [&dyn DiscoveryLayer; 4] = [&a, &b, &c, &d];
let all: std::collections::BTreeSet<_> = layer_names(&layers).into_iter().collect();
let contribs: std::collections::BTreeSet<_> =
contributor_names(&layers).into_iter().collect();
let silent: std::collections::BTreeSet<_> =
silent_layer_names(&layers).into_iter().collect();
let union: std::collections::BTreeSet<_> = contribs.union(&silent).copied().collect();
assert_eq!(union, all, "contributors ∪ silent == declared names");
assert!(contribs.is_disjoint(&silent), "contributors ∩ silent == ∅",);
assert_eq!(
contribs.len() + silent.len(),
layer_names(&layers).len(),
"distinct names ⇒ length sum matches",
);
}
#[test]
fn silent_layer_names_agrees_with_layer_names_minus_contributor_names() {
let a = Fixed("z-first", dict(&[("k", Value::from(1i64))]));
let b = Fixed("m-empty", Dict::new());
let c = Fixed("a-third", dict(&[("k", Value::from(2i64))]));
let d = Fixed("q-empty", Dict::new());
let layers: [&dyn DiscoveryLayer; 4] = [&a, &b, &c, &d];
let all: std::collections::BTreeSet<_> = layer_names(&layers).into_iter().collect();
let contribs: std::collections::BTreeSet<_> =
contributor_names(&layers).into_iter().collect();
let silent: std::collections::BTreeSet<_> =
silent_layer_names(&layers).into_iter().collect();
let derived: std::collections::BTreeSet<_> = all.difference(&contribs).copied().collect();
assert_eq!(silent, derived, "silent == layer_names − contributors");
}
#[test]
fn silent_layer_names_disjoint_from_surviving_layer_names() {
let coarse = Fixed("coarse", dict(&[("setpoint", Value::from(0.80))]));
let specific = Fixed("specific", dict(&[("setpoint", Value::from(0.70))]));
let empty = Fixed("undetectable", Dict::new());
let layers: [&dyn DiscoveryLayer; 3] = [&coarse, &specific, &empty];
let silent: std::collections::BTreeSet<_> =
silent_layer_names(&layers).into_iter().collect();
let survivors: std::collections::BTreeSet<_> = compose_with_provenance(&layers)
.attribution
.surviving_layer_names()
.into_iter()
.collect();
assert!(
silent.is_disjoint(&survivors),
"silent axes cannot survive the merge (they wrote nothing)",
);
assert_eq!(silent, std::collections::BTreeSet::from(["undetectable"]));
assert_eq!(survivors, std::collections::BTreeSet::from(["specific"]));
}
#[test]
fn silent_layer_names_iter_collect_matches_silent_layer_names() {
let a = Fixed("platform", dict(&[("a", Value::from(1i64))]));
let quiet = Fixed("cloud", Dict::new());
let c = Fixed("tenancy", dict(&[("c", Value::from(3i64))]));
let layers: [&dyn DiscoveryLayer; 3] = [&a, &quiet, &c];
assert_eq!(
silent_layer_names_iter(&layers).collect::<Vec<_>>(),
silent_layer_names(&layers),
"iter → Vec matches silent_layer_names verbatim",
);
}
#[test]
fn silent_layer_names_iter_empty_stack_is_empty_stream() {
let layers: [&dyn DiscoveryLayer; 0] = [];
assert!(
silent_layer_names_iter(&layers).next().is_none(),
"no layers → no silent names",
);
}
#[test]
fn silent_layer_names_iter_all_contributing_is_empty_stream() {
let a = Fixed("platform", dict(&[("a", Value::from(1i64))]));
let b = Fixed("cloud", dict(&[("b", Value::from(2i64))]));
let layers: [&dyn DiscoveryLayer; 2] = [&a, &b];
assert!(
silent_layer_names_iter(&layers).next().is_none(),
"every axis contributes → the stream is empty",
);
}
#[test]
fn silent_layer_names_iter_all_silent_yields_every_declared_name() {
let a = Fixed("platform", Dict::new());
let b = Fixed("cloud", Dict::new());
let c = Fixed("tenancy", Dict::new());
let layers: [&dyn DiscoveryLayer; 3] = [&a, &b, &c];
assert_eq!(
silent_layer_names_iter(&layers).collect::<Vec<_>>(),
layer_names(&layers),
"all silent ⇒ silent iter reproduces layer_names",
);
}
#[test]
fn silent_layer_names_iter_preserves_application_order() {
let a = Fixed("platform", Dict::new());
let b = Fixed("cloud", Dict::new());
let c = Fixed("tenancy", Dict::new());
let layers: [&dyn DiscoveryLayer; 3] = [&a, &b, &c];
assert_eq!(
silent_layer_names_iter(&layers).collect::<Vec<_>>(),
vec!["platform", "cloud", "tenancy"],
"iter yields names coarse→specific in application order",
);
}
#[test]
fn silent_layer_names_iter_rev_reverses_forward_walk() {
let a = Fixed("platform", dict(&[("a", Value::from(1i64))]));
let quiet1 = Fixed("cloud", Dict::new());
let quiet2 = Fixed("region", Dict::new());
let c = Fixed("tenancy", dict(&[("c", Value::from(3i64))]));
let layers: [&dyn DiscoveryLayer; 4] = [&a, &quiet1, &quiet2, &c];
let forward = silent_layer_names_iter(&layers).collect::<Vec<_>>();
let reverse = silent_layer_names_iter(&layers).rev().collect::<Vec<_>>();
assert_eq!(
reverse,
forward.iter().rev().copied().collect::<Vec<_>>(),
".rev() over the iter recovers the reverse of the forward walk",
);
}
#[test]
fn silent_layer_names_iter_clone_yields_independent_walks() {
let a = Fixed("platform", dict(&[("a", Value::from(1i64))]));
let quiet = Fixed("cloud", Dict::new());
let c = Fixed("tenancy", dict(&[("c", Value::from(3i64))]));
let layers: [&dyn DiscoveryLayer; 3] = [&a, &quiet, &c];
let one = silent_layer_names_iter(&layers);
let two = one.clone();
assert_eq!(
one.collect::<Vec<_>>(),
two.collect::<Vec<_>>(),
"two independent walks agree",
);
}
#[test]
fn silent_layer_names_iter_is_fused_past_exhaustion() {
let a = Fixed("platform", Dict::new());
let layers: [&dyn DiscoveryLayer; 1] = [&a];
let mut it = silent_layer_names_iter(&layers);
assert_eq!(it.next(), Some("platform"));
for _ in 0..4 {
assert!(it.next().is_none(), "post-exhaustion pulls stay None");
}
}
#[test]
fn silent_layer_names_iter_head_short_circuits_without_full_sweep() {
let a = Fixed("platform", dict(&[("a", Value::from(1i64))]));
let quiet = Fixed("cloud", Dict::new());
let b = Fixed("region", dict(&[("b", Value::from(2i64))]));
let quieter = Fixed("tenancy", Dict::new());
let layers: [&dyn DiscoveryLayer; 4] = [&a, &quiet, &b, &quieter];
assert_eq!(
silent_layer_names_iter(&layers).next(),
Some("cloud"),
".next() yields the first silent axis without walking the rest",
);
}
#[test]
fn silent_layer_names_iter_chained_with_contributor_names_iter_covers_layer_names() {
let coarse = Fixed("platform", dict(&[("a", Value::from(1i64))]));
let empty1 = Fixed("cloud", Dict::new());
let mid = Fixed("region", dict(&[("b", Value::from(2i64))]));
let empty2 = Fixed("tenancy", Dict::new());
let layers: [&dyn DiscoveryLayer; 4] = [&coarse, &empty1, &mid, &empty2];
let all: std::collections::BTreeSet<_> = layer_names(&layers).into_iter().collect();
let chained: std::collections::BTreeSet<_> = contributor_names_iter(&layers)
.chain(silent_layer_names_iter(&layers))
.collect();
assert_eq!(
chained, all,
"contributor_iter ⨄ silent_iter covers layer_names"
);
}
#[test]
fn silent_layer_names_iter_return_type_is_nameable_silent_layer_names_iter() {
struct HoldsSilentLayerNames<'a> {
iter: SilentLayerNamesIter<'a>,
}
let a = Fixed("platform", dict(&[("a", Value::from(1i64))]));
let b = Fixed("cloud", Dict::new());
let c = Fixed("tenancy", dict(&[("c", Value::from(3i64))]));
let layers: [&dyn DiscoveryLayer; 3] = [&a, &b, &c];
let held = HoldsSilentLayerNames {
iter: silent_layer_names_iter(&layers),
};
let out: Vec<&'static str> = held.iter.collect();
assert_eq!(out, vec!["cloud"]);
}
#[test]
fn silent_layer_names_iter_clone_preserves_static_traits() {
fn requires_full_traits<I>(_it: &I)
where
I: Iterator + DoubleEndedIterator + std::iter::FusedIterator + Clone,
{
}
let a = Fixed("platform", dict(&[("a", Value::from(1i64))]));
let b = Fixed("cloud", Dict::new());
let c = Fixed("tenancy", dict(&[("c", Value::from(3i64))]));
let layers: [&dyn DiscoveryLayer; 3] = [&a, &b, &c];
let it: SilentLayerNamesIter<'_> = silent_layer_names_iter(&layers);
requires_full_traits(&it);
let clone = it.clone();
let via_original: Vec<&'static str> = it.collect();
let via_clone: Vec<&'static str> = clone.collect();
assert_eq!(
via_original, via_clone,
"cloned handle walks the same silent-name stream",
);
}
#[test]
fn silent_layer_names_iter_next_back_walks_specific_to_coarse() {
let a = Fixed("platform", Dict::new());
let loud = Fixed("cloud", dict(&[("k", Value::from(1i64))]));
let c = Fixed("tenancy", Dict::new());
let tail_loud = Fixed("aftermath", dict(&[("k", Value::from(9i64))]));
let layers: [&dyn DiscoveryLayer; 4] = [&a, &loud, &c, &tail_loud];
let mut it = silent_layer_names_iter(&layers);
assert_eq!(
it.next_back(),
Some("tenancy"),
"tail contributor 'aftermath' is skipped and 'tenancy' is the first reverse yield",
);
assert_eq!(
it.next_back(),
Some("platform"),
"mid contributor 'cloud' is skipped and 'platform' is next in reverse",
);
assert!(
it.next_back().is_none(),
"both remaining cursor ends have been swept by next_back",
);
}
#[test]
fn silent_layer_names_iter_debug_impl_omits_layers_handle() {
let a = Fixed("platform", dict(&[("a", Value::from(1i64))]));
let b = Fixed("cloud", Dict::new());
let c = Fixed("tenancy", dict(&[("c", Value::from(3i64))]));
let layers: [&dyn DiscoveryLayer; 3] = [&a, &b, &c];
let it: SilentLayerNamesIter<'_> = silent_layer_names_iter(&layers);
let rendered = format!("{it:?}");
assert!(
rendered.starts_with("SilentLayerNamesIter"),
"Debug names the concrete struct: {rendered}",
);
assert!(
rendered.contains("layers_remaining"),
"Debug reports the remaining layer count: {rendered}",
);
assert!(
rendered.contains('3'),
"Debug reports the initial cursor length: {rendered}",
);
}
#[test]
fn subtree_leaf_counts_by_layer_empty_prefix_equals_leaf_counts_by_layer() {
let out = subtree_fixture();
assert_eq!(
out.attribution.subtree_leaf_counts_by_layer(&[]),
out.attribution.leaf_counts_by_layer(),
);
}
#[test]
fn subtree_leaf_counts_by_layer_at_named_prefix_counts_only_leaves_under_it() {
let out = subtree_fixture();
let prefix = vec![s("breathe")];
let counts = out.attribution.subtree_leaf_counts_by_layer(&prefix);
assert_eq!(counts.get("coarse").copied(), Some(1));
assert_eq!(counts.get("specific").copied(), Some(1));
assert_eq!(counts.len(), 2);
}
#[test]
fn subtree_leaf_counts_by_layer_agrees_with_subtree_leaf_counts_by_layer() {
let out = subtree_fixture();
for prefix in [
vec![],
vec![s("breathe")],
vec![s("alpha")],
vec![s("nonexistent")],
] {
assert_eq!(
out.attribution.subtree_leaf_counts_by_layer(&prefix),
out.attribution.subtree(&prefix).leaf_counts_by_layer(),
"direct vs composition must agree at prefix {prefix:?}",
);
}
}
#[test]
fn subtree_leaf_counts_by_layer_absent_prefix_is_empty() {
let out = subtree_fixture();
assert!(
out.attribution
.subtree_leaf_counts_by_layer(&[s("nonexistent")])
.is_empty(),
);
}
#[test]
fn subtree_leaf_counts_by_layer_at_exact_scalar_leaf_counts_one() {
let out = subtree_fixture();
let prefix = vec![s("alpha")];
let counts = out.attribution.subtree_leaf_counts_by_layer(&prefix);
assert_eq!(counts.get("coarse").copied(), Some(1));
assert_eq!(counts.len(), 1);
}
#[test]
fn subtree_leaf_counts_by_layer_stops_at_prefix_extending_sibling_key() {
let out = subtree_fixture();
let prefix = vec![s("breathe")];
let sub_counts = out.attribution.subtree_leaf_counts_by_layer(&prefix);
let parent_counts = out.attribution.leaf_counts_by_layer();
assert_eq!(sub_counts.get("specific").copied(), Some(1));
assert_eq!(parent_counts.get("specific").copied(), Some(2));
}
#[test]
fn subtree_leaf_counts_by_layer_partition_count_law() {
let out = subtree_fixture();
for prefix in [
vec![],
vec![s("breathe")],
vec![s("alpha")],
vec![s("nonexistent")],
] {
let counts = out.attribution.subtree_leaf_counts_by_layer(&prefix);
let sum: usize = counts.values().copied().sum();
let subtree_len = out.attribution.subtree(&prefix).len();
assert_eq!(
sum, subtree_len,
"partition-count law failed at prefix {prefix:?}",
);
assert_eq!(
sum,
out.attribution.subtree_iter(&prefix).count(),
"sum must equal subtree_iter count at prefix {prefix:?}",
);
}
}
#[test]
fn subtree_leaf_counts_by_layer_keys_equal_subtree_surviving_layer_names() {
let out = subtree_fixture();
for prefix in [
vec![],
vec![s("breathe")],
vec![s("alpha")],
vec![s("nonexistent")],
] {
let via_counts: Vec<&'static str> = out
.attribution
.subtree_leaf_counts_by_layer(&prefix)
.into_keys()
.collect();
let via_names = out.attribution.subtree_surviving_layer_names(&prefix);
assert_eq!(
via_counts, via_names,
"histogram key set must equal name-set at prefix {prefix:?}",
);
}
}
#[test]
fn subtree_leaf_counts_by_layer_is_leq_leaf_counts_by_layer_pointwise() {
let out = subtree_fixture();
let parent_counts = out.attribution.leaf_counts_by_layer();
for prefix in [
vec![],
vec![s("breathe")],
vec![s("alpha")],
vec![s("nonexistent")],
] {
let sub_counts = out.attribution.subtree_leaf_counts_by_layer(&prefix);
for (layer, sub_count) in &sub_counts {
let parent_count = parent_counts
.get(layer)
.copied()
.expect("every subtree layer appears in the parent");
assert!(
*sub_count <= parent_count,
"sub-count for {layer} at {prefix:?} ({sub_count}) must not exceed parent count ({parent_count})",
);
}
}
}
fn own_writes(
writes: BTreeMap<&'static str, Vec<&[String]>>,
) -> BTreeMap<&'static str, Vec<Vec<String>>> {
writes
.into_iter()
.map(|(layer, paths)| (layer, paths.into_iter().map(<[String]>::to_vec).collect()))
.collect()
}
#[test]
fn subtree_writes_by_layer_empty_prefix_equals_writes_by_layer() {
let out = subtree_fixture();
assert_eq!(
own_writes(out.attribution.subtree_writes_by_layer(&[])),
own_writes(out.attribution.writes_by_layer()),
);
}
#[test]
fn subtree_writes_by_layer_at_named_prefix_lists_paths_under_it() {
let out = subtree_fixture();
let prefix = vec![s("breathe")];
let writes = own_writes(out.attribution.subtree_writes_by_layer(&prefix));
assert_eq!(
writes.get("coarse"),
Some(&vec![vec![s("breathe"), s("mode")]]),
);
assert_eq!(
writes.get("specific"),
Some(&vec![vec![s("breathe"), s("setpoint")]]),
);
assert_eq!(writes.len(), 2);
}
#[test]
fn subtree_writes_by_layer_agrees_with_subtree_writes_by_layer_composition() {
let out = subtree_fixture();
for prefix in [
vec![],
vec![s("breathe")],
vec![s("alpha")],
vec![s("nonexistent")],
] {
let sub = out.attribution.subtree(&prefix);
assert_eq!(
own_writes(out.attribution.subtree_writes_by_layer(&prefix)),
own_writes(sub.writes_by_layer()),
"direct vs composition must agree at prefix {prefix:?}",
);
}
}
#[test]
fn subtree_writes_by_layer_absent_prefix_is_empty() {
let out = subtree_fixture();
assert!(
out.attribution
.subtree_writes_by_layer(&[s("nonexistent")])
.is_empty(),
);
}
#[test]
fn subtree_writes_by_layer_at_exact_scalar_leaf_yields_that_path_only() {
let out = subtree_fixture();
let prefix = vec![s("alpha")];
let writes = own_writes(out.attribution.subtree_writes_by_layer(&prefix));
assert_eq!(writes.get("coarse"), Some(&vec![vec![s("alpha")]]));
assert_eq!(writes.len(), 1);
}
#[test]
fn subtree_writes_by_layer_stops_at_prefix_extending_sibling_key() {
let out = subtree_fixture();
let prefix = vec![s("breathe")];
let sub_writes = own_writes(out.attribution.subtree_writes_by_layer(&prefix));
let parent_writes = own_writes(out.attribution.writes_by_layer());
assert_eq!(
sub_writes.get("specific"),
Some(&vec![vec![s("breathe"), s("setpoint")]]),
);
let parent_specific = parent_writes
.get("specific")
.expect("specific wrote at least one leaf globally");
assert!(
parent_specific.contains(&vec![s("breatheZ")]),
"the excluded sibling IS in the parent's bucket",
);
assert!(
!sub_writes
.get("specific")
.expect("specific wrote a leaf under the subtree")
.contains(&vec![s("breatheZ")]),
"the excluded sibling is NOT in the subtree's bucket",
);
}
#[test]
fn subtree_writes_by_layer_partition_law() {
let out = subtree_fixture();
for prefix in [
vec![],
vec![s("breathe")],
vec![s("alpha")],
vec![s("nonexistent")],
] {
let writes = own_writes(out.attribution.subtree_writes_by_layer(&prefix));
let sum: usize = writes.values().map(Vec::len).sum();
let subtree_len = out.attribution.subtree(&prefix).len();
assert_eq!(
sum, subtree_len,
"partition law failed at prefix {prefix:?}",
);
assert_eq!(
sum,
out.attribution.subtree_iter(&prefix).count(),
"sum must equal subtree_iter count at prefix {prefix:?}",
);
let mut union_paths: Vec<Vec<String>> =
writes.values().flat_map(|v| v.iter().cloned()).collect();
union_paths.sort();
let mut walk_paths: Vec<Vec<String>> = out
.attribution
.subtree_iter(&prefix)
.map(|(p, _)| p.to_vec())
.collect();
walk_paths.sort();
assert_eq!(
union_paths, walk_paths,
"union of inner Vecs must equal subtree_iter's path multiset at {prefix:?}",
);
}
}
#[test]
fn subtree_writes_by_layer_keys_and_bucket_lengths_agree_with_peers() {
let out = subtree_fixture();
for prefix in [
vec![],
vec![s("breathe")],
vec![s("alpha")],
vec![s("nonexistent")],
] {
let writes = own_writes(out.attribution.subtree_writes_by_layer(&prefix));
let via_keys: Vec<&'static str> = writes.keys().copied().collect();
let via_names = out.attribution.subtree_surviving_layer_names(&prefix);
assert_eq!(
via_keys, via_names,
"wide seam key set must equal name-set at prefix {prefix:?}",
);
let counts = out.attribution.subtree_leaf_counts_by_layer(&prefix);
for (layer, paths) in &writes {
assert_eq!(
counts.get(layer).copied(),
Some(paths.len()),
"wide-seam bucket len must equal count-seam counter for {layer} at {prefix:?}",
);
}
}
}
#[test]
fn subtree_writes_by_layer_is_subsequence_of_writes_by_layer_pointwise() {
let out = subtree_fixture();
let parent_writes = own_writes(out.attribution.writes_by_layer());
for prefix in [
vec![],
vec![s("breathe")],
vec![s("alpha")],
vec![s("nonexistent")],
] {
let sub_writes = own_writes(out.attribution.subtree_writes_by_layer(&prefix));
for (layer, sub_paths) in &sub_writes {
let parent_paths = parent_writes
.get(layer)
.expect("every subtree layer appears in the parent");
assert!(
sub_paths.len() <= parent_paths.len(),
"sub-bucket length for {layer} at {prefix:?} exceeds parent",
);
for path in sub_paths {
assert!(
parent_paths.contains(path),
"sub path {path:?} for {layer} at {prefix:?} missing from parent bucket",
);
assert_eq!(
out.attribution.layer_of_owned(path),
Some(*layer),
"sub-bucket path {path:?} must attribute to {layer} on the parent",
);
}
}
}
let specific_sub = own_writes(out.attribution.subtree_writes_by_layer(&[s("breathe")]))
.remove("specific")
.expect("specific wrote under `breathe`");
let specific_parent = own_writes(out.attribution.writes_by_layer())
.remove("specific")
.expect("specific wrote globally");
assert!(
specific_sub.len() < specific_parent.len(),
"strict subsequence pinned on `specific` under `breathe.*` (sub {} < parent {})",
specific_sub.len(),
specific_parent.len(),
);
}
fn layer_axis_fixture() -> DiscoveryComposition {
let a = Fixed(
"platform",
dict(&[("k1", Value::from(1i64)), ("k2", Value::from(2i64))]),
);
let b = Fixed(
"tenancy",
dict(&[("k2", Value::from(20i64)), ("k3", Value::from(3i64))]),
);
compose_with_provenance(&[&a, &b])
}
#[test]
fn writes_of_layer_agrees_with_writes_by_layer_bucket() {
let out = layer_axis_fixture();
let groups = out.attribution.writes_by_layer();
for layer in out.attribution.surviving_layer_names() {
let single: Vec<&[String]> = out.attribution.writes_of_layer(layer);
let bucket: Vec<&[String]> = groups.get(layer).cloned().unwrap_or_default();
assert_eq!(
single, bucket,
"single-layer wide seam equals writes_by_layer[{layer}] verbatim",
);
}
}
#[test]
fn writes_of_layer_preserves_lex_order() {
let a = Fixed(
"A",
dict(&[
("m", Value::from(3i64)),
("a", Value::from(dict(&[("y", Value::from(2i64))]))),
]),
);
let b = Fixed("Z", dict(&[("z", Value::from(1i64))]));
let out = compose_with_provenance(&[&a, &b]);
let a_paths = out.attribution.writes_of_layer("A");
assert_eq!(
a_paths,
vec![
["a".to_owned(), "y".to_owned()].as_slice(),
["m".to_owned()].as_slice(),
],
"single-layer wide seam preserves lex path order",
);
for path in &a_paths {
let owned: Vec<String> = path.iter().map(std::borrow::ToOwned::to_owned).collect();
assert_eq!(
out.attribution.layer_of_owned(&owned),
Some("A"),
"every path in writes_of_layer(A) attributes to A",
);
}
}
#[test]
fn writes_of_layer_missing_writer_is_empty() {
let real = Fixed("real", dict(&[("k", Value::from(1i64))]));
let silent = Fixed("undetectable", Dict::new());
let out = compose_with_provenance(&[&real, &silent]);
assert!(
out.attribution.writes_of_layer("undetectable").is_empty(),
"silent writer yields empty writes",
);
assert!(
out.attribution.writes_of_layer("never-declared").is_empty(),
"never-declared writer yields empty writes",
);
}
#[test]
fn writes_of_layer_empty_attribution_is_empty() {
let out = compose_with_provenance(&[]);
assert!(
out.attribution.writes_of_layer("anything").is_empty(),
"empty attribution yields empty writes for any writer",
);
}
#[test]
fn leaf_count_of_layer_agrees_with_leaf_counts_by_layer_bucket() {
let out = layer_axis_fixture();
let counts = out.attribution.leaf_counts_by_layer();
for layer in out.attribution.surviving_layer_names() {
let single = out.attribution.leaf_count_of_layer(layer);
let bucket = counts.get(layer).copied().unwrap_or(0);
assert_eq!(
single, bucket,
"single-layer count seam equals leaf_counts_by_layer[{layer}] verbatim",
);
}
}
#[test]
fn leaf_count_of_layer_agrees_with_writes_of_layer_len() {
let out = layer_axis_fixture();
for layer in out.attribution.surviving_layer_names() {
assert_eq!(
out.attribution.leaf_count_of_layer(layer),
out.attribution.writes_of_layer(layer).len(),
"leaf_count_of_layer({layer}) == writes_of_layer({layer}).len()",
);
}
}
#[test]
fn leaf_count_of_layer_partition_count_law() {
let out = layer_axis_fixture();
let survivors = out.attribution.surviving_layer_names();
let total: usize = survivors
.iter()
.map(|l| out.attribution.leaf_count_of_layer(l))
.sum();
assert_eq!(
total,
out.attribution.len(),
"sum of per-writer counts equals total leaf count",
);
}
#[test]
fn leaf_count_of_layer_missing_writer_is_zero() {
let real = Fixed("real", dict(&[("k", Value::from(1i64))]));
let silent = Fixed("undetectable", Dict::new());
let out = compose_with_provenance(&[&real, &silent]);
assert_eq!(
out.attribution.leaf_count_of_layer("undetectable"),
0,
"silent writer yields count zero",
);
assert_eq!(
out.attribution.leaf_count_of_layer("never-declared"),
0,
"never-declared writer yields count zero",
);
let empty = compose_with_provenance(&[]);
assert_eq!(
empty.attribution.leaf_count_of_layer("anything"),
0,
"empty attribution yields count zero for any writer",
);
}
#[test]
fn subtree_writes_of_layer_empty_prefix_equals_writes_of_layer() {
let out = layer_axis_fixture();
for layer in out.attribution.surviving_layer_names() {
assert_eq!(
out.attribution.subtree_writes_of_layer(&[], layer),
out.attribution.writes_of_layer(layer),
"empty prefix ⇒ subtree_writes_of_layer({layer}) equals writes_of_layer({layer})",
);
}
assert!(
out.attribution
.subtree_writes_of_layer(&[], "never-declared")
.is_empty(),
"empty prefix + never-declared writer ⇒ empty",
);
}
#[test]
fn subtree_writes_of_layer_agrees_with_subtree_writes_by_layer_bucket() {
let out = subtree_fixture();
for prefix in [
vec![],
vec![s("breathe")],
vec![s("alpha")],
vec![s("nonexistent")],
] {
let groups = out.attribution.subtree_writes_by_layer(&prefix);
for layer in out.attribution.subtree_surviving_layer_names(&prefix) {
let single: Vec<&[String]> =
out.attribution.subtree_writes_of_layer(&prefix, layer);
let bucket: Vec<&[String]> = groups.get(layer).cloned().unwrap_or_default();
assert_eq!(
single, bucket,
"single-writer seam at prefix {prefix:?} equals subtree_writes_by_layer[{layer}]",
);
}
}
}
#[test]
fn subtree_writes_of_layer_at_named_prefix_lists_only_this_writer_under_it() {
let out = subtree_fixture();
let prefix = vec![s("breathe")];
let coarse: Vec<Vec<String>> = out
.attribution
.subtree_writes_of_layer(&prefix, "coarse")
.into_iter()
.map(<[String]>::to_vec)
.collect();
assert_eq!(coarse, vec![vec![s("breathe"), s("mode")]]);
let specific: Vec<Vec<String>> = out
.attribution
.subtree_writes_of_layer(&prefix, "specific")
.into_iter()
.map(<[String]>::to_vec)
.collect();
assert_eq!(specific, vec![vec![s("breathe"), s("setpoint")]]);
}
#[test]
fn subtree_writes_of_layer_stops_at_prefix_extending_sibling_key() {
let out = subtree_fixture();
let prefix = vec![s("breathe")];
let sub: Vec<Vec<String>> = out
.attribution
.subtree_writes_of_layer(&prefix, "specific")
.into_iter()
.map(<[String]>::to_vec)
.collect();
assert!(
!sub.contains(&vec![s("breatheZ")]),
"prefix-extending sibling is excluded from the 2D-restricted seam",
);
let parent: Vec<Vec<String>> = out
.attribution
.writes_of_layer("specific")
.into_iter()
.map(<[String]>::to_vec)
.collect();
assert!(
parent.contains(&vec![s("breatheZ")]),
"the excluded sibling IS in the top-level layer-axis seam",
);
}
#[test]
fn subtree_writes_of_layer_preserves_lex_order() {
let a = Fixed(
"A",
dict(&[
(
"s",
Value::from(dict(&[
("m", Value::from(3i64)),
("a", Value::from(dict(&[("y", Value::from(2i64))]))),
])),
),
("t", Value::from(4i64)),
]),
);
let b = Fixed(
"B",
dict(&[("s", Value::from(dict(&[("p", Value::from(9i64))])))]),
);
let out = compose_with_provenance(&[&a, &b]);
let prefix = vec![s("s")];
let a_paths: Vec<Vec<String>> = out
.attribution
.subtree_writes_of_layer(&prefix, "A")
.into_iter()
.map(<[String]>::to_vec)
.collect();
assert_eq!(
a_paths,
vec![vec![s("s"), s("a"), s("y")], vec![s("s"), s("m")],],
"2D-restricted seam preserves lex path order under the subtree",
);
for path in &a_paths {
assert_eq!(
out.attribution.layer_of_owned(path),
Some("A"),
"every path attributes to A on the parent",
);
}
}
#[test]
fn subtree_writes_of_layer_absent_prefix_is_empty() {
let out = subtree_fixture();
for layer in ["coarse", "specific", "never-declared"] {
assert!(
out.attribution
.subtree_writes_of_layer(&[s("nonexistent")], layer)
.is_empty(),
"absent prefix ⇒ subtree_writes_of_layer({layer}) is empty",
);
}
}
#[test]
fn subtree_writes_of_layer_missing_writer_is_empty() {
let out = subtree_fixture();
let prefix = vec![s("breathe")];
assert!(
out.attribution
.subtree_writes_of_layer(&prefix, "never-declared")
.is_empty(),
);
let elsewhere = Fixed("elsewhere", dict(&[("outside", Value::from(1i64))]));
let under = Fixed(
"under",
dict(&[("root", Value::from(dict(&[("leaf", Value::from(2i64))])))]),
);
let out2 = compose_with_provenance(&[&elsewhere, &under]);
assert!(
out2.attribution
.subtree_writes_of_layer(&[s("root")], "elsewhere")
.is_empty(),
"writer active elsewhere but silent under the subtree ⇒ empty",
);
}
#[test]
fn subtree_leaf_count_of_layer_empty_prefix_equals_leaf_count_of_layer() {
let out = layer_axis_fixture();
for layer in out.attribution.surviving_layer_names() {
assert_eq!(
out.attribution.subtree_leaf_count_of_layer(&[], layer),
out.attribution.leaf_count_of_layer(layer),
"empty prefix ⇒ subtree_leaf_count_of_layer({layer}) equals leaf_count_of_layer({layer})",
);
}
assert_eq!(
out.attribution
.subtree_leaf_count_of_layer(&[], "never-declared"),
0,
"empty prefix + never-declared writer ⇒ zero",
);
}
#[test]
fn subtree_leaf_count_of_layer_agrees_with_subtree_writes_of_layer_len() {
let out = subtree_fixture();
for prefix in [
vec![],
vec![s("breathe")],
vec![s("alpha")],
vec![s("nonexistent")],
] {
for layer in ["coarse", "specific", "never-declared"] {
assert_eq!(
out.attribution.subtree_leaf_count_of_layer(&prefix, layer),
out.attribution
.subtree_writes_of_layer(&prefix, layer)
.len(),
"count seam == wide seam length at prefix {prefix:?} × layer {layer}",
);
}
}
}
#[test]
fn subtree_leaf_count_of_layer_agrees_with_subtree_leaf_counts_by_layer_bucket() {
let out = subtree_fixture();
for prefix in [
vec![],
vec![s("breathe")],
vec![s("alpha")],
vec![s("nonexistent")],
] {
let counts = out.attribution.subtree_leaf_counts_by_layer(&prefix);
for layer in out.attribution.subtree_surviving_layer_names(&prefix) {
let single = out.attribution.subtree_leaf_count_of_layer(&prefix, layer);
let bucket = counts.get(layer).copied().unwrap_or(0);
assert_eq!(
single, bucket,
"single-writer count at prefix {prefix:?} equals subtree_leaf_counts_by_layer[{layer}]",
);
}
}
}
#[test]
fn subtree_leaf_count_of_layer_partition_count_law() {
let out = subtree_fixture();
for prefix in [vec![], vec![s("breathe")], vec![s("alpha")]] {
let survivors = out.attribution.subtree_surviving_layer_names(&prefix);
let total: usize = survivors
.iter()
.map(|l| out.attribution.subtree_leaf_count_of_layer(&prefix, l))
.sum();
let expected = out.attribution.subtree_iter(&prefix).count();
assert_eq!(
total, expected,
"sum of per-writer counts at prefix {prefix:?} equals subtree leaf count",
);
}
}
#[test]
fn subtree_leaf_count_of_layer_absent_prefix_is_zero() {
let out = subtree_fixture();
for layer in ["coarse", "specific", "never-declared"] {
assert_eq!(
out.attribution
.subtree_leaf_count_of_layer(&[s("nonexistent")], layer),
0,
"absent prefix ⇒ zero for every writer ({layer})",
);
}
}
#[test]
fn subtree_leaf_count_of_layer_missing_writer_is_zero() {
let out = subtree_fixture();
let prefix = vec![s("breathe")];
assert_eq!(
out.attribution
.subtree_leaf_count_of_layer(&prefix, "never-declared"),
0,
"never-declared writer under a real subtree ⇒ zero",
);
let empty = compose_with_provenance(&[]);
assert_eq!(
empty
.attribution
.subtree_leaf_count_of_layer(&[s("anything")], "anyone"),
0,
"empty attribution ⇒ zero for every (prefix, writer)",
);
}
#[test]
fn subtree_leaf_count_of_layer_is_leq_leaf_count_of_layer_pointwise() {
let out = subtree_fixture();
for prefix in [vec![], vec![s("breathe")], vec![s("alpha")]] {
for layer in ["coarse", "specific"] {
let sub = out.attribution.subtree_leaf_count_of_layer(&prefix, layer);
let parent = out.attribution.leaf_count_of_layer(layer);
assert!(
sub <= parent,
"sub count for {layer} at prefix {prefix:?} ({sub}) must not exceed parent count ({parent})",
);
}
}
let strict_prefix = vec![s("breathe")];
assert!(
out.attribution
.subtree_leaf_count_of_layer(&strict_prefix, "coarse")
< out.attribution.leaf_count_of_layer("coarse"),
"strict inequality when coarse wrote leaves outside `breathe.*`",
);
}
#[test]
fn subtree_writes_of_layer_at_exact_scalar_leaf_yields_that_leaf_only() {
let out = subtree_fixture();
let prefix = vec![s("alpha")];
let coarse: Vec<Vec<String>> = out
.attribution
.subtree_writes_of_layer(&prefix, "coarse")
.into_iter()
.map(<[String]>::to_vec)
.collect();
assert_eq!(coarse, vec![vec![s("alpha")]]);
assert!(
out.attribution
.subtree_writes_of_layer(&prefix, "specific")
.is_empty(),
"the leaf's non-writer gets no bucket at the exact-leaf prefix",
);
assert_eq!(
out.attribution
.subtree_leaf_count_of_layer(&prefix, "coarse"),
1,
"the leaf's writer gets count 1 at the exact-leaf prefix",
);
assert_eq!(
out.attribution
.subtree_leaf_count_of_layer(&prefix, "specific"),
0,
"non-writer's count at the exact-leaf prefix is zero",
);
}
fn three_way_tie_fixture() -> DiscoveryComposition {
let a = Fixed("aaa", dict(&[("ka", Value::from(1i64))]));
let b = Fixed("bbb", dict(&[("kb", Value::from(2i64))]));
let c = Fixed("ccc", dict(&[("kc", Value::from(3i64))]));
compose_with_provenance(&[&a, &b, &c])
}
fn inversion_fixture() -> DiscoveryComposition {
let coarse = Fixed(
"coarse",
dict(&[
(
"big",
Value::from(dict(&[
("a", Value::from(1i64)),
("b", Value::from(2i64)),
("c", Value::from(3i64)),
])),
),
("small", Value::from(dict(&[("x", Value::from(4i64))]))),
]),
);
let specific = Fixed(
"specific",
dict(&[(
"small",
Value::from(dict(&[("y", Value::from(5i64)), ("z", Value::from(6i64))])),
)]),
);
compose_with_provenance(&[&coarse, &specific])
}
#[test]
fn dominant_layer_agrees_with_leaf_counts_argmax() {
let out = layer_axis_fixture();
let dominant = out.attribution.dominant_layer().expect("non-empty");
assert_eq!(dominant, "tenancy", "tenancy owns 2 leaves > platform's 1");
let counts = out.attribution.leaf_counts_by_layer();
let max_count = counts.values().copied().max().expect("non-empty");
assert_eq!(
counts.get(dominant).copied().unwrap_or(0),
max_count,
"dominant writer's count equals the max of leaf_counts_by_layer",
);
assert_eq!(
out.attribution.leaf_count_of_layer(dominant),
max_count,
"leaf_count_of_layer(dominant) also equals the max",
);
}
#[test]
fn dominant_layer_ties_broken_by_lex_name_ascending() {
let out = three_way_tie_fixture();
assert_eq!(
out.attribution.dominant_layer(),
Some("aaa"),
"on a three-way tie, the smallest lex name wins",
);
}
#[test]
fn dominant_layer_empty_attribution_is_none() {
let empty = compose_with_provenance(&[]);
assert_eq!(
empty.attribution.dominant_layer(),
None,
"empty attribution ⇒ no dominant layer",
);
let silent = Fixed("silent-a", Dict::new());
let more_silent = Fixed("silent-b", Dict::new());
let silent_out = compose_with_provenance(&[&silent, &more_silent]);
assert_eq!(
silent_out.attribution.dominant_layer(),
None,
"silent-only stack ⇒ no dominant layer",
);
}
#[test]
fn dominant_layer_single_writer_is_that_writer() {
let solo = Fixed(
"solo",
dict(&[("k1", Value::from(1i64)), ("k2", Value::from(2i64))]),
);
let silent = Fixed("silent", Dict::new());
let out = compose_with_provenance(&[&solo, &silent]);
assert_eq!(
out.attribution.dominant_layer(),
Some("solo"),
"the only surviving writer is the dominant one",
);
}
#[test]
fn dominant_layer_is_member_of_surviving_layer_names() {
for out in [
layer_axis_fixture(),
subtree_fixture(),
three_way_tie_fixture(),
inversion_fixture(),
] {
if let Some(dominant) = out.attribution.dominant_layer() {
assert!(
out.attribution.surviving_layer_names().contains(&dominant),
"dominant_layer must be a member of surviving_layer_names",
);
}
}
}
#[test]
fn subtree_dominant_layer_empty_prefix_equals_dominant_layer() {
for out in [
layer_axis_fixture(),
subtree_fixture(),
three_way_tie_fixture(),
inversion_fixture(),
compose_with_provenance(&[]),
] {
assert_eq!(
out.attribution.subtree_dominant_layer(&[]),
out.attribution.dominant_layer(),
"empty prefix ⇒ subtree_dominant_layer equals dominant_layer",
);
}
}
#[test]
fn subtree_dominant_layer_at_named_prefix_narrows_the_argmax() {
let out = subtree_fixture();
assert_eq!(
out.attribution.subtree_dominant_layer(&[s("breathe")]),
Some("coarse"),
"under breathe.*, coarse and specific tie at 1 leaf each — coarse wins by lex",
);
assert_eq!(
out.attribution.subtree_dominant_layer(&[s("alpha")]),
Some("coarse"),
"under alpha (a leaf), coarse alone is dominant",
);
}
#[test]
fn subtree_dominant_layer_absent_prefix_is_none() {
let out = subtree_fixture();
assert_eq!(
out.attribution.subtree_dominant_layer(&[s("nonexistent")]),
None,
"absent prefix ⇒ empty subtree ⇒ None",
);
}
#[test]
fn subtree_dominant_layer_agrees_with_argmax_of_subtree_counts() {
let prefixes: Vec<Vec<String>> = vec![
vec![],
vec![s("breathe")],
vec![s("alpha")],
vec![s("small")],
vec![s("big")],
vec![s("nonexistent")],
];
for out in [subtree_fixture(), inversion_fixture(), layer_axis_fixture()] {
for prefix in &prefixes {
let counts = out.attribution.subtree_leaf_counts_by_layer(prefix);
let dominant = out.attribution.subtree_dominant_layer(prefix);
if let Some(name) = dominant {
let max_count = counts.values().copied().max().unwrap_or(0);
assert_eq!(
counts.get(name).copied().unwrap_or(0),
max_count,
"at prefix {prefix:?}, dominant {name}'s subtree count equals the max",
);
assert_eq!(
out.attribution.subtree_leaf_count_of_layer(prefix, name),
max_count,
"at prefix {prefix:?}, subtree_leaf_count_of_layer({name}) also equals the max",
);
let tied_at_max: Vec<&'static str> = counts
.iter()
.filter_map(|(k, v)| (*v == max_count).then_some(*k))
.collect();
assert_eq!(
tied_at_max.first().copied(),
Some(name),
"the winner is the smallest lex name among tied maxima",
);
} else {
assert!(
counts.is_empty(),
"None ⇒ empty subtree_leaf_counts_by_layer at prefix {prefix:?}",
);
assert_eq!(
out.attribution.subtree_iter(prefix).count(),
0,
"None ⇒ empty subtree_iter at prefix {prefix:?}",
);
}
}
}
}
#[test]
fn subtree_dominant_layer_is_member_of_subtree_surviving_layer_names_when_some() {
let prefixes: Vec<Vec<String>> = vec![
vec![],
vec![s("breathe")],
vec![s("alpha")],
vec![s("small")],
vec![s("big")],
vec![s("nonexistent")],
];
for out in [subtree_fixture(), inversion_fixture(), layer_axis_fixture()] {
for prefix in &prefixes {
if let Some(dominant) = out.attribution.subtree_dominant_layer(prefix) {
assert!(
out.attribution
.subtree_surviving_layer_names(prefix)
.contains(&dominant),
"at prefix {prefix:?}, dominant {dominant} must be in subtree_surviving_layer_names",
);
assert!(
out.attribution.surviving_layer_names().contains(&dominant),
"at prefix {prefix:?}, dominant {dominant} must be in surviving_layer_names",
);
}
}
}
}
#[test]
fn subtree_dominant_layer_can_differ_from_dominant_layer() {
let out = inversion_fixture();
assert_eq!(
out.attribution.dominant_layer(),
Some("coarse"),
"coarse owns the top-level argmax (4 leaves)",
);
assert_eq!(
out.attribution.subtree_dominant_layer(&[s("small")]),
Some("specific"),
"specific owns the ['small'] subtree (2 leaves vs coarse's 1)",
);
assert_eq!(
out.attribution.subtree_dominant_layer(&[s("big")]),
Some("coarse"),
"coarse still owns the ['big'] subtree (3 leaves vs specific's 0)",
);
}
#[test]
fn layer_ranking_agrees_with_leaf_counts_by_layer() {
for out in [
layer_axis_fixture(),
subtree_fixture(),
three_way_tie_fixture(),
inversion_fixture(),
] {
let ranking = out.attribution.layer_ranking();
let counts = out.attribution.leaf_counts_by_layer();
for (name, count) in &ranking {
assert_eq!(
counts.get(name).copied(),
Some(*count),
"ranking entry ({name}, {count}) must match leaf_counts_by_layer",
);
assert_eq!(
out.attribution.leaf_count_of_layer(name),
*count,
"ranking entry ({name}, {count}) must match leaf_count_of_layer",
);
}
let ranking_names: std::collections::BTreeSet<&'static str> =
ranking.iter().map(|(n, _)| *n).collect();
let counts_names: std::collections::BTreeSet<&'static str> =
counts.into_keys().collect();
assert_eq!(
ranking_names, counts_names,
"ranking names ≡ leaf_counts_by_layer keys (as a set)",
);
}
}
#[test]
fn layer_ranking_len_equals_surviving_layer_names_len() {
for out in [
layer_axis_fixture(),
subtree_fixture(),
three_way_tie_fixture(),
inversion_fixture(),
compose_with_provenance(&[]),
] {
assert_eq!(
out.attribution.layer_ranking().len(),
out.attribution.surviving_layer_names().len(),
"|layer_ranking| = |surviving_layer_names|",
);
assert_eq!(
out.attribution.layer_ranking().len(),
out.attribution.leaf_counts_by_layer().len(),
"|layer_ranking| = |leaf_counts_by_layer|",
);
}
}
#[test]
fn layer_ranking_counts_sum_to_len() {
for out in [
layer_axis_fixture(),
subtree_fixture(),
three_way_tie_fixture(),
inversion_fixture(),
compose_with_provenance(&[]),
] {
let sum: usize = out.attribution.layer_ranking().iter().map(|(_, c)| c).sum();
assert_eq!(sum, out.attribution.len(), "Σ counts = attribution.len()");
}
}
#[test]
fn layer_ranking_empty_iff_attribution_is_empty() {
assert!(
compose_with_provenance(&[])
.attribution
.layer_ranking()
.is_empty(),
"empty attribution ⇒ empty ranking",
);
for out in [
layer_axis_fixture(),
subtree_fixture(),
three_way_tie_fixture(),
inversion_fixture(),
] {
assert!(
!out.attribution.layer_ranking().is_empty(),
"non-empty attribution ⇒ non-empty ranking",
);
}
}
#[test]
fn layer_ranking_first_equals_dominant_layer() {
for out in [
layer_axis_fixture(),
subtree_fixture(),
three_way_tie_fixture(),
inversion_fixture(),
compose_with_provenance(&[]),
] {
let ranking_first: Option<&'static str> =
out.attribution.layer_ranking().first().map(|(n, _)| *n);
assert_eq!(
ranking_first,
out.attribution.dominant_layer(),
"ranking.first().name ≡ dominant_layer()",
);
}
}
#[test]
fn layer_ranking_counts_are_non_increasing() {
for out in [
layer_axis_fixture(),
subtree_fixture(),
three_way_tie_fixture(),
inversion_fixture(),
] {
let ranking = out.attribution.layer_ranking();
for window in ranking.windows(2) {
assert!(
window[0].1 >= window[1].1,
"counts must be non-increasing: {} !>= {}",
window[0].1,
window[1].1,
);
}
}
}
#[test]
fn layer_ranking_ties_are_lex_ascending() {
let out = three_way_tie_fixture();
assert_eq!(
out.attribution.layer_ranking(),
vec![("aaa", 1), ("bbb", 1), ("ccc", 1)],
"three-way tie orders by lex ascending",
);
for out in [
layer_axis_fixture(),
subtree_fixture(),
three_way_tie_fixture(),
inversion_fixture(),
] {
let ranking = out.attribution.layer_ranking();
for window in ranking.windows(2) {
if window[0].1 == window[1].1 {
assert!(
window[0].0 < window[1].0,
"tied names must be lex-ascending: {} !< {}",
window[0].0,
window[1].0,
);
}
}
}
}
#[test]
fn subtree_layer_ranking_empty_prefix_equals_layer_ranking() {
for out in [
layer_axis_fixture(),
subtree_fixture(),
three_way_tie_fixture(),
inversion_fixture(),
compose_with_provenance(&[]),
] {
assert_eq!(
out.attribution.subtree_layer_ranking(&[]),
out.attribution.layer_ranking(),
"empty prefix ⇒ subtree_layer_ranking equals layer_ranking",
);
}
}
#[test]
fn subtree_layer_ranking_absent_prefix_is_empty() {
let out = subtree_fixture();
assert!(
out.attribution
.subtree_layer_ranking(&[s("nonexistent")])
.is_empty(),
"absent prefix ⇒ empty subtree ⇒ empty ranking",
);
}
#[test]
fn subtree_layer_ranking_first_equals_subtree_dominant_layer() {
let prefixes: Vec<Vec<String>> = vec![
vec![],
vec![s("breathe")],
vec![s("alpha")],
vec![s("small")],
vec![s("big")],
vec![s("nonexistent")],
];
for out in [
subtree_fixture(),
inversion_fixture(),
layer_axis_fixture(),
three_way_tie_fixture(),
] {
for prefix in &prefixes {
let ranking_first: Option<&'static str> = out
.attribution
.subtree_layer_ranking(prefix)
.first()
.map(|(n, _)| *n);
assert_eq!(
ranking_first,
out.attribution.subtree_dominant_layer(prefix),
"at prefix {prefix:?}, subtree ranking.first().name ≡ subtree_dominant_layer",
);
}
}
}
#[test]
fn subtree_layer_ranking_agrees_with_subtree_leaf_counts() {
let prefixes: Vec<Vec<String>> = vec![
vec![],
vec![s("breathe")],
vec![s("alpha")],
vec![s("small")],
vec![s("big")],
vec![s("nonexistent")],
];
for out in [subtree_fixture(), inversion_fixture(), layer_axis_fixture()] {
for prefix in &prefixes {
let ranking = out.attribution.subtree_layer_ranking(prefix);
let counts = out.attribution.subtree_leaf_counts_by_layer(prefix);
let sum: usize = ranking.iter().map(|(_, c)| c).sum();
assert_eq!(
sum,
out.attribution.subtree_iter(prefix).count(),
"at prefix {prefix:?}, Σ counts = subtree_iter count",
);
for (name, count) in &ranking {
assert_eq!(
counts.get(name).copied(),
Some(*count),
"at prefix {prefix:?}, ranking entry ({name}, {count}) matches subtree_leaf_counts_by_layer",
);
assert_eq!(
out.attribution.subtree_leaf_count_of_layer(prefix, name),
*count,
"at prefix {prefix:?}, ranking entry ({name}, {count}) matches subtree_leaf_count_of_layer",
);
}
let ranking_names: std::collections::BTreeSet<&'static str> =
ranking.iter().map(|(n, _)| *n).collect();
let survivor_names: std::collections::BTreeSet<&'static str> = out
.attribution
.subtree_surviving_layer_names(prefix)
.into_iter()
.collect();
assert_eq!(
ranking_names, survivor_names,
"at prefix {prefix:?}, ranking names ≡ subtree_surviving_layer_names (as a set)",
);
}
}
}
#[test]
fn subtree_layer_ranking_counts_are_non_increasing_and_ties_lex_ascending() {
let prefixes: Vec<Vec<String>> = vec![
vec![],
vec![s("breathe")],
vec![s("alpha")],
vec![s("small")],
vec![s("big")],
];
for out in [
subtree_fixture(),
inversion_fixture(),
layer_axis_fixture(),
three_way_tie_fixture(),
] {
for prefix in &prefixes {
let ranking = out.attribution.subtree_layer_ranking(prefix);
for window in ranking.windows(2) {
assert!(
window[0].1 >= window[1].1,
"at prefix {prefix:?}, counts non-increasing: {} !>= {}",
window[0].1,
window[1].1,
);
if window[0].1 == window[1].1 {
assert!(
window[0].0 < window[1].0,
"at prefix {prefix:?}, tied names lex-ascending: {} !< {}",
window[0].0,
window[1].0,
);
}
}
}
}
}
#[test]
fn subtree_layer_ranking_narrows_at_named_prefix() {
let out = inversion_fixture();
assert_eq!(
out.attribution.subtree_layer_ranking(&[s("small")]),
vec![("specific", 2), ("coarse", 1)],
"under small.*, specific tops the ranking (2 vs 1)",
);
assert_eq!(
out.attribution.subtree_layer_ranking(&[s("big")]),
vec![("coarse", 3)],
"under big.*, only coarse contributes (3 leaves)",
);
}
#[test]
fn subtree_layer_ranking_name_set_subset_of_surviving_layer_names() {
let prefixes: Vec<Vec<String>> = vec![
vec![],
vec![s("breathe")],
vec![s("alpha")],
vec![s("small")],
vec![s("big")],
vec![s("nonexistent")],
];
for out in [subtree_fixture(), inversion_fixture(), layer_axis_fixture()] {
let global: std::collections::BTreeSet<&'static str> = out
.attribution
.surviving_layer_names()
.into_iter()
.collect();
for prefix in &prefixes {
let ranking = out.attribution.subtree_layer_ranking(prefix);
for (name, count) in &ranking {
assert!(
global.contains(name),
"at prefix {prefix:?}, subtree ranking name {name} must survive globally",
);
assert!(
*count <= out.attribution.leaf_count_of_layer(name),
"at prefix {prefix:?}, subtree count {count} ≤ global {} for {name}",
out.attribution.leaf_count_of_layer(name),
);
}
}
}
}
#[test]
fn layer_ranking_iter_collect_matches_layer_ranking() {
for out in [subtree_fixture(), inversion_fixture(), layer_axis_fixture()] {
assert_eq!(
out.attribution.layer_ranking_iter().collect::<Vec<_>>(),
out.attribution.layer_ranking(),
"iter dual collects to the same Vec as the collecting form",
);
}
}
#[test]
fn layer_ranking_iter_empty_attribution_is_empty_stream() {
let empty = compose_with_provenance(&[]);
let iter = empty.attribution.layer_ranking_iter();
assert_eq!(iter.len(), 0);
assert_eq!(iter.size_hint(), (0, Some(0)));
assert_eq!(
empty.attribution.layer_ranking_iter().collect::<Vec<_>>(),
Vec::<(&'static str, usize)>::new(),
);
}
#[test]
fn layer_ranking_iter_len_equals_distinct_writer_count() {
for out in [subtree_fixture(), inversion_fixture(), layer_axis_fixture()] {
let iter = out.attribution.layer_ranking_iter();
let expected = out.attribution.layer_ranking().len();
assert_eq!(iter.len(), expected);
assert_eq!(iter.size_hint(), (expected, Some(expected)));
}
}
#[test]
fn layer_ranking_iter_next_agrees_with_dominant_layer() {
let out = layer_axis_fixture();
let head = out.attribution.layer_ranking_iter().next();
assert_eq!(head.map(|(n, _)| n), out.attribution.dominant_layer());
assert_eq!(head, out.attribution.dominant_entry());
}
#[test]
fn layer_ranking_iter_next_back_agrees_with_weakest_layer() {
let out = layer_axis_fixture();
let tail = out.attribution.layer_ranking_iter().next_back();
assert_eq!(tail.map(|(n, _)| n), out.attribution.weakest_layer());
assert_eq!(tail, out.attribution.weakest_entry());
assert_eq!(out.attribution.layer_ranking_iter().last(), tail);
}
#[test]
fn layer_ranking_iter_rev_matches_layer_ranking_reversed() {
let out = inversion_fixture();
let forward = out.attribution.layer_ranking();
let mut expected = forward.clone();
expected.reverse();
assert_eq!(
out.attribution
.layer_ranking_iter()
.rev()
.collect::<Vec<_>>(),
expected,
);
}
#[test]
fn layer_ranking_iter_take_short_circuits_at_top_k() {
let out = inversion_fixture();
let full = out.attribution.layer_ranking();
for k in 0..=full.len() {
let via_iter: Vec<_> = out.attribution.layer_ranking_iter().take(k).collect();
assert_eq!(via_iter, full[..k].to_vec(), "top-{k} slice");
}
}
#[test]
fn layer_ranking_iter_fused_after_exhaustion() {
let out = layer_axis_fixture();
let mut iter = out.attribution.layer_ranking_iter();
while iter.next().is_some() {}
assert_eq!(iter.next(), None);
assert_eq!(iter.next(), None);
assert_eq!(iter.next(), None);
}
#[test]
fn layer_ranking_iter_clone_walks_independently() {
let out = inversion_fixture();
let iter = out.attribution.layer_ranking_iter();
let clone = iter.clone();
let via_original: Vec<_> = iter.collect();
let via_clone: Vec<_> = clone.collect();
assert_eq!(via_original, via_clone);
assert_eq!(via_original, out.attribution.layer_ranking());
}
#[test]
fn subtree_layer_ranking_iter_collect_matches_subtree_layer_ranking() {
let out = subtree_fixture();
for prefix in [
vec![],
vec![s("breathe")],
vec![s("alpha")],
vec![s("nonexistent")],
] {
assert_eq!(
out.attribution
.subtree_layer_ranking_iter(&prefix)
.collect::<Vec<_>>(),
out.attribution.subtree_layer_ranking(&prefix),
"iter dual collects to the same Vec at {prefix:?}",
);
}
}
#[test]
fn subtree_layer_ranking_iter_empty_prefix_matches_layer_ranking_iter() {
for out in [subtree_fixture(), inversion_fixture(), layer_axis_fixture()] {
assert_eq!(
out.attribution
.subtree_layer_ranking_iter(&[])
.collect::<Vec<_>>(),
out.attribution.layer_ranking_iter().collect::<Vec<_>>(),
);
}
}
#[test]
fn subtree_layer_ranking_iter_empty_attribution_is_empty_stream() {
let empty = compose_with_provenance(&[]);
for prefix in [vec![], vec![s("any")], vec![s("nested"), s("under")]] {
let iter = empty.attribution.subtree_layer_ranking_iter(&prefix);
assert_eq!(iter.len(), 0, "empty attribution at {prefix:?}");
assert_eq!(iter.size_hint(), (0, Some(0)));
assert_eq!(
empty
.attribution
.subtree_layer_ranking_iter(&prefix)
.collect::<Vec<_>>(),
Vec::<(&'static str, usize)>::new(),
);
}
}
#[test]
fn subtree_layer_ranking_iter_absent_prefix_is_empty_stream() {
let out = subtree_fixture();
let iter = out
.attribution
.subtree_layer_ranking_iter(&[s("nonexistent")]);
assert_eq!(iter.len(), 0);
assert_eq!(iter.size_hint(), (0, Some(0)));
assert_eq!(
out.attribution
.subtree_layer_ranking_iter(&[s("nonexistent")])
.collect::<Vec<_>>(),
Vec::<(&'static str, usize)>::new(),
);
}
#[test]
fn subtree_layer_ranking_iter_len_equals_distinct_writer_count_under_subtree() {
let out = subtree_fixture();
for prefix in [vec![], vec![s("breathe")], vec![s("alpha")]] {
let iter = out.attribution.subtree_layer_ranking_iter(&prefix);
let expected = out.attribution.subtree_layer_ranking(&prefix).len();
assert_eq!(iter.len(), expected, "len at {prefix:?}");
assert_eq!(iter.size_hint(), (expected, Some(expected)));
}
}
#[test]
fn subtree_layer_ranking_iter_next_agrees_with_subtree_dominant_layer() {
let out = subtree_fixture();
for prefix in [vec![], vec![s("breathe")], vec![s("alpha")]] {
let head = out.attribution.subtree_layer_ranking_iter(&prefix).next();
assert_eq!(
head.map(|(n, _)| n),
out.attribution.subtree_dominant_layer(&prefix),
"head endpoint at {prefix:?}",
);
assert_eq!(head, out.attribution.subtree_dominant_entry(&prefix));
}
}
#[test]
fn subtree_layer_ranking_iter_next_back_agrees_with_subtree_weakest_layer() {
let out = subtree_fixture();
for prefix in [vec![], vec![s("breathe")], vec![s("alpha")]] {
let tail = out
.attribution
.subtree_layer_ranking_iter(&prefix)
.next_back();
assert_eq!(
tail.map(|(n, _)| n),
out.attribution.subtree_weakest_layer(&prefix),
"tail endpoint at {prefix:?}",
);
assert_eq!(tail, out.attribution.subtree_weakest_entry(&prefix));
assert_eq!(
out.attribution.subtree_layer_ranking_iter(&prefix).last(),
tail,
"overridden .last() at {prefix:?} matches .next_back()",
);
}
}
#[test]
fn subtree_layer_ranking_iter_stops_at_prefix_extending_sibling_key() {
let out = subtree_fixture();
let global_names: std::collections::BTreeSet<&'static str> = out
.attribution
.layer_ranking_iter()
.map(|(n, _)| n)
.collect();
let subtree_names: std::collections::BTreeSet<&'static str> = out
.attribution
.subtree_layer_ranking_iter(&[s("breathe")])
.map(|(n, _)| n)
.collect();
assert!(
subtree_names.is_subset(&global_names),
"subtree names ⊆ global names",
);
let total_under_subtree: usize = out
.attribution
.subtree_layer_ranking_iter(&[s("breathe")])
.map(|(_, c)| c)
.sum();
let subtree_leaf_count = out.attribution.subtree_iter(&[s("breathe")]).count();
assert_eq!(total_under_subtree, subtree_leaf_count);
}
#[test]
fn subtree_layer_ranking_iter_fused_after_exhaustion() {
let out = subtree_fixture();
for prefix in [vec![], vec![s("breathe")], vec![s("nonexistent")]] {
let mut iter = out.attribution.subtree_layer_ranking_iter(&prefix);
while iter.next().is_some() {}
assert_eq!(iter.next(), None);
assert_eq!(iter.next(), None);
assert_eq!(iter.next(), None);
}
}
#[test]
fn subtree_layer_ranking_iter_clone_walks_independently() {
let out = subtree_fixture();
let prefix = vec![s("breathe")];
let iter = out.attribution.subtree_layer_ranking_iter(&prefix);
let clone = iter.clone();
let via_original: Vec<_> = iter.collect();
let via_clone: Vec<_> = clone.collect();
assert_eq!(via_original, via_clone);
assert_eq!(via_original, out.attribution.subtree_layer_ranking(&prefix));
}
#[test]
fn layer_ranking_names_iter_matches_layer_ranking_iter_map_name() {
for out in [subtree_fixture(), inversion_fixture(), layer_axis_fixture()] {
let via_names_iter: Vec<&'static str> =
out.attribution.layer_ranking_names_iter().collect();
let via_ranking_map: Vec<&'static str> = out
.attribution
.layer_ranking_iter()
.map(|(n, _)| n)
.collect();
assert_eq!(via_names_iter, via_ranking_map);
}
}
#[test]
fn layer_ranking_names_iter_empty_attribution_is_empty_stream() {
let empty = compose_with_provenance(&[]);
let iter = empty.attribution.layer_ranking_names_iter();
assert_eq!(iter.len(), 0);
assert_eq!(iter.size_hint(), (0, Some(0)));
assert_eq!(
empty
.attribution
.layer_ranking_names_iter()
.collect::<Vec<_>>(),
Vec::<&'static str>::new(),
);
}
#[test]
fn layer_ranking_names_iter_len_equals_distinct_writer_count() {
for out in [subtree_fixture(), inversion_fixture(), layer_axis_fixture()] {
let iter = out.attribution.layer_ranking_names_iter();
let expected = out.attribution.layer_ranking().len();
assert_eq!(iter.len(), expected);
assert_eq!(iter.size_hint(), (expected, Some(expected)));
}
}
#[test]
fn layer_ranking_names_iter_next_agrees_with_dominant_layer() {
let out = layer_axis_fixture();
let head = out.attribution.layer_ranking_names_iter().next();
assert_eq!(head, out.attribution.dominant_layer());
}
#[test]
fn layer_ranking_names_iter_next_back_agrees_with_weakest_layer() {
let out = layer_axis_fixture();
let tail = out.attribution.layer_ranking_names_iter().next_back();
assert_eq!(tail, out.attribution.weakest_layer());
assert_eq!(out.attribution.layer_ranking_names_iter().last(), tail);
}
#[test]
fn layer_ranking_names_iter_rev_matches_names_reversed() {
let out = inversion_fixture();
let mut expected: Vec<&'static str> = out
.attribution
.layer_ranking()
.into_iter()
.map(|(n, _)| n)
.collect();
expected.reverse();
assert_eq!(
out.attribution
.layer_ranking_names_iter()
.rev()
.collect::<Vec<_>>(),
expected,
);
}
#[test]
fn layer_ranking_names_iter_take_short_circuits_at_top_k() {
let out = inversion_fixture();
let full: Vec<&'static str> = out
.attribution
.layer_ranking()
.into_iter()
.map(|(n, _)| n)
.collect();
for k in 0..=full.len() {
let via_iter: Vec<&'static str> =
out.attribution.layer_ranking_names_iter().take(k).collect();
assert_eq!(via_iter, full[..k].to_vec(), "top-{k} slice");
}
}
#[test]
fn layer_ranking_names_iter_set_equals_surviving_layer_names() {
for out in [subtree_fixture(), inversion_fixture(), layer_axis_fixture()] {
let via_ranking_names: std::collections::BTreeSet<&'static str> =
out.attribution.layer_ranking_names_iter().collect();
let via_survivors: std::collections::BTreeSet<&'static str> = out
.attribution
.surviving_layer_names()
.into_iter()
.collect();
assert_eq!(via_ranking_names, via_survivors);
}
}
#[test]
fn layer_ranking_names_iter_fused_after_exhaustion() {
let out = layer_axis_fixture();
let mut iter = out.attribution.layer_ranking_names_iter();
while iter.next().is_some() {}
assert_eq!(iter.next(), None);
assert_eq!(iter.next(), None);
assert_eq!(iter.next(), None);
}
#[test]
fn layer_ranking_names_iter_clone_walks_independently() {
let out = inversion_fixture();
let iter = out.attribution.layer_ranking_names_iter();
let clone = iter.clone();
let via_original: Vec<_> = iter.collect();
let via_clone: Vec<_> = clone.collect();
assert_eq!(via_original, via_clone);
let expected: Vec<&'static str> = out
.attribution
.layer_ranking()
.into_iter()
.map(|(n, _)| n)
.collect();
assert_eq!(via_original, expected);
}
#[test]
fn subtree_layer_ranking_names_iter_matches_ranking_iter_map_name() {
let out = subtree_fixture();
for prefix in [
vec![],
vec![s("breathe")],
vec![s("alpha")],
vec![s("nonexistent")],
] {
let via_names_iter: Vec<&'static str> = out
.attribution
.subtree_layer_ranking_names_iter(&prefix)
.collect();
let via_ranking_map: Vec<&'static str> = out
.attribution
.subtree_layer_ranking_iter(&prefix)
.map(|(n, _)| n)
.collect();
assert_eq!(via_names_iter, via_ranking_map, "at {prefix:?}");
}
}
#[test]
fn subtree_layer_ranking_names_iter_empty_prefix_matches_free_axis() {
for out in [subtree_fixture(), inversion_fixture(), layer_axis_fixture()] {
assert_eq!(
out.attribution
.subtree_layer_ranking_names_iter(&[])
.collect::<Vec<_>>(),
out.attribution
.layer_ranking_names_iter()
.collect::<Vec<_>>(),
);
}
}
#[test]
fn subtree_layer_ranking_names_iter_empty_attribution_is_empty_stream() {
let empty = compose_with_provenance(&[]);
for prefix in [vec![], vec![s("any")], vec![s("nested"), s("under")]] {
let iter = empty.attribution.subtree_layer_ranking_names_iter(&prefix);
assert_eq!(iter.len(), 0, "empty attribution at {prefix:?}");
assert_eq!(iter.size_hint(), (0, Some(0)));
assert_eq!(
empty
.attribution
.subtree_layer_ranking_names_iter(&prefix)
.collect::<Vec<_>>(),
Vec::<&'static str>::new(),
);
}
}
#[test]
fn subtree_layer_ranking_names_iter_absent_prefix_is_empty_stream() {
let out = subtree_fixture();
let iter = out
.attribution
.subtree_layer_ranking_names_iter(&[s("nonexistent")]);
assert_eq!(iter.len(), 0);
assert_eq!(iter.size_hint(), (0, Some(0)));
assert_eq!(
out.attribution
.subtree_layer_ranking_names_iter(&[s("nonexistent")])
.collect::<Vec<_>>(),
Vec::<&'static str>::new(),
);
}
#[test]
fn subtree_layer_ranking_names_iter_len_equals_distinct_writer_count_under_subtree() {
let out = subtree_fixture();
for prefix in [vec![], vec![s("breathe")], vec![s("alpha")]] {
let iter = out.attribution.subtree_layer_ranking_names_iter(&prefix);
let expected = out.attribution.subtree_layer_ranking(&prefix).len();
assert_eq!(iter.len(), expected, "len at {prefix:?}");
assert_eq!(iter.size_hint(), (expected, Some(expected)));
}
}
#[test]
fn subtree_layer_ranking_names_iter_next_agrees_with_subtree_dominant_layer() {
let out = subtree_fixture();
for prefix in [vec![], vec![s("breathe")], vec![s("alpha")]] {
let head = out
.attribution
.subtree_layer_ranking_names_iter(&prefix)
.next();
assert_eq!(
head,
out.attribution.subtree_dominant_layer(&prefix),
"head endpoint at {prefix:?}",
);
}
}
#[test]
fn subtree_layer_ranking_names_iter_next_back_agrees_with_subtree_weakest_layer() {
let out = subtree_fixture();
for prefix in [vec![], vec![s("breathe")], vec![s("alpha")]] {
let tail = out
.attribution
.subtree_layer_ranking_names_iter(&prefix)
.next_back();
assert_eq!(
tail,
out.attribution.subtree_weakest_layer(&prefix),
"tail endpoint at {prefix:?}",
);
assert_eq!(
out.attribution
.subtree_layer_ranking_names_iter(&prefix)
.last(),
tail,
"overridden .last() at {prefix:?} matches .next_back()",
);
}
}
#[test]
fn subtree_layer_ranking_names_iter_set_equals_subtree_surviving_layer_names() {
let out = subtree_fixture();
for prefix in [vec![], vec![s("breathe")], vec![s("alpha")]] {
let via_ranking_names: std::collections::BTreeSet<&'static str> = out
.attribution
.subtree_layer_ranking_names_iter(&prefix)
.collect();
let via_survivors: std::collections::BTreeSet<&'static str> = out
.attribution
.subtree_surviving_layer_names(&prefix)
.into_iter()
.collect();
assert_eq!(via_ranking_names, via_survivors, "at {prefix:?}");
}
}
#[test]
fn subtree_layer_ranking_names_iter_subset_of_free_axis() {
let out = subtree_fixture();
let global_names: std::collections::BTreeSet<&'static str> =
out.attribution.layer_ranking_names_iter().collect();
let subtree_names: std::collections::BTreeSet<&'static str> = out
.attribution
.subtree_layer_ranking_names_iter(&[s("breathe")])
.collect();
assert!(
subtree_names.is_subset(&global_names),
"subtree names ⊆ global names",
);
}
#[test]
fn subtree_layer_ranking_names_iter_fused_after_exhaustion() {
let out = subtree_fixture();
for prefix in [vec![], vec![s("breathe")], vec![s("nonexistent")]] {
let mut iter = out.attribution.subtree_layer_ranking_names_iter(&prefix);
while iter.next().is_some() {}
assert_eq!(iter.next(), None);
assert_eq!(iter.next(), None);
assert_eq!(iter.next(), None);
}
}
#[test]
fn subtree_layer_ranking_names_iter_clone_walks_independently() {
let out = subtree_fixture();
let prefix = vec![s("breathe")];
let iter = out.attribution.subtree_layer_ranking_names_iter(&prefix);
let clone = iter.clone();
let via_original: Vec<_> = iter.collect();
let via_clone: Vec<_> = clone.collect();
assert_eq!(via_original, via_clone);
let expected: Vec<&'static str> = out
.attribution
.subtree_layer_ranking(&prefix)
.into_iter()
.map(|(n, _)| n)
.collect();
assert_eq!(via_original, expected);
}
#[test]
fn weakest_layer_agrees_with_leaf_counts_argmin() {
let out = layer_axis_fixture();
let weakest = out.attribution.weakest_layer().expect("non-empty");
assert_eq!(weakest, "platform", "platform owns 1 leaf < tenancy's 2");
let counts = out.attribution.leaf_counts_by_layer();
let min_count = counts.values().copied().min().expect("non-empty");
assert_eq!(
counts.get(weakest).copied().unwrap_or(0),
min_count,
"weakest writer's count equals the min of leaf_counts_by_layer",
);
assert_eq!(
out.attribution.leaf_count_of_layer(weakest),
min_count,
"leaf_count_of_layer(weakest) also equals the min",
);
}
#[test]
fn weakest_layer_ties_broken_by_lex_name_descending() {
let out = three_way_tie_fixture();
assert_eq!(
out.attribution.weakest_layer(),
Some("ccc"),
"on a three-way tie, the largest lex name wins the argmin",
);
}
#[test]
fn weakest_layer_empty_attribution_is_none() {
let empty = compose_with_provenance(&[]);
assert_eq!(empty.attribution.weakest_layer(), None);
let silent = Fixed("silent-a", Dict::new());
let more_silent = Fixed("silent-b", Dict::new());
let silent_out = compose_with_provenance(&[&silent, &more_silent]);
assert_eq!(silent_out.attribution.weakest_layer(), None);
}
#[test]
fn weakest_layer_single_writer_is_that_writer() {
let solo = Fixed(
"solo",
dict(&[("k1", Value::from(1i64)), ("k2", Value::from(2i64))]),
);
let silent = Fixed("silent", Dict::new());
let out = compose_with_provenance(&[&solo, &silent]);
assert_eq!(out.attribution.weakest_layer(), Some("solo"));
assert_eq!(
out.attribution.weakest_layer(),
out.attribution.dominant_layer(),
"single-writer bookend collapse",
);
}
#[test]
fn weakest_layer_is_member_of_surviving_layer_names() {
for out in [
layer_axis_fixture(),
subtree_fixture(),
three_way_tie_fixture(),
inversion_fixture(),
] {
if let Some(weakest) = out.attribution.weakest_layer() {
assert!(
out.attribution.surviving_layer_names().contains(&weakest),
"weakest_layer must be a member of surviving_layer_names",
);
}
}
}
#[test]
fn weakest_layer_equals_layer_ranking_last() {
for out in [
layer_axis_fixture(),
subtree_fixture(),
three_way_tie_fixture(),
inversion_fixture(),
compose_with_provenance(&[]),
] {
let ranking_last: Option<&'static str> =
out.attribution.layer_ranking().last().map(|(n, _)| *n);
assert_eq!(
ranking_last,
out.attribution.weakest_layer(),
"ranking.last().name ≡ weakest_layer()",
);
}
}
#[test]
fn weakest_layer_equals_dominant_layer_on_single_writer_or_flat() {
let solo = Fixed("solo", dict(&[("k", Value::from(1i64))]));
let out = compose_with_provenance(&[&solo]);
assert_eq!(
out.attribution.weakest_layer(),
out.attribution.dominant_layer(),
"single-writer ⇒ bookends coincide",
);
let tied = three_way_tie_fixture();
assert_ne!(
tied.attribution.weakest_layer(),
tied.attribution.dominant_layer(),
"flat but multi-writer ⇒ bookends disagree by tie-break rule",
);
assert_eq!(tied.attribution.dominant_layer(), Some("aaa"));
assert_eq!(tied.attribution.weakest_layer(), Some("ccc"));
let axis = layer_axis_fixture();
assert_ne!(
axis.attribution.weakest_layer(),
axis.attribution.dominant_layer(),
"distinct counts ⇒ bookends differ",
);
}
#[test]
fn subtree_weakest_layer_empty_prefix_equals_weakest_layer() {
for out in [
layer_axis_fixture(),
subtree_fixture(),
three_way_tie_fixture(),
inversion_fixture(),
compose_with_provenance(&[]),
] {
assert_eq!(
out.attribution.subtree_weakest_layer(&[]),
out.attribution.weakest_layer(),
"empty prefix ⇒ subtree_weakest_layer equals weakest_layer",
);
}
}
#[test]
fn subtree_weakest_layer_at_named_prefix_narrows_the_argmin() {
let out = subtree_fixture();
assert_eq!(
out.attribution.subtree_weakest_layer(&[s("breathe")]),
Some("specific"),
"under breathe.*, tied at 1 leaf each — specific wins by largest lex",
);
assert_eq!(
out.attribution.subtree_weakest_layer(&[s("alpha")]),
Some("coarse"),
"under alpha (a leaf), coarse alone is trivially weakest",
);
let inv = inversion_fixture();
assert_eq!(
inv.attribution.subtree_weakest_layer(&[s("small")]),
Some("coarse"),
"under small.*, coarse (1 leaf) is weaker than specific (2)",
);
assert_eq!(
inv.attribution.subtree_weakest_layer(&[s("big")]),
Some("coarse"),
"under big.*, coarse alone is trivially weakest",
);
}
#[test]
fn subtree_weakest_layer_absent_prefix_is_none() {
let out = subtree_fixture();
assert_eq!(
out.attribution.subtree_weakest_layer(&[s("nonexistent")]),
None,
"absent prefix ⇒ empty subtree ⇒ None",
);
}
#[test]
fn subtree_weakest_layer_agrees_with_argmin_of_subtree_counts() {
let prefixes: Vec<Vec<String>> = vec![
vec![],
vec![s("breathe")],
vec![s("alpha")],
vec![s("small")],
vec![s("big")],
vec![s("nonexistent")],
];
for out in [
subtree_fixture(),
inversion_fixture(),
layer_axis_fixture(),
three_way_tie_fixture(),
] {
for prefix in &prefixes {
let weakest = out.attribution.subtree_weakest_layer(prefix);
let counts = out.attribution.subtree_leaf_counts_by_layer(prefix);
if let Some(name) = weakest {
let min_count = counts
.values()
.copied()
.min()
.expect("non-empty subtree ⇒ non-empty counter map");
assert_eq!(
counts.get(name).copied(),
Some(min_count),
"at prefix {prefix:?}, weakest {name} owns the min count",
);
assert_eq!(
out.attribution.subtree_leaf_count_of_layer(prefix, name),
min_count,
"at prefix {prefix:?}, subtree_leaf_count_of_layer({name}) equals the min",
);
let tied_at_min: Vec<&'static str> = counts
.iter()
.filter_map(|(n, c)| (*c == min_count).then_some(*n))
.collect();
assert_eq!(
tied_at_min.last().copied(),
Some(name),
"at prefix {prefix:?}, weakest picks the largest lex name among tied minima",
);
} else {
assert!(
counts.is_empty(),
"at prefix {prefix:?}, None ⇒ counter map is empty",
);
assert_eq!(
out.attribution.subtree_iter(prefix).count(),
0,
"at prefix {prefix:?}, None ⇒ subtree_iter is empty",
);
}
}
}
}
#[test]
fn subtree_weakest_layer_is_member_of_subtree_surviving_layer_names_when_some() {
let prefixes: Vec<Vec<String>> = vec![
vec![],
vec![s("breathe")],
vec![s("alpha")],
vec![s("small")],
vec![s("big")],
vec![s("nonexistent")],
];
for out in [
subtree_fixture(),
inversion_fixture(),
layer_axis_fixture(),
three_way_tie_fixture(),
] {
let global: std::collections::BTreeSet<&'static str> = out
.attribution
.surviving_layer_names()
.into_iter()
.collect();
for prefix in &prefixes {
if let Some(weakest) = out.attribution.subtree_weakest_layer(prefix) {
let subtree_set: std::collections::BTreeSet<&'static str> = out
.attribution
.subtree_surviving_layer_names(prefix)
.into_iter()
.collect();
assert!(
subtree_set.contains(weakest),
"at prefix {prefix:?}, weakest {weakest} lives in subtree_surviving_layer_names",
);
assert!(
global.contains(weakest),
"at prefix {prefix:?}, weakest {weakest} lives in the global surviving set",
);
}
}
}
}
#[test]
fn subtree_weakest_layer_equals_subtree_layer_ranking_last() {
let prefixes: Vec<Vec<String>> = vec![
vec![],
vec![s("breathe")],
vec![s("alpha")],
vec![s("small")],
vec![s("big")],
vec![s("nonexistent")],
];
for out in [
subtree_fixture(),
inversion_fixture(),
layer_axis_fixture(),
three_way_tie_fixture(),
] {
for prefix in &prefixes {
let ranking_last: Option<&'static str> = out
.attribution
.subtree_layer_ranking(prefix)
.last()
.map(|(n, _)| *n);
assert_eq!(
ranking_last,
out.attribution.subtree_weakest_layer(prefix),
"at prefix {prefix:?}, subtree ranking.last().name ≡ subtree_weakest_layer",
);
}
}
}
#[test]
fn subtree_weakest_layer_can_differ_from_weakest_layer() {
let out = inversion_fixture();
assert_eq!(out.attribution.weakest_layer(), Some("specific"));
assert_eq!(
out.attribution.subtree_weakest_layer(&[s("big")]),
Some("coarse"),
"under big.*, specific is absent — coarse is the only (and weakest) writer",
);
assert_eq!(
out.attribution.subtree_weakest_layer(&[s("small")]),
Some("coarse"),
"under small.*, coarse (1 leaf) is weaker than specific (2)",
);
}
#[test]
fn dominant_entry_agrees_with_leaf_counts_argmax() {
let out = layer_axis_fixture();
let entry = out.attribution.dominant_entry().expect("non-empty");
assert_eq!(entry, ("tenancy", 2));
let counts = out.attribution.leaf_counts_by_layer();
let max_count = counts.values().copied().max().expect("non-empty");
assert_eq!(entry.1, max_count);
assert_eq!(counts.get(entry.0).copied(), Some(entry.1));
}
#[test]
fn dominant_entry_ties_broken_by_lex_name_ascending() {
let out = three_way_tie_fixture();
assert_eq!(
out.attribution.dominant_entry(),
Some(("aaa", 1)),
"on a three-way tie, smallest lex name wins with its count",
);
}
#[test]
fn dominant_entry_empty_attribution_is_none() {
let empty = compose_with_provenance(&[]);
assert_eq!(empty.attribution.dominant_entry(), None);
let silent = Fixed("silent-a", Dict::new());
let more_silent = Fixed("silent-b", Dict::new());
let silent_out = compose_with_provenance(&[&silent, &more_silent]);
assert_eq!(silent_out.attribution.dominant_entry(), None);
}
#[test]
fn dominant_entry_single_writer_pairs_writer_with_its_leaf_count() {
let solo = Fixed(
"solo",
dict(&[("k1", Value::from(1i64)), ("k2", Value::from(2i64))]),
);
let silent = Fixed("silent", Dict::new());
let out = compose_with_provenance(&[&solo, &silent]);
assert_eq!(out.attribution.dominant_entry(), Some(("solo", 2)));
}
#[test]
fn dominant_entry_equals_layer_ranking_first() {
for out in [
layer_axis_fixture(),
subtree_fixture(),
three_way_tie_fixture(),
inversion_fixture(),
compose_with_provenance(&[]),
] {
let via_ranking: Option<(&'static str, usize)> =
out.attribution.layer_ranking().first().copied();
assert_eq!(
out.attribution.dominant_entry(),
via_ranking,
"dominant_entry() ≡ layer_ranking().first().copied()",
);
}
}
#[test]
fn dominant_entry_name_projection_equals_dominant_layer() {
for out in [
layer_axis_fixture(),
subtree_fixture(),
three_way_tie_fixture(),
inversion_fixture(),
compose_with_provenance(&[]),
] {
let entry_name: Option<&'static str> = out.attribution.dominant_entry().map(|(n, _)| n);
assert_eq!(
entry_name,
out.attribution.dominant_layer(),
"dominant_entry().map(|(n, _)| n) ≡ dominant_layer()",
);
}
}
#[test]
fn dominant_entry_count_projection_equals_leaf_counts_max() {
for out in [
layer_axis_fixture(),
subtree_fixture(),
three_way_tie_fixture(),
inversion_fixture(),
compose_with_provenance(&[]),
] {
let entry_count: Option<usize> = out.attribution.dominant_entry().map(|(_, c)| c);
let max_count: Option<usize> = out
.attribution
.leaf_counts_by_layer()
.values()
.copied()
.max();
assert_eq!(
entry_count, max_count,
"dominant_entry().map(|(_, c)| c) ≡ leaf_counts_by_layer().values().max()",
);
}
}
#[test]
fn dominant_entry_count_agrees_with_leaf_count_of_layer() {
for out in [
layer_axis_fixture(),
subtree_fixture(),
three_way_tie_fixture(),
inversion_fixture(),
] {
let (name, count) = out.attribution.dominant_entry().expect("non-empty fixture");
assert_eq!(
count,
out.attribution.leaf_count_of_layer(name),
"dominant_entry count ≡ leaf_count_of_layer(name)",
);
}
}
#[test]
fn subtree_dominant_entry_empty_prefix_equals_dominant_entry() {
for out in [
layer_axis_fixture(),
subtree_fixture(),
three_way_tie_fixture(),
inversion_fixture(),
compose_with_provenance(&[]),
] {
assert_eq!(
out.attribution.subtree_dominant_entry(&[]),
out.attribution.dominant_entry(),
"empty prefix ⇒ subtree_dominant_entry ≡ dominant_entry",
);
}
}
#[test]
fn subtree_dominant_entry_at_named_prefix_narrows_the_argmax() {
let out = subtree_fixture();
assert_eq!(
out.attribution.subtree_dominant_entry(&[s("breathe")]),
Some(("coarse", 1)),
"under breathe.*, tied at 1 leaf each — coarse wins by smallest lex",
);
assert_eq!(
out.attribution.subtree_dominant_entry(&[s("alpha")]),
Some(("coarse", 1)),
"under alpha (a leaf), coarse alone owns the row",
);
let inv = inversion_fixture();
assert_eq!(
inv.attribution.subtree_dominant_entry(&[s("small")]),
Some(("specific", 2)),
"under small.*, specific (2 leaves) beats coarse (1)",
);
assert_eq!(
inv.attribution.subtree_dominant_entry(&[s("big")]),
Some(("coarse", 3)),
"under big.*, coarse alone owns the row with 3 leaves",
);
}
#[test]
fn subtree_dominant_entry_absent_prefix_is_none() {
let out = subtree_fixture();
assert_eq!(
out.attribution.subtree_dominant_entry(&[s("nonexistent")]),
None,
"absent prefix ⇒ empty subtree ⇒ None",
);
}
#[test]
fn subtree_dominant_entry_agrees_with_argmax_of_subtree_counts() {
let prefixes: Vec<Vec<String>> = vec![
vec![],
vec![s("breathe")],
vec![s("alpha")],
vec![s("small")],
vec![s("big")],
vec![s("nonexistent")],
];
for out in [
subtree_fixture(),
inversion_fixture(),
layer_axis_fixture(),
three_way_tie_fixture(),
] {
for prefix in &prefixes {
let entry = out.attribution.subtree_dominant_entry(prefix);
let counts = out.attribution.subtree_leaf_counts_by_layer(prefix);
if let Some((name, count)) = entry {
let max_count = counts
.values()
.copied()
.max()
.expect("non-empty subtree ⇒ non-empty counter map");
assert_eq!(
count, max_count,
"at prefix {prefix:?}, entry count equals subtree argmax",
);
assert_eq!(
counts.get(name).copied(),
Some(count),
"at prefix {prefix:?}, entry count equals the histogram bucket",
);
assert_eq!(
out.attribution.subtree_leaf_count_of_layer(prefix, name),
count,
"at prefix {prefix:?}, entry count ≡ subtree_leaf_count_of_layer",
);
let tied_at_max: Vec<&'static str> = counts
.iter()
.filter_map(|(n, c)| (*c == max_count).then_some(*n))
.collect();
assert_eq!(
tied_at_max.first().copied(),
Some(name),
"at prefix {prefix:?}, entry picks smallest lex name among tied maxima",
);
} else {
assert!(
counts.is_empty(),
"at prefix {prefix:?}, None ⇒ counter map is empty",
);
assert_eq!(
out.attribution.subtree_iter(prefix).count(),
0,
"at prefix {prefix:?}, None ⇒ subtree_iter is empty",
);
}
}
}
}
#[test]
fn subtree_dominant_entry_equals_subtree_layer_ranking_first() {
let prefixes: Vec<Vec<String>> = vec![
vec![],
vec![s("breathe")],
vec![s("alpha")],
vec![s("small")],
vec![s("big")],
vec![s("nonexistent")],
];
for out in [
subtree_fixture(),
inversion_fixture(),
layer_axis_fixture(),
three_way_tie_fixture(),
] {
for prefix in &prefixes {
let via_ranking: Option<(&'static str, usize)> = out
.attribution
.subtree_layer_ranking(prefix)
.first()
.copied();
assert_eq!(
out.attribution.subtree_dominant_entry(prefix),
via_ranking,
"at prefix {prefix:?}, subtree_dominant_entry ≡ subtree_layer_ranking.first().copied()",
);
}
}
}
#[test]
fn subtree_dominant_entry_projections_equal_scalars() {
let prefixes: Vec<Vec<String>> = vec![
vec![],
vec![s("breathe")],
vec![s("alpha")],
vec![s("small")],
vec![s("big")],
vec![s("nonexistent")],
];
for out in [
subtree_fixture(),
inversion_fixture(),
layer_axis_fixture(),
three_way_tie_fixture(),
compose_with_provenance(&[]),
] {
for prefix in &prefixes {
let entry = out.attribution.subtree_dominant_entry(prefix);
assert_eq!(
entry.map(|(n, _)| n),
out.attribution.subtree_dominant_layer(prefix),
"at prefix {prefix:?}, name projection ≡ subtree_dominant_layer",
);
let counts_max: Option<usize> = out
.attribution
.subtree_leaf_counts_by_layer(prefix)
.values()
.copied()
.max();
assert_eq!(
entry.map(|(_, c)| c),
counts_max,
"at prefix {prefix:?}, count projection ≡ subtree histogram max",
);
}
}
}
#[test]
fn subtree_dominant_entry_name_in_surviving_and_count_le_global() {
let prefixes: Vec<Vec<String>> = vec![
vec![],
vec![s("breathe")],
vec![s("alpha")],
vec![s("small")],
vec![s("big")],
vec![s("nonexistent")],
];
for out in [
subtree_fixture(),
inversion_fixture(),
layer_axis_fixture(),
three_way_tie_fixture(),
] {
let global: std::collections::BTreeSet<&'static str> = out
.attribution
.surviving_layer_names()
.into_iter()
.collect();
for prefix in &prefixes {
if let Some((name, count)) = out.attribution.subtree_dominant_entry(prefix) {
assert!(
global.contains(name),
"at prefix {prefix:?}, entry name {name} lives in the global surviving set",
);
assert!(
count <= out.attribution.leaf_count_of_layer(name),
"at prefix {prefix:?}, subtree count {count} ≤ global {} for {name}",
out.attribution.leaf_count_of_layer(name),
);
}
}
}
}
#[test]
fn subtree_dominant_entry_can_differ_from_dominant_entry() {
let out = inversion_fixture();
assert_eq!(out.attribution.dominant_entry(), Some(("coarse", 4)));
assert_eq!(
out.attribution.subtree_dominant_entry(&[s("small")]),
Some(("specific", 2)),
"under small.*, specific owns the top row locally",
);
assert_eq!(
out.attribution.subtree_dominant_entry(&[s("big")]),
Some(("coarse", 3)),
"under big.*, coarse alone with 3 leaves — count narrows",
);
}
#[test]
fn weakest_entry_agrees_with_leaf_counts_argmin() {
let out = layer_axis_fixture();
let entry = out.attribution.weakest_entry().expect("non-empty");
assert_eq!(entry, ("platform", 1));
let counts = out.attribution.leaf_counts_by_layer();
let min_count = counts.values().copied().min().expect("non-empty");
assert_eq!(entry.1, min_count);
assert_eq!(counts.get(entry.0).copied(), Some(entry.1));
}
#[test]
fn weakest_entry_ties_broken_by_lex_name_descending() {
let out = three_way_tie_fixture();
assert_eq!(
out.attribution.weakest_entry(),
Some(("ccc", 1)),
"on a three-way tie, the largest lex name wins with its count",
);
}
#[test]
fn weakest_entry_empty_attribution_is_none() {
let empty = compose_with_provenance(&[]);
assert_eq!(empty.attribution.weakest_entry(), None);
let silent = Fixed("silent-a", Dict::new());
let more_silent = Fixed("silent-b", Dict::new());
let silent_out = compose_with_provenance(&[&silent, &more_silent]);
assert_eq!(silent_out.attribution.weakest_entry(), None);
}
#[test]
fn weakest_entry_single_writer_pairs_writer_with_its_leaf_count() {
let solo = Fixed(
"solo",
dict(&[("k1", Value::from(1i64)), ("k2", Value::from(2i64))]),
);
let silent = Fixed("silent", Dict::new());
let out = compose_with_provenance(&[&solo, &silent]);
assert_eq!(out.attribution.weakest_entry(), Some(("solo", 2)));
assert_eq!(
out.attribution.weakest_entry(),
out.attribution.dominant_entry(),
"single-writer ⇒ bookend entries coincide",
);
}
#[test]
fn weakest_entry_equals_layer_ranking_last() {
for out in [
layer_axis_fixture(),
subtree_fixture(),
three_way_tie_fixture(),
inversion_fixture(),
compose_with_provenance(&[]),
] {
let via_ranking: Option<(&'static str, usize)> =
out.attribution.layer_ranking().last().copied();
assert_eq!(
out.attribution.weakest_entry(),
via_ranking,
"weakest_entry() ≡ layer_ranking().last().copied()",
);
}
}
#[test]
fn weakest_entry_name_projection_equals_weakest_layer() {
for out in [
layer_axis_fixture(),
subtree_fixture(),
three_way_tie_fixture(),
inversion_fixture(),
compose_with_provenance(&[]),
] {
let entry_name: Option<&'static str> = out.attribution.weakest_entry().map(|(n, _)| n);
assert_eq!(
entry_name,
out.attribution.weakest_layer(),
"weakest_entry().map(|(n, _)| n) ≡ weakest_layer()",
);
}
}
#[test]
fn weakest_entry_count_projection_equals_leaf_counts_min() {
for out in [
layer_axis_fixture(),
subtree_fixture(),
three_way_tie_fixture(),
inversion_fixture(),
compose_with_provenance(&[]),
] {
let entry_count: Option<usize> = out.attribution.weakest_entry().map(|(_, c)| c);
let min_count: Option<usize> = out
.attribution
.leaf_counts_by_layer()
.values()
.copied()
.min();
assert_eq!(
entry_count, min_count,
"weakest_entry().map(|(_, c)| c) ≡ leaf_counts_by_layer().values().min()",
);
}
}
#[test]
fn weakest_entry_count_agrees_with_leaf_count_of_layer() {
for out in [
layer_axis_fixture(),
subtree_fixture(),
three_way_tie_fixture(),
inversion_fixture(),
] {
let (name, count) = out.attribution.weakest_entry().expect("non-empty fixture");
assert_eq!(
count,
out.attribution.leaf_count_of_layer(name),
"weakest_entry count ≡ leaf_count_of_layer(name)",
);
}
}
#[test]
fn weakest_entry_bookend_law_vs_dominant_entry() {
let solo = Fixed("solo", dict(&[("k", Value::from(1i64))]));
let solo_out = compose_with_provenance(&[&solo]);
assert_eq!(
solo_out.attribution.weakest_entry(),
solo_out.attribution.dominant_entry(),
"single-writer ⇒ bookend entries coincide",
);
let tied = three_way_tie_fixture();
let dom = tied.attribution.dominant_entry().expect("non-empty");
let weak = tied.attribution.weakest_entry().expect("non-empty");
assert_ne!(dom.0, weak.0, "flat but multi-writer ⇒ names disagree");
assert_eq!(dom.1, weak.1, "flat ⇒ counts agree");
assert_eq!(dom, ("aaa", 1));
assert_eq!(weak, ("ccc", 1));
let axis = layer_axis_fixture();
assert_ne!(
axis.attribution.weakest_entry(),
axis.attribution.dominant_entry(),
"distinct counts ⇒ bookend entries disagree",
);
}
#[test]
fn subtree_weakest_entry_empty_prefix_equals_weakest_entry() {
for out in [
layer_axis_fixture(),
subtree_fixture(),
three_way_tie_fixture(),
inversion_fixture(),
compose_with_provenance(&[]),
] {
assert_eq!(
out.attribution.subtree_weakest_entry(&[]),
out.attribution.weakest_entry(),
"empty prefix ⇒ subtree_weakest_entry ≡ weakest_entry",
);
}
}
#[test]
fn subtree_weakest_entry_at_named_prefix_narrows_the_argmin() {
let out = subtree_fixture();
assert_eq!(
out.attribution.subtree_weakest_entry(&[s("breathe")]),
Some(("specific", 1)),
"under breathe.*, tied at 1 leaf each — specific wins by largest lex",
);
assert_eq!(
out.attribution.subtree_weakest_entry(&[s("alpha")]),
Some(("coarse", 1)),
"under alpha (a leaf), coarse alone owns the row",
);
let inv = inversion_fixture();
assert_eq!(
inv.attribution.subtree_weakest_entry(&[s("small")]),
Some(("coarse", 1)),
"under small.*, coarse (1 leaf) is the weakest row",
);
assert_eq!(
inv.attribution.subtree_weakest_entry(&[s("big")]),
Some(("coarse", 3)),
"under big.*, coarse alone owns the row with 3 leaves",
);
}
#[test]
fn subtree_weakest_entry_absent_prefix_is_none() {
let out = subtree_fixture();
assert_eq!(
out.attribution.subtree_weakest_entry(&[s("nonexistent")]),
None,
"absent prefix ⇒ empty subtree ⇒ None",
);
}
#[test]
fn subtree_weakest_entry_agrees_with_argmin_of_subtree_counts() {
let prefixes: Vec<Vec<String>> = vec![
vec![],
vec![s("breathe")],
vec![s("alpha")],
vec![s("small")],
vec![s("big")],
vec![s("nonexistent")],
];
for out in [
subtree_fixture(),
inversion_fixture(),
layer_axis_fixture(),
three_way_tie_fixture(),
] {
for prefix in &prefixes {
let entry = out.attribution.subtree_weakest_entry(prefix);
let counts = out.attribution.subtree_leaf_counts_by_layer(prefix);
if let Some((name, count)) = entry {
let min_count = counts
.values()
.copied()
.min()
.expect("non-empty subtree ⇒ non-empty counter map");
assert_eq!(
count, min_count,
"at prefix {prefix:?}, entry count equals subtree argmin",
);
assert_eq!(
counts.get(name).copied(),
Some(count),
"at prefix {prefix:?}, entry count equals the histogram bucket",
);
assert_eq!(
out.attribution.subtree_leaf_count_of_layer(prefix, name),
count,
"at prefix {prefix:?}, entry count ≡ subtree_leaf_count_of_layer",
);
let tied_at_min: Vec<&'static str> = counts
.iter()
.filter_map(|(n, c)| (*c == min_count).then_some(*n))
.collect();
assert_eq!(
tied_at_min.last().copied(),
Some(name),
"at prefix {prefix:?}, entry picks largest lex name among tied minima",
);
} else {
assert!(
counts.is_empty(),
"at prefix {prefix:?}, None ⇒ counter map is empty",
);
assert_eq!(
out.attribution.subtree_iter(prefix).count(),
0,
"at prefix {prefix:?}, None ⇒ subtree_iter is empty",
);
}
}
}
}
#[test]
fn subtree_weakest_entry_equals_subtree_layer_ranking_last() {
let prefixes: Vec<Vec<String>> = vec![
vec![],
vec![s("breathe")],
vec![s("alpha")],
vec![s("small")],
vec![s("big")],
vec![s("nonexistent")],
];
for out in [
subtree_fixture(),
inversion_fixture(),
layer_axis_fixture(),
three_way_tie_fixture(),
] {
for prefix in &prefixes {
let via_ranking: Option<(&'static str, usize)> = out
.attribution
.subtree_layer_ranking(prefix)
.last()
.copied();
assert_eq!(
out.attribution.subtree_weakest_entry(prefix),
via_ranking,
"at prefix {prefix:?}, subtree_weakest_entry ≡ subtree_layer_ranking.last().copied()",
);
}
}
}
#[test]
fn subtree_weakest_entry_projections_equal_scalars() {
let prefixes: Vec<Vec<String>> = vec![
vec![],
vec![s("breathe")],
vec![s("alpha")],
vec![s("small")],
vec![s("big")],
vec![s("nonexistent")],
];
for out in [
subtree_fixture(),
inversion_fixture(),
layer_axis_fixture(),
three_way_tie_fixture(),
compose_with_provenance(&[]),
] {
for prefix in &prefixes {
let entry = out.attribution.subtree_weakest_entry(prefix);
assert_eq!(
entry.map(|(n, _)| n),
out.attribution.subtree_weakest_layer(prefix),
"at prefix {prefix:?}, name projection ≡ subtree_weakest_layer",
);
let counts_min: Option<usize> = out
.attribution
.subtree_leaf_counts_by_layer(prefix)
.values()
.copied()
.min();
assert_eq!(
entry.map(|(_, c)| c),
counts_min,
"at prefix {prefix:?}, count projection ≡ subtree histogram min",
);
}
}
}
#[test]
fn subtree_weakest_entry_name_in_surviving_and_count_le_global() {
let prefixes: Vec<Vec<String>> = vec![
vec![],
vec![s("breathe")],
vec![s("alpha")],
vec![s("small")],
vec![s("big")],
vec![s("nonexistent")],
];
for out in [
subtree_fixture(),
inversion_fixture(),
layer_axis_fixture(),
three_way_tie_fixture(),
] {
let global: std::collections::BTreeSet<&'static str> = out
.attribution
.surviving_layer_names()
.into_iter()
.collect();
for prefix in &prefixes {
if let Some((name, count)) = out.attribution.subtree_weakest_entry(prefix) {
assert!(
global.contains(name),
"at prefix {prefix:?}, entry name {name} lives in the global surviving set",
);
assert!(
count <= out.attribution.leaf_count_of_layer(name),
"at prefix {prefix:?}, subtree count {count} ≤ global {} for {name}",
out.attribution.leaf_count_of_layer(name),
);
}
}
}
}
#[test]
fn subtree_weakest_entry_can_differ_from_weakest_entry() {
let out = inversion_fixture();
assert_eq!(out.attribution.weakest_entry(), Some(("specific", 2)));
assert_eq!(
out.attribution.subtree_weakest_entry(&[s("big")]),
Some(("coarse", 3)),
"under big.*, specific is absent — coarse alone owns the row",
);
assert_eq!(
out.attribution.subtree_weakest_entry(&[s("small")]),
Some(("coarse", 1)),
"under small.*, coarse (1 leaf) is weakest locally",
);
}
#[test]
fn contributors_at_lists_layers_that_touched_leaf_in_application_order() {
let a = Fixed("a", dict(&[("k", Value::from(1i64))]));
let b = Fixed("b", dict(&[("k", Value::from(2i64))]));
let c = Fixed("c", dict(&[("other", Value::from(3i64))]));
let silent = Fixed("silent", Dict::new());
assert_eq!(
contributors_at(&[&a, &b, &c, &silent], &["k"]),
vec!["a", "b"],
);
assert_eq!(
contributors_at(&[&a, &b, &c, &silent], &["other"]),
vec!["c"]
);
assert_eq!(
contributors_at(&[&a, &b, &c, &silent], &["nope"]),
Vec::<&'static str>::new(),
);
}
#[test]
fn contributors_at_includes_prefix_scalar_and_dict_container_touchers() {
let a = Fixed(
"a",
dict(&[("x", Value::from(dict(&[("a", Value::from(1i64))])))]),
);
let b = Fixed("b", dict(&[("x", Value::from(9i64))]));
assert_eq!(contributors_at(&[&a, &b], &["x", "a"]), vec!["a", "b"]);
let out = compose_with_provenance(&[&a, &b]);
assert_eq!(out.attribution.layer_of(&["x", "a"]), None);
}
#[test]
fn contributors_at_last_element_equals_layer_of_when_leaf_survives() {
let coarse = Fixed(
"platform",
dict(&[(
"breathe",
Value::from(dict(&[
("setpoint", Value::from(0.80)),
("mode", Value::from("live")),
])),
)]),
);
let specific = Fixed(
"tenancy",
dict(&[(
"breathe",
Value::from(dict(&[("mode", Value::from("shadow"))])),
)]),
);
let layers: [&dyn DiscoveryLayer; 2] = [&coarse, &specific];
let out = compose_with_provenance(&layers);
let contested = contributors_at(&layers, &["breathe", "mode"]);
assert_eq!(contested, vec!["platform", "tenancy"]);
assert_eq!(
contested.last().copied(),
out.attribution.layer_of(&["breathe", "mode"])
);
let uncontested = contributors_at(&layers, &["breathe", "setpoint"]);
assert_eq!(uncontested, vec!["platform"]);
assert_eq!(
uncontested.last().copied(),
out.attribution.layer_of(&["breathe", "setpoint"]),
);
}
#[test]
fn contributors_at_root_equals_contributor_names() {
let coarse = Fixed("platform", dict(&[("a", Value::from(1i64))]));
let silent = Fixed("undetectable", Dict::new());
let specific = Fixed("tenancy", dict(&[("b", Value::from(2i64))]));
let layers: [&dyn DiscoveryLayer; 3] = [&coarse, &silent, &specific];
assert_eq!(contributors_at(&layers, &[]), contributor_names(&layers));
assert_eq!(contributors_at(&layers, &[]), vec!["platform", "tenancy"]);
}
#[test]
fn contributors_at_is_subset_of_contributor_names() {
let a = Fixed("a", dict(&[("k", Value::from(1i64))]));
let b = Fixed("b", dict(&[("k", Value::from(2i64))]));
let c = Fixed("c", dict(&[("other", Value::from(3i64))]));
let silent = Fixed("silent", Dict::new());
let layers: [&dyn DiscoveryLayer; 4] = [&a, &b, &c, &silent];
let all: std::collections::BTreeSet<_> = contributor_names(&layers).into_iter().collect();
for path in [&["k"][..], &["other"][..], &["nope"][..], &[][..]] {
let restricted: std::collections::BTreeSet<_> =
contributors_at(&layers, path).into_iter().collect();
assert!(
restricted.is_subset(&all),
"contributors_at({path:?}) = {restricted:?} not ⊆ contributor_names = {all:?}",
);
}
}
#[test]
fn contributors_at_empty_layers_is_empty() {
assert_eq!(contributors_at(&[], &["k"]), Vec::<&'static str>::new());
assert_eq!(contributors_at(&[], &[]), Vec::<&'static str>::new());
}
#[test]
fn contributors_at_ignores_layers_with_disjoint_content() {
let match_layer = Fixed(
"match",
dict(&[("a", Value::from(dict(&[("b", Value::from(1i64))])))]),
);
let disjoint = Fixed("disjoint", dict(&[("z", Value::from(9i64))]));
assert_eq!(
contributors_at(&[&match_layer, &disjoint], &["a", "b"]),
vec!["match"],
);
}
#[test]
fn contributors_at_iter_collect_matches_contributors_at() {
let a = Fixed("a", dict(&[("k", Value::from(1i64))]));
let b = Fixed("b", dict(&[("k", Value::from(2i64))]));
let c = Fixed("c", dict(&[("other", Value::from(3i64))]));
let silent = Fixed("silent", Dict::new());
let layers: [&dyn DiscoveryLayer; 4] = [&a, &b, &c, &silent];
for path in [&["k"][..], &["other"][..], &["nope"][..], &[][..]] {
assert_eq!(
contributors_at_iter(&layers, path).collect::<Vec<_>>(),
contributors_at(&layers, path),
"iter → Vec matches contributors_at at path {path:?}",
);
}
}
#[test]
fn contributors_at_iter_empty_layers_is_empty_stream() {
let layers: [&dyn DiscoveryLayer; 0] = [];
assert!(contributors_at_iter(&layers, &["k"]).next().is_none());
assert!(contributors_at_iter(&layers, &[]).next().is_none());
}
#[test]
fn contributors_at_iter_empty_path_matches_contributor_names_iter() {
let coarse = Fixed("platform", dict(&[("a", Value::from(1i64))]));
let silent = Fixed("undetectable", Dict::new());
let specific = Fixed("tenancy", dict(&[("b", Value::from(2i64))]));
let layers: [&dyn DiscoveryLayer; 3] = [&coarse, &silent, &specific];
assert_eq!(
contributors_at_iter(&layers, &[]).collect::<Vec<_>>(),
contributor_names_iter(&layers).collect::<Vec<_>>(),
"empty path collapses to the whole-layer contributor stream",
);
}
#[test]
fn contributors_at_iter_preserves_application_order() {
let coarse = Fixed("tenancy", dict(&[("k", Value::from(1i64))]));
let specific = Fixed("platform", dict(&[("k", Value::from(2i64))]));
let layers: [&dyn DiscoveryLayer; 2] = [&coarse, &specific];
assert_eq!(
contributors_at_iter(&layers, &["k"]).collect::<Vec<_>>(),
vec!["tenancy", "platform"],
);
}
#[test]
fn contributors_at_iter_rev_reverses_forward_walk() {
let a = Fixed("a", dict(&[("k", Value::from(1i64))]));
let disjoint = Fixed("disjoint", dict(&[("other", Value::from(9i64))]));
let b = Fixed("b", dict(&[("k", Value::from(2i64))]));
let layers: [&dyn DiscoveryLayer; 3] = [&a, &disjoint, &b];
let forward = contributors_at_iter(&layers, &["k"]).collect::<Vec<_>>();
let reverse = contributors_at_iter(&layers, &["k"])
.rev()
.collect::<Vec<_>>();
assert_eq!(
reverse,
forward.iter().rev().copied().collect::<Vec<_>>(),
".rev() over the iter recovers the reverse of the forward walk",
);
}
#[test]
fn contributors_at_iter_clone_yields_independent_walks() {
let a = Fixed("a", dict(&[("k", Value::from(1i64))]));
let b = Fixed("b", dict(&[("k", Value::from(2i64))]));
let c = Fixed("c", dict(&[("other", Value::from(3i64))]));
let layers: [&dyn DiscoveryLayer; 3] = [&a, &b, &c];
let one = contributors_at_iter(&layers, &["k"]);
let two = one.clone();
assert_eq!(
one.collect::<Vec<_>>(),
two.collect::<Vec<_>>(),
"two independent walks agree",
);
}
#[test]
fn contributors_at_iter_is_fused_past_exhaustion() {
let a = Fixed("a", dict(&[("k", Value::from(1i64))]));
let layers: [&dyn DiscoveryLayer; 1] = [&a];
let mut it = contributors_at_iter(&layers, &["k"]);
assert_eq!(it.next(), Some("a"));
for _ in 0..4 {
assert!(it.next().is_none(), "post-exhaustion pulls stay None");
}
}
#[test]
fn contributors_at_iter_head_short_circuits_without_full_sweep() {
let a = Fixed("platform", dict(&[("k", Value::from(1i64))]));
let b = Fixed("cloud", dict(&[("k", Value::from(2i64))]));
let c = Fixed("tenancy", dict(&[("k", Value::from(3i64))]));
let layers: [&dyn DiscoveryLayer; 3] = [&a, &b, &c];
assert_eq!(
contributors_at_iter(&layers, &["k"]).next(),
Some("platform"),
".next() yields the coarsest contributor without walking the rest",
);
}
#[test]
fn contributors_at_iter_last_element_equals_layer_of_when_leaf_survives() {
let coarse = Fixed(
"platform",
dict(&[(
"breathe",
Value::from(dict(&[
("setpoint", Value::from(0.80)),
("mode", Value::from("live")),
])),
)]),
);
let specific = Fixed(
"tenancy",
dict(&[(
"breathe",
Value::from(dict(&[("mode", Value::from("shadow"))])),
)]),
);
let layers: [&dyn DiscoveryLayer; 2] = [&coarse, &specific];
let out = compose_with_provenance(&layers);
assert_eq!(
contributors_at_iter(&layers, &["breathe", "mode"]).last(),
out.attribution.layer_of(&["breathe", "mode"]),
"iter .last() equals attribution.layer_of on a surviving contested leaf",
);
assert_eq!(
contributors_at_iter(&layers, &["breathe", "setpoint"]).last(),
out.attribution.layer_of(&["breathe", "setpoint"]),
"iter .last() equals attribution.layer_of on a surviving uncontested leaf",
);
}
#[test]
fn contributors_at_iter_count_matches_contributor_count_at() {
let a = Fixed("a", dict(&[("k", Value::from(1i64))]));
let b = Fixed("b", dict(&[("k", Value::from(2i64))]));
let c = Fixed("c", dict(&[("other", Value::from(3i64))]));
let silent = Fixed("silent", Dict::new());
let layers: [&dyn DiscoveryLayer; 4] = [&a, &b, &c, &silent];
for path in [&["k"][..], &["other"][..], &["nope"][..], &[][..]] {
assert_eq!(
contributors_at_iter(&layers, path).count(),
contributor_count_at(&layers, path),
".count() on the iter matches the scalar contributor_count_at at path {path:?}",
);
}
}
#[test]
fn contributors_at_iter_ignores_layers_with_disjoint_content() {
let match_layer = Fixed(
"match",
dict(&[("a", Value::from(dict(&[("b", Value::from(1i64))])))]),
);
let disjoint = Fixed("disjoint", dict(&[("z", Value::from(9i64))]));
let layers: [&dyn DiscoveryLayer; 2] = [&match_layer, &disjoint];
assert_eq!(
contributors_at_iter(&layers, &["a", "b"]).collect::<Vec<_>>(),
vec!["match"],
);
}
#[test]
fn contributors_at_iter_agrees_with_path_contest_contributors_iter() {
let coarse = Fixed("platform", dict(&[("k", Value::from("via_platform"))]));
let mid = Fixed("cloud", dict(&[("k", Value::from("via_cloud"))]));
let specific = Fixed("tenancy", dict(&[("k", Value::from("via_tenancy"))]));
let layers: [&dyn DiscoveryLayer; 3] = [&coarse, &mid, &specific];
let via_free_function: Vec<&'static str> = contributors_at_iter(&layers, &["k"]).collect();
let via_contest: Vec<&'static str> = contest_at(&layers, &["k"])
.expect("three touchers materialize a PathContest")
.contributors_iter()
.collect();
assert_eq!(
via_free_function, via_contest,
"both iter altitudes agree on the winners+losers walk",
);
assert!(
contributors_at_iter(&layers, &["nope"]).next().is_none(),
"no touchers → the iter is drained at once",
);
assert!(
contest_at(&layers, &["nope"]).is_none(),
"no touchers → no PathContest to materialize",
);
}
#[test]
fn contributors_at_iter_return_type_is_nameable_contributors_at_iter() {
struct HoldsContributorsAt<'a> {
iter: ContributorsAtIter<'a>,
}
let a = Fixed("platform", dict(&[("k", Value::from(1i64))]));
let disjoint = Fixed("cloud", dict(&[("other", Value::from(9i64))]));
let c = Fixed("tenancy", dict(&[("k", Value::from(3i64))]));
let layers: [&dyn DiscoveryLayer; 3] = [&a, &disjoint, &c];
let held = HoldsContributorsAt {
iter: contributors_at_iter(&layers, &["k"]),
};
let out: Vec<&'static str> = held.iter.collect();
assert_eq!(out, vec!["platform", "tenancy"]);
}
#[test]
fn contributors_at_iter_clone_preserves_static_traits() {
fn requires_full_traits<I>(_it: &I)
where
I: Iterator + DoubleEndedIterator + std::iter::FusedIterator + Clone,
{
}
let a = Fixed("platform", dict(&[("k", Value::from(1i64))]));
let disjoint = Fixed("cloud", dict(&[("other", Value::from(9i64))]));
let c = Fixed("tenancy", dict(&[("k", Value::from(3i64))]));
let layers: [&dyn DiscoveryLayer; 3] = [&a, &disjoint, &c];
let it: ContributorsAtIter<'_> = contributors_at_iter(&layers, &["k"]);
requires_full_traits(&it);
let clone = it.clone();
let via_original: Vec<&'static str> = it.collect();
let via_clone: Vec<&'static str> = clone.collect();
assert_eq!(
via_original, via_clone,
"cloned handle walks the same per-path contributor stream",
);
}
#[test]
fn contributors_at_iter_next_back_walks_specific_to_coarse() {
let a = Fixed("platform", dict(&[("k", Value::from(1i64))]));
let miss_mid = Fixed("cloud", dict(&[("other", Value::from(9i64))]));
let c = Fixed("tenancy", dict(&[("k", Value::from(3i64))]));
let miss_tail = Fixed("aftermath", dict(&[("other", Value::from(9i64))]));
let layers: [&dyn DiscoveryLayer; 4] = [&a, &miss_mid, &c, &miss_tail];
let mut it = contributors_at_iter(&layers, &["k"]);
assert_eq!(
it.next_back(),
Some("tenancy"),
"tail miss-path 'aftermath' is skipped and 'tenancy' is the first reverse yield",
);
assert_eq!(
it.next_back(),
Some("platform"),
"mid miss-path 'cloud' is skipped and 'platform' is next in reverse",
);
assert!(
it.next_back().is_none(),
"both remaining cursor ends have been swept by next_back",
);
}
#[test]
fn contributors_at_iter_debug_impl_omits_layers_handle() {
let a = Fixed("platform", dict(&[("k", Value::from(1i64))]));
let disjoint = Fixed("cloud", dict(&[("other", Value::from(9i64))]));
let c = Fixed("tenancy", dict(&[("k", Value::from(3i64))]));
let layers: [&dyn DiscoveryLayer; 3] = [&a, &disjoint, &c];
let it: ContributorsAtIter<'_> = contributors_at_iter(&layers, &["k"]);
let rendered = format!("{it:?}");
assert!(
rendered.starts_with("ContributorsAtIter"),
"Debug names the concrete struct: {rendered}",
);
assert!(
rendered.contains("layers_remaining"),
"Debug reports the remaining layer count: {rendered}",
);
assert!(
rendered.contains('3'),
"Debug reports the initial cursor length: {rendered}",
);
assert!(
rendered.contains("path"),
"Debug reports the captured path field: {rendered}",
);
assert!(
rendered.contains("\"k\""),
"Debug renders the captured path contents: {rendered}",
);
}
#[test]
fn silenced_at_lists_overridden_touchers_in_application_order() {
let a = Fixed("a", dict(&[("k", Value::from(1i64))]));
let b = Fixed("b", dict(&[("k", Value::from(2i64))]));
let c = Fixed("c", dict(&[("k", Value::from(3i64))]));
let disjoint = Fixed("disjoint", dict(&[("other", Value::from(9i64))]));
assert_eq!(
silenced_at(&[&a, &b, &c, &disjoint], &["k"]),
vec!["a", "b"],
);
}
#[test]
fn silenced_at_empty_when_single_toucher_or_no_toucher() {
let a = Fixed("a", dict(&[("k", Value::from(1i64))]));
let disjoint = Fixed("z", dict(&[("other", Value::from(9i64))]));
assert_eq!(
silenced_at(&[&a, &disjoint], &["k"]),
Vec::<&'static str>::new(),
);
assert_eq!(
silenced_at(&[&a, &disjoint], &["nope"]),
Vec::<&'static str>::new(),
);
assert_eq!(silenced_at(&[], &["k"]), Vec::<&'static str>::new());
assert_eq!(silenced_at(&[], &[]), Vec::<&'static str>::new());
}
#[test]
fn silenced_at_partitions_contributors_at_disjointly() {
let coarse = Fixed(
"platform",
dict(&[(
"breathe",
Value::from(dict(&[
("setpoint", Value::from(0.80)),
("mode", Value::from("live")),
])),
)]),
);
let specific = Fixed(
"tenancy",
dict(&[(
"breathe",
Value::from(dict(&[("mode", Value::from("shadow"))])),
)]),
);
let layers: [&dyn DiscoveryLayer; 2] = [&coarse, &specific];
for path in [
&["breathe", "mode"][..],
&["breathe", "setpoint"][..],
&["breathe"][..],
&["absent"][..],
&[][..],
] {
let contributors = contributors_at(&layers, path);
let mut recomposed = silenced_at(&layers, path);
if let Some(&decider) = contributors.last() {
recomposed.push(decider);
}
assert_eq!(
recomposed, contributors,
"silenced_at ⊎ decider != contributors_at at {path:?}",
);
assert_eq!(
silenced_at(&layers, path).len(),
contributors.len().saturating_sub(1),
"silenced_at.len() != contributors_at.len() - 1 at {path:?}",
);
}
}
#[test]
fn silenced_at_excludes_layer_of_winner_when_leaf_survives() {
let coarse = Fixed(
"platform",
dict(&[(
"breathe",
Value::from(dict(&[
("setpoint", Value::from(0.80)),
("mode", Value::from("live")),
])),
)]),
);
let specific = Fixed(
"tenancy",
dict(&[(
"breathe",
Value::from(dict(&[("mode", Value::from("shadow"))])),
)]),
);
let layers: [&dyn DiscoveryLayer; 2] = [&coarse, &specific];
let out = compose_with_provenance(&layers);
let winner = out.attribution.layer_of(&["breathe", "mode"]);
assert_eq!(winner, Some("tenancy"));
let silenced = silenced_at(&layers, &["breathe", "mode"]);
assert_eq!(silenced, vec!["platform"]);
assert!(
!silenced.contains(&"tenancy"),
"winner never appears silenced"
);
let winner = out.attribution.layer_of(&["breathe", "setpoint"]);
assert_eq!(winner, Some("platform"));
assert_eq!(
silenced_at(&layers, &["breathe", "setpoint"]),
Vec::<&'static str>::new(),
);
}
#[test]
fn silenced_at_credits_earlier_writer_when_prefix_scalar_erases_subtree() {
let a = Fixed(
"a",
dict(&[("x", Value::from(dict(&[("a", Value::from(1i64))])))]),
);
let b = Fixed("b", dict(&[("x", Value::from(9i64))]));
assert_eq!(silenced_at(&[&a, &b], &["x", "a"]), vec!["a"]);
let out = compose_with_provenance(&[&a, &b]);
assert_eq!(out.attribution.layer_of(&["x", "a"]), None);
assert_eq!(
contributors_at(&[&a, &b], &["x", "a"]),
vec!["a", "b"],
"contributors_at includes both toucher and erasure decider",
);
}
#[test]
fn silenced_at_at_root_equals_contributor_names_minus_last() {
let coarse = Fixed("platform", dict(&[("a", Value::from(1i64))]));
let silent = Fixed("undetectable", Dict::new());
let middle = Fixed("cloud", dict(&[("c", Value::from(3i64))]));
let specific = Fixed("tenancy", dict(&[("b", Value::from(2i64))]));
let layers: [&dyn DiscoveryLayer; 4] = [&coarse, &silent, &middle, &specific];
let mut expected = contributor_names(&layers);
expected.pop();
assert_eq!(silenced_at(&layers, &[]), expected);
assert_eq!(silenced_at(&layers, &[]), vec!["platform", "cloud"]);
}
#[test]
fn silenced_at_is_subset_of_contributors_at() {
let a = Fixed("a", dict(&[("k", Value::from(1i64))]));
let b = Fixed("b", dict(&[("k", Value::from(2i64))]));
let c = Fixed("c", dict(&[("other", Value::from(3i64))]));
let silent = Fixed("silent", Dict::new());
let layers: [&dyn DiscoveryLayer; 4] = [&a, &b, &c, &silent];
for path in [&["k"][..], &["other"][..], &["nope"][..], &[][..]] {
let contributors: std::collections::BTreeSet<_> =
contributors_at(&layers, path).into_iter().collect();
let silenced: std::collections::BTreeSet<_> =
silenced_at(&layers, path).into_iter().collect();
assert!(
silenced.is_subset(&contributors),
"silenced_at({path:?}) = {silenced:?} not ⊆ contributors_at = {contributors:?}",
);
}
}
#[test]
fn silenced_at_iter_collect_matches_silenced_at() {
let a = Fixed("a", dict(&[("k", Value::from(1i64))]));
let b = Fixed("b", dict(&[("k", Value::from(2i64))]));
let c = Fixed("c", dict(&[("other", Value::from(3i64))]));
let silent = Fixed("silent", Dict::new());
let layers: [&dyn DiscoveryLayer; 4] = [&a, &b, &c, &silent];
for path in [&["k"][..], &["other"][..], &["nope"][..], &[][..]] {
assert_eq!(
silenced_at_iter(&layers, path).collect::<Vec<_>>(),
silenced_at(&layers, path),
"iter → Vec matches silenced_at at path {path:?}",
);
}
}
#[test]
fn silenced_at_iter_empty_layers_is_empty_stream() {
let layers: [&dyn DiscoveryLayer; 0] = [];
assert!(silenced_at_iter(&layers, &["k"]).next().is_none());
assert!(silenced_at_iter(&layers, &[]).next().is_none());
}
#[test]
fn silenced_at_iter_single_toucher_is_empty_stream() {
let a = Fixed("only", dict(&[("k", Value::from(1i64))]));
let disjoint = Fixed("disjoint", dict(&[("other", Value::from(9i64))]));
let layers: [&dyn DiscoveryLayer; 2] = [&a, &disjoint];
assert!(silenced_at_iter(&layers, &["k"]).next().is_none());
}
#[test]
fn silenced_at_iter_preserves_application_order() {
let coarse = Fixed("tenancy", dict(&[("k", Value::from(1i64))]));
let middle = Fixed("cloud", dict(&[("k", Value::from(2i64))]));
let specific = Fixed("platform", dict(&[("k", Value::from(3i64))]));
let layers: [&dyn DiscoveryLayer; 3] = [&coarse, &middle, &specific];
assert_eq!(
silenced_at_iter(&layers, &["k"]).collect::<Vec<_>>(),
vec!["tenancy", "cloud"],
);
}
#[test]
fn silenced_at_iter_clone_yields_independent_walks() {
let a = Fixed("a", dict(&[("k", Value::from(1i64))]));
let b = Fixed("b", dict(&[("k", Value::from(2i64))]));
let c = Fixed("c", dict(&[("k", Value::from(3i64))]));
let layers: [&dyn DiscoveryLayer; 3] = [&a, &b, &c];
let one = silenced_at_iter(&layers, &["k"]);
let two = one.clone();
assert_eq!(
one.collect::<Vec<_>>(),
two.collect::<Vec<_>>(),
"two independent walks agree",
);
}
#[test]
fn silenced_at_iter_is_fused_past_exhaustion() {
let a = Fixed("a", dict(&[("k", Value::from(1i64))]));
let b = Fixed("b", dict(&[("k", Value::from(2i64))]));
let c = Fixed("c", dict(&[("k", Value::from(3i64))]));
let layers: [&dyn DiscoveryLayer; 3] = [&a, &b, &c];
let mut it = silenced_at_iter(&layers, &["k"]);
assert_eq!(it.next(), Some("a"));
assert_eq!(it.next(), Some("b"));
for _ in 0..4 {
assert!(it.next().is_none(), "post-exhaustion pulls stay None");
}
}
#[test]
fn silenced_at_iter_head_short_circuits_without_full_sweep() {
let a = Fixed("platform", dict(&[("k", Value::from(1i64))]));
let b = Fixed("cloud", dict(&[("k", Value::from(2i64))]));
let c = Fixed("tenancy", dict(&[("k", Value::from(3i64))]));
let d = Fixed("dev", dict(&[("k", Value::from(4i64))]));
let layers: [&dyn DiscoveryLayer; 4] = [&a, &b, &c, &d];
assert_eq!(
silenced_at_iter(&layers, &["k"]).next(),
Some("platform"),
".next() yields the coarsest silenced layer without walking the rest",
);
}
#[test]
fn silenced_at_iter_last_element_equals_runner_up_at() {
let coarse = Fixed("platform", dict(&[("k", Value::from(1i64))]));
let middle = Fixed("cloud", dict(&[("k", Value::from(2i64))]));
let specific = Fixed("tenancy", dict(&[("k", Value::from(3i64))]));
let layers: [&dyn DiscoveryLayer; 3] = [&coarse, &middle, &specific];
assert_eq!(
silenced_at_iter(&layers, &["k"]).last(),
runner_up_at(&layers, &["k"]),
"iter .last() equals runner_up_at on a contested leaf",
);
let solo = Fixed("solo", dict(&[("k", Value::from(1i64))]));
let disjoint = Fixed("disjoint", dict(&[("other", Value::from(9i64))]));
let layers: [&dyn DiscoveryLayer; 2] = [&solo, &disjoint];
assert_eq!(silenced_at_iter(&layers, &["k"]).last(), None);
assert_eq!(runner_up_at(&layers, &["k"]), None);
}
#[test]
fn silenced_at_iter_count_matches_silenced_count_at() {
let a = Fixed("a", dict(&[("k", Value::from(1i64))]));
let b = Fixed("b", dict(&[("k", Value::from(2i64))]));
let c = Fixed("c", dict(&[("other", Value::from(3i64))]));
let silent = Fixed("silent", Dict::new());
let layers: [&dyn DiscoveryLayer; 4] = [&a, &b, &c, &silent];
for path in [&["k"][..], &["other"][..], &["nope"][..], &[][..]] {
assert_eq!(
silenced_at_iter(&layers, path).count(),
silenced_count_at(&layers, path),
".count() on the iter matches the scalar silenced_count_at at path {path:?}",
);
}
}
#[test]
fn silenced_at_iter_is_subset_of_contributors_at_iter() {
let a = Fixed("a", dict(&[("k", Value::from(1i64))]));
let b = Fixed("b", dict(&[("k", Value::from(2i64))]));
let c = Fixed("c", dict(&[("other", Value::from(3i64))]));
let silent = Fixed("silent", Dict::new());
let layers: [&dyn DiscoveryLayer; 4] = [&a, &b, &c, &silent];
for path in [&["k"][..], &["other"][..], &["nope"][..], &[][..]] {
let contributors: std::collections::BTreeSet<_> =
contributors_at_iter(&layers, path).collect();
let silenced: std::collections::BTreeSet<_> = silenced_at_iter(&layers, path).collect();
assert!(
silenced.is_subset(&contributors),
"silenced_at_iter({path:?}) = {silenced:?} not ⊆ contributors_at_iter = {contributors:?}",
);
}
}
#[test]
fn silenced_at_iter_credits_earlier_writer_when_prefix_scalar_erases_subtree() {
let coarse = Fixed(
"platform",
dict(&[(
"breathe",
Value::from(dict(&[("mode", Value::from("live"))])),
)]),
);
let eraser = Fixed("tenancy", dict(&[("breathe", Value::from("disabled"))]));
let layers: [&dyn DiscoveryLayer; 2] = [&coarse, &eraser];
assert_eq!(
silenced_at_iter(&layers, &["breathe", "mode"]).collect::<Vec<_>>(),
vec!["platform"],
"prefix-scalar erasure silences the earlier subtree writer",
);
}
#[test]
fn silenced_at_iter_ignores_layers_with_disjoint_content() {
let match_a = Fixed(
"a",
dict(&[("a", Value::from(dict(&[("b", Value::from(1i64))])))]),
);
let disjoint = Fixed("disjoint", dict(&[("z", Value::from(9i64))]));
let match_b = Fixed(
"b",
dict(&[("a", Value::from(dict(&[("b", Value::from(2i64))])))]),
);
let layers: [&dyn DiscoveryLayer; 3] = [&match_a, &disjoint, &match_b];
assert_eq!(
silenced_at_iter(&layers, &["a", "b"]).collect::<Vec<_>>(),
vec!["a"],
"disjoint layer is filtered before the drop-last comparison",
);
}
#[test]
fn silenced_at_iter_agrees_with_path_contest_silenced_iter() {
let coarse = Fixed("platform", dict(&[("k", Value::from("via_platform"))]));
let mid = Fixed("cloud", dict(&[("k", Value::from("via_cloud"))]));
let specific = Fixed("tenancy", dict(&[("k", Value::from("via_tenancy"))]));
let layers: [&dyn DiscoveryLayer; 3] = [&coarse, &mid, &specific];
let via_free_function: Vec<&'static str> = silenced_at_iter(&layers, &["k"]).collect();
let via_contest: Vec<&'static str> = contest_at(&layers, &["k"])
.expect("three touchers materialize a PathContest")
.silenced_iter()
.collect();
assert_eq!(
via_free_function, via_contest,
"both iter altitudes agree on the losers walk",
);
assert!(
silenced_at_iter(&layers, &["nope"]).next().is_none(),
"no touchers → the iter is drained at once",
);
assert!(
contest_at(&layers, &["nope"]).is_none(),
"no touchers → no PathContest to materialize",
);
let solo = Fixed("solo", dict(&[("only", Value::from("value"))]));
let one_layer: [&dyn DiscoveryLayer; 1] = [&solo];
assert!(silenced_at_iter(&one_layer, &["only"]).next().is_none());
assert!(
contest_at(&one_layer, &["only"])
.expect("one toucher materializes a PathContest")
.silenced_iter()
.next()
.is_none(),
);
}
#[test]
fn silenced_at_iter_return_type_is_nameable_silenced_at_iter() {
struct HoldsSilenced<'a> {
iter: SilencedAtIter<'a>,
}
let coarse = Fixed("platform", dict(&[("k", Value::from(1i64))]));
let mid = Fixed("cloud", dict(&[("k", Value::from(2i64))]));
let specific = Fixed("tenancy", dict(&[("k", Value::from(3i64))]));
let layers: [&dyn DiscoveryLayer; 3] = [&coarse, &mid, &specific];
let path = ["k"];
let held = HoldsSilenced {
iter: silenced_at_iter(&layers, &path),
};
let out: Vec<&'static str> = held.iter.collect();
assert_eq!(out, vec!["platform", "cloud"]);
}
#[test]
fn silenced_at_iter_clone_preserves_static_traits() {
fn requires_fused_clone<I>(_it: &I)
where
I: Iterator + std::iter::FusedIterator + Clone,
{
}
let coarse = Fixed("platform", dict(&[("k", Value::from(1i64))]));
let mid = Fixed("cloud", dict(&[("k", Value::from(2i64))]));
let specific = Fixed("tenancy", dict(&[("k", Value::from(3i64))]));
let layers: [&dyn DiscoveryLayer; 3] = [&coarse, &mid, &specific];
let path = ["k"];
let it: SilencedAtIter<'_> = silenced_at_iter(&layers, &path);
requires_fused_clone(&it);
let clone = it.clone();
let via_original: Vec<&'static str> = it.collect();
let via_clone: Vec<&'static str> = clone.collect();
assert_eq!(
via_original, via_clone,
"cloned handle walks the same losers stream",
);
}
#[test]
fn silenced_at_iter_debug_impl_omits_layers_handle() {
let coarse = Fixed("platform", dict(&[("k", Value::from(1i64))]));
let mid = Fixed("cloud", dict(&[("k", Value::from(2i64))]));
let specific = Fixed("tenancy", dict(&[("k", Value::from(3i64))]));
let layers: [&dyn DiscoveryLayer; 3] = [&coarse, &mid, &specific];
let path = ["k"];
let it: SilencedAtIter<'_> = silenced_at_iter(&layers, &path);
let rendered = format!("{it:?}");
assert!(
rendered.starts_with("SilencedAtIter"),
"Debug names the concrete struct: {rendered}",
);
assert!(
rendered.contains("layers_remaining"),
"Debug reports the remaining layer count: {rendered}",
);
assert!(
rendered.contains("path"),
"Debug reports the query path: {rendered}",
);
}
#[test]
fn decider_at_names_most_specific_toucher() {
let a = Fixed("a", dict(&[("k", Value::from(1i64))]));
let b = Fixed("b", dict(&[("k", Value::from(2i64))]));
let c = Fixed("c", dict(&[("k", Value::from(3i64))]));
let disjoint = Fixed("disjoint", dict(&[("other", Value::from(9i64))]));
assert_eq!(decider_at(&[&a, &b, &c, &disjoint], &["k"]), Some("c"));
}
#[test]
fn decider_at_none_on_no_toucher_and_empty_stack() {
let a = Fixed("a", dict(&[("k", Value::from(1i64))]));
let disjoint = Fixed("z", dict(&[("other", Value::from(9i64))]));
assert_eq!(decider_at(&[&a, &disjoint], &["nope"]), None);
assert_eq!(decider_at(&[], &["k"]), None);
assert_eq!(decider_at(&[], &[]), None);
}
#[test]
fn decider_at_single_toucher_is_that_toucher() {
let a = Fixed("a", dict(&[("k", Value::from(1i64))]));
let disjoint = Fixed("z", dict(&[("other", Value::from(9i64))]));
assert_eq!(decider_at(&[&a, &disjoint], &["k"]), Some("a"));
}
#[test]
fn decider_at_order_sensitivity() {
let a = Fixed("a", dict(&[("k", Value::from(1i64))]));
let b = Fixed("b", dict(&[("k", Value::from(2i64))]));
assert_eq!(decider_at(&[&a, &b], &["k"]), Some("b"));
assert_eq!(decider_at(&[&b, &a], &["k"]), Some("a"));
}
#[test]
fn decider_at_partitions_contributors_at_disjointly_with_silenced_at() {
let coarse = Fixed(
"platform",
dict(&[(
"breathe",
Value::from(dict(&[
("setpoint", Value::from(0.80)),
("mode", Value::from("live")),
])),
)]),
);
let specific = Fixed(
"tenancy",
dict(&[(
"breathe",
Value::from(dict(&[("mode", Value::from("shadow"))])),
)]),
);
let layers: [&dyn DiscoveryLayer; 2] = [&coarse, &specific];
for path in [
&["breathe", "mode"][..],
&["breathe", "setpoint"][..],
&["breathe"][..],
&["absent"][..],
&[][..],
] {
let contributors = contributors_at(&layers, path);
let mut recomposed = silenced_at(&layers, path);
recomposed.extend(decider_at(&layers, path));
assert_eq!(
recomposed, contributors,
"silenced_at ⊎ decider_at != contributors_at at {path:?}",
);
assert_eq!(
decider_at(&layers, path),
contributors.last().copied(),
"decider_at != contributors_at.last() at {path:?}",
);
}
}
#[test]
fn decider_at_agrees_with_layer_of_on_surviving_leaves() {
let coarse = Fixed(
"platform",
dict(&[(
"breathe",
Value::from(dict(&[
("setpoint", Value::from(0.80)),
("mode", Value::from("live")),
])),
)]),
);
let specific = Fixed(
"tenancy",
dict(&[(
"breathe",
Value::from(dict(&[("mode", Value::from("shadow"))])),
)]),
);
let layers: [&dyn DiscoveryLayer; 2] = [&coarse, &specific];
let out = compose_with_provenance(&layers);
for path in [&["breathe", "mode"][..], &["breathe", "setpoint"][..]] {
assert_eq!(
decider_at(&layers, path),
out.attribution.layer_of(path),
"decider_at != layer_of on surviving leaf {path:?}",
);
}
}
#[test]
fn decider_at_names_erasure_agent_when_prefix_scalar_wipes_subtree() {
let a = Fixed(
"a",
dict(&[("x", Value::from(dict(&[("a", Value::from(1i64))])))]),
);
let b = Fixed("b", dict(&[("x", Value::from(9i64))]));
assert_eq!(decider_at(&[&a, &b], &["x", "a"]), Some("b"));
assert_eq!(decider_at(&[&a, &b], &["x"]), Some("b"));
let out = compose_with_provenance(&[&a, &b]);
assert_eq!(out.attribution.layer_of(&["x", "a"]), None);
}
#[test]
fn decider_at_at_root_equals_last_contributor_name() {
let coarse = Fixed("platform", dict(&[("a", Value::from(1i64))]));
let silent = Fixed("undetectable", Dict::new());
let middle = Fixed("cloud", dict(&[("c", Value::from(3i64))]));
let specific = Fixed("tenancy", dict(&[("b", Value::from(2i64))]));
let layers: [&dyn DiscoveryLayer; 4] = [&coarse, &silent, &middle, &specific];
assert_eq!(
decider_at(&layers, &[]),
contributor_names(&layers).last().copied(),
);
assert_eq!(decider_at(&layers, &[]), Some("tenancy"));
}
#[test]
fn decider_at_matches_contributors_at_last_across_all_path_shapes() {
let a = Fixed(
"a",
dict(&[("x", Value::from(dict(&[("a", Value::from(1i64))])))]),
);
let b = Fixed("b", dict(&[("x", Value::from(9i64))]));
let c = Fixed("c", dict(&[("k", Value::from(3i64))]));
let d = Fixed("d", dict(&[("k", Value::from(4i64))]));
let layers: [&dyn DiscoveryLayer; 4] = [&a, &b, &c, &d];
for path in [
&["k"][..],
&["x"][..],
&["x", "a"][..],
&["nope"][..],
&[][..],
] {
assert_eq!(
decider_at(&layers, path),
contributors_at(&layers, path).last().copied(),
"decider_at != contributors_at.last() at {path:?}",
);
}
}
#[test]
fn contest_at_none_on_no_toucher_and_empty_stack() {
let a = Fixed("a", dict(&[("k", Value::from(1i64))]));
let disjoint = Fixed("z", dict(&[("other", Value::from(9i64))]));
assert_eq!(contest_at(&[&a, &disjoint], &["nope"]), None);
assert_eq!(contest_at(&[], &["k"]), None);
assert_eq!(contest_at(&[], &[]), None);
}
#[test]
fn contest_at_single_toucher_is_uncontested_with_that_decider() {
let a = Fixed("a", dict(&[("k", Value::from(1i64))]));
let disjoint = Fixed("z", dict(&[("other", Value::from(9i64))]));
let contest = contest_at(&[&a, &disjoint], &["k"]).expect("some toucher");
assert_eq!(contest.decider, "a");
assert!(contest.overridden.is_empty(), "no override contest");
assert!(!contest.is_contested(), "single toucher is not contested");
assert_eq!(contest.contributor_count(), 1);
}
#[test]
fn contest_at_lists_overridden_in_application_order() {
let a = Fixed("a", dict(&[("k", Value::from(1i64))]));
let b = Fixed("b", dict(&[("k", Value::from(2i64))]));
let c = Fixed("c", dict(&[("k", Value::from(3i64))]));
let disjoint = Fixed("disjoint", dict(&[("other", Value::from(9i64))]));
let contest = contest_at(&[&a, &b, &c, &disjoint], &["k"]).expect("some toucher");
assert_eq!(contest.decider, "c");
assert_eq!(contest.overridden, vec!["a", "b"]);
assert!(contest.is_contested());
assert_eq!(contest.contributor_count(), 3);
}
#[test]
fn contest_at_covers_erasure_case() {
let a = Fixed(
"a",
dict(&[("x", Value::from(dict(&[("a", Value::from(1i64))])))]),
);
let b = Fixed("b", dict(&[("x", Value::from(9i64))]));
let contest = contest_at(&[&a, &b], &["x", "a"]).expect("erasure decider is a toucher");
assert_eq!(
contest.decider, "b",
"erasure agent decides the erased path"
);
assert_eq!(contest.overridden, vec!["a"]);
let out = compose_with_provenance(&[&a, &b]);
assert_eq!(out.attribution.layer_of(&["x", "a"]), None);
}
#[test]
fn contest_at_projections_match_decider_and_silenced_axes() {
let coarse = Fixed(
"platform",
dict(&[(
"breathe",
Value::from(dict(&[
("setpoint", Value::from(0.80)),
("mode", Value::from("live")),
])),
)]),
);
let specific = Fixed(
"tenancy",
dict(&[(
"breathe",
Value::from(dict(&[("mode", Value::from("shadow"))])),
)]),
);
let layers: [&dyn DiscoveryLayer; 2] = [&coarse, &specific];
for path in [
&["breathe", "mode"][..],
&["breathe", "setpoint"][..],
&["breathe"][..],
&["absent"][..],
&[][..],
] {
let contest = contest_at(&layers, path);
assert_eq!(
contest.as_ref().map(|c| c.decider),
decider_at(&layers, path),
"contest.decider != decider_at at {path:?}",
);
match &contest {
Some(c) => assert_eq!(
c.overridden,
silenced_at(&layers, path),
"contest.overridden != silenced_at at {path:?}",
),
None => assert!(
silenced_at(&layers, path).is_empty()
&& contributors_at(&layers, path).is_empty(),
"contest_at is None but touchers exist at {path:?}",
),
}
}
}
#[test]
fn contest_at_reconstructs_contributors_at() {
let coarse = Fixed(
"platform",
dict(&[(
"breathe",
Value::from(dict(&[
("setpoint", Value::from(0.80)),
("mode", Value::from("live")),
])),
)]),
);
let middle = Fixed(
"cloud",
dict(&[(
"breathe",
Value::from(dict(&[("mode", Value::from("staging"))])),
)]),
);
let specific = Fixed(
"tenancy",
dict(&[(
"breathe",
Value::from(dict(&[("mode", Value::from("shadow"))])),
)]),
);
let layers: [&dyn DiscoveryLayer; 3] = [&coarse, &middle, &specific];
for path in [
&["breathe", "mode"][..],
&["breathe", "setpoint"][..],
&["breathe"][..],
&["absent"][..],
&[][..],
] {
let contributors = contributors_at(&layers, path);
let recomposed = contest_at(&layers, path).map_or_else(Vec::new, |c| {
let mut v = c.overridden.clone();
v.push(c.decider);
v
});
assert_eq!(
recomposed, contributors,
"reconstructed != contributors_at at {path:?}",
);
}
}
#[test]
fn contest_at_contributor_count_matches_contributors_at_len() {
let a = Fixed("a", dict(&[("k", Value::from(1i64))]));
let b = Fixed("b", dict(&[("k", Value::from(2i64))]));
let c = Fixed("c", dict(&[("other", Value::from(3i64))]));
let silent = Fixed("silent", Dict::new());
let layers: [&dyn DiscoveryLayer; 4] = [&a, &b, &c, &silent];
for path in [&["k"][..], &["other"][..], &["nope"][..], &[][..]] {
assert_eq!(
contest_at(&layers, path).map_or(0, |c| c.contributor_count()),
contributors_at(&layers, path).len(),
"contributor_count != contributors_at.len() at {path:?}",
);
}
}
#[test]
fn contest_at_is_contested_iff_silenced_non_empty() {
let a = Fixed("a", dict(&[("k", Value::from(1i64))]));
let b = Fixed("b", dict(&[("k", Value::from(2i64))]));
let c = Fixed("c", dict(&[("other", Value::from(3i64))]));
let layers: [&dyn DiscoveryLayer; 3] = [&a, &b, &c];
for path in [&["k"][..], &["other"][..], &["nope"][..], &[][..]] {
let contested_via_fused = contest_at(&layers, path).is_some_and(|c| c.is_contested());
let contested_via_loose = !silenced_at(&layers, path).is_empty();
assert_eq!(
contested_via_fused, contested_via_loose,
"is_contested() != !silenced_at.is_empty() at {path:?}",
);
}
}
#[test]
fn contest_at_root_boundary() {
let coarse = Fixed("platform", dict(&[("a", Value::from(1i64))]));
let silent = Fixed("undetectable", Dict::new());
let middle = Fixed("cloud", dict(&[("c", Value::from(3i64))]));
let specific = Fixed("tenancy", dict(&[("b", Value::from(2i64))]));
let layers: [&dyn DiscoveryLayer; 4] = [&coarse, &silent, &middle, &specific];
let contest = contest_at(&layers, &[]).expect("some non-empty layer at root");
assert_eq!(contest.decider, "tenancy");
assert_eq!(contest.overridden, vec!["platform", "cloud"]);
let mut expected_overridden = contributor_names(&layers);
expected_overridden.pop();
assert_eq!(contest.overridden, expected_overridden);
}
#[test]
fn contest_at_agrees_with_layer_of_on_surviving_leaves() {
let coarse = Fixed(
"platform",
dict(&[(
"breathe",
Value::from(dict(&[
("setpoint", Value::from(0.80)),
("mode", Value::from("live")),
])),
)]),
);
let specific = Fixed(
"tenancy",
dict(&[(
"breathe",
Value::from(dict(&[("mode", Value::from("shadow"))])),
)]),
);
let layers: [&dyn DiscoveryLayer; 2] = [&coarse, &specific];
let out = compose_with_provenance(&layers);
for path in [&["breathe", "mode"][..], &["breathe", "setpoint"][..]] {
let contest = contest_at(&layers, path).expect("surviving leaf has toucher");
assert_eq!(
Some(contest.decider),
out.attribution.layer_of(path),
"contest.decider != layer_of on surviving leaf {path:?}",
);
}
}
#[test]
fn path_contest_contributors_uncontested_returns_singleton_decider() {
let contest = PathContest {
decider: "solo",
overridden: vec![],
};
assert_eq!(contest.contributors(), vec!["solo"]);
assert!(!contest.is_contested());
assert_eq!(contest.contributors().len(), 1);
assert_eq!(contest.contributors().len(), contest.contributor_count());
}
#[test]
fn path_contest_contributors_three_writers_ordered_coarse_to_specific() {
let platform = Fixed(
"platform",
dict(&[(
"breathe",
Value::from(dict(&[("mode", Value::from("live"))])),
)]),
);
let cloud = Fixed(
"cloud",
dict(&[(
"breathe",
Value::from(dict(&[("mode", Value::from("aws"))])),
)]),
);
let tenancy = Fixed(
"tenancy",
dict(&[(
"breathe",
Value::from(dict(&[("mode", Value::from("prod"))])),
)]),
);
let disjoint = Fixed("logger", dict(&[("logger", Value::from("info"))]));
let layers: [&dyn DiscoveryLayer; 4] = [&platform, &cloud, &tenancy, &disjoint];
let contest = contest_at(&layers, &["breathe", "mode"]).expect("three touchers");
assert_eq!(
contest.contributors(),
vec!["platform", "cloud", "tenancy"],
"contributors() enumerates touchers coarse→specific",
);
}
#[test]
fn path_contest_contributors_matches_contributors_at() {
let a = Fixed(
"a",
dict(&[(
"breathe",
Value::from(dict(&[
("mode", Value::from("live")),
("setpoint", Value::from(0.80)),
])),
)]),
);
let b = Fixed(
"b",
dict(&[(
"breathe",
Value::from(dict(&[("mode", Value::from("shadow"))])),
)]),
);
let c = Fixed("c", dict(&[("logger", Value::from("info"))]));
let layers: [&dyn DiscoveryLayer; 3] = [&a, &b, &c];
for path in [
&[][..],
&["breathe"][..],
&["breathe", "mode"][..],
&["breathe", "setpoint"][..],
&["logger"][..],
&["absent"][..],
] {
let expected = contributors_at(&layers, path);
let via_fused = contest_at(&layers, path).map_or_else(Vec::new, |c| c.contributors());
assert_eq!(
via_fused, expected,
"contest.contributors() != contributors_at at {path:?}",
);
}
}
#[test]
fn path_contest_contributors_len_matches_contributor_count() {
let a = Fixed(
"a",
dict(&[("k", Value::from(dict(&[("leaf", Value::from(1i64))])))]),
);
let b = Fixed("b", dict(&[("k", Value::from("erased"))]));
let c = Fixed(
"c",
dict(&[("k", Value::from(dict(&[("leaf", Value::from(3i64))])))]),
);
let layers: [&dyn DiscoveryLayer; 3] = [&a, &b, &c];
for path in [&[][..], &["k"][..], &["k", "leaf"][..], &["absent"][..]] {
let expected = contributors_at(&layers, path).len();
let via_contributors = contest_at(&layers, path).map_or(0, |c| c.contributors().len());
let via_count = contest_at(&layers, path).map_or(0, |c| c.contributor_count());
assert_eq!(via_contributors, expected, "len mismatch at {path:?}");
assert_eq!(via_count, expected, "count mismatch at {path:?}");
}
}
#[test]
fn path_contest_contributors_trailing_element_is_decider() {
let a = Fixed(
"a",
dict(&[(
"breathe",
Value::from(dict(&[("mode", Value::from("live"))])),
)]),
);
let b = Fixed(
"b",
dict(&[(
"breathe",
Value::from(dict(&[("mode", Value::from("shadow"))])),
)]),
);
let c = Fixed(
"c",
dict(&[(
"breathe",
Value::from(dict(&[("mode", Value::from("prod"))])),
)]),
);
let layers: [&dyn DiscoveryLayer; 3] = [&a, &b, &c];
for path in [&["breathe"][..], &["breathe", "mode"][..], &[][..]] {
let contest = contest_at(&layers, path).expect("some toucher");
let contributors = contest.contributors();
assert_eq!(
contributors.last().copied(),
Some(contest.decider),
"trailing element != decider at {path:?}",
);
}
}
#[test]
fn path_contest_contributors_leading_prefix_is_overridden() {
let a = Fixed(
"a",
dict(&[(
"breathe",
Value::from(dict(&[("mode", Value::from("live"))])),
)]),
);
let b = Fixed(
"b",
dict(&[(
"breathe",
Value::from(dict(&[("mode", Value::from("shadow"))])),
)]),
);
let c = Fixed(
"c",
dict(&[(
"breathe",
Value::from(dict(&[("mode", Value::from("prod"))])),
)]),
);
let layers: [&dyn DiscoveryLayer; 3] = [&a, &b, &c];
for path in [&["breathe"][..], &["breathe", "mode"][..], &[][..]] {
let contest = contest_at(&layers, path).expect("some toucher");
let contributors = contest.contributors();
let leading = &contributors[..contest.overridden.len()];
assert_eq!(
leading,
contest.overridden.as_slice(),
"leading prefix != overridden at {path:?}",
);
}
}
#[test]
fn path_contest_contributors_covers_erasure_case() {
let a = Fixed(
"a",
dict(&[("k", Value::from(dict(&[("leaf", Value::from(1i64))])))]),
);
let b = Fixed("b", dict(&[("k", Value::from("erased"))]));
let layers: [&dyn DiscoveryLayer; 2] = [&a, &b];
let contest = contest_at(&layers, &["k", "leaf"]).expect("erasure decider is a toucher");
assert_eq!(contest.contributors(), vec!["a", "b"]);
assert_eq!(contest.decider, "b");
assert_eq!(contest.overridden, vec!["a"]);
}
#[test]
fn path_contest_contributors_iter_singleton_yields_decider_only() {
let contest = PathContest {
decider: "solo",
overridden: vec![],
};
let materialized: Vec<&'static str> = contest.contributors_iter().collect();
assert_eq!(
materialized,
vec!["solo"],
"sole toucher yields exactly [decider]",
);
assert_eq!(
contest.contributors_iter().count(),
1,
".count() aliases contributor_count() on the uncontested singleton",
);
assert_eq!(
contest.contributors_iter().count(),
contest.contributor_count(),
"count identity holds on the empty-losers boundary",
);
}
#[test]
fn path_contest_contributors_iter_matches_contributors_across_fixture() {
let (sole, pair_coarse, pair_specific) = contest_fixture();
for layers in [
&[sole.as_ref()][..],
&[pair_coarse.as_ref(), pair_specific.as_ref()][..],
&[sole.as_ref(), pair_coarse.as_ref(), pair_specific.as_ref()][..],
] {
let contest = contest_at(layers, &["k"]).unwrap();
let lazy: Vec<&'static str> = contest.contributors_iter().collect();
assert_eq!(
lazy,
contest.contributors(),
"iter().collect() disagrees with contributors() on a {}-toucher fixture",
contest.contributor_count(),
);
}
}
#[test]
fn path_contest_contributors_iter_matches_silenced_chain_decider() {
let (sole, pair_coarse, pair_specific) = contest_fixture();
for layers in [
&[sole.as_ref()][..],
&[pair_coarse.as_ref(), pair_specific.as_ref()][..],
&[sole.as_ref(), pair_coarse.as_ref(), pair_specific.as_ref()][..],
] {
let contest = contest_at(layers, &["k"]).unwrap();
let via_method: Vec<&'static str> = contest.contributors_iter().collect();
let via_hand: Vec<&'static str> = contest
.silenced()
.iter()
.copied()
.chain(std::iter::once(contest.decider))
.collect();
assert_eq!(
via_method, via_hand,
"iter() disagrees with the substrate-side concat chain",
);
}
}
#[test]
fn path_contest_contributors_iter_endpoints_alias_coarsest_and_decider() {
let (sole, pair_coarse, pair_specific) = contest_fixture();
let layers: [&dyn DiscoveryLayer; 1] = [sole.as_ref()];
let contest = contest_at(&layers, &["k"]).unwrap();
assert_eq!(contest.contributors_iter().next(), Some(contest.coarsest()));
assert_eq!(contest.contributors_iter().last(), Some(contest.decider));
assert_eq!(contest.coarsest(), contest.decider, "singleton collapse");
let layers: [&dyn DiscoveryLayer; 3] =
[sole.as_ref(), pair_coarse.as_ref(), pair_specific.as_ref()];
let contest = contest_at(&layers, &["k"]).unwrap();
assert_eq!(contest.contributors_iter().next(), Some(contest.coarsest()));
assert_eq!(contest.contributors_iter().last(), Some(contest.decider));
assert_ne!(
contest.coarsest(),
contest.decider,
"contested-triple endpoints are structurally distinct",
);
}
#[test]
fn path_contest_contributors_iter_count_matches_contributor_count() {
let (sole, pair_coarse, pair_specific) = contest_fixture();
for layers in [
&[sole.as_ref()][..],
&[pair_coarse.as_ref(), pair_specific.as_ref()][..],
&[sole.as_ref(), pair_coarse.as_ref(), pair_specific.as_ref()][..],
] {
let contest = contest_at(layers, &["k"]).unwrap();
assert_eq!(
contest.contributors_iter().count(),
contest.contributor_count(),
);
assert_eq!(
contest.contributors_iter().count(),
contest.silenced_count() + 1,
);
}
}
#[test]
fn path_contest_contributors_iter_matches_contributors_at_across_paths() {
let platform = Fixed(
"platform",
dict(&[(
"breathe",
Value::from(dict(&[
("mode", Value::from("live")),
("setpoint", Value::from(0.80)),
])),
)]),
);
let cloud = Fixed(
"cloud",
dict(&[(
"breathe",
Value::from(dict(&[("mode", Value::from("shadow"))])),
)]),
);
let tenancy = Fixed(
"tenancy",
dict(&[(
"breathe",
Value::from(dict(&[("mode", Value::from("live"))])),
)]),
);
let layers: [&dyn DiscoveryLayer; 3] = [&platform, &cloud, &tenancy];
for path in [
&[][..],
&["breathe"][..],
&["breathe", "mode"][..],
&["breathe", "setpoint"][..],
&["absent"][..],
] {
let via_method: Vec<&'static str> =
contest_at(&layers, path).map_or(vec![], |c| c.contributors_iter().collect());
let via_free_fn = contributors_at(&layers, path);
assert_eq!(
via_method, via_free_fn,
"iter().collect() disagrees with contributors_at at path {path:?}",
);
}
}
#[test]
fn path_contest_contributors_iter_enumerate_pins_positions() {
let (sole, pair_coarse, pair_specific) = contest_fixture();
let layers: [&dyn DiscoveryLayer; 3] =
[sole.as_ref(), pair_coarse.as_ref(), pair_specific.as_ref()];
let contest = contest_at(&layers, &["k"]).unwrap();
let materialized = contest.contributors();
for (idx, name) in contest.contributors_iter().enumerate() {
assert_eq!(
name, materialized[idx],
"enumerated iterator diverges from contributors() at index {idx}",
);
}
let last_idx = contest.contributor_count() - 1;
assert_eq!(contest.contributors_iter().nth(0), Some(contest.coarsest()),);
assert_eq!(
contest.contributors_iter().nth(last_idx),
Some(contest.decider),
);
assert_eq!(
contest.contributors_iter().nth(last_idx - 1),
contest.runner_up(),
"index n-2 aliases runner_up() on the contested branch",
);
}
#[test]
fn path_contest_contributors_iter_root_specialization_matches_contributor_names() {
let a = Fixed("a", dict(&[("x", Value::from(1i64))]));
let silent = Fixed("silent", Dict::new());
let b = Fixed("b", dict(&[("y", Value::from(2i64))]));
let layers: [&dyn DiscoveryLayer; 3] = [&a, &silent, &b];
let contest = contest_at(&layers, &[]).expect("root is touched");
let iter_collected: Vec<&'static str> = contest.contributors_iter().collect();
assert_eq!(iter_collected, contributor_names(&layers));
assert_eq!(iter_collected, vec!["a", "b"]);
}
#[test]
fn path_contest_contributors_iter_rev_reverses_forward_walk_across_fixture() {
let (sole, pair_coarse, pair_specific) = contest_fixture();
for layers in [
vec![sole.as_ref()],
vec![pair_coarse.as_ref(), pair_specific.as_ref()],
vec![sole.as_ref(), pair_coarse.as_ref(), pair_specific.as_ref()],
] {
let contest = contest_at(&layers, &["k"]).expect("k is touched");
let mut expected = contest.contributors();
expected.reverse();
let reversed: Vec<&'static str> = contest.contributors_iter().rev().collect();
assert_eq!(reversed, expected);
}
}
#[test]
fn path_contest_contributors_iter_rev_endpoints_alias_decider_and_coarsest() {
let uncontested = PathContest {
decider: "solo",
overridden: vec![],
};
assert_eq!(uncontested.contributors_iter().rev().next(), Some("solo"));
assert_eq!(uncontested.contributors_iter().rev().last(), Some("solo"));
assert_eq!(
uncontested.contributors_iter().rev().next(),
Some(uncontested.decider),
);
assert_eq!(
uncontested.contributors_iter().rev().last(),
Some(uncontested.coarsest()),
);
let multi = PathContest {
decider: "tenancy",
overridden: vec!["platform", "cloud", "orchestrator"],
};
assert_eq!(multi.contributors_iter().rev().next(), Some("tenancy"));
assert_eq!(multi.contributors_iter().rev().last(), Some("platform"));
assert_eq!(multi.contributors_iter().rev().next(), Some(multi.decider),);
assert_eq!(
multi.contributors_iter().rev().last(),
Some(multi.coarsest()),
);
}
#[test]
fn path_contest_contributors_iter_rev_nth_walks_specific_to_coarse() {
let multi = PathContest {
decider: "tenancy",
overridden: vec!["platform", "cloud", "orchestrator"],
};
assert_eq!(multi.contributors_iter().rev().nth(0), Some(multi.decider));
assert_eq!(multi.contributors_iter().rev().nth(1), multi.runner_up());
let last_idx = multi.contributor_count() - 1;
assert_eq!(
multi.contributors_iter().rev().nth(last_idx),
Some(multi.coarsest()),
);
}
#[test]
fn path_contest_contributors_iter_clone_yields_independent_walks() {
let contest = PathContest {
decider: "tenancy",
overridden: vec!["platform", "cloud", "orchestrator"],
};
let a = contest.contributors_iter();
let b = a.clone();
let a_collected: Vec<&'static str> = a.collect();
let b_collected: Vec<&'static str> = b.collect();
assert_eq!(a_collected, b_collected);
assert_eq!(a_collected, contest.contributors());
let mut left = contest.contributors_iter();
let mut right = left.clone();
assert_eq!(left.next(), Some(contest.coarsest()));
assert_eq!(right.next(), Some(contest.coarsest()));
assert_eq!(left.next(), Some("cloud"));
assert_eq!(right.next(), Some("cloud"));
assert_eq!(left.next(), Some("orchestrator"));
assert_eq!(left.next(), Some(contest.decider));
assert_eq!(left.next(), None);
assert_eq!(right.next(), Some("orchestrator"));
assert_eq!(right.next(), Some(contest.decider));
assert_eq!(right.next(), None);
}
#[test]
fn path_contest_contributors_iter_clone_and_rev_compose_across_fixture() {
let (sole, pair_coarse, pair_specific) = contest_fixture();
for layers in [
vec![sole.as_ref()],
vec![pair_coarse.as_ref(), pair_specific.as_ref()],
vec![sole.as_ref(), pair_coarse.as_ref(), pair_specific.as_ref()],
] {
let contest = contest_at(&layers, &["k"]).expect("k is touched");
let base: Vec<&'static str> = contest.contributors_iter().rev().collect();
let via_clone_then_rev: Vec<&'static str> =
contest.contributors_iter().clone().rev().collect();
let via_rev_then_clone: Vec<&'static str> = {
let rev = contest.contributors_iter().rev();
rev.clone().collect()
};
assert_eq!(base, via_clone_then_rev);
assert_eq!(base, via_rev_then_clone);
}
}
#[test]
fn path_contest_contributors_iter_len_matches_contributor_count_across_fixture() {
let (sole, pair_coarse, pair_specific) = contest_fixture();
for layers in [
vec![sole.as_ref()],
vec![pair_coarse.as_ref(), pair_specific.as_ref()],
vec![sole.as_ref(), pair_coarse.as_ref(), pair_specific.as_ref()],
] {
let contest = contest_at(&layers, &["k"]).expect("k is touched");
let iter = contest.contributors_iter();
assert_eq!(iter.len(), contest.contributor_count());
assert_eq!(
contest.contributors_iter().count(),
contest.contributor_count(),
);
}
}
#[test]
fn path_contest_contributors_iter_size_hint_reports_exact_length() {
let uncontested = PathContest {
decider: "solo",
overridden: vec![],
};
let hint = uncontested.contributors_iter().size_hint();
assert_eq!(hint, (1, Some(1)));
let multi = PathContest {
decider: "tenancy",
overridden: vec!["platform", "cloud", "orchestrator"],
};
let hint = multi.contributors_iter().size_hint();
assert_eq!(hint, (4, Some(4)));
}
#[test]
fn path_contest_contributors_iter_len_decreases_by_one_per_advance() {
let multi = PathContest {
decider: "tenancy",
overridden: vec!["platform", "cloud", "orchestrator"],
};
let mut iter = multi.contributors_iter();
assert_eq!(iter.len(), 4);
assert_eq!(iter.next(), Some("platform"));
assert_eq!(iter.len(), 3);
assert_eq!(iter.next_back(), Some("tenancy"));
assert_eq!(iter.len(), 2);
assert_eq!(iter.next(), Some("cloud"));
assert_eq!(iter.len(), 1);
assert_eq!(iter.next_back(), Some("orchestrator"));
assert_eq!(iter.len(), 0);
assert_eq!(iter.next(), None);
assert_eq!(iter.len(), 0);
assert_eq!(iter.next_back(), None);
assert_eq!(iter.len(), 0);
}
#[test]
fn path_contest_contributors_iter_is_fused_past_exhaustion() {
let uncontested = PathContest {
decider: "solo",
overridden: vec![],
};
let mut iter = uncontested.contributors_iter();
assert_eq!(iter.next(), Some("solo"));
for _ in 0..4 {
assert_eq!(iter.next(), None);
assert_eq!(iter.next_back(), None);
}
let pair = PathContest {
decider: "tenancy",
overridden: vec!["platform"],
};
let mut iter = pair.contributors_iter();
assert_eq!(iter.next(), Some("platform"));
assert_eq!(iter.next(), Some("tenancy"));
for _ in 0..4 {
assert_eq!(iter.next(), None);
assert_eq!(iter.next_back(), None);
}
}
#[test]
fn path_contest_contributors_iter_last_returns_decider_end_of_forward_walk() {
let multi = PathContest {
decider: "tenancy",
overridden: vec!["platform", "cloud", "orchestrator"],
};
assert_eq!(multi.contributors_iter().last(), Some("tenancy"));
let uncontested = PathContest {
decider: "solo",
overridden: vec![],
};
assert_eq!(uncontested.contributors_iter().last(), Some("solo"));
let mut partially = multi.contributors_iter();
assert_eq!(partially.next_back(), Some("tenancy"));
assert_eq!(partially.last(), Some("orchestrator"));
}
#[test]
fn path_contest_contributors_iter_named_type_carries_trait_algebra() {
fn is_iter<I: Iterator<Item = &'static str>>(_: &I) {}
fn is_double_ended<I: DoubleEndedIterator<Item = &'static str>>(_: &I) {}
fn is_exact_size<I: ExactSizeIterator<Item = &'static str>>(_: &I) {}
fn is_fused<I: std::iter::FusedIterator<Item = &'static str>>(_: &I) {}
fn is_clone<T: Clone>(_: &T) {}
fn is_debug<T: std::fmt::Debug>(_: &T) {}
let contest = PathContest {
decider: "d",
overridden: vec!["o0", "o1"],
};
let iter: PathContestContributorsIter<'_> = contest.contributors_iter();
is_iter(&iter);
is_double_ended(&iter);
is_exact_size(&iter);
is_fused(&iter);
is_clone(&iter);
is_debug(&iter);
}
#[test]
fn path_contest_silenced_iter_empty_on_uncontested_singleton() {
let contest = PathContest {
decider: "solo",
overridden: vec![],
};
assert_eq!(contest.silenced_iter().count(), 0);
assert!(contest.silenced_iter().next().is_none());
assert!(contest.silenced_iter().last().is_none());
assert_eq!(
contest.silenced_iter().count(),
contest.silenced_count(),
"count identity holds on the empty-losers boundary",
);
}
#[test]
fn path_contest_silenced_iter_matches_silenced_across_fixture() {
let (sole, pair_coarse, pair_specific) = contest_fixture();
for layers in [
&[sole.as_ref()][..],
&[pair_coarse.as_ref(), pair_specific.as_ref()][..],
&[sole.as_ref(), pair_coarse.as_ref(), pair_specific.as_ref()][..],
] {
let contest = contest_at(layers, &["k"]).unwrap();
let via_iter: Vec<&'static str> = contest.silenced_iter().collect();
assert_eq!(
via_iter,
contest.silenced().to_vec(),
"silenced_iter().collect() disagrees with silenced().to_vec() on a {}-silenced fixture",
contest.silenced_count(),
);
}
}
#[test]
fn path_contest_silenced_iter_chain_once_decider_matches_contributors_iter() {
let (sole, pair_coarse, pair_specific) = contest_fixture();
for layers in [
&[sole.as_ref()][..],
&[pair_coarse.as_ref(), pair_specific.as_ref()][..],
&[sole.as_ref(), pair_coarse.as_ref(), pair_specific.as_ref()][..],
] {
let contest = contest_at(layers, &["k"]).unwrap();
let via_chain: Vec<&'static str> = contest
.silenced_iter()
.chain(std::iter::once(contest.decider))
.collect();
let via_contributors: Vec<&'static str> = contest.contributors_iter().collect();
assert_eq!(
via_chain, via_contributors,
"chain(once(decider)) disagrees with contributors_iter()",
);
}
}
#[test]
fn path_contest_silenced_iter_endpoints_alias_coarsest_silenced_and_runner_up() {
let (sole, pair_coarse, pair_specific) = contest_fixture();
let layers: [&dyn DiscoveryLayer; 1] = [sole.as_ref()];
let contest = contest_at(&layers, &["k"]).unwrap();
assert_eq!(contest.silenced_iter().next(), contest.coarsest_silenced());
assert_eq!(contest.silenced_iter().last(), contest.runner_up());
assert!(contest.silenced_iter().next().is_none());
let layers: [&dyn DiscoveryLayer; 2] = [pair_coarse.as_ref(), pair_specific.as_ref()];
let contest = contest_at(&layers, &["k"]).unwrap();
assert_eq!(contest.silenced_iter().next(), contest.coarsest_silenced());
assert_eq!(contest.silenced_iter().last(), contest.runner_up());
assert_eq!(
contest.silenced_iter().next(),
contest.silenced_iter().last(),
"singly silenced: endpoints alias",
);
let layers: [&dyn DiscoveryLayer; 3] =
[sole.as_ref(), pair_coarse.as_ref(), pair_specific.as_ref()];
let contest = contest_at(&layers, &["k"]).unwrap();
assert_eq!(contest.silenced_iter().next(), contest.coarsest_silenced());
assert_eq!(contest.silenced_iter().last(), contest.runner_up());
assert_ne!(
contest.silenced_iter().next(),
contest.silenced_iter().last(),
"multiply silenced: endpoints structurally distinct",
);
}
#[test]
fn path_contest_silenced_iter_count_and_len_match_silenced_count() {
let (sole, pair_coarse, pair_specific) = contest_fixture();
for layers in [
&[sole.as_ref()][..],
&[pair_coarse.as_ref(), pair_specific.as_ref()][..],
&[sole.as_ref(), pair_coarse.as_ref(), pair_specific.as_ref()][..],
] {
let contest = contest_at(layers, &["k"]).unwrap();
assert_eq!(contest.silenced_iter().count(), contest.silenced_count());
assert_eq!(contest.silenced_iter().len(), contest.silenced_count());
assert_eq!(
contest.silenced_iter().count(),
contest.silenced_iter().len()
);
}
}
#[test]
fn path_contest_silenced_iter_matches_silenced_at_across_paths() {
let platform = Fixed(
"platform",
dict(&[(
"breathe",
Value::from(dict(&[
("mode", Value::from("live")),
("setpoint", Value::from(0.80)),
])),
)]),
);
let cloud = Fixed(
"cloud",
dict(&[(
"breathe",
Value::from(dict(&[("mode", Value::from("shadow"))])),
)]),
);
let tenancy = Fixed(
"tenancy",
dict(&[(
"breathe",
Value::from(dict(&[("mode", Value::from("live"))])),
)]),
);
let layers: [&dyn DiscoveryLayer; 3] = [&platform, &cloud, &tenancy];
for path in [
&[][..],
&["breathe"][..],
&["breathe", "mode"][..],
&["breathe", "setpoint"][..],
&["absent"][..],
] {
let via_method: Vec<&'static str> =
contest_at(&layers, path).map_or(vec![], |c| c.silenced_iter().collect());
let via_free_fn = silenced_at(&layers, path);
assert_eq!(
via_method, via_free_fn,
"silenced_iter().collect() disagrees with silenced_at at path {path:?}",
);
}
}
#[test]
fn path_contest_silenced_iter_rev_reverses_forward_walk_across_fixture() {
let (sole, pair_coarse, pair_specific) = contest_fixture();
for layers in [
vec![sole.as_ref()],
vec![pair_coarse.as_ref(), pair_specific.as_ref()],
vec![sole.as_ref(), pair_coarse.as_ref(), pair_specific.as_ref()],
] {
let contest = contest_at(&layers, &["k"]).expect("k is touched");
let mut expected = contest.silenced().to_vec();
expected.reverse();
let reversed: Vec<&'static str> = contest.silenced_iter().rev().collect();
assert_eq!(reversed, expected);
}
}
#[test]
fn path_contest_silenced_iter_rev_endpoints_swap_endpoints() {
let (sole, pair_coarse, pair_specific) = contest_fixture();
let layers: [&dyn DiscoveryLayer; 3] =
[sole.as_ref(), pair_coarse.as_ref(), pair_specific.as_ref()];
let contest = contest_at(&layers, &["k"]).expect("k is touched");
assert_eq!(contest.silenced_iter().rev().next(), contest.runner_up());
assert_eq!(
contest.silenced_iter().rev().last(),
contest.coarsest_silenced(),
);
}
#[test]
fn path_contest_silenced_iter_clone_yields_independent_walks() {
let (sole, pair_coarse, pair_specific) = contest_fixture();
let layers: [&dyn DiscoveryLayer; 3] =
[sole.as_ref(), pair_coarse.as_ref(), pair_specific.as_ref()];
let contest = contest_at(&layers, &["k"]).expect("k is touched");
let a = contest.silenced_iter();
let b = a.clone();
let via_a: Vec<&'static str> = a.collect();
let via_b: Vec<&'static str> = b.collect();
assert_eq!(via_a, via_b);
assert_eq!(via_a, contest.silenced().to_vec());
}
#[test]
fn path_contest_silenced_iter_len_matches_silenced_count_across_fixture() {
let (sole, pair_coarse, pair_specific) = contest_fixture();
for layers in [
vec![sole.as_ref()],
vec![pair_coarse.as_ref(), pair_specific.as_ref()],
vec![sole.as_ref(), pair_coarse.as_ref(), pair_specific.as_ref()],
] {
let contest = contest_at(&layers, &["k"]).expect("k is touched");
let iter = contest.silenced_iter();
let via_len = iter.len();
assert_eq!(via_len, contest.silenced_count());
assert_eq!(via_len, contest.silenced().len());
}
}
#[test]
fn path_contest_silenced_iter_size_hint_reports_exact_length() {
let (sole, pair_coarse, pair_specific) = contest_fixture();
for layers in [
vec![sole.as_ref()],
vec![pair_coarse.as_ref(), pair_specific.as_ref()],
vec![sole.as_ref(), pair_coarse.as_ref(), pair_specific.as_ref()],
] {
let contest = contest_at(&layers, &["k"]).expect("k is touched");
let iter = contest.silenced_iter();
let n = contest.silenced_count();
assert_eq!(iter.size_hint(), (n, Some(n)));
}
}
#[test]
fn path_contest_silenced_iter_len_decreases_by_one_per_advance() {
let (sole, pair_coarse, pair_specific) = contest_fixture();
let layers: [&dyn DiscoveryLayer; 3] =
[sole.as_ref(), pair_coarse.as_ref(), pair_specific.as_ref()];
let contest = contest_at(&layers, &["k"]).expect("k is touched");
let n = contest.silenced_count();
assert!(n >= 2, "fixture chosen so silenced_count() >= 2");
let mut it = contest.silenced_iter();
let mut remaining = n;
assert_eq!(it.len(), remaining);
while it.next().is_some() {
remaining -= 1;
assert_eq!(it.len(), remaining);
}
assert_eq!(remaining, 0);
assert_eq!(it.len(), 0);
let mut it = contest.silenced_iter();
let mut remaining = n;
while it.next_back().is_some() {
remaining -= 1;
assert_eq!(it.len(), remaining);
}
assert_eq!(remaining, 0);
assert_eq!(it.len(), 0);
}
#[test]
fn path_contest_silenced_iter_is_fused_past_exhaustion() {
let (sole, pair_coarse, pair_specific) = contest_fixture();
let layers: [&dyn DiscoveryLayer; 3] =
[sole.as_ref(), pair_coarse.as_ref(), pair_specific.as_ref()];
let contest = contest_at(&layers, &["k"]).expect("k is touched");
let mut it = contest.silenced_iter();
while it.next().is_some() {}
for _ in 0..4 {
assert_eq!(it.next(), None);
assert_eq!(it.next_back(), None);
}
let mut it = contest.silenced_iter();
while it.next_back().is_some() {}
for _ in 0..4 {
assert_eq!(it.next(), None);
assert_eq!(it.next_back(), None);
}
}
#[test]
fn path_contest_silenced_iter_named_type_carries_trait_algebra() {
fn is_iter<I: Iterator<Item = &'static str>>(_: &I) {}
fn is_double_ended<I: DoubleEndedIterator<Item = &'static str>>(_: &I) {}
fn is_exact_size<I: ExactSizeIterator<Item = &'static str>>(_: &I) {}
fn is_fused<I: std::iter::FusedIterator<Item = &'static str>>(_: &I) {}
fn is_clone<T: Clone>(_: &T) {}
fn is_debug<T: std::fmt::Debug>(_: &T) {}
let contest = PathContest {
decider: "d",
overridden: vec!["o0", "o1"],
};
let iter: PathContestSilencedIter<'_> = contest.silenced_iter();
is_iter(&iter);
is_double_ended(&iter);
is_exact_size(&iter);
is_fused(&iter);
is_clone(&iter);
is_debug(&iter);
}
#[test]
fn path_contest_silenced_iter_nth_and_nth_back_walk_indices() {
let contest = PathContest {
decider: "d",
overridden: vec!["o0", "o1", "o2", "o3"],
};
let expected = contest.silenced().to_vec();
let n = expected.len();
for k in 0..n {
let mut it = contest.silenced_iter();
assert_eq!(it.nth(k), Some(expected[k]));
}
let mut it = contest.silenced_iter();
assert_eq!(it.nth(n), None);
for k in 0..n {
let mut it = contest.silenced_iter();
assert_eq!(it.nth_back(k), Some(expected[n - 1 - k]));
}
let mut it = contest.silenced_iter();
assert_eq!(it.nth_back(n), None);
}
#[test]
fn path_contest_coarsest_uncontested_singleton_equals_decider() {
let contest = PathContest {
decider: "solo",
overridden: vec![],
};
assert_eq!(contest.coarsest(), "solo");
assert_eq!(contest.coarsest(), contest.decider);
assert!(!contest.is_contested());
}
#[test]
fn path_contest_coarsest_three_writers_returns_leading_overridden() {
let platform = Fixed(
"platform",
dict(&[(
"breathe",
Value::from(dict(&[("mode", Value::from("live"))])),
)]),
);
let cloud = Fixed(
"cloud",
dict(&[(
"breathe",
Value::from(dict(&[("mode", Value::from("aws"))])),
)]),
);
let tenancy = Fixed(
"tenancy",
dict(&[(
"breathe",
Value::from(dict(&[("mode", Value::from("prod"))])),
)]),
);
let disjoint = Fixed("logger", dict(&[("logger", Value::from("info"))]));
let layers: [&dyn DiscoveryLayer; 4] = [&platform, &cloud, &tenancy, &disjoint];
let contest = contest_at(&layers, &["breathe", "mode"]).expect("three touchers");
assert_eq!(contest.coarsest(), "platform");
assert_eq!(contest.decider, "tenancy");
assert_ne!(contest.coarsest(), contest.decider);
assert_eq!(
contest.coarsest(),
contest.overridden[0],
"coarsest is the leading overridden entry when contested",
);
}
#[test]
fn path_contest_coarsest_matches_contributors_first() {
let a = Fixed(
"a",
dict(&[(
"breathe",
Value::from(dict(&[
("mode", Value::from("live")),
("setpoint", Value::from(0.80)),
])),
)]),
);
let b = Fixed(
"b",
dict(&[(
"breathe",
Value::from(dict(&[("mode", Value::from("shadow"))])),
)]),
);
let c = Fixed("c", dict(&[("logger", Value::from("info"))]));
let layers: [&dyn DiscoveryLayer; 3] = [&a, &b, &c];
for path in [
&[][..],
&["breathe"][..],
&["breathe", "mode"][..],
&["breathe", "setpoint"][..],
&["logger"][..],
] {
let contest = contest_at(&layers, path).expect("some toucher");
let leading = contest
.contributors()
.first()
.copied()
.expect("contest is non-empty");
assert_eq!(
contest.coarsest(),
leading,
"coarsest() != contributors().first() at {path:?}",
);
}
}
#[test]
fn path_contest_coarsest_matches_contributors_at_first() {
let coarse = Fixed(
"platform",
dict(&[(
"breathe",
Value::from(dict(&[
("setpoint", Value::from(0.80)),
("mode", Value::from("live")),
])),
)]),
);
let middle = Fixed(
"cloud",
dict(&[(
"breathe",
Value::from(dict(&[("mode", Value::from("staging"))])),
)]),
);
let specific = Fixed(
"tenancy",
dict(&[(
"breathe",
Value::from(dict(&[("mode", Value::from("shadow"))])),
)]),
);
let layers: [&dyn DiscoveryLayer; 3] = [&coarse, &middle, &specific];
for path in [
&["breathe", "mode"][..],
&["breathe", "setpoint"][..],
&["breathe"][..],
&["absent"][..],
&[][..],
] {
let via_fused = contest_at(&layers, path).map(|c| c.coarsest());
let via_loose = contributors_at(&layers, path).first().copied();
assert_eq!(
via_fused, via_loose,
"coarsest() != contributors_at.first() at {path:?}",
);
}
}
#[test]
fn path_contest_coarsest_equals_decider_iff_uncontested() {
let a = Fixed(
"a",
dict(&[
("solo", Value::from(1i64)),
(
"breathe",
Value::from(dict(&[("mode", Value::from("live"))])),
),
]),
);
let b = Fixed(
"b",
dict(&[(
"breathe",
Value::from(dict(&[("mode", Value::from("shadow"))])),
)]),
);
let layers: [&dyn DiscoveryLayer; 2] = [&a, &b];
for path in [
&["solo"][..], &["breathe"][..], &["breathe", "mode"][..], ] {
let contest = contest_at(&layers, path).expect("some toucher");
let uncontested = !contest.is_contested();
let coarsest_is_decider = contest.coarsest() == contest.decider;
assert_eq!(
uncontested, coarsest_is_decider,
"!is_contested() != (coarsest == decider) at {path:?}",
);
}
}
#[test]
fn path_contest_coarsest_covers_erasure_case() {
let a = Fixed(
"a",
dict(&[("k", Value::from(dict(&[("leaf", Value::from(1i64))])))]),
);
let b = Fixed("b", dict(&[("k", Value::from("erased"))]));
let layers: [&dyn DiscoveryLayer; 2] = [&a, &b];
let contest = contest_at(&layers, &["k", "leaf"]).expect("erasure decider is a toucher");
assert_eq!(contest.coarsest(), "a");
assert_eq!(contest.decider, "b");
assert_ne!(contest.coarsest(), contest.decider);
}
#[test]
fn path_contest_coarsest_root_boundary() {
let coarse = Fixed("platform", dict(&[("a", Value::from(1i64))]));
let silent = Fixed("undetectable", Dict::new());
let middle = Fixed("cloud", dict(&[("c", Value::from(3i64))]));
let specific = Fixed("tenancy", dict(&[("b", Value::from(2i64))]));
let layers: [&dyn DiscoveryLayer; 4] = [&coarse, &silent, &middle, &specific];
let contest = contest_at(&layers, &[]).expect("some non-empty layer at root");
let names = contributor_names(&layers);
assert_eq!(
contest.coarsest(),
*names.first().expect("some contributor"),
"root coarsest is first contributor_name",
);
assert_eq!(
contest.decider,
*names.last().expect("some contributor"),
"root decider is last contributor_name",
);
assert_eq!(contest.coarsest(), "platform");
assert_eq!(contest.decider, "tenancy");
}
#[test]
fn coarsest_at_none_boundary_matches_decider_at_and_contributors_at() {
let a = Fixed("a", dict(&[("k", Value::from(1i64))]));
let b = Fixed("b", dict(&[("k", Value::from(2i64))]));
let layers: [&dyn DiscoveryLayer; 2] = [&a, &b];
assert_eq!(coarsest_at(&layers, &["absent"]), None);
assert_eq!(decider_at(&layers, &["absent"]), None);
assert!(contributors_at(&layers, &["absent"]).is_empty());
assert!(contest_at(&layers, &["absent"]).is_none());
let empty: [&dyn DiscoveryLayer; 0] = [];
assert_eq!(coarsest_at(&empty, &[]), None);
assert_eq!(decider_at(&empty, &[]), None);
}
#[test]
fn coarsest_at_matches_contributors_at_first_across_paths() {
let a = Fixed(
"a",
dict(&[(
"breathe",
Value::from(dict(&[
("mode", Value::from("live")),
("setpoint", Value::from(0.80)),
])),
)]),
);
let b = Fixed(
"b",
dict(&[(
"breathe",
Value::from(dict(&[("mode", Value::from("shadow"))])),
)]),
);
let c = Fixed("c", dict(&[("logger", Value::from("info"))]));
let layers: [&dyn DiscoveryLayer; 3] = [&a, &b, &c];
for path in [
&[][..],
&["breathe"][..],
&["breathe", "mode"][..],
&["breathe", "setpoint"][..],
&["logger"][..],
&["absent"][..],
] {
let via_primitive = coarsest_at(&layers, path);
let via_loose = contributors_at(&layers, path).first().copied();
assert_eq!(
via_primitive, via_loose,
"coarsest_at != contributors_at.first() at {path:?}",
);
}
}
#[test]
fn coarsest_at_matches_contest_at_coarsest_across_paths() {
let coarse = Fixed(
"platform",
dict(&[(
"breathe",
Value::from(dict(&[
("setpoint", Value::from(0.80)),
("mode", Value::from("live")),
])),
)]),
);
let middle = Fixed(
"cloud",
dict(&[(
"breathe",
Value::from(dict(&[("mode", Value::from("staging"))])),
)]),
);
let specific = Fixed(
"tenancy",
dict(&[(
"breathe",
Value::from(dict(&[("mode", Value::from("shadow"))])),
)]),
);
let layers: [&dyn DiscoveryLayer; 3] = [&coarse, &middle, &specific];
for path in [
&["breathe", "mode"][..],
&["breathe", "setpoint"][..],
&["breathe"][..],
&["absent"][..],
&[][..],
] {
let via_primitive = coarsest_at(&layers, path);
let via_fused = contest_at(&layers, path).map(|c| c.coarsest());
assert_eq!(
via_primitive, via_fused,
"coarsest_at != contest_at.map(|c| c.coarsest()) at {path:?}",
);
}
}
#[test]
fn coarsest_at_three_writers_returns_leading_toucher() {
let platform = Fixed(
"platform",
dict(&[(
"breathe",
Value::from(dict(&[("mode", Value::from("live"))])),
)]),
);
let cloud = Fixed(
"cloud",
dict(&[(
"breathe",
Value::from(dict(&[("mode", Value::from("aws"))])),
)]),
);
let tenancy = Fixed(
"tenancy",
dict(&[(
"breathe",
Value::from(dict(&[("mode", Value::from("prod"))])),
)]),
);
let disjoint = Fixed("logger", dict(&[("logger", Value::from("info"))]));
let layers: [&dyn DiscoveryLayer; 4] = [&platform, &cloud, &tenancy, &disjoint];
assert_eq!(coarsest_at(&layers, &["breathe", "mode"]), Some("platform"));
assert_eq!(decider_at(&layers, &["breathe", "mode"]), Some("tenancy"));
assert_ne!(
coarsest_at(&layers, &["breathe", "mode"]),
decider_at(&layers, &["breathe", "mode"]),
);
}
#[test]
fn coarsest_at_equals_decider_at_iff_at_most_one_toucher() {
let a = Fixed(
"a",
dict(&[
("solo", Value::from(1i64)),
(
"breathe",
Value::from(dict(&[("mode", Value::from("live"))])),
),
]),
);
let b = Fixed(
"b",
dict(&[(
"breathe",
Value::from(dict(&[("mode", Value::from("shadow"))])),
)]),
);
let layers: [&dyn DiscoveryLayer; 2] = [&a, &b];
for path in [
&["solo"][..], &["absent"][..], &["breathe"][..], &["breathe", "mode"][..], ] {
let coarsest = coarsest_at(&layers, path);
let decider = decider_at(&layers, path);
let at_most_one = contributors_at(&layers, path).len() <= 1;
assert_eq!(
coarsest == decider,
at_most_one,
"coarsest_at == decider_at != (contributors_at.len() <= 1) at {path:?}",
);
}
}
#[test]
fn coarsest_at_covers_prefix_scalar_erasure() {
let a = Fixed(
"a",
dict(&[("k", Value::from(dict(&[("leaf", Value::from(1i64))])))]),
);
let b = Fixed("b", dict(&[("k", Value::from("erased"))]));
let layers: [&dyn DiscoveryLayer; 2] = [&a, &b];
assert_eq!(coarsest_at(&layers, &["k", "leaf"]), Some("a"));
assert_eq!(decider_at(&layers, &["k", "leaf"]), Some("b"));
assert_ne!(
coarsest_at(&layers, &["k", "leaf"]),
decider_at(&layers, &["k", "leaf"]),
);
}
#[test]
fn coarsest_at_root_boundary_equals_first_contributor_name() {
let coarse = Fixed("platform", dict(&[("a", Value::from(1i64))]));
let silent = Fixed("undetectable", Dict::new());
let middle = Fixed("cloud", dict(&[("c", Value::from(3i64))]));
let specific = Fixed("tenancy", dict(&[("b", Value::from(2i64))]));
let layers: [&dyn DiscoveryLayer; 4] = [&coarse, &silent, &middle, &specific];
let names = contributor_names(&layers);
assert_eq!(coarsest_at(&layers, &[]), names.first().copied());
assert_eq!(decider_at(&layers, &[]), names.last().copied());
assert_eq!(coarsest_at(&layers, &[]), Some("platform"));
assert_eq!(decider_at(&layers, &[]), Some("tenancy"));
}
#[test]
fn is_contested_at_false_boundary_on_zero_or_one_toucher() {
let a = Fixed(
"a",
dict(&[
("solo", Value::from(1i64)),
(
"breathe",
Value::from(dict(&[("mode", Value::from("live"))])),
),
]),
);
let b = Fixed("b", dict(&[("logger", Value::from("info"))]));
let layers: [&dyn DiscoveryLayer; 2] = [&a, &b];
assert!(!is_contested_at(&layers, &["absent"]));
assert!(!is_contested_at(&layers, &["solo"]));
assert!(!is_contested_at(&layers, &["breathe"]));
assert!(!is_contested_at(&layers, &["breathe", "mode"]));
assert!(!is_contested_at(&layers, &["logger"]));
let empty: [&dyn DiscoveryLayer; 0] = [];
assert!(!is_contested_at(&empty, &[]));
assert!(!is_contested_at(&empty, &["absent"]));
}
#[test]
fn is_contested_at_matches_silenced_non_empty_across_paths() {
let a = Fixed(
"a",
dict(&[(
"breathe",
Value::from(dict(&[
("mode", Value::from("live")),
("setpoint", Value::from(0.80)),
])),
)]),
);
let b = Fixed(
"b",
dict(&[(
"breathe",
Value::from(dict(&[("mode", Value::from("shadow"))])),
)]),
);
let c = Fixed("c", dict(&[("logger", Value::from("info"))]));
let layers: [&dyn DiscoveryLayer; 3] = [&a, &b, &c];
for path in [
&[][..],
&["breathe"][..],
&["breathe", "mode"][..],
&["breathe", "setpoint"][..],
&["logger"][..],
&["absent"][..],
] {
let via_primitive = is_contested_at(&layers, path);
let via_loose = !silenced_at(&layers, path).is_empty();
assert_eq!(
via_primitive, via_loose,
"is_contested_at != !silenced_at.is_empty() at {path:?}",
);
}
}
#[test]
fn is_contested_at_matches_contest_at_is_contested_across_paths() {
let coarse = Fixed(
"platform",
dict(&[(
"breathe",
Value::from(dict(&[
("setpoint", Value::from(0.80)),
("mode", Value::from("live")),
])),
)]),
);
let middle = Fixed(
"cloud",
dict(&[(
"breathe",
Value::from(dict(&[("mode", Value::from("staging"))])),
)]),
);
let specific = Fixed(
"tenancy",
dict(&[(
"breathe",
Value::from(dict(&[("mode", Value::from("shadow"))])),
)]),
);
let layers: [&dyn DiscoveryLayer; 3] = [&coarse, &middle, &specific];
for path in [
&["breathe", "mode"][..],
&["breathe", "setpoint"][..],
&["breathe"][..],
&["absent"][..],
&[][..],
] {
let via_primitive = is_contested_at(&layers, path);
let via_fused = contest_at(&layers, path).is_some_and(|c| c.is_contested());
assert_eq!(
via_primitive, via_fused,
"is_contested_at != contest_at.is_some_and(is_contested) at {path:?}",
);
}
}
#[test]
fn is_contested_at_matches_contributors_len_ge_two_across_paths() {
let a = Fixed(
"a",
dict(&[(
"breathe",
Value::from(dict(&[
("mode", Value::from("live")),
("setpoint", Value::from(0.80)),
])),
)]),
);
let b = Fixed(
"b",
dict(&[(
"breathe",
Value::from(dict(&[("mode", Value::from("shadow"))])),
)]),
);
let c = Fixed("c", dict(&[("logger", Value::from("info"))]));
let layers: [&dyn DiscoveryLayer; 3] = [&a, &b, &c];
for path in [
&[][..],
&["breathe"][..],
&["breathe", "mode"][..],
&["breathe", "setpoint"][..],
&["logger"][..],
&["absent"][..],
] {
let via_primitive = is_contested_at(&layers, path);
let via_len = contributors_at(&layers, path).len() >= 2;
assert_eq!(
via_primitive, via_len,
"is_contested_at != contributors_at.len() >= 2 at {path:?}",
);
}
}
#[test]
fn is_contested_at_matches_endpoint_inequality_across_paths() {
let a = Fixed(
"a",
dict(&[
("solo", Value::from(1i64)),
(
"breathe",
Value::from(dict(&[("mode", Value::from("live"))])),
),
]),
);
let b = Fixed(
"b",
dict(&[(
"breathe",
Value::from(dict(&[("mode", Value::from("shadow"))])),
)]),
);
let layers: [&dyn DiscoveryLayer; 2] = [&a, &b];
for path in [
&["solo"][..], &["absent"][..], &["breathe"][..], &["breathe", "mode"][..], ] {
let via_primitive = is_contested_at(&layers, path);
let via_endpoints = coarsest_at(&layers, path) != decider_at(&layers, path);
assert_eq!(
via_primitive, via_endpoints,
"is_contested_at != (coarsest_at != decider_at) at {path:?}",
);
}
}
#[test]
fn is_contested_at_covers_prefix_scalar_erasure() {
let a = Fixed(
"a",
dict(&[("k", Value::from(dict(&[("leaf", Value::from(1i64))])))]),
);
let b = Fixed("b", dict(&[("k", Value::from("erased"))]));
let layers: [&dyn DiscoveryLayer; 2] = [&a, &b];
assert!(is_contested_at(&layers, &["k", "leaf"]));
assert_eq!(coarsest_at(&layers, &["k", "leaf"]), Some("a"));
assert_eq!(decider_at(&layers, &["k", "leaf"]), Some("b"));
}
#[test]
fn is_contested_at_root_boundary_filters_silent_layers() {
let coarse = Fixed("platform", dict(&[("a", Value::from(1i64))]));
let silent = Fixed("undetectable", Dict::new());
let middle = Fixed("cloud", dict(&[("c", Value::from(3i64))]));
let specific = Fixed("tenancy", dict(&[("b", Value::from(2i64))]));
let layers_four: [&dyn DiscoveryLayer; 4] = [&coarse, &silent, &middle, &specific];
assert!(is_contested_at(&layers_four, &[]));
let layers_one: [&dyn DiscoveryLayer; 2] = [&coarse, &silent];
assert!(!is_contested_at(&layers_one, &[]));
let layers_zero: [&dyn DiscoveryLayer; 2] = [&silent, &silent];
assert!(!is_contested_at(&layers_zero, &[]));
}
#[test]
fn contributor_count_at_matches_contributors_len_across_paths() {
let a = Fixed(
"a",
dict(&[(
"breathe",
Value::from(dict(&[
("mode", Value::from("live")),
("setpoint", Value::from(0.80)),
])),
)]),
);
let b = Fixed(
"b",
dict(&[(
"breathe",
Value::from(dict(&[("mode", Value::from("shadow"))])),
)]),
);
let c = Fixed("c", dict(&[("logger", Value::from("info"))]));
let layers: [&dyn DiscoveryLayer; 3] = [&a, &b, &c];
for path in [
&[][..],
&["breathe"][..],
&["breathe", "mode"][..],
&["breathe", "setpoint"][..],
&["logger"][..],
&["absent"][..],
] {
let via_primitive = contributor_count_at(&layers, path);
let via_len = contributors_at(&layers, path).len();
assert_eq!(
via_primitive, via_len,
"contributor_count_at != contributors_at.len() at {path:?}",
);
}
}
#[test]
fn contributor_count_at_matches_contest_at_contributor_count_across_paths() {
let coarse = Fixed(
"platform",
dict(&[(
"breathe",
Value::from(dict(&[
("setpoint", Value::from(0.80)),
("mode", Value::from("live")),
])),
)]),
);
let middle = Fixed(
"cloud",
dict(&[(
"breathe",
Value::from(dict(&[("mode", Value::from("staging"))])),
)]),
);
let specific = Fixed(
"tenancy",
dict(&[(
"breathe",
Value::from(dict(&[("mode", Value::from("shadow"))])),
)]),
);
let layers: [&dyn DiscoveryLayer; 3] = [&coarse, &middle, &specific];
for path in [
&["breathe", "mode"][..],
&["breathe", "setpoint"][..],
&["breathe"][..],
&["absent"][..],
&[][..],
] {
let via_primitive = contributor_count_at(&layers, path);
let via_fused = contest_at(&layers, path).map_or(0, |c| c.contributor_count());
assert_eq!(
via_primitive, via_fused,
"contributor_count_at != contest_at.map_or(0, contributor_count) at {path:?}",
);
}
}
#[test]
fn contributor_count_at_matches_partition_across_paths() {
let a = Fixed(
"a",
dict(&[
("solo", Value::from(1i64)),
(
"breathe",
Value::from(dict(&[("mode", Value::from("live"))])),
),
]),
);
let b = Fixed(
"b",
dict(&[(
"breathe",
Value::from(dict(&[("mode", Value::from("shadow"))])),
)]),
);
let c = Fixed("c", dict(&[("logger", Value::from("info"))]));
let layers: [&dyn DiscoveryLayer; 3] = [&a, &b, &c];
for path in [
&[][..],
&["solo"][..],
&["breathe"][..],
&["breathe", "mode"][..],
&["logger"][..],
&["absent"][..],
] {
let via_primitive = contributor_count_at(&layers, path);
let via_partition =
silenced_at(&layers, path).len() + usize::from(decider_at(&layers, path).is_some());
assert_eq!(
via_primitive, via_partition,
"contributor_count_at != silenced_at.len() + decider_at.is_some() at {path:?}",
);
}
}
#[test]
fn contributor_count_at_matches_is_contested_threshold_across_paths() {
let a = Fixed(
"a",
dict(&[
("solo", Value::from(1i64)),
(
"breathe",
Value::from(dict(&[("mode", Value::from("live"))])),
),
]),
);
let b = Fixed(
"b",
dict(&[(
"breathe",
Value::from(dict(&[("mode", Value::from("shadow"))])),
)]),
);
let layers: [&dyn DiscoveryLayer; 2] = [&a, &b];
for path in [
&["solo"][..],
&["absent"][..],
&["breathe"][..],
&["breathe", "mode"][..],
] {
let via_scalar = contributor_count_at(&layers, path) >= 2;
let via_bool = is_contested_at(&layers, path);
assert_eq!(
via_scalar, via_bool,
"(contributor_count_at >= 2) != is_contested_at at {path:?}",
);
}
}
#[test]
fn contributor_count_at_zero_pins_every_none_endpoint() {
let a = Fixed(
"a",
dict(&[
("solo", Value::from(1i64)),
(
"breathe",
Value::from(dict(&[("mode", Value::from("live"))])),
),
]),
);
let b = Fixed(
"b",
dict(&[(
"breathe",
Value::from(dict(&[("mode", Value::from("shadow"))])),
)]),
);
let layers: [&dyn DiscoveryLayer; 2] = [&a, &b];
for path in [
&["solo"][..],
&["absent"][..],
&["breathe"][..],
&["breathe", "mode"][..],
&[][..],
] {
let zero = contributor_count_at(&layers, path) == 0;
assert_eq!(
zero,
contest_at(&layers, path).is_none(),
"zero != contest_at.is_none() at {path:?}",
);
assert_eq!(
zero,
decider_at(&layers, path).is_none(),
"zero != decider_at.is_none() at {path:?}",
);
assert_eq!(
zero,
coarsest_at(&layers, path).is_none(),
"zero != coarsest_at.is_none() at {path:?}",
);
assert_eq!(
zero,
contributors_at(&layers, path).is_empty(),
"zero != contributors_at.is_empty() at {path:?}",
);
}
let empty: [&dyn DiscoveryLayer; 0] = [];
assert_eq!(contributor_count_at(&empty, &[]), 0);
assert_eq!(contributor_count_at(&empty, &["absent"]), 0);
}
#[test]
fn contributor_count_at_credits_prefix_scalar_erasure_toucher() {
let a = Fixed(
"a",
dict(&[("k", Value::from(dict(&[("leaf", Value::from(1i64))])))]),
);
let b = Fixed("b", dict(&[("k", Value::from("erased"))]));
let layers: [&dyn DiscoveryLayer; 2] = [&a, &b];
assert_eq!(contributor_count_at(&layers, &["k", "leaf"]), 2);
assert_eq!(contributor_count_at(&layers, &["k"]), 2);
}
#[test]
fn contributor_count_at_root_boundary_filters_silent_layers() {
let coarse = Fixed("platform", dict(&[("a", Value::from(1i64))]));
let silent = Fixed("undetectable", Dict::new());
let middle = Fixed("cloud", dict(&[("c", Value::from(3i64))]));
let specific = Fixed("tenancy", dict(&[("b", Value::from(2i64))]));
let layers_four: [&dyn DiscoveryLayer; 4] = [&coarse, &silent, &middle, &specific];
assert_eq!(contributor_count_at(&layers_four, &[]), 3);
let layers_one: [&dyn DiscoveryLayer; 2] = [&coarse, &silent];
assert_eq!(contributor_count_at(&layers_one, &[]), 1);
let layers_zero: [&dyn DiscoveryLayer; 2] = [&silent, &silent];
assert_eq!(contributor_count_at(&layers_zero, &[]), 0);
}
#[test]
fn silenced_count_at_matches_silenced_len_across_paths() {
let a = Fixed(
"a",
dict(&[(
"breathe",
Value::from(dict(&[
("mode", Value::from("live")),
("setpoint", Value::from(0.80)),
])),
)]),
);
let b = Fixed(
"b",
dict(&[(
"breathe",
Value::from(dict(&[("mode", Value::from("shadow"))])),
)]),
);
let c = Fixed("c", dict(&[("logger", Value::from("info"))]));
let layers: [&dyn DiscoveryLayer; 3] = [&a, &b, &c];
for path in [
&[][..],
&["breathe"][..],
&["breathe", "mode"][..],
&["breathe", "setpoint"][..],
&["logger"][..],
&["absent"][..],
] {
let via_primitive = silenced_count_at(&layers, path);
let via_len = silenced_at(&layers, path).len();
assert_eq!(
via_primitive, via_len,
"silenced_count_at != silenced_at.len() at {path:?}",
);
}
}
#[test]
fn silenced_count_at_pins_partition_against_touched_across_paths() {
let coarse = Fixed(
"platform",
dict(&[(
"breathe",
Value::from(dict(&[
("setpoint", Value::from(0.80)),
("mode", Value::from("live")),
])),
)]),
);
let middle = Fixed(
"cloud",
dict(&[(
"breathe",
Value::from(dict(&[("mode", Value::from("staging"))])),
)]),
);
let specific = Fixed(
"tenancy",
dict(&[(
"breathe",
Value::from(dict(&[("mode", Value::from("shadow"))])),
)]),
);
let layers: [&dyn DiscoveryLayer; 3] = [&coarse, &middle, &specific];
for path in [
&[][..],
&["breathe"][..],
&["breathe", "mode"][..],
&["breathe", "setpoint"][..],
&["absent"][..],
] {
let losers = silenced_count_at(&layers, path);
let touched = usize::from(is_touched_at(&layers, path));
let total = contributor_count_at(&layers, path);
assert_eq!(
losers + touched,
total,
"silenced_count_at + is_touched_at.into() != contributor_count_at at {path:?}",
);
}
}
#[test]
fn silenced_count_at_matches_saturating_complement_across_paths() {
let a = Fixed(
"a",
dict(&[
("solo", Value::from(1i64)),
(
"breathe",
Value::from(dict(&[("mode", Value::from("live"))])),
),
]),
);
let b = Fixed(
"b",
dict(&[(
"breathe",
Value::from(dict(&[("mode", Value::from("shadow"))])),
)]),
);
let c = Fixed("c", dict(&[("logger", Value::from("info"))]));
let layers: [&dyn DiscoveryLayer; 3] = [&a, &b, &c];
for path in [
&[][..],
&["solo"][..],
&["breathe"][..],
&["breathe", "mode"][..],
&["logger"][..],
&["absent"][..],
] {
let via_primitive = silenced_count_at(&layers, path);
let via_complement = contributor_count_at(&layers, path).saturating_sub(1);
assert_eq!(
via_primitive, via_complement,
"silenced_count_at != contributor_count_at.saturating_sub(1) at {path:?}",
);
}
let empty: [&dyn DiscoveryLayer; 0] = [];
assert_eq!(silenced_count_at(&empty, &[]), 0);
assert_eq!(silenced_count_at(&empty, &["absent"]), 0);
assert_eq!(silenced_count_at(&empty, &["a", "b", "c"]), 0);
}
#[test]
fn silenced_count_at_matches_is_contested_threshold_across_paths() {
let a = Fixed(
"a",
dict(&[
("solo", Value::from(1i64)),
(
"breathe",
Value::from(dict(&[("mode", Value::from("live"))])),
),
]),
);
let b = Fixed(
"b",
dict(&[(
"breathe",
Value::from(dict(&[("mode", Value::from("shadow"))])),
)]),
);
let layers: [&dyn DiscoveryLayer; 2] = [&a, &b];
for path in [
&["solo"][..],
&["absent"][..],
&["breathe"][..],
&["breathe", "mode"][..],
] {
let via_scalar_ge_one = silenced_count_at(&layers, path) >= 1;
let via_bool = is_contested_at(&layers, path);
assert_eq!(
via_scalar_ge_one, via_bool,
"(silenced_count_at >= 1) != is_contested_at at {path:?}",
);
let via_scalar_zero = silenced_count_at(&layers, path) == 0;
assert_eq!(
via_scalar_zero, !via_bool,
"(silenced_count_at == 0) != !is_contested_at at {path:?}",
);
}
}
#[test]
fn silenced_count_at_matches_contest_at_silenced_count_across_paths() {
let coarse = Fixed(
"platform",
dict(&[(
"breathe",
Value::from(dict(&[
("setpoint", Value::from(0.80)),
("mode", Value::from("live")),
])),
)]),
);
let middle = Fixed(
"cloud",
dict(&[(
"breathe",
Value::from(dict(&[("mode", Value::from("staging"))])),
)]),
);
let specific = Fixed(
"tenancy",
dict(&[(
"breathe",
Value::from(dict(&[("mode", Value::from("shadow"))])),
)]),
);
let layers: [&dyn DiscoveryLayer; 3] = [&coarse, &middle, &specific];
for path in [
&["breathe", "mode"][..],
&["breathe", "setpoint"][..],
&["breathe"][..],
&["absent"][..],
&[][..],
] {
let via_primitive = silenced_count_at(&layers, path);
let via_fused = contest_at(&layers, path).map_or(0, |c| c.silenced_count());
assert_eq!(
via_primitive, via_fused,
"silenced_count_at != contest_at.map_or(0, silenced_count) at {path:?}",
);
}
}
#[test]
fn silenced_count_at_credits_prefix_scalar_erasure_toucher() {
let a = Fixed(
"a",
dict(&[("k", Value::from(dict(&[("leaf", Value::from(1i64))])))]),
);
let b = Fixed("b", dict(&[("k", Value::from("erased"))]));
let layers: [&dyn DiscoveryLayer; 2] = [&a, &b];
assert_eq!(silenced_count_at(&layers, &["k", "leaf"]), 1);
assert_eq!(silenced_count_at(&layers, &["k"]), 1);
assert_eq!(silenced_count_at(&layers, &["unrelated"]), 0);
}
#[test]
fn silenced_count_at_root_boundary_filters_silent_layers() {
let coarse = Fixed("platform", dict(&[("a", Value::from(1i64))]));
let silent = Fixed("undetectable", Dict::new());
let middle = Fixed("cloud", dict(&[("c", Value::from(3i64))]));
let specific = Fixed("tenancy", dict(&[("b", Value::from(2i64))]));
let layers_four: [&dyn DiscoveryLayer; 4] = [&coarse, &silent, &middle, &specific];
assert_eq!(silenced_count_at(&layers_four, &[]), 2);
let layers_one: [&dyn DiscoveryLayer; 2] = [&coarse, &silent];
assert_eq!(silenced_count_at(&layers_one, &[]), 0);
let layers_zero: [&dyn DiscoveryLayer; 2] = [&silent, &silent];
assert_eq!(silenced_count_at(&layers_zero, &[]), 0);
}
#[test]
fn path_contest_silenced_count_field_length_projection() {
let coarse = Fixed(
"platform",
dict(&[(
"breathe",
Value::from(dict(&[
("setpoint", Value::from(0.80)),
("mode", Value::from("live")),
])),
)]),
);
let middle = Fixed(
"cloud",
dict(&[(
"breathe",
Value::from(dict(&[("mode", Value::from("staging"))])),
)]),
);
let specific = Fixed(
"tenancy",
dict(&[(
"breathe",
Value::from(dict(&[("mode", Value::from("shadow"))])),
)]),
);
let layers: [&dyn DiscoveryLayer; 3] = [&coarse, &middle, &specific];
let contested = contest_at(&layers, &["breathe", "mode"]).expect("some toucher");
assert_eq!(contested.silenced_count(), contested.overridden.len());
assert_eq!(contested.silenced_count(), 2);
assert_eq!(
contested.silenced_count() + 1,
contested.contributor_count()
);
assert!(contested.silenced_count() >= 1);
assert!(contested.is_contested());
let singleton = contest_at(&layers, &["breathe", "setpoint"]).expect("some toucher");
assert_eq!(singleton.silenced_count(), 0);
assert_eq!(
singleton.silenced_count() + 1,
singleton.contributor_count()
);
assert!(!singleton.is_contested());
}
#[test]
fn is_touched_at_matches_contributor_count_ge_one_across_paths() {
let a = Fixed(
"a",
dict(&[
("solo", Value::from(1i64)),
(
"breathe",
Value::from(dict(&[("mode", Value::from("live"))])),
),
]),
);
let b = Fixed(
"b",
dict(&[(
"breathe",
Value::from(dict(&[("mode", Value::from("shadow"))])),
)]),
);
let layers: [&dyn DiscoveryLayer; 2] = [&a, &b];
for path in [
&[][..],
&["solo"][..],
&["absent"][..],
&["breathe"][..],
&["breathe", "mode"][..],
] {
let via_bool = is_touched_at(&layers, path);
let via_scalar = contributor_count_at(&layers, path) >= 1;
assert_eq!(
via_bool, via_scalar,
"is_touched_at != (contributor_count_at >= 1) at {path:?}",
);
}
}
#[test]
fn is_touched_at_pins_every_none_endpoint_across_paths() {
let coarse = Fixed(
"platform",
dict(&[(
"breathe",
Value::from(dict(&[
("setpoint", Value::from(0.80)),
("mode", Value::from("live")),
])),
)]),
);
let specific = Fixed(
"tenancy",
dict(&[(
"breathe",
Value::from(dict(&[("mode", Value::from("shadow"))])),
)]),
);
let layers: [&dyn DiscoveryLayer; 2] = [&coarse, &specific];
for path in [
&[][..],
&["breathe"][..],
&["breathe", "mode"][..],
&["breathe", "setpoint"][..],
&["absent"][..],
&["breathe", "absent"][..],
] {
let touched = is_touched_at(&layers, path);
assert_eq!(
touched,
contest_at(&layers, path).is_some(),
"is_touched_at != contest_at.is_some() at {path:?}",
);
assert_eq!(
touched,
decider_at(&layers, path).is_some(),
"is_touched_at != decider_at.is_some() at {path:?}",
);
assert_eq!(
touched,
coarsest_at(&layers, path).is_some(),
"is_touched_at != coarsest_at.is_some() at {path:?}",
);
assert_eq!(
touched,
!contributors_at(&layers, path).is_empty(),
"is_touched_at != !contributors_at.is_empty() at {path:?}",
);
}
let empty: [&dyn DiscoveryLayer; 0] = [];
assert!(!is_touched_at(&empty, &[]));
assert!(!is_touched_at(&empty, &["absent"]));
}
#[test]
fn is_touched_at_matches_monotonic_chain_against_is_contested_at() {
let a = Fixed(
"a",
dict(&[
("solo", Value::from(1i64)),
(
"breathe",
Value::from(dict(&[("mode", Value::from("live"))])),
),
]),
);
let b = Fixed(
"b",
dict(&[(
"breathe",
Value::from(dict(&[("mode", Value::from("shadow"))])),
)]),
);
let layers: [&dyn DiscoveryLayer; 2] = [&a, &b];
for path in [
&[][..],
&["solo"][..],
&["absent"][..],
&["breathe"][..],
&["breathe", "mode"][..],
] {
let touched = is_touched_at(&layers, path);
let contested = is_contested_at(&layers, path);
assert!(
!contested || touched,
"is_contested_at ⇒ is_touched_at broken at {path:?}",
);
assert!(
touched || !contested,
"!is_touched_at ⇒ !is_contested_at broken at {path:?}",
);
}
}
#[test]
fn is_touched_at_singleton_characterization_across_paths() {
let a = Fixed(
"a",
dict(&[
("solo", Value::from(1i64)),
(
"breathe",
Value::from(dict(&[("mode", Value::from("live"))])),
),
]),
);
let b = Fixed(
"b",
dict(&[(
"breathe",
Value::from(dict(&[("mode", Value::from("shadow"))])),
)]),
);
let c = Fixed("c", dict(&[("logger", Value::from("info"))]));
let layers: [&dyn DiscoveryLayer; 3] = [&a, &b, &c];
for path in [
&[][..],
&["solo"][..],
&["logger"][..],
&["breathe"][..],
&["breathe", "mode"][..],
&["absent"][..],
] {
let singleton_via_bools =
is_touched_at(&layers, path) && !is_contested_at(&layers, path);
let singleton_via_scalar = contributor_count_at(&layers, path) == 1;
assert_eq!(
singleton_via_bools, singleton_via_scalar,
"singleton characterization broken at {path:?}",
);
}
}
#[test]
fn is_touched_at_credits_prefix_scalar_erasure_toucher() {
let a = Fixed(
"a",
dict(&[("k", Value::from(dict(&[("leaf", Value::from(1i64))])))]),
);
let b = Fixed("b", dict(&[("k", Value::from("erased"))]));
let layers: [&dyn DiscoveryLayer; 2] = [&a, &b];
assert!(is_touched_at(&layers, &["k", "leaf"]));
assert!(is_touched_at(&layers, &["k"]));
assert!(!is_touched_at(&layers, &["unrelated"]));
assert!(!is_touched_at(&layers, &["unrelated", "deep"]));
}
#[test]
fn is_touched_at_root_boundary_filters_silent_layers() {
let coarse = Fixed("platform", dict(&[("a", Value::from(1i64))]));
let silent = Fixed("undetectable", Dict::new());
let specific = Fixed("tenancy", dict(&[("b", Value::from(2i64))]));
let layers_two_non_empty: [&dyn DiscoveryLayer; 3] = [&coarse, &silent, &specific];
assert!(is_touched_at(&layers_two_non_empty, &[]));
let layers_one: [&dyn DiscoveryLayer; 2] = [&coarse, &silent];
assert!(is_touched_at(&layers_one, &[]));
let layers_only_silent: [&dyn DiscoveryLayer; 2] = [&silent, &silent];
assert!(!is_touched_at(&layers_only_silent, &[]));
}
fn count_contributor_fixture() -> [Box<dyn DiscoveryLayer>; 6] {
[
Box::new(Fixed("platform", dict(&[("a", Value::from(1i64))]))),
Box::new(Fixed("undetectable_kanchi", Dict::new())),
Box::new(Fixed(
"tenancy",
dict(&[("b", Value::from(dict(&[("nested", Value::from(2i64))])))]),
)),
Box::new(Fixed("host_silent", Dict::new())),
Box::new(Fixed("user", dict(&[("c", Value::from("v"))]))),
Box::new(Fixed("undetectable_hostgroup", Dict::new())),
]
}
fn as_refs(layers: &[Box<dyn DiscoveryLayer>]) -> Vec<&dyn DiscoveryLayer> {
layers.iter().map(std::convert::AsRef::as_ref).collect()
}
#[test]
fn contributor_count_matches_contributor_names_len() {
let owned = count_contributor_fixture();
let layers = as_refs(&owned);
let via_primitive = contributor_count(&layers);
let via_names_len = contributor_names(&layers).len();
assert_eq!(
via_primitive, via_names_len,
"contributor_count != contributor_names.len()",
);
assert_eq!(via_primitive, 3, "three non-empty layers in the fixture");
}
#[test]
fn contributor_count_matches_nonempty_layer_dicts_len() {
let owned = count_contributor_fixture();
let layers = as_refs(&owned);
let via_primitive = contributor_count(&layers);
let via_pairs_len = nonempty_layer_dicts(&layers).len();
assert_eq!(
via_primitive, via_pairs_len,
"contributor_count != nonempty_layer_dicts.len()",
);
}
#[test]
fn contributor_count_matches_contributor_count_at_root() {
let owned = count_contributor_fixture();
let layers = as_refs(&owned);
let via_root = contributor_count(&layers);
let via_point_at_root = contributor_count_at(&layers, &[]);
assert_eq!(
via_root, via_point_at_root,
"contributor_count != contributor_count_at(layers, &[])",
);
let empty: [&dyn DiscoveryLayer; 0] = [];
assert_eq!(contributor_count(&empty), 0);
assert_eq!(contributor_count(&empty), contributor_count_at(&empty, &[]));
let silent = Fixed("undetectable", Dict::new());
let all_silent: [&dyn DiscoveryLayer; 3] = [&silent, &silent, &silent];
assert_eq!(contributor_count(&all_silent), 0);
assert_eq!(
contributor_count(&all_silent),
contributor_count_at(&all_silent, &[]),
);
}
#[test]
fn contributor_count_partition_pins_layer_names_len() {
let owned = count_contributor_fixture();
let layers = as_refs(&owned);
let contributors = contributor_count(&layers);
let silent_len = silent_layer_names(&layers).len();
let declared = layer_names(&layers).len();
assert_eq!(
contributors + silent_len,
declared,
"contributor_count + silent_layer_names.len() != layer_names.len()",
);
assert_eq!(contributors, 3, "three contributors");
assert_eq!(silent_len, 3, "three silent layers");
assert_eq!(declared, 6, "six declared layers");
}
#[test]
fn contributor_count_zero_pins_root_presence_endpoints() {
let empty_stack: [&dyn DiscoveryLayer; 0] = [];
assert_eq!(contributor_count(&empty_stack), 0);
assert!(!is_touched_at(&empty_stack, &[]));
assert!(contributor_names(&empty_stack).is_empty());
assert!(nonempty_layer_dicts(&empty_stack).is_empty());
let silent = Fixed("undetectable", Dict::new());
let only_silent: [&dyn DiscoveryLayer; 3] = [&silent, &silent, &silent];
assert_eq!(contributor_count(&only_silent), 0);
assert!(!is_touched_at(&only_silent, &[]));
assert!(contributor_names(&only_silent).is_empty());
assert!(nonempty_layer_dicts(&only_silent).is_empty());
let one = Fixed("only", dict(&[("k", Value::from(1i64))]));
let one_and_silence: [&dyn DiscoveryLayer; 3] = [&silent, &one, &silent];
assert_eq!(contributor_count(&one_and_silence), 1);
assert!(is_touched_at(&one_and_silence, &[]));
assert_eq!(contributor_names(&one_and_silence).len(), 1);
assert_eq!(nonempty_layer_dicts(&one_and_silence).len(), 1);
}
#[test]
fn contributor_count_bounded_by_layer_names_len() {
let owned = count_contributor_fixture();
let layers = as_refs(&owned);
let total_declared = layer_names(&layers).len();
let contributors = contributor_count(&layers);
assert!(
contributors <= total_declared,
"contributor_count > layer_names.len()",
);
let a = Fixed("a", dict(&[("k1", Value::from(1i64))]));
let b = Fixed("b", dict(&[("k2", Value::from(2i64))]));
let c = Fixed("c", dict(&[("k3", Value::from(3i64))]));
let all_contribute: [&dyn DiscoveryLayer; 3] = [&a, &b, &c];
assert_eq!(
contributor_count(&all_contribute),
layer_names(&all_contribute).len(),
"upper bound: every layer is a contributor",
);
let silent = Fixed("undetectable", Dict::new());
let all_silent: [&dyn DiscoveryLayer; 3] = [&silent, &silent, &silent];
assert_eq!(contributor_count(&all_silent), 0, "lower bound: all silent");
}
#[test]
fn silent_layer_count_matches_silent_layer_names_len() {
let owned = count_contributor_fixture();
let layers = as_refs(&owned);
let via_primitive = silent_layer_count(&layers);
let via_names_len = silent_layer_names(&layers).len();
assert_eq!(
via_primitive, via_names_len,
"silent_layer_count != silent_layer_names.len()",
);
assert_eq!(via_primitive, 3, "three silent layers in the fixture");
}
#[test]
fn silent_layer_count_pure_scalar_partition_pins_layer_names_len() {
let owned = count_contributor_fixture();
let layers = as_refs(&owned);
let silent = silent_layer_count(&layers);
let contributors = contributor_count(&layers);
let declared = layer_names(&layers).len();
assert_eq!(
silent + contributors,
declared,
"silent_layer_count + contributor_count != layer_names.len()",
);
assert_eq!(silent, 3, "three silent layers");
assert_eq!(contributors, 3, "three contributors");
assert_eq!(declared, 6, "six declared layers");
}
#[test]
fn silent_layer_count_complements_contributor_count() {
let owned = count_contributor_fixture();
let layers = as_refs(&owned);
let via_primitive = silent_layer_count(&layers);
let via_complement = layer_names(&layers).len() - contributor_count(&layers);
assert_eq!(
via_primitive, via_complement,
"silent_layer_count != layer_names.len() - contributor_count",
);
let empty: [&dyn DiscoveryLayer; 0] = [];
assert_eq!(silent_layer_count(&empty), 0);
assert_eq!(
silent_layer_count(&empty),
layer_names(&empty).len() - contributor_count(&empty),
);
let silent = Fixed("undetectable", Dict::new());
let all_silent: [&dyn DiscoveryLayer; 3] = [&silent, &silent, &silent];
assert_eq!(silent_layer_count(&all_silent), 3);
assert_eq!(
silent_layer_count(&all_silent),
layer_names(&all_silent).len() - contributor_count(&all_silent),
);
}
#[test]
fn silent_layer_count_zero_pins_all_contribute_endpoint() {
let empty_stack: [&dyn DiscoveryLayer; 0] = [];
assert_eq!(silent_layer_count(&empty_stack), 0);
assert!(silent_layer_names(&empty_stack).is_empty());
let a = Fixed("a", dict(&[("k1", Value::from(1i64))]));
let b = Fixed("b", dict(&[("k2", Value::from(2i64))]));
let c = Fixed("c", dict(&[("k3", Value::from(3i64))]));
let all_contribute: [&dyn DiscoveryLayer; 3] = [&a, &b, &c];
assert_eq!(silent_layer_count(&all_contribute), 0);
assert!(silent_layer_names(&all_contribute).is_empty());
assert_eq!(
contributor_count(&all_contribute),
layer_names(&all_contribute).len(),
);
}
#[test]
fn silent_layer_count_saturates_at_all_silent_endpoint() {
let silent = Fixed("undetectable", Dict::new());
let all_silent: [&dyn DiscoveryLayer; 3] = [&silent, &silent, &silent];
assert_eq!(silent_layer_count(&all_silent), 3);
assert_eq!(
silent_layer_count(&all_silent),
layer_names(&all_silent).len()
);
assert_eq!(contributor_count(&all_silent), 0);
assert!(!is_touched_at(&all_silent, &[]));
assert!(contributor_names(&all_silent).is_empty());
assert!(nonempty_layer_dicts(&all_silent).is_empty());
}
#[test]
fn silent_layer_count_bounded_by_layer_names_len() {
let owned = count_contributor_fixture();
let layers = as_refs(&owned);
let total_declared = layer_names(&layers).len();
let silent = silent_layer_count(&layers);
assert!(
silent <= total_declared,
"silent_layer_count > layer_names.len()",
);
let silent_layer = Fixed("undetectable", Dict::new());
let all_silent: [&dyn DiscoveryLayer; 3] = [&silent_layer, &silent_layer, &silent_layer];
assert_eq!(
silent_layer_count(&all_silent),
layer_names(&all_silent).len(),
"upper bound: every layer is silent",
);
let a = Fixed("a", dict(&[("k1", Value::from(1i64))]));
let b = Fixed("b", dict(&[("k2", Value::from(2i64))]));
let c = Fixed("c", dict(&[("k3", Value::from(3i64))]));
let all_contribute: [&dyn DiscoveryLayer; 3] = [&a, &b, &c];
assert_eq!(
silent_layer_count(&all_contribute),
0,
"lower bound: every layer is a contributor",
);
}
#[test]
fn has_contributor_matches_contributor_names_nonempty() {
let owned = count_contributor_fixture();
let layers = as_refs(&owned);
let via_primitive = has_contributor(&layers);
let via_names_nonempty = !contributor_names(&layers).is_empty();
assert_eq!(
via_primitive, via_names_nonempty,
"has_contributor != !contributor_names.is_empty()",
);
assert!(via_primitive, "the fixture has three contributors");
}
#[test]
fn has_contributor_matches_contributor_count_threshold() {
let owned = count_contributor_fixture();
let layers = as_refs(&owned);
let via_primitive = has_contributor(&layers);
let via_threshold = contributor_count(&layers) >= 1;
assert_eq!(
via_primitive, via_threshold,
"has_contributor != contributor_count >= 1",
);
let empty: [&dyn DiscoveryLayer; 0] = [];
assert!(!has_contributor(&empty));
assert_eq!(has_contributor(&empty), contributor_count(&empty) >= 1);
let silent = Fixed("undetectable", Dict::new());
let all_silent: [&dyn DiscoveryLayer; 3] = [&silent, &silent, &silent];
assert!(!has_contributor(&all_silent));
assert_eq!(
has_contributor(&all_silent),
contributor_count(&all_silent) >= 1,
);
}
#[test]
fn has_contributor_matches_nonempty_layer_dicts_nonempty() {
let owned = count_contributor_fixture();
let layers = as_refs(&owned);
let via_primitive = has_contributor(&layers);
let via_pairs_nonempty = !nonempty_layer_dicts(&layers).is_empty();
assert_eq!(
via_primitive, via_pairs_nonempty,
"has_contributor != !nonempty_layer_dicts.is_empty()",
);
}
#[test]
fn has_contributor_matches_is_touched_at_root() {
let owned = count_contributor_fixture();
let layers = as_refs(&owned);
let via_root = has_contributor(&layers);
let via_point_at_root = is_touched_at(&layers, &[]);
assert_eq!(
via_root, via_point_at_root,
"has_contributor != is_touched_at(layers, &[])",
);
let empty: [&dyn DiscoveryLayer; 0] = [];
assert_eq!(has_contributor(&empty), is_touched_at(&empty, &[]));
assert!(!has_contributor(&empty));
let silent = Fixed("undetectable", Dict::new());
let all_silent: [&dyn DiscoveryLayer; 3] = [&silent, &silent, &silent];
assert_eq!(
has_contributor(&all_silent),
is_touched_at(&all_silent, &[]),
);
assert!(!has_contributor(&all_silent));
}
#[test]
fn has_contributor_partition_complement_matches_silent_layer_count() {
let owned = count_contributor_fixture();
let layers = as_refs(&owned);
let via_primitive = has_contributor(&layers);
let via_complement = silent_layer_count(&layers) < layer_names(&layers).len();
assert_eq!(
via_primitive, via_complement,
"has_contributor != (silent_layer_count < layer_names.len())",
);
let empty: [&dyn DiscoveryLayer; 0] = [];
assert_eq!(
has_contributor(&empty),
silent_layer_count(&empty) < layer_names(&empty).len(),
);
assert!(!has_contributor(&empty));
let silent = Fixed("undetectable", Dict::new());
let all_silent: [&dyn DiscoveryLayer; 3] = [&silent, &silent, &silent];
assert_eq!(
has_contributor(&all_silent),
silent_layer_count(&all_silent) < layer_names(&all_silent).len(),
);
assert!(!has_contributor(&all_silent));
let a = Fixed("a", dict(&[("k1", Value::from(1i64))]));
let b = Fixed("b", dict(&[("k2", Value::from(2i64))]));
let c = Fixed("c", dict(&[("k3", Value::from(3i64))]));
let all_contribute: [&dyn DiscoveryLayer; 3] = [&a, &b, &c];
assert_eq!(
has_contributor(&all_contribute),
silent_layer_count(&all_contribute) < layer_names(&all_contribute).len(),
);
assert!(has_contributor(&all_contribute));
}
#[test]
fn has_contributor_partition_truth_table() {
let empty: [&dyn DiscoveryLayer; 0] = [];
assert!(!has_contributor(&empty));
assert!(silent_layer_count(&empty) == 0);
let a = Fixed("a", dict(&[("k1", Value::from(1i64))]));
let b = Fixed("b", dict(&[("k2", Value::from(2i64))]));
let c = Fixed("c", dict(&[("k3", Value::from(3i64))]));
let all_contribute: [&dyn DiscoveryLayer; 3] = [&a, &b, &c];
assert!(has_contributor(&all_contribute));
assert!(silent_layer_count(&all_contribute) == 0);
let silent = Fixed("undetectable", Dict::new());
let all_silent: [&dyn DiscoveryLayer; 3] = [&silent, &silent, &silent];
assert!(!has_contributor(&all_silent));
assert!(silent_layer_count(&all_silent) >= 1);
let owned = count_contributor_fixture();
let mixed = as_refs(&owned);
assert!(has_contributor(&mixed));
assert!(silent_layer_count(&mixed) >= 1);
}
#[test]
fn has_contributor_short_circuits_on_coarsest_hit() {
let head = Fixed("platform", dict(&[("k", Value::from(1i64))]));
let silent = Fixed("undetectable", Dict::new());
let coarsest_hit: [&dyn DiscoveryLayer; 4] = [&head, &silent, &silent, &silent];
assert!(has_contributor(&coarsest_hit));
assert_eq!(
has_contributor(&coarsest_hit),
contributor_count(&coarsest_hit) >= 1
);
let tail_only: [&dyn DiscoveryLayer; 4] = [&silent, &silent, &silent, &head];
assert!(has_contributor(&tail_only));
assert_eq!(
has_contributor(&tail_only),
contributor_count(&tail_only) >= 1
);
}
#[test]
fn has_silent_layer_matches_silent_layer_names_nonempty() {
let owned = count_contributor_fixture();
let layers = as_refs(&owned);
let via_primitive = has_silent_layer(&layers);
let via_names_nonempty = !silent_layer_names(&layers).is_empty();
assert_eq!(
via_primitive, via_names_nonempty,
"has_silent_layer != !silent_layer_names.is_empty()",
);
assert!(via_primitive, "the fixture has three silent layers");
}
#[test]
fn has_silent_layer_matches_silent_layer_count_threshold() {
let owned = count_contributor_fixture();
let layers = as_refs(&owned);
let via_primitive = has_silent_layer(&layers);
let via_threshold = silent_layer_count(&layers) >= 1;
assert_eq!(
via_primitive, via_threshold,
"has_silent_layer != silent_layer_count >= 1",
);
let empty: [&dyn DiscoveryLayer; 0] = [];
assert!(!has_silent_layer(&empty));
assert_eq!(has_silent_layer(&empty), silent_layer_count(&empty) >= 1);
let a = Fixed("a", dict(&[("k1", Value::from(1i64))]));
let b = Fixed("b", dict(&[("k2", Value::from(2i64))]));
let c = Fixed("c", dict(&[("k3", Value::from(3i64))]));
let all_contribute: [&dyn DiscoveryLayer; 3] = [&a, &b, &c];
assert!(!has_silent_layer(&all_contribute));
assert_eq!(
has_silent_layer(&all_contribute),
silent_layer_count(&all_contribute) >= 1,
);
}
#[test]
fn has_silent_layer_partition_complement_matches_contributor_count() {
let owned = count_contributor_fixture();
let layers = as_refs(&owned);
let via_primitive = has_silent_layer(&layers);
let via_complement = contributor_count(&layers) < layer_names(&layers).len();
assert_eq!(
via_primitive, via_complement,
"has_silent_layer != (contributor_count < layer_names.len())",
);
let empty: [&dyn DiscoveryLayer; 0] = [];
assert_eq!(
has_silent_layer(&empty),
contributor_count(&empty) < layer_names(&empty).len(),
);
assert!(!has_silent_layer(&empty));
let a = Fixed("a", dict(&[("k1", Value::from(1i64))]));
let b = Fixed("b", dict(&[("k2", Value::from(2i64))]));
let c = Fixed("c", dict(&[("k3", Value::from(3i64))]));
let all_contribute: [&dyn DiscoveryLayer; 3] = [&a, &b, &c];
assert_eq!(
has_silent_layer(&all_contribute),
contributor_count(&all_contribute) < layer_names(&all_contribute).len(),
);
assert!(!has_silent_layer(&all_contribute));
let silent = Fixed("undetectable", Dict::new());
let all_silent: [&dyn DiscoveryLayer; 3] = [&silent, &silent, &silent];
assert_eq!(
has_silent_layer(&all_silent),
contributor_count(&all_silent) < layer_names(&all_silent).len(),
);
assert!(has_silent_layer(&all_silent));
}
#[test]
fn has_silent_layer_matches_nonempty_layer_dicts_partition() {
let owned = count_contributor_fixture();
let layers = as_refs(&owned);
let via_primitive = has_silent_layer(&layers);
let via_pairs = nonempty_layer_dicts(&layers).len() < layer_names(&layers).len();
assert_eq!(
via_primitive, via_pairs,
"has_silent_layer != (nonempty_layer_dicts.len() < layer_names.len())",
);
}
#[test]
fn has_silent_layer_partition_truth_table_vs_has_contributor() {
let empty: [&dyn DiscoveryLayer; 0] = [];
assert!(!has_contributor(&empty));
assert!(!has_silent_layer(&empty));
let a = Fixed("a", dict(&[("k1", Value::from(1i64))]));
let b = Fixed("b", dict(&[("k2", Value::from(2i64))]));
let c = Fixed("c", dict(&[("k3", Value::from(3i64))]));
let all_contribute: [&dyn DiscoveryLayer; 3] = [&a, &b, &c];
assert!(has_contributor(&all_contribute));
assert!(!has_silent_layer(&all_contribute));
let silent = Fixed("undetectable", Dict::new());
let all_silent: [&dyn DiscoveryLayer; 3] = [&silent, &silent, &silent];
assert!(!has_contributor(&all_silent));
assert!(has_silent_layer(&all_silent));
let owned = count_contributor_fixture();
let mixed = as_refs(&owned);
assert!(has_contributor(&mixed));
assert!(has_silent_layer(&mixed));
}
#[test]
fn has_silent_layer_short_circuits_on_coarsest_silent() {
let silent = Fixed("undetectable", Dict::new());
let contrib = Fixed("k", dict(&[("k", Value::from(1i64))]));
let coarsest_silent: [&dyn DiscoveryLayer; 4] = [&silent, &contrib, &contrib, &contrib];
assert!(has_silent_layer(&coarsest_silent));
assert_eq!(
has_silent_layer(&coarsest_silent),
silent_layer_count(&coarsest_silent) >= 1
);
let tail_only: [&dyn DiscoveryLayer; 4] = [&contrib, &contrib, &contrib, &silent];
assert!(has_silent_layer(&tail_only));
assert_eq!(
has_silent_layer(&tail_only),
silent_layer_count(&tail_only) >= 1
);
}
#[test]
fn has_multiple_contributors_matches_contributor_count_threshold() {
let owned = count_contributor_fixture();
let layers = as_refs(&owned);
let via_primitive = has_multiple_contributors(&layers);
let via_threshold = contributor_count(&layers) >= 2;
assert_eq!(
via_primitive, via_threshold,
"has_multiple_contributors != contributor_count >= 2",
);
assert!(
via_primitive,
"the fixture has three contributors — the ≥ 2 threshold holds",
);
let empty: [&dyn DiscoveryLayer; 0] = [];
assert!(!has_multiple_contributors(&empty));
assert_eq!(
has_multiple_contributors(&empty),
contributor_count(&empty) >= 2,
);
let silent = Fixed("undetectable", Dict::new());
let all_silent: [&dyn DiscoveryLayer; 3] = [&silent, &silent, &silent];
assert!(!has_multiple_contributors(&all_silent));
assert_eq!(
has_multiple_contributors(&all_silent),
contributor_count(&all_silent) >= 2,
);
let solo = Fixed("solo", dict(&[("k", Value::from(1i64))]));
let single: [&dyn DiscoveryLayer; 4] = [&silent, &solo, &silent, &silent];
assert!(!has_multiple_contributors(&single));
assert_eq!(
has_multiple_contributors(&single),
contributor_count(&single) >= 2,
);
}
#[test]
fn has_multiple_contributors_matches_is_contested_at_root() {
let owned = count_contributor_fixture();
let layers = as_refs(&owned);
let via_root = has_multiple_contributors(&layers);
let via_point = is_contested_at(&layers, &[]);
assert_eq!(
via_root, via_point,
"has_multiple_contributors != is_contested_at(layers, &[])",
);
let empty: [&dyn DiscoveryLayer; 0] = [];
assert_eq!(
has_multiple_contributors(&empty),
is_contested_at(&empty, &[]),
);
assert!(!has_multiple_contributors(&empty));
let silent = Fixed("undetectable", Dict::new());
let all_silent: [&dyn DiscoveryLayer; 3] = [&silent, &silent, &silent];
assert_eq!(
has_multiple_contributors(&all_silent),
is_contested_at(&all_silent, &[]),
);
assert!(!has_multiple_contributors(&all_silent));
let solo = Fixed("solo", dict(&[("k", Value::from(1i64))]));
let single: [&dyn DiscoveryLayer; 2] = [&solo, &silent];
assert_eq!(
has_multiple_contributors(&single),
is_contested_at(&single, &[]),
);
assert!(!has_multiple_contributors(&single));
}
#[test]
fn has_multiple_contributors_matches_contributor_names_len_threshold() {
let owned = count_contributor_fixture();
let layers = as_refs(&owned);
let via_primitive = has_multiple_contributors(&layers);
let via_names_len = contributor_names(&layers).len() >= 2;
assert_eq!(
via_primitive, via_names_len,
"has_multiple_contributors != contributor_names.len() >= 2",
);
}
#[test]
fn has_multiple_contributors_matches_nonempty_layer_dicts_len_threshold() {
let owned = count_contributor_fixture();
let layers = as_refs(&owned);
let via_primitive = has_multiple_contributors(&layers);
let via_pairs_len = nonempty_layer_dicts(&layers).len() >= 2;
assert_eq!(
via_primitive, via_pairs_len,
"has_multiple_contributors != nonempty_layer_dicts.len() >= 2",
);
}
#[test]
fn has_multiple_contributors_partitions_trichotomy_with_has_contributor() {
let empty: [&dyn DiscoveryLayer; 0] = [];
assert!(!has_contributor(&empty));
assert!(!has_multiple_contributors(&empty));
let silent = Fixed("undetectable", Dict::new());
let all_silent: [&dyn DiscoveryLayer; 3] = [&silent, &silent, &silent];
assert!(!has_contributor(&all_silent));
assert!(!has_multiple_contributors(&all_silent));
let solo = Fixed("solo", dict(&[("k", Value::from(1i64))]));
let single: [&dyn DiscoveryLayer; 3] = [&silent, &solo, &silent];
assert!(has_contributor(&single));
assert!(!has_multiple_contributors(&single));
assert_eq!(contributor_count(&single), 1);
let owned = count_contributor_fixture();
let layered = as_refs(&owned);
assert!(has_contributor(&layered));
assert!(has_multiple_contributors(&layered));
assert!(contributor_count(&layered) >= 2);
for fixture in [
&empty as &[&dyn DiscoveryLayer],
&all_silent as &[&dyn DiscoveryLayer],
&single as &[&dyn DiscoveryLayer],
&layered,
] {
let via_pair = has_contributor(fixture) && !has_multiple_contributors(fixture);
let via_scalar = contributor_count(fixture) == 1;
assert_eq!(
via_pair,
via_scalar,
"singleton characterization mismatched on fixture with \
contributor_count == {}",
contributor_count(fixture),
);
}
}
#[test]
fn has_multiple_contributors_monotonic_chain_with_has_contributor() {
let silent = Fixed("undetectable", Dict::new());
let solo = Fixed("solo", dict(&[("k", Value::from(1i64))]));
let a = Fixed("a", dict(&[("k1", Value::from(1i64))]));
let b = Fixed("b", dict(&[("k2", Value::from(2i64))]));
let empty: [&dyn DiscoveryLayer; 0] = [];
let all_silent: [&dyn DiscoveryLayer; 3] = [&silent, &silent, &silent];
let single: [&dyn DiscoveryLayer; 3] = [&silent, &solo, &silent];
let pair: [&dyn DiscoveryLayer; 2] = [&a, &b];
let owned = count_contributor_fixture();
let layered = as_refs(&owned);
for fixture in [
&empty as &[&dyn DiscoveryLayer],
&all_silent as &[&dyn DiscoveryLayer],
&single as &[&dyn DiscoveryLayer],
&pair as &[&dyn DiscoveryLayer],
&layered,
] {
if has_multiple_contributors(fixture) {
assert!(
has_contributor(fixture),
"has_multiple_contributors ⇒ has_contributor was violated",
);
}
if !has_contributor(fixture) {
assert!(
!has_multiple_contributors(fixture),
"!has_contributor ⇒ !has_multiple_contributors was violated",
);
}
}
}
#[test]
fn has_multiple_contributors_gates_leaf_override_contests() {
let a = Fixed("shared", dict(&[("k", Value::from(1i64))]));
let b = Fixed("shared", dict(&[("k", Value::from(2i64))]));
let overlapping: [&dyn DiscoveryLayer; 2] = [&a, &b];
assert!(is_contested_at(&overlapping, &["k"]));
assert!(has_multiple_contributors(&overlapping));
let x = Fixed("x_only", dict(&[("x", Value::from(1i64))]));
let y = Fixed("y_only", dict(&[("y", Value::from(2i64))]));
let disjoint: [&dyn DiscoveryLayer; 2] = [&x, &y];
assert!(has_multiple_contributors(&disjoint));
assert!(!is_contested_at(&disjoint, &["x"]));
assert!(!is_contested_at(&disjoint, &["y"]));
let silent = Fixed("undetectable", Dict::new());
let solo = Fixed("solo", dict(&[("k", Value::from(1i64))]));
let single: [&dyn DiscoveryLayer; 3] = [&silent, &solo, &silent];
assert!(!has_multiple_contributors(&single));
assert!(!is_contested_at(&single, &["k"]));
}
#[test]
fn has_multiple_contributors_short_circuits_on_early_pair() {
let a = Fixed("a", dict(&[("k1", Value::from(1i64))]));
let b = Fixed("b", dict(&[("k2", Value::from(2i64))]));
let silent = Fixed("undetectable", Dict::new());
let early_pair: [&dyn DiscoveryLayer; 5] = [&a, &b, &silent, &silent, &silent];
assert!(has_multiple_contributors(&early_pair));
assert_eq!(
has_multiple_contributors(&early_pair),
contributor_count(&early_pair) >= 2,
);
let late_pair: [&dyn DiscoveryLayer; 5] = [&silent, &silent, &silent, &a, &b];
assert!(has_multiple_contributors(&late_pair));
assert_eq!(
has_multiple_contributors(&late_pair),
contributor_count(&late_pair) >= 2,
);
let single: [&dyn DiscoveryLayer; 5] = [&silent, &silent, &a, &silent, &silent];
assert!(!has_multiple_contributors(&single));
assert_eq!(
has_multiple_contributors(&single),
contributor_count(&single) >= 2,
);
}
#[test]
fn has_multiple_silent_layers_matches_silent_layer_count_threshold() {
let owned = count_contributor_fixture();
let layers = as_refs(&owned);
let via_primitive = has_multiple_silent_layers(&layers);
let via_threshold = silent_layer_count(&layers) >= 2;
assert_eq!(
via_primitive, via_threshold,
"has_multiple_silent_layers != silent_layer_count >= 2",
);
assert!(
via_primitive,
"the fixture has three silent layers — the ≥ 2 threshold holds",
);
let empty: [&dyn DiscoveryLayer; 0] = [];
assert!(!has_multiple_silent_layers(&empty));
assert_eq!(
has_multiple_silent_layers(&empty),
silent_layer_count(&empty) >= 2,
);
let a = Fixed("a", dict(&[("k1", Value::from(1i64))]));
let b = Fixed("b", dict(&[("k2", Value::from(2i64))]));
let all_contribute: [&dyn DiscoveryLayer; 3] = [&a, &b, &a];
assert!(!has_multiple_silent_layers(&all_contribute));
assert_eq!(
has_multiple_silent_layers(&all_contribute),
silent_layer_count(&all_contribute) >= 2,
);
let silent = Fixed("undetectable", Dict::new());
let single: [&dyn DiscoveryLayer; 4] = [&a, &silent, &b, &a];
assert!(!has_multiple_silent_layers(&single));
assert_eq!(
has_multiple_silent_layers(&single),
silent_layer_count(&single) >= 2,
);
}
#[test]
fn has_multiple_silent_layers_matches_silent_names_len_threshold() {
let owned = count_contributor_fixture();
let layers = as_refs(&owned);
let via_primitive = has_multiple_silent_layers(&layers);
let via_names_len = silent_layer_names(&layers).len() >= 2;
assert_eq!(
via_primitive, via_names_len,
"has_multiple_silent_layers != silent_layer_names.len() >= 2",
);
}
#[test]
fn has_multiple_silent_layers_matches_partition_complement() {
let owned = count_contributor_fixture();
let layers = as_refs(&owned);
let via_primitive = has_multiple_silent_layers(&layers);
let via_complement = layer_names(&layers).len() >= contributor_count(&layers) + 2;
assert_eq!(
via_primitive, via_complement,
"has_multiple_silent_layers != layer_names.len() >= contributor_count + 2",
);
let empty: [&dyn DiscoveryLayer; 0] = [];
assert_eq!(
has_multiple_silent_layers(&empty),
layer_names(&empty).len() >= contributor_count(&empty) + 2,
);
let silent = Fixed("undetectable", Dict::new());
let all_silent: [&dyn DiscoveryLayer; 3] = [&silent, &silent, &silent];
assert!(has_multiple_silent_layers(&all_silent));
assert_eq!(
has_multiple_silent_layers(&all_silent),
layer_names(&all_silent).len() >= contributor_count(&all_silent) + 2,
);
let via_pair_complement =
layer_names(&layers).len() >= nonempty_layer_dicts(&layers).len() + 2;
assert_eq!(
via_primitive, via_pair_complement,
"has_multiple_silent_layers != layer_names.len() >= nonempty_layer_dicts.len() + 2",
);
}
#[test]
fn has_multiple_silent_layers_partitions_trichotomy_with_has_silent_layer() {
let empty: [&dyn DiscoveryLayer; 0] = [];
assert!(!has_silent_layer(&empty));
assert!(!has_multiple_silent_layers(&empty));
let a = Fixed("a", dict(&[("k1", Value::from(1i64))]));
let b = Fixed("b", dict(&[("k2", Value::from(2i64))]));
let c = Fixed("c", dict(&[("k3", Value::from(3i64))]));
let all_contribute: [&dyn DiscoveryLayer; 3] = [&a, &b, &c];
assert!(!has_silent_layer(&all_contribute));
assert!(!has_multiple_silent_layers(&all_contribute));
let silent = Fixed("undetectable", Dict::new());
let single_silent: [&dyn DiscoveryLayer; 3] = [&a, &silent, &b];
assert!(has_silent_layer(&single_silent));
assert!(!has_multiple_silent_layers(&single_silent));
assert_eq!(silent_layer_count(&single_silent), 1);
let owned = count_contributor_fixture();
let layered = as_refs(&owned);
assert!(has_silent_layer(&layered));
assert!(has_multiple_silent_layers(&layered));
assert!(silent_layer_count(&layered) >= 2);
for fixture in [
&empty as &[&dyn DiscoveryLayer],
&all_contribute as &[&dyn DiscoveryLayer],
&single_silent as &[&dyn DiscoveryLayer],
&layered,
] {
let via_pair = has_silent_layer(fixture) && !has_multiple_silent_layers(fixture);
let via_scalar = silent_layer_count(fixture) == 1;
assert_eq!(
via_pair,
via_scalar,
"singleton characterization mismatched on fixture with \
silent_layer_count == {}",
silent_layer_count(fixture),
);
}
}
#[test]
fn has_multiple_silent_layers_monotonic_chain_with_has_silent_layer() {
let silent = Fixed("undetectable", Dict::new());
let a = Fixed("a", dict(&[("k1", Value::from(1i64))]));
let b = Fixed("b", dict(&[("k2", Value::from(2i64))]));
let empty: [&dyn DiscoveryLayer; 0] = [];
let all_contribute: [&dyn DiscoveryLayer; 2] = [&a, &b];
let single_silent: [&dyn DiscoveryLayer; 3] = [&a, &silent, &b];
let pair_silent: [&dyn DiscoveryLayer; 2] = [&silent, &silent];
let owned = count_contributor_fixture();
let layered = as_refs(&owned);
for fixture in [
&empty as &[&dyn DiscoveryLayer],
&all_contribute as &[&dyn DiscoveryLayer],
&single_silent as &[&dyn DiscoveryLayer],
&pair_silent as &[&dyn DiscoveryLayer],
&layered,
] {
if has_multiple_silent_layers(fixture) {
assert!(
has_silent_layer(fixture),
"has_multiple_silent_layers ⇒ has_silent_layer was violated",
);
}
if !has_silent_layer(fixture) {
assert!(
!has_multiple_silent_layers(fixture),
"!has_silent_layer ⇒ !has_multiple_silent_layers was violated",
);
}
}
}
#[test]
fn has_multiple_silent_layers_dual_of_has_multiple_contributors() {
let a = Fixed("a", dict(&[("k1", Value::from(1i64))]));
let b = Fixed("b", dict(&[("k2", Value::from(2i64))]));
let silent = Fixed("undetectable", Dict::new());
let two_silent_one_contrib: [&dyn DiscoveryLayer; 3] = [&silent, &a, &silent];
assert!(has_multiple_silent_layers(&two_silent_one_contrib));
assert!(!has_multiple_contributors(&two_silent_one_contrib));
let two_contrib_one_silent: [&dyn DiscoveryLayer; 3] = [&a, &silent, &b];
assert!(!has_multiple_silent_layers(&two_contrib_one_silent));
assert!(has_multiple_contributors(&two_contrib_one_silent));
}
#[test]
fn has_multiple_silent_layers_short_circuits_on_early_pair() {
let a = Fixed("a", dict(&[("k1", Value::from(1i64))]));
let silent = Fixed("undetectable", Dict::new());
let early_pair: [&dyn DiscoveryLayer; 5] = [&silent, &silent, &a, &a, &a];
assert!(has_multiple_silent_layers(&early_pair));
assert_eq!(
has_multiple_silent_layers(&early_pair),
silent_layer_count(&early_pair) >= 2,
);
let late_pair: [&dyn DiscoveryLayer; 5] = [&a, &a, &a, &silent, &silent];
assert!(has_multiple_silent_layers(&late_pair));
assert_eq!(
has_multiple_silent_layers(&late_pair),
silent_layer_count(&late_pair) >= 2,
);
let single: [&dyn DiscoveryLayer; 5] = [&a, &a, &silent, &a, &a];
assert!(!has_multiple_silent_layers(&single));
assert_eq!(
has_multiple_silent_layers(&single),
silent_layer_count(&single) >= 2,
);
}
fn multi_silenced_fixture() -> [Box<dyn DiscoveryLayer>; 3] {
let a: Box<dyn DiscoveryLayer> = Box::new(Fixed(
"a",
dict(&[
("solo", Value::from(1i64)),
("pair", Value::from(dict(&[("mode", Value::from("live"))]))),
("chain", Value::from(dict(&[("mode", Value::from("live"))]))),
]),
));
let b: Box<dyn DiscoveryLayer> = Box::new(Fixed(
"b",
dict(&[
(
"pair",
Value::from(dict(&[("mode", Value::from("shadow"))])),
),
(
"chain",
Value::from(dict(&[("mode", Value::from("staging"))])),
),
]),
));
let c: Box<dyn DiscoveryLayer> = Box::new(Fixed(
"c",
dict(&[(
"chain",
Value::from(dict(&[("mode", Value::from("shadow"))])),
)]),
));
[a, b, c]
}
#[test]
fn is_multiply_silenced_at_matches_silenced_count_threshold() {
let owned = multi_silenced_fixture();
let layers = as_refs(&owned);
for path in [
&[][..],
&["absent"][..],
&["solo"][..],
&["pair"][..],
&["pair", "mode"][..],
&["chain"][..],
&["chain", "mode"][..],
] {
let via_primitive = is_multiply_silenced_at(&layers, path);
let via_threshold = silenced_count_at(&layers, path) >= 2;
assert_eq!(
via_primitive, via_threshold,
"is_multiply_silenced_at != silenced_count_at >= 2 at {path:?}",
);
}
assert!(is_multiply_silenced_at(&layers, &["chain", "mode"]));
assert_eq!(silenced_count_at(&layers, &["chain", "mode"]), 2);
assert!(!is_multiply_silenced_at(&layers, &["pair", "mode"]));
assert!(is_contested_at(&layers, &["pair", "mode"]));
}
#[test]
fn is_multiply_silenced_at_matches_silenced_len_threshold() {
let owned = multi_silenced_fixture();
let layers = as_refs(&owned);
for path in [
&[][..],
&["absent"][..],
&["solo"][..],
&["pair", "mode"][..],
&["chain", "mode"][..],
] {
let via_primitive = is_multiply_silenced_at(&layers, path);
let via_len = silenced_at(&layers, path).len() >= 2;
assert_eq!(
via_primitive, via_len,
"is_multiply_silenced_at != silenced_at.len() >= 2 at {path:?}",
);
}
}
#[test]
fn is_multiply_silenced_at_matches_contributor_count_at_ge_three() {
let owned = multi_silenced_fixture();
let layers = as_refs(&owned);
for path in [
&[][..],
&["absent"][..],
&["solo"][..],
&["pair"][..],
&["pair", "mode"][..],
&["chain"][..],
&["chain", "mode"][..],
] {
let via_primitive = is_multiply_silenced_at(&layers, path);
let via_touchers = contributor_count_at(&layers, path) >= 3;
assert_eq!(
via_primitive, via_touchers,
"is_multiply_silenced_at != contributor_count_at >= 3 at {path:?}",
);
let via_touchers_vec = contributors_at(&layers, path).len() >= 3;
assert_eq!(
via_primitive, via_touchers_vec,
"is_multiply_silenced_at != contributors_at.len() >= 3 at {path:?}",
);
}
}
#[test]
fn is_multiply_silenced_at_matches_contest_at_folded_projection() {
let owned = multi_silenced_fixture();
let layers = as_refs(&owned);
for path in [
&[][..],
&["absent"][..],
&["solo"][..],
&["pair"][..],
&["pair", "mode"][..],
&["chain"][..],
&["chain", "mode"][..],
] {
let via_primitive = is_multiply_silenced_at(&layers, path);
let via_fused = contest_at(&layers, path).is_some_and(|c| c.silenced_count() >= 2);
assert_eq!(
via_primitive, via_fused,
"is_multiply_silenced_at != contest_at.is_some_and(silenced_count >= 2) at {path:?}",
);
}
}
#[test]
fn is_multiply_silenced_at_partitions_four_way_touchers_axis() {
let owned = multi_silenced_fixture();
let layers = as_refs(&owned);
assert!(!is_touched_at(&layers, &["absent"]));
assert!(!is_contested_at(&layers, &["absent"]));
assert!(!is_multiply_silenced_at(&layers, &["absent"]));
assert!(is_touched_at(&layers, &["solo"]));
assert!(!is_contested_at(&layers, &["solo"]));
assert!(!is_multiply_silenced_at(&layers, &["solo"]));
assert!(is_touched_at(&layers, &["pair", "mode"]));
assert!(is_contested_at(&layers, &["pair", "mode"]));
assert!(!is_multiply_silenced_at(&layers, &["pair", "mode"]));
assert!(is_touched_at(&layers, &["chain", "mode"]));
assert!(is_contested_at(&layers, &["chain", "mode"]));
assert!(is_multiply_silenced_at(&layers, &["chain", "mode"]));
for path in [
&["absent"][..],
&["solo"][..],
&["pair", "mode"][..],
&["chain", "mode"][..],
] {
let via_pair =
is_contested_at(&layers, path) && !is_multiply_silenced_at(&layers, path);
let via_silenced = silenced_count_at(&layers, path) == 1;
let via_touchers = contributor_count_at(&layers, path) == 2;
assert_eq!(
via_pair, via_silenced,
"singleton characterization != silenced_count_at == 1 at {path:?}",
);
assert_eq!(
via_pair, via_touchers,
"singleton characterization != contributor_count_at == 2 at {path:?}",
);
}
}
#[test]
fn is_multiply_silenced_at_monotonic_chain_with_is_contested_at() {
let owned = multi_silenced_fixture();
let layers = as_refs(&owned);
for path in [
&[][..],
&["absent"][..],
&["solo"][..],
&["pair"][..],
&["pair", "mode"][..],
&["chain"][..],
&["chain", "mode"][..],
] {
if is_multiply_silenced_at(&layers, path) {
assert!(
is_contested_at(&layers, path),
"is_multiply_silenced_at ⇒ is_contested_at was violated at {path:?}",
);
assert!(
is_touched_at(&layers, path),
"is_multiply_silenced_at ⇒ is_touched_at was violated at {path:?}",
);
}
if !is_contested_at(&layers, path) {
assert!(
!is_multiply_silenced_at(&layers, path),
"!is_contested_at ⇒ !is_multiply_silenced_at was violated at {path:?}",
);
}
if !is_touched_at(&layers, path) {
assert!(
!is_multiply_silenced_at(&layers, path),
"!is_touched_at ⇒ !is_multiply_silenced_at was violated at {path:?}",
);
}
}
}
#[test]
fn is_multiply_silenced_at_covers_prefix_scalar_erasure() {
let a = Fixed(
"a",
dict(&[("k", Value::from(dict(&[("leaf", Value::from(1i64))])))]),
);
let b = Fixed("b", dict(&[("k", Value::from("shadowed"))]));
let c = Fixed("c", dict(&[("k", Value::from("erased"))]));
let layers: [&dyn DiscoveryLayer; 3] = [&a, &b, &c];
assert!(is_multiply_silenced_at(&layers, &["k", "leaf"]));
assert!(is_multiply_silenced_at(&layers, &["k"]));
assert_eq!(contributor_count_at(&layers, &["k"]), 3);
assert_eq!(silenced_count_at(&layers, &["k"]), 2);
}
#[test]
fn is_multiply_silenced_at_root_specialization_filters_silent_layers() {
let coarse = Fixed("platform", dict(&[("a", Value::from(1i64))]));
let silent = Fixed("undetectable", Dict::new());
let middle = Fixed("cloud", dict(&[("c", Value::from(3i64))]));
let specific = Fixed("tenancy", dict(&[("b", Value::from(2i64))]));
let three: [&dyn DiscoveryLayer; 5] = [&coarse, &silent, &middle, &silent, &specific];
assert!(is_multiply_silenced_at(&three, &[]));
assert_eq!(
is_multiply_silenced_at(&three, &[]),
contributor_count(&three) >= 3,
);
let two: [&dyn DiscoveryLayer; 4] = [&coarse, &silent, &middle, &silent];
assert!(!is_multiply_silenced_at(&two, &[]));
assert!(is_contested_at(&two, &[]));
assert_eq!(
is_multiply_silenced_at(&two, &[]),
contributor_count(&two) >= 3,
);
let none: [&dyn DiscoveryLayer; 3] = [&silent, &silent, &silent];
assert!(!is_multiply_silenced_at(&none, &[]));
assert!(!is_contested_at(&none, &[]));
assert!(!is_touched_at(&none, &[]));
}
#[test]
fn is_multiply_silenced_at_short_circuits_on_early_triple() {
let a = Fixed("a", dict(&[("k", Value::from(1i64))]));
let b = Fixed("b", dict(&[("k", Value::from(2i64))]));
let c = Fixed("c", dict(&[("k", Value::from(3i64))]));
let silent = Fixed("undetectable", Dict::new());
let early_triple: [&dyn DiscoveryLayer; 5] = [&a, &b, &c, &silent, &silent];
assert!(is_multiply_silenced_at(&early_triple, &["k"]));
let late_triple: [&dyn DiscoveryLayer; 5] = [&silent, &silent, &a, &b, &c];
assert!(is_multiply_silenced_at(&late_triple, &["k"]));
let two_touchers: [&dyn DiscoveryLayer; 5] = [&a, &silent, &b, &silent, &silent];
assert!(!is_multiply_silenced_at(&two_touchers, &["k"]));
assert!(is_contested_at(&two_touchers, &["k"]));
assert_eq!(
is_multiply_silenced_at(&two_touchers, &["k"]),
silenced_count_at(&two_touchers, &["k"]) >= 2,
);
}
fn contest_fixture() -> (
Box<dyn DiscoveryLayer>,
Box<dyn DiscoveryLayer>,
Box<dyn DiscoveryLayer>,
) {
let sole = Fixed("sole", dict(&[("k", Value::from(1i64))]));
let pair_coarse = Fixed("pair_coarse", dict(&[("k", Value::from(1i64))]));
let pair_specific = Fixed("pair_specific", dict(&[("k", Value::from(2i64))]));
(
Box::new(sole),
Box::new(pair_coarse),
Box::new(pair_specific),
)
}
#[test]
fn path_contest_is_multiply_silenced_false_when_uncontested() {
let (sole, _, _) = contest_fixture();
let layers: [&dyn DiscoveryLayer; 1] = [sole.as_ref()];
let contest = contest_at(&layers, &["k"]).unwrap();
assert!(!contest.is_contested(), "uncontested singleton");
assert!(
!contest.is_multiply_silenced(),
"≥ 2 silenced predicate collapses to false on uncontested singleton"
);
}
#[test]
fn path_contest_is_multiply_silenced_false_when_singly_contested() {
let (_, pair_coarse, pair_specific) = contest_fixture();
let layers: [&dyn DiscoveryLayer; 2] = [pair_coarse.as_ref(), pair_specific.as_ref()];
let contest = contest_at(&layers, &["k"]).unwrap();
assert!(contest.is_contested(), "strict contest");
assert!(
!contest.is_multiply_silenced(),
"≥ 2 silenced predicate collapses to false at exactly one silenced"
);
}
#[test]
fn path_contest_is_multiply_silenced_true_when_multiply_silenced() {
let (sole, pair_coarse, pair_specific) = contest_fixture();
let layers: [&dyn DiscoveryLayer; 3] =
[sole.as_ref(), pair_coarse.as_ref(), pair_specific.as_ref()];
let contest = contest_at(&layers, &["k"]).unwrap();
assert!(contest.is_contested(), "still strictly contested");
assert!(
contest.is_multiply_silenced(),
"≥ 2 silenced predicate is true"
);
}
#[test]
fn path_contest_is_multiply_silenced_matches_silenced_count_threshold() {
let (sole, pair_coarse, pair_specific) = contest_fixture();
let three: [&dyn DiscoveryLayer; 3] =
[sole.as_ref(), pair_coarse.as_ref(), pair_specific.as_ref()];
let contest = contest_at(&three, &["k"]).unwrap();
assert_eq!(
contest.is_multiply_silenced(),
contest.silenced_count() >= 2
);
let two: [&dyn DiscoveryLayer; 2] = [pair_coarse.as_ref(), pair_specific.as_ref()];
let contest = contest_at(&two, &["k"]).unwrap();
assert_eq!(
contest.is_multiply_silenced(),
contest.silenced_count() >= 2
);
let one: [&dyn DiscoveryLayer; 1] = [sole.as_ref()];
let contest = contest_at(&one, &["k"]).unwrap();
assert_eq!(
contest.is_multiply_silenced(),
contest.silenced_count() >= 2
);
}
#[test]
fn path_contest_is_multiply_silenced_matches_contributor_count_ge_three() {
let (sole, pair_coarse, pair_specific) = contest_fixture();
for layers in [
&[sole.as_ref()][..],
&[pair_coarse.as_ref(), pair_specific.as_ref()][..],
&[sole.as_ref(), pair_coarse.as_ref(), pair_specific.as_ref()][..],
] {
let contest = contest_at(layers, &["k"]).unwrap();
assert_eq!(
contest.is_multiply_silenced(),
contest.contributor_count() >= 3,
"method identity fails on {}-toucher fixture",
contest.contributor_count(),
);
}
}
#[test]
fn path_contest_is_multiply_silenced_matches_is_multiply_silenced_at_via_contest_at() {
let (sole, pair_coarse, pair_specific) = contest_fixture();
let silent = Fixed("silent", Dict::new());
for layers in [
&[silent.clone_boxed().as_ref()][..], &[sole.as_ref()][..],
&[pair_coarse.as_ref(), pair_specific.as_ref()][..],
&[sole.as_ref(), pair_coarse.as_ref(), pair_specific.as_ref()][..],
] {
let via_method = contest_at(layers, &["k"]).is_some_and(|c| c.is_multiply_silenced());
let via_free_fn = is_multiply_silenced_at(layers, &["k"]);
assert_eq!(
via_method, via_free_fn,
"method peer disagrees with free-fn point primitive"
);
}
}
#[test]
fn path_contest_is_multiply_silenced_implies_is_contested() {
let (sole, pair_coarse, pair_specific) = contest_fixture();
for layers in [
&[sole.as_ref()][..],
&[pair_coarse.as_ref(), pair_specific.as_ref()][..],
&[sole.as_ref(), pair_coarse.as_ref(), pair_specific.as_ref()][..],
] {
let contest = contest_at(layers, &["k"]).unwrap();
if contest.is_multiply_silenced() {
assert!(
contest.is_contested(),
"≥ 2 silenced must imply ≥ 1 silenced"
);
}
}
}
#[test]
fn path_contest_runner_up_none_when_uncontested() {
let (sole, _, _) = contest_fixture();
let layers: [&dyn DiscoveryLayer; 1] = [sole.as_ref()];
let contest = contest_at(&layers, &["k"]).unwrap();
assert!(!contest.is_contested(), "uncontested singleton");
assert_eq!(
contest.runner_up(),
None,
"runner_up is None on the no-silenced boundary",
);
}
#[test]
fn path_contest_runner_up_some_when_singly_contested() {
let (_, pair_coarse, pair_specific) = contest_fixture();
let layers: [&dyn DiscoveryLayer; 2] = [pair_coarse.as_ref(), pair_specific.as_ref()];
let contest = contest_at(&layers, &["k"]).unwrap();
assert!(contest.is_contested(), "strict contest");
assert_eq!(
contest.runner_up(),
Some("pair_coarse"),
"runner_up is the sole silenced layer",
);
assert_eq!(
contest.runner_up(),
Some(contest.coarsest()),
"at exactly one silenced, runner_up == Some(coarsest)",
);
}
#[test]
fn path_contest_runner_up_multiply_silenced_returns_finest_loser() {
let (sole, pair_coarse, pair_specific) = contest_fixture();
let layers: [&dyn DiscoveryLayer; 3] =
[sole.as_ref(), pair_coarse.as_ref(), pair_specific.as_ref()];
let contest = contest_at(&layers, &["k"]).unwrap();
assert!(contest.is_multiply_silenced(), "≥ 2 silenced");
assert_eq!(
contest.runner_up(),
Some("pair_coarse"),
"runner_up is the finest (most-specific) silenced layer",
);
assert_ne!(
contest.runner_up(),
Some(contest.coarsest()),
"at ≥ 2 silenced, runner_up and coarsest occupy distinct positions",
);
assert_ne!(
contest.runner_up(),
Some(contest.decider),
"runner_up is never the decider — the decider is the winner, not a loser",
);
}
#[test]
fn path_contest_runner_up_matches_overridden_last() {
let (sole, pair_coarse, pair_specific) = contest_fixture();
for layers in [
&[sole.as_ref()][..],
&[pair_coarse.as_ref(), pair_specific.as_ref()][..],
&[sole.as_ref(), pair_coarse.as_ref(), pair_specific.as_ref()][..],
] {
let contest = contest_at(layers, &["k"]).unwrap();
assert_eq!(
contest.runner_up(),
contest.overridden.last().copied(),
"runner_up disagrees with overridden.last() on {}-toucher fixture",
contest.contributor_count(),
);
}
}
#[test]
fn path_contest_runner_up_matches_contributors_nth_back_one() {
let (sole, pair_coarse, pair_specific) = contest_fixture();
for layers in [
&[sole.as_ref()][..],
&[pair_coarse.as_ref(), pair_specific.as_ref()][..],
&[sole.as_ref(), pair_coarse.as_ref(), pair_specific.as_ref()][..],
] {
let contest = contest_at(layers, &["k"]).unwrap();
let via_contributors = contest.contributors().iter().nth_back(1).copied();
assert_eq!(
contest.runner_up(),
via_contributors,
"runner_up disagrees with contributors().nth_back(1) on {}-toucher fixture",
contest.contributor_count(),
);
}
}
#[test]
fn path_contest_runner_up_is_some_iff_is_contested() {
let (sole, pair_coarse, pair_specific) = contest_fixture();
for layers in [
&[sole.as_ref()][..],
&[pair_coarse.as_ref(), pair_specific.as_ref()][..],
&[sole.as_ref(), pair_coarse.as_ref(), pair_specific.as_ref()][..],
] {
let contest = contest_at(layers, &["k"]).unwrap();
assert_eq!(
contest.runner_up().is_some(),
contest.is_contested(),
"runner_up presence disagrees with is_contested on {}-toucher fixture",
contest.contributor_count(),
);
}
}
#[test]
fn path_contest_runner_up_never_equals_decider() {
let (sole, pair_coarse, pair_specific) = contest_fixture();
for layers in [
&[sole.as_ref()][..],
&[pair_coarse.as_ref(), pair_specific.as_ref()][..],
&[sole.as_ref(), pair_coarse.as_ref(), pair_specific.as_ref()][..],
] {
let contest = contest_at(layers, &["k"]).unwrap();
if let Some(runner) = contest.runner_up() {
assert_ne!(
runner,
contest.decider,
"runner_up must not alias decider on {}-toucher fixture",
contest.contributor_count(),
);
assert!(
contest.overridden.contains(&runner),
"runner_up must be drawn from the overridden list",
);
}
}
}
#[test]
fn runner_up_at_none_boundary_matches_is_contested_at() {
let a = Fixed(
"a",
dict(&[
("solo", Value::from(1i64)),
(
"breathe",
Value::from(dict(&[("mode", Value::from("live"))])),
),
]),
);
let b = Fixed("b", dict(&[("logger", Value::from("info"))]));
let layers: [&dyn DiscoveryLayer; 2] = [&a, &b];
assert_eq!(runner_up_at(&layers, &["absent"]), None);
assert!(!is_contested_at(&layers, &["absent"]));
assert_eq!(runner_up_at(&layers, &["solo"]), None);
assert!(!is_contested_at(&layers, &["solo"]));
assert_eq!(runner_up_at(&layers, &["logger"]), None);
assert!(!is_contested_at(&layers, &["logger"]));
let empty: [&dyn DiscoveryLayer; 0] = [];
assert_eq!(runner_up_at(&empty, &[]), None);
assert_eq!(runner_up_at(&empty, &["absent"]), None);
}
#[test]
fn runner_up_at_matches_silenced_at_last_across_paths() {
let a = Fixed(
"a",
dict(&[(
"breathe",
Value::from(dict(&[
("mode", Value::from("live")),
("setpoint", Value::from(0.80)),
])),
)]),
);
let b = Fixed(
"b",
dict(&[(
"breathe",
Value::from(dict(&[("mode", Value::from("shadow"))])),
)]),
);
let c = Fixed("c", dict(&[("logger", Value::from("info"))]));
let layers: [&dyn DiscoveryLayer; 3] = [&a, &b, &c];
for path in [
&[][..],
&["breathe"][..],
&["breathe", "mode"][..],
&["breathe", "setpoint"][..],
&["logger"][..],
&["absent"][..],
] {
let via_primitive = runner_up_at(&layers, path);
let via_loose = silenced_at(&layers, path).last().copied();
assert_eq!(
via_primitive, via_loose,
"runner_up_at != silenced_at.last() at {path:?}",
);
}
}
#[test]
fn runner_up_at_matches_contest_at_runner_up_across_paths() {
let coarse = Fixed(
"platform",
dict(&[(
"breathe",
Value::from(dict(&[
("setpoint", Value::from(0.80)),
("mode", Value::from("live")),
])),
)]),
);
let middle = Fixed(
"cloud",
dict(&[(
"breathe",
Value::from(dict(&[("mode", Value::from("staging"))])),
)]),
);
let specific = Fixed(
"tenancy",
dict(&[(
"breathe",
Value::from(dict(&[("mode", Value::from("shadow"))])),
)]),
);
let layers: [&dyn DiscoveryLayer; 3] = [&coarse, &middle, &specific];
for path in [
&["breathe", "mode"][..],
&["breathe", "setpoint"][..],
&["breathe"][..],
&["absent"][..],
&[][..],
] {
let via_primitive = runner_up_at(&layers, path);
let via_fused = contest_at(&layers, path).and_then(|c| c.runner_up());
assert_eq!(
via_primitive, via_fused,
"runner_up_at != contest_at.and_then(|c| c.runner_up()) at {path:?}",
);
}
}
#[test]
fn runner_up_at_three_writers_returns_middle_toucher() {
let platform = Fixed(
"platform",
dict(&[(
"breathe",
Value::from(dict(&[("mode", Value::from("live"))])),
)]),
);
let cloud = Fixed(
"cloud",
dict(&[(
"breathe",
Value::from(dict(&[("mode", Value::from("aws"))])),
)]),
);
let tenancy = Fixed(
"tenancy",
dict(&[(
"breathe",
Value::from(dict(&[("mode", Value::from("prod"))])),
)]),
);
let disjoint = Fixed("logger", dict(&[("logger", Value::from("info"))]));
let layers: [&dyn DiscoveryLayer; 4] = [&platform, &cloud, &tenancy, &disjoint];
assert_eq!(
runner_up_at(&layers, &["breathe", "mode"]),
Some("cloud"),
"runner_up_at is the second-to-last toucher"
);
assert_eq!(coarsest_at(&layers, &["breathe", "mode"]), Some("platform"));
assert_eq!(decider_at(&layers, &["breathe", "mode"]), Some("tenancy"));
assert_ne!(
runner_up_at(&layers, &["breathe", "mode"]),
coarsest_at(&layers, &["breathe", "mode"]),
"at ≥ 2 silenced, runner_up_at and coarsest_at diverge",
);
assert_ne!(
runner_up_at(&layers, &["breathe", "mode"]),
decider_at(&layers, &["breathe", "mode"]),
"runner_up_at is drawn from the losers list, never aliases decider_at",
);
}
#[test]
fn runner_up_at_singly_contested_aliases_coarsest_at() {
let coarse = Fixed(
"platform",
dict(&[(
"breathe",
Value::from(dict(&[("mode", Value::from("live"))])),
)]),
);
let specific = Fixed(
"tenancy",
dict(&[(
"breathe",
Value::from(dict(&[("mode", Value::from("shadow"))])),
)]),
);
let layers: [&dyn DiscoveryLayer; 2] = [&coarse, &specific];
assert_eq!(silenced_count_at(&layers, &["breathe", "mode"]), 1);
assert_eq!(
runner_up_at(&layers, &["breathe", "mode"]),
coarsest_at(&layers, &["breathe", "mode"]),
"at exactly one silenced, runner_up_at aliases coarsest_at",
);
assert_eq!(
runner_up_at(&layers, &["breathe", "mode"]),
Some("platform"),
);
assert_ne!(
runner_up_at(&layers, &["breathe", "mode"]),
decider_at(&layers, &["breathe", "mode"]),
"runner_up_at ≠ decider_at even on the singly-contested cell",
);
}
#[test]
fn runner_up_at_covers_prefix_scalar_erasure() {
let a = Fixed(
"a",
dict(&[("k", Value::from(dict(&[("leaf", Value::from(1i64))])))]),
);
let b = Fixed(
"b",
dict(&[("k", Value::from(dict(&[("leaf", Value::from(2i64))])))]),
);
let c = Fixed("c", dict(&[("k", Value::from("erased"))]));
let layers: [&dyn DiscoveryLayer; 3] = [&a, &b, &c];
assert_eq!(coarsest_at(&layers, &["k", "leaf"]), Some("a"));
assert_eq!(runner_up_at(&layers, &["k", "leaf"]), Some("b"));
assert_eq!(decider_at(&layers, &["k", "leaf"]), Some("c"));
let leading = coarsest_at(&layers, &["k", "leaf"]);
let middle = runner_up_at(&layers, &["k", "leaf"]);
let trailing = decider_at(&layers, &["k", "leaf"]);
assert_ne!(leading, middle, "coarsest ≠ runner_up at ≥ 3 touchers");
assert_ne!(middle, trailing, "runner_up ≠ decider structurally");
assert_ne!(leading, trailing, "coarsest ≠ decider at ≥ 2 touchers");
}
#[test]
fn runner_up_at_root_boundary_equals_contributor_names_nth_back_one() {
let coarse = Fixed("platform", dict(&[("a", Value::from(1i64))]));
let silent = Fixed("undetectable", Dict::new());
let middle = Fixed("cloud", dict(&[("c", Value::from(3i64))]));
let specific = Fixed("tenancy", dict(&[("b", Value::from(2i64))]));
let layers: [&dyn DiscoveryLayer; 4] = [&coarse, &silent, &middle, &specific];
let names = contributor_names(&layers);
assert_eq!(
runner_up_at(&layers, &[]),
names.iter().nth_back(1).copied()
);
assert_eq!(runner_up_at(&layers, &[]), Some("cloud"));
assert_eq!(coarsest_at(&layers, &[]), Some("platform"));
assert_eq!(decider_at(&layers, &[]), Some("tenancy"));
}
#[test]
fn path_contest_silenced_empty_iff_uncontested() {
let sole = Fixed("only", dict(&[("k", Value::from(1i64))]));
let layers: [&dyn DiscoveryLayer; 1] = [&sole];
let contest = contest_at(&layers, &["k"]).expect("sole toucher yields Some");
assert!(contest.silenced().is_empty(), "no silenced touchers");
assert_eq!(contest.silenced().len(), 0);
assert_eq!(contest.silenced().len(), contest.silenced_count());
assert_eq!(contest.silenced().is_empty(), !contest.is_contested());
}
#[test]
fn path_contest_silenced_singleton_holds_leading_and_trailing_at_once() {
let coarse = Fixed("platform", dict(&[("mode", Value::from("live"))]));
let specific = Fixed("tenancy", dict(&[("mode", Value::from("dry"))]));
let layers: [&dyn DiscoveryLayer; 2] = [&coarse, &specific];
let contest = contest_at(&layers, &["mode"]).expect("two touchers yield Some");
let silenced = contest.silenced();
assert_eq!(silenced, &["platform"]);
assert_eq!(silenced.len(), 1);
assert_eq!(silenced.first().copied(), Some("platform"));
assert_eq!(silenced.last().copied(), contest.runner_up());
assert_eq!(silenced.first().copied(), silenced.last().copied());
}
#[test]
fn path_contest_silenced_multi_preserves_coarse_to_specific_order() {
let l0 = Fixed("platform", dict(&[("mode", Value::from(0i64))]));
let l1 = Fixed("cloud", dict(&[("mode", Value::from(1i64))]));
let l2 = Fixed("orchestrator", dict(&[("mode", Value::from(2i64))]));
let l3 = Fixed("tenancy", dict(&[("mode", Value::from(3i64))]));
let layers: [&dyn DiscoveryLayer; 4] = [&l0, &l1, &l2, &l3];
let contest = contest_at(&layers, &["mode"]).expect("four touchers yield Some");
let silenced = contest.silenced();
assert_eq!(silenced, &["platform", "cloud", "orchestrator"]);
assert_eq!(silenced.last().copied(), contest.runner_up());
assert_eq!(silenced.first().copied(), Some(contest.coarsest()));
assert_ne!(silenced.first().copied(), silenced.last().copied());
assert_eq!(silenced.len() >= 2, contest.is_multiply_silenced());
}
#[test]
fn path_contest_silenced_matches_silenced_at_across_paths() {
let base = Fixed(
"platform",
dict(&[
(
"breathe",
Value::from(dict(&[
("setpoint", Value::from(0.80)),
("mode", Value::from("live")),
])),
),
("only_in_base", Value::from(0i64)),
]),
);
let overlay = Fixed(
"tenancy",
dict(&[(
"breathe",
Value::from(dict(&[
("mode", Value::from("dry")),
("only_in_overlay", Value::from(1i64)),
])),
)]),
);
let layers: [&dyn DiscoveryLayer; 2] = [&base, &overlay];
for path in [
vec![],
vec!["breathe"],
vec!["breathe", "mode"],
vec!["breathe", "only_in_overlay"],
vec!["only_in_base"],
vec!["missing"],
] {
let free = silenced_at(&layers, &path);
let method_owned =
contest_at(&layers, &path).map_or_else(Vec::new, |c| c.silenced().to_vec());
assert_eq!(
method_owned, free,
"silenced().to_vec() == silenced_at at path {path:?}"
);
}
}
#[test]
fn path_contest_silenced_plus_decider_reconstructs_contributors() {
let l0 = Fixed("platform", dict(&[("k", Value::from(0i64))]));
let l1 = Fixed("cloud", dict(&[("k", Value::from(1i64))]));
let l2 = Fixed("tenancy", dict(&[("k", Value::from(2i64))]));
let layers: [&dyn DiscoveryLayer; 3] = [&l0, &l1, &l2];
let contest = contest_at(&layers, &["k"]).expect("three touchers yield Some");
let mut recomposed: Vec<&'static str> = contest.silenced().to_vec();
recomposed.push(contest.decider);
assert_eq!(recomposed, contest.contributors());
}
#[test]
fn path_contest_silenced_aliases_overridden_field_slice() {
let l0 = Fixed("platform", dict(&[("k", Value::from(0i64))]));
let l1 = Fixed("cloud", dict(&[("k", Value::from(1i64))]));
let l2 = Fixed("orchestrator", dict(&[("k", Value::from(2i64))]));
let l3 = Fixed("tenancy", dict(&[("k", Value::from(3i64))]));
let layers: [&dyn DiscoveryLayer; 4] = [&l0, &l1, &l2, &l3];
let contest = contest_at(&layers, &["k"]).expect("four touchers yield Some");
assert_eq!(contest.silenced(), contest.overridden.as_slice());
}
#[test]
fn path_contest_silenced_root_specialization_matches_silenced_at_root() {
let coarse = Fixed("platform", dict(&[("a", Value::from(1i64))]));
let silent = Fixed("undetectable", Dict::new());
let middle = Fixed("cloud", dict(&[("c", Value::from(3i64))]));
let specific = Fixed("tenancy", dict(&[("b", Value::from(2i64))]));
let layers: [&dyn DiscoveryLayer; 4] = [&coarse, &silent, &middle, &specific];
let contest = contest_at(&layers, &[]).expect("root has touchers");
assert_eq!(contest.silenced(), &["platform", "cloud"]);
assert_eq!(contest.silenced().to_vec(), silenced_at(&layers, &[]));
}
#[test]
fn path_contest_coarsest_silenced_none_when_uncontested() {
let sole = Fixed("only", dict(&[("k", Value::from(1i64))]));
let layers: [&dyn DiscoveryLayer; 1] = [&sole];
let contest = contest_at(&layers, &["k"]).expect("sole toucher yields Some");
assert_eq!(contest.coarsest_silenced(), None);
assert_eq!(
contest.coarsest_silenced().is_some(),
contest.is_contested()
);
assert_eq!(contest.coarsest(), contest.decider);
assert_eq!(
contest.coarsest_silenced().unwrap_or(contest.decider),
contest.coarsest(),
);
}
#[test]
fn path_contest_coarsest_silenced_singly_contested_aliases_runner_up_and_coarsest() {
let coarse = Fixed("platform", dict(&[("mode", Value::from("live"))]));
let specific = Fixed("tenancy", dict(&[("mode", Value::from("dry"))]));
let layers: [&dyn DiscoveryLayer; 2] = [&coarse, &specific];
let contest = contest_at(&layers, &["mode"]).expect("two touchers yield Some");
assert_eq!(contest.coarsest_silenced(), Some("platform"));
assert_eq!(contest.coarsest_silenced(), contest.runner_up());
assert_eq!(contest.coarsest_silenced(), Some(contest.coarsest()));
assert_eq!(
contest.coarsest_silenced(),
coarsest_silenced_at(&layers, &["mode"]),
);
}
#[test]
fn path_contest_coarsest_silenced_multi_diverges_from_runner_up() {
let l0 = Fixed("platform", dict(&[("mode", Value::from(0i64))]));
let l1 = Fixed("cloud", dict(&[("mode", Value::from(1i64))]));
let l2 = Fixed("orchestrator", dict(&[("mode", Value::from(2i64))]));
let l3 = Fixed("tenancy", dict(&[("mode", Value::from(3i64))]));
let layers: [&dyn DiscoveryLayer; 4] = [&l0, &l1, &l2, &l3];
let contest = contest_at(&layers, &["mode"]).expect("four touchers yield Some");
assert_eq!(contest.coarsest_silenced(), Some("platform"));
assert_ne!(contest.coarsest_silenced(), contest.runner_up());
assert_eq!(contest.coarsest_silenced(), Some(contest.coarsest()));
assert!(contest.is_multiply_silenced());
}
#[test]
fn path_contest_coarsest_silenced_matches_overridden_first() {
let l0 = Fixed("platform", dict(&[("k", Value::from(0i64))]));
let l1 = Fixed("cloud", dict(&[("k", Value::from(1i64))]));
let l2 = Fixed("orchestrator", dict(&[("k", Value::from(2i64))]));
let l3 = Fixed("tenancy", dict(&[("k", Value::from(3i64))]));
let layers: [&dyn DiscoveryLayer; 4] = [&l0, &l1, &l2, &l3];
let contest = contest_at(&layers, &["k"]).expect("four touchers yield Some");
assert_eq!(
contest.coarsest_silenced(),
contest.overridden.first().copied()
);
assert_eq!(
contest.coarsest_silenced(),
contest.silenced().first().copied()
);
}
#[test]
fn path_contest_coarsest_silenced_matches_free_fn_across_paths() {
let base = Fixed(
"platform",
dict(&[
(
"breathe",
Value::from(dict(&[
("setpoint", Value::from(0.80)),
("mode", Value::from("live")),
])),
),
("only_in_base", Value::from(0i64)),
]),
);
let overlay = Fixed(
"tenancy",
dict(&[(
"breathe",
Value::from(dict(&[
("mode", Value::from("dry")),
("only_in_overlay", Value::from(1i64)),
])),
)]),
);
let layers: [&dyn DiscoveryLayer; 2] = [&base, &overlay];
for path in [
&[][..],
&["breathe"][..],
&["breathe", "mode"][..],
&["breathe", "only_in_overlay"][..],
&["only_in_base"][..],
&["missing"][..],
] {
let free = coarsest_silenced_at(&layers, path);
let method = contest_at(&layers, path).and_then(|c| c.coarsest_silenced());
assert_eq!(
method, free,
"coarsest_silenced() != coarsest_silenced_at at path {path:?}"
);
}
}
#[test]
fn path_contest_coarsest_silenced_totalization_holds_across_paths() {
let l0 = Fixed("platform", dict(&[("a", Value::from(1i64))]));
let l1 = Fixed("cloud", dict(&[("a", Value::from(2i64))]));
let l2 = Fixed(
"tenancy",
dict(&[("a", Value::from(3i64)), ("b", Value::from(0i64))]),
);
let layers: [&dyn DiscoveryLayer; 3] = [&l0, &l1, &l2];
let cont = contest_at(&layers, &["a"]).expect("three touchers yield Some");
assert_eq!(
cont.coarsest_silenced().unwrap_or(cont.decider),
cont.coarsest()
);
let uncont = contest_at(&layers, &["b"]).expect("sole toucher yields Some");
assert_eq!(
uncont.coarsest_silenced().unwrap_or(uncont.decider),
uncont.coarsest(),
);
assert_eq!(uncont.coarsest_silenced(), None);
assert_eq!(uncont.coarsest(), uncont.decider);
}
#[test]
fn coarsest_silenced_at_none_boundary_matches_is_contested_at() {
let l0 = Fixed("platform", dict(&[("solo", Value::from(1i64))]));
let l1 = Fixed(
"tenancy",
dict(&[
("logger", Value::from("json")),
(
"breathe",
Value::from(dict(&[("mode", Value::from("dry"))])),
),
]),
);
let layers: [&dyn DiscoveryLayer; 2] = [&l0, &l1];
assert_eq!(coarsest_silenced_at(&layers, &["absent"]), None);
assert!(!is_contested_at(&layers, &["absent"]));
assert_eq!(coarsest_silenced_at(&layers, &["solo"]), None);
assert!(!is_contested_at(&layers, &["solo"]));
assert_eq!(coarsest_silenced_at(&layers, &["logger"]), None);
assert!(!is_contested_at(&layers, &["logger"]));
let empty: [&dyn DiscoveryLayer; 0] = [];
assert_eq!(coarsest_silenced_at(&empty, &[]), None);
assert_eq!(coarsest_silenced_at(&empty, &["absent"]), None);
}
#[test]
fn coarsest_silenced_at_matches_silenced_at_first_across_paths() {
let base = Fixed(
"platform",
dict(&[
(
"breathe",
Value::from(dict(&[
("setpoint", Value::from(0.80)),
("mode", Value::from("live")),
])),
),
("only_in_base", Value::from(0i64)),
]),
);
let overlay = Fixed(
"tenancy",
dict(&[(
"breathe",
Value::from(dict(&[
("mode", Value::from("dry")),
("only_in_overlay", Value::from(1i64)),
])),
)]),
);
let layers: [&dyn DiscoveryLayer; 2] = [&base, &overlay];
for path in [
&[][..],
&["breathe"][..],
&["breathe", "mode"][..],
&["breathe", "only_in_overlay"][..],
&["only_in_base"][..],
&["missing"][..],
] {
let via_primitive = coarsest_silenced_at(&layers, path);
let via_silenced_first = silenced_at(&layers, path).first().copied();
assert_eq!(
via_primitive, via_silenced_first,
"coarsest_silenced_at != silenced_at.first() at {path:?}",
);
}
}
#[test]
fn coarsest_silenced_at_matches_contest_at_projection_across_paths() {
let l0 = Fixed(
"platform",
dict(&[
(
"breathe",
Value::from(dict(&[
("mode", Value::from("live")),
("setpoint", Value::from(0.80)),
])),
),
("solo", Value::from(0i64)),
]),
);
let l1 = Fixed(
"cloud",
dict(&[(
"breathe",
Value::from(dict(&[("mode", Value::from("shadow"))])),
)]),
);
let l2 = Fixed(
"tenancy",
dict(&[(
"breathe",
Value::from(dict(&[("mode", Value::from("dry"))])),
)]),
);
let layers: [&dyn DiscoveryLayer; 3] = [&l0, &l1, &l2];
for path in [
&[][..],
&["breathe"][..],
&["breathe", "mode"][..],
&["breathe", "setpoint"][..],
&["solo"][..],
&["absent"][..],
] {
let via_primitive = coarsest_silenced_at(&layers, path);
let via_contest = contest_at(&layers, path).and_then(|c| c.coarsest_silenced());
assert_eq!(
via_primitive, via_contest,
"coarsest_silenced_at != contest_at.and_then(|c| c.coarsest_silenced()) at {path:?}",
);
}
}
#[test]
fn coarsest_silenced_at_three_writers_returns_leading_toucher() {
let l0 = Fixed(
"platform",
dict(&[(
"breathe",
Value::from(dict(&[("mode", Value::from("live"))])),
)]),
);
let l1 = Fixed(
"cloud",
dict(&[(
"breathe",
Value::from(dict(&[("mode", Value::from("shadow"))])),
)]),
);
let l2 = Fixed(
"tenancy",
dict(&[(
"breathe",
Value::from(dict(&[("mode", Value::from("dry"))])),
)]),
);
let layers: [&dyn DiscoveryLayer; 3] = [&l0, &l1, &l2];
assert_eq!(
coarsest_silenced_at(&layers, &["breathe", "mode"]),
Some("platform"),
"coarsest_silenced_at is the leading (coarsest) toucher",
);
assert_ne!(
coarsest_silenced_at(&layers, &["breathe", "mode"]),
runner_up_at(&layers, &["breathe", "mode"]),
"at ≥ 2 silenced, coarsest_silenced_at and runner_up_at diverge",
);
assert_ne!(
coarsest_silenced_at(&layers, &["breathe", "mode"]),
decider_at(&layers, &["breathe", "mode"]),
"coarsest_silenced_at is drawn from the losers list, never aliases decider_at",
);
assert_eq!(
coarsest_silenced_at(&layers, &["breathe", "mode"]),
coarsest_at(&layers, &["breathe", "mode"]),
"on the contested branch, the coarsest overall IS the coarsest silenced",
);
}
#[test]
fn coarsest_silenced_at_singly_contested_aliases_runner_up_at() {
let coarse = Fixed(
"platform",
dict(&[(
"breathe",
Value::from(dict(&[("mode", Value::from("live"))])),
)]),
);
let specific = Fixed(
"tenancy",
dict(&[(
"breathe",
Value::from(dict(&[("mode", Value::from("dry"))])),
)]),
);
let layers: [&dyn DiscoveryLayer; 2] = [&coarse, &specific];
assert_eq!(
coarsest_silenced_at(&layers, &["breathe", "mode"]),
Some("platform"),
);
assert_eq!(
coarsest_silenced_at(&layers, &["breathe", "mode"]),
runner_up_at(&layers, &["breathe", "mode"]),
"at exactly one silenced, coarsest_silenced_at aliases runner_up_at",
);
assert_eq!(
coarsest_silenced_at(&layers, &["breathe", "mode"]),
coarsest_at(&layers, &["breathe", "mode"]),
);
assert_ne!(
coarsest_silenced_at(&layers, &["breathe", "mode"]),
decider_at(&layers, &["breathe", "mode"]),
"coarsest_silenced_at ≠ decider_at even on the singly-contested cell",
);
}
#[test]
fn coarsest_silenced_at_covers_prefix_scalar_erasure() {
let a = Fixed(
"a",
dict(&[("k", Value::from(dict(&[("leaf", Value::from(1i64))])))]),
);
let b = Fixed(
"b",
dict(&[("k", Value::from(dict(&[("leaf", Value::from(2i64))])))]),
);
let c = Fixed("c", dict(&[("k", Value::from("scalar"))]));
let layers: [&dyn DiscoveryLayer; 3] = [&a, &b, &c];
assert_eq!(coarsest_silenced_at(&layers, &["k", "leaf"]), Some("a"));
assert_eq!(runner_up_at(&layers, &["k", "leaf"]), Some("b"));
assert_eq!(decider_at(&layers, &["k", "leaf"]), Some("c"));
assert_ne!(
coarsest_silenced_at(&layers, &["k", "leaf"]),
runner_up_at(&layers, &["k", "leaf"]),
);
}
#[test]
fn coarsest_silenced_at_root_boundary_equals_contributor_names_first() {
let l0 = Fixed("platform", dict(&[("a", Value::from(1i64))]));
let silent = Fixed("undetectable", Dict::new());
let l1 = Fixed("cloud", dict(&[("c", Value::from(3i64))]));
let l2 = Fixed("tenancy", dict(&[("b", Value::from(2i64))]));
let layers: [&dyn DiscoveryLayer; 4] = [&l0, &silent, &l1, &l2];
assert_eq!(coarsest_silenced_at(&layers, &[]), Some("platform"));
assert_eq!(
coarsest_silenced_at(&layers, &[]),
contributor_names(&layers).first().copied(),
);
assert_eq!(coarsest_at(&layers, &[]), Some("platform"));
assert_eq!(runner_up_at(&layers, &[]), Some("cloud"));
assert_eq!(decider_at(&layers, &[]), Some("tenancy"));
}
#[test]
fn writes_of_layer_iter_collect_matches_writes_of_layer() {
let out = layer_axis_fixture();
for layer in out.attribution.surviving_layer_names() {
let iter: Vec<&[String]> = out.attribution.writes_of_layer_iter(layer).collect();
let collected = out.attribution.writes_of_layer(layer);
assert_eq!(
iter, collected,
"iter().collect() equals writes_of_layer({layer}) verbatim",
);
}
}
#[test]
fn writes_of_layer_iter_missing_writer_is_empty_stream() {
let real = Fixed("real", dict(&[("k", Value::from(1i64))]));
let silent = Fixed("undetectable", Dict::new());
let out = compose_with_provenance(&[&real, &silent]);
assert_eq!(
out.attribution.writes_of_layer_iter("undetectable").next(),
None,
"silent writer yields empty iter stream",
);
assert_eq!(
out.attribution
.writes_of_layer_iter("never-declared")
.next(),
None,
"never-declared writer yields empty iter stream",
);
}
#[test]
fn writes_of_layer_iter_preserves_lex_order() {
let a = Fixed(
"A",
dict(&[
("m", Value::from(3i64)),
("a", Value::from(dict(&[("y", Value::from(2i64))]))),
]),
);
let b = Fixed("Z", dict(&[("z", Value::from(1i64))]));
let out = compose_with_provenance(&[&a, &b]);
let a_paths: Vec<&[String]> = out.attribution.writes_of_layer_iter("A").collect();
assert_eq!(
a_paths,
vec![
["a".to_owned(), "y".to_owned()].as_slice(),
["m".to_owned()].as_slice(),
],
"iter preserves lex path order",
);
}
#[test]
fn writes_of_layer_iter_next_back_walks_reverse() {
let a = Fixed(
"A",
dict(&[
("a", Value::from(1i64)),
("b", Value::from(2i64)),
("c", Value::from(3i64)),
("d", Value::from(4i64)),
]),
);
let out = compose_with_provenance(&[&a]);
let mut it = out.attribution.writes_of_layer_iter("A");
assert_eq!(it.next(), Some(["a".to_owned()].as_slice()));
assert_eq!(it.next_back(), Some(["d".to_owned()].as_slice()));
assert_eq!(it.next(), Some(["b".to_owned()].as_slice()));
assert_eq!(it.next_back(), Some(["c".to_owned()].as_slice()));
assert_eq!(it.next(), None);
assert_eq!(it.next_back(), None);
}
#[test]
fn writes_of_layer_iter_last_equals_writes_of_layer_last() {
let out = layer_axis_fixture();
for layer in out.attribution.surviving_layer_names() {
let iter_last = out.attribution.writes_of_layer_iter(layer).next_back();
let collect_last = out.attribution.writes_of_layer(layer).last().copied();
assert_eq!(
iter_last, collect_last,
"iter.next_back() equals writes_of_layer({layer}).last() verbatim",
);
}
assert_eq!(
out.attribution
.writes_of_layer_iter("never-here")
.next_back(),
None,
);
}
#[test]
fn writes_of_layer_iter_count_matches_leaf_count_of_layer() {
let out = layer_axis_fixture();
for layer in out.attribution.surviving_layer_names() {
let iter_count = out.attribution.writes_of_layer_iter(layer).count();
let scalar_count = out.attribution.leaf_count_of_layer(layer);
assert_eq!(iter_count, scalar_count, "counts agree for {layer}");
}
assert_eq!(
out.attribution.writes_of_layer_iter("never-here").count(),
0,
);
}
#[test]
fn writes_of_layer_iter_clone_yields_independent_walks() {
let out = layer_axis_fixture();
let mut a = out.attribution.writes_of_layer_iter("platform");
let first = a.next();
let mut b = a.clone();
assert_eq!(a.next(), b.next());
assert_eq!(a.next(), b.next());
assert_eq!(a.next(), None);
assert_eq!(b.next(), None);
let mut fresh = out.attribution.writes_of_layer_iter("platform");
assert_eq!(fresh.next(), first);
}
#[test]
fn writes_of_layer_iter_is_fused_past_exhaustion() {
let out = layer_axis_fixture();
let mut it = out.attribution.writes_of_layer_iter("tenancy");
while it.next().is_some() {}
for _ in 0..8 {
assert_eq!(it.next(), None, "fused past exhaustion (forward)");
assert_eq!(it.next_back(), None, "fused past exhaustion (back)");
}
}
#[test]
fn writes_of_layer_iter_head_short_circuits_without_full_sweep() {
let a = Fixed("target", dict(&[("aaa", Value::from(1i64))]));
let b = Fixed(
"peer",
dict(&[
("bbb", Value::from(2i64)),
("ccc", Value::from(3i64)),
("ddd", Value::from(4i64)),
]),
);
let out = compose_with_provenance(&[&a, &b]);
let head = out.attribution.writes_of_layer_iter("target").next();
assert_eq!(head, Some(["aaa".to_owned()].as_slice()));
}
#[test]
fn writes_of_layer_iter_find_locates_positional_match() {
let a = Fixed(
"A",
dict(&[
("aaa", Value::from(1i64)),
("mmm", Value::from(2i64)),
("zzz", Value::from(3i64)),
]),
);
let out = compose_with_provenance(&[&a]);
let hit = out
.attribution
.writes_of_layer_iter("A")
.find(|p| p.first().is_some_and(|s| s == "mmm"));
assert_eq!(hit, Some(["mmm".to_owned()].as_slice()));
}
#[test]
fn writes_of_layer_iter_empty_attribution_is_empty_stream() {
let out = compose_with_provenance(&[]);
assert_eq!(out.attribution.writes_of_layer_iter("any").next(), None);
}
#[test]
fn subtree_writes_of_layer_iter_collect_matches_subtree_writes_of_layer() {
let out = subtree_fixture();
for prefix in [
vec![],
vec![s("breathe")],
vec![s("alpha")],
vec![s("nonexistent")],
] {
for layer in ["coarse", "specific", "never-declared"] {
let iter: Vec<&[String]> = out
.attribution
.subtree_writes_of_layer_iter(&prefix, layer)
.collect();
let collected = out.attribution.subtree_writes_of_layer(&prefix, layer);
assert_eq!(
iter, collected,
"iter.collect() at prefix {prefix:?} equals subtree_writes_of_layer({layer}) verbatim",
);
}
}
}
#[test]
fn subtree_writes_of_layer_iter_empty_prefix_equals_writes_of_layer_iter() {
let out = layer_axis_fixture();
for layer in out.attribution.surviving_layer_names() {
let sub: Vec<&[String]> = out
.attribution
.subtree_writes_of_layer_iter(&[], layer)
.collect();
let top: Vec<&[String]> = out.attribution.writes_of_layer_iter(layer).collect();
assert_eq!(
sub, top,
"empty prefix ⇒ subtree_writes_of_layer_iter({layer}) equals writes_of_layer_iter({layer})",
);
}
assert_eq!(
out.attribution
.subtree_writes_of_layer_iter(&[], "never-declared")
.next(),
None,
"empty prefix + never-declared writer ⇒ empty stream",
);
}
#[test]
fn subtree_writes_of_layer_iter_stops_at_prefix_extending_sibling() {
let out = subtree_fixture();
let prefix = vec![s("breathe")];
let sub: Vec<Vec<String>> = out
.attribution
.subtree_writes_of_layer_iter(&prefix, "specific")
.map(<[String]>::to_vec)
.collect();
assert!(
!sub.contains(&vec![s("breatheZ")]),
"prefix-extending sibling is excluded from the 2D-restricted iter",
);
let parent: Vec<Vec<String>> = out
.attribution
.writes_of_layer_iter("specific")
.map(<[String]>::to_vec)
.collect();
assert!(
parent.contains(&vec![s("breatheZ")]),
"the excluded sibling IS in the top-level layer-axis iter",
);
}
#[test]
fn subtree_writes_of_layer_iter_preserves_lex_order() {
let a = Fixed(
"A",
dict(&[
(
"s",
Value::from(dict(&[
("m", Value::from(3i64)),
("a", Value::from(dict(&[("y", Value::from(2i64))]))),
])),
),
("t", Value::from(4i64)),
]),
);
let b = Fixed(
"B",
dict(&[("s", Value::from(dict(&[("p", Value::from(9i64))])))]),
);
let out = compose_with_provenance(&[&a, &b]);
let prefix = vec![s("s")];
let a_paths: Vec<Vec<String>> = out
.attribution
.subtree_writes_of_layer_iter(&prefix, "A")
.map(<[String]>::to_vec)
.collect();
assert_eq!(
a_paths,
vec![vec![s("s"), s("a"), s("y")], vec![s("s"), s("m")]],
"2D-restricted iter preserves lex path order under the subtree",
);
}
#[test]
fn subtree_writes_of_layer_iter_absent_prefix_is_empty_stream() {
let out = subtree_fixture();
for layer in ["coarse", "specific", "never-declared"] {
assert_eq!(
out.attribution
.subtree_writes_of_layer_iter(&[s("nonexistent")], layer)
.next(),
None,
"absent prefix ⇒ subtree_writes_of_layer_iter({layer}) is empty",
);
}
}
#[test]
fn subtree_writes_of_layer_iter_missing_writer_is_empty_stream() {
let out = subtree_fixture();
let prefix = vec![s("breathe")];
assert_eq!(
out.attribution
.subtree_writes_of_layer_iter(&prefix, "never-declared")
.next(),
None,
);
let elsewhere = Fixed("elsewhere", dict(&[("outside", Value::from(1i64))]));
let under = Fixed(
"under",
dict(&[("root", Value::from(dict(&[("leaf", Value::from(2i64))])))]),
);
let out2 = compose_with_provenance(&[&elsewhere, &under]);
assert_eq!(
out2.attribution
.subtree_writes_of_layer_iter(&[s("root")], "elsewhere")
.next(),
None,
"writer active elsewhere but silent under the subtree ⇒ empty stream",
);
}
#[test]
fn subtree_writes_of_layer_iter_count_matches_subtree_leaf_count_of_layer() {
let out = subtree_fixture();
for prefix in [
vec![],
vec![s("breathe")],
vec![s("alpha")],
vec![s("nonexistent")],
] {
for layer in ["coarse", "specific", "never-declared"] {
let iter_count = out
.attribution
.subtree_writes_of_layer_iter(&prefix, layer)
.count();
let scalar_count = out.attribution.subtree_leaf_count_of_layer(&prefix, layer);
assert_eq!(
iter_count, scalar_count,
"iter.count() at prefix {prefix:?} equals subtree_leaf_count_of_layer({layer})",
);
}
}
}
#[test]
fn subtree_writes_of_layer_iter_clone_yields_independent_walks() {
let a = Fixed(
"A",
dict(&[(
"s",
Value::from(dict(&[
("a", Value::from(1i64)),
("b", Value::from(2i64)),
("c", Value::from(3i64)),
])),
)]),
);
let out = compose_with_provenance(&[&a]);
let prefix = vec![s("s")];
let mut walk_a = out.attribution.subtree_writes_of_layer_iter(&prefix, "A");
let first = walk_a.next();
assert_eq!(first, Some([s("s"), s("a")].as_slice()));
let mut walk_b = walk_a.clone();
assert_eq!(walk_a.next(), walk_b.next());
assert_eq!(walk_a.next(), walk_b.next());
assert_eq!(walk_a.next(), None);
assert_eq!(walk_b.next(), None);
let mut fresh = out.attribution.subtree_writes_of_layer_iter(&prefix, "A");
assert_eq!(fresh.next(), first);
}
#[test]
fn subtree_writes_of_layer_iter_is_fused_past_exhaustion() {
let out = subtree_fixture();
let prefix = vec![s("breathe")];
let mut it = out
.attribution
.subtree_writes_of_layer_iter(&prefix, "coarse");
while it.next().is_some() {}
for _ in 0..8 {
assert_eq!(it.next(), None, "fused past exhaustion (forward)");
}
}
#[test]
fn subtree_writes_of_layer_iter_head_short_circuits_without_full_sweep() {
let a = Fixed(
"target",
dict(&[("sub", Value::from(dict(&[("aaa", Value::from(1i64))])))]),
);
let b = Fixed(
"peer",
dict(&[(
"sub",
Value::from(dict(&[
("bbb", Value::from(2i64)),
("ccc", Value::from(3i64)),
("ddd", Value::from(4i64)),
])),
)]),
);
let out = compose_with_provenance(&[&a, &b]);
let prefix = [s("sub")];
let head = out
.attribution
.subtree_writes_of_layer_iter(&prefix, "target")
.next();
assert_eq!(head, Some([s("sub"), s("aaa")].as_slice()));
}
#[test]
fn subtree_writes_of_layer_iter_find_locates_positional_match() {
let a = Fixed(
"A",
dict(&[(
"sub",
Value::from(dict(&[
("aaa", Value::from(1i64)),
("mmm", Value::from(2i64)),
("zzz", Value::from(3i64)),
])),
)]),
);
let out = compose_with_provenance(&[&a]);
let prefix = [s("sub")];
let hit = out
.attribution
.subtree_writes_of_layer_iter(&prefix, "A")
.find(|p| p.last().is_some_and(|s| s == "mmm"));
assert_eq!(hit, Some([s("sub"), s("mmm")].as_slice()));
}
#[test]
fn subtree_writes_of_layer_iter_empty_attribution_is_empty_stream() {
let out = compose_with_provenance(&[]);
assert_eq!(
out.attribution
.subtree_writes_of_layer_iter(&[], "any")
.next(),
None,
);
assert_eq!(
out.attribution
.subtree_writes_of_layer_iter(&[s("root")], "any")
.next(),
None,
);
}
#[test]
fn from_iter_empty_source_produces_default_attribution() {
let empty: LayerAttribution = std::iter::empty::<(Vec<String>, &'static str)>().collect();
assert_eq!(empty, LayerAttribution::default());
assert!(empty.is_empty());
assert_eq!(empty.len(), 0);
}
#[test]
fn from_iter_roundtrips_through_owned_pairs() {
let out = subtree_fixture();
let round: LayerAttribution = (&out.attribution)
.into_iter()
.map(|(p, l)| (p.to_vec(), l))
.collect();
assert_eq!(round, out.attribution);
}
#[test]
fn from_iter_last_write_wins_at_duplicate_path() {
let attr: LayerAttribution = vec![
(vec![s("a")], "first"),
(vec![s("a")], "second"),
(vec![s("b")], "first"),
]
.into_iter()
.collect();
assert_eq!(attr.layer_of_owned(&[s("a")]), Some("second"));
assert_eq!(attr.layer_of_owned(&[s("b")]), Some("first"));
assert_eq!(attr.len(), 2);
}
#[test]
fn subtree_agrees_with_direct_from_iter_collect() {
let out = subtree_fixture();
let prefix = vec![s("breathe")];
let via_subtree = out.attribution.subtree(&prefix);
let via_from_iter: LayerAttribution = out
.attribution
.subtree_iter(&prefix)
.map(|(p, l)| (p.to_vec(), l))
.collect();
assert_eq!(via_subtree, via_from_iter);
}
#[test]
fn extend_appends_and_overwrites_prior_entries() {
let mut attr: LayerAttribution = vec![(vec![s("a")], "first"), (vec![s("b")], "first")]
.into_iter()
.collect();
attr.extend(vec![(vec![s("b")], "second"), (vec![s("c")], "second")]);
assert_eq!(attr.layer_of_owned(&[s("a")]), Some("first"));
assert_eq!(attr.layer_of_owned(&[s("b")]), Some("second"));
assert_eq!(attr.layer_of_owned(&[s("c")]), Some("second"));
assert_eq!(attr.len(), 3);
}
#[test]
fn extend_with_empty_source_preserves_attribution() {
let out = subtree_fixture();
let mut attr = out.attribution.clone();
attr.extend(std::iter::empty::<(Vec<String>, &'static str)>());
assert_eq!(attr, out.attribution);
}
#[test]
fn into_iter_owned_empty_attribution_is_empty_stream() {
let attr = LayerAttribution::default();
let mut iter = attr.into_iter();
assert_eq!(iter.len(), 0);
assert_eq!(iter.size_hint(), (0, Some(0)));
assert_eq!(iter.next(), None);
}
#[test]
fn into_iter_owned_yields_owned_pairs_in_lex_order() {
let out = subtree_fixture();
let borrowed: Vec<(Vec<String>, &'static str)> = (&out.attribution)
.into_iter()
.map(|(p, l)| (p.to_vec(), l))
.collect();
let owned: Vec<(Vec<String>, &'static str)> = out.attribution.into_iter().collect();
assert_eq!(borrowed, owned);
}
#[test]
fn into_iter_owned_len_equals_attribution_len() {
let out = subtree_fixture();
let expected = out.attribution.len();
let iter = out.attribution.into_iter();
assert_eq!(iter.len(), expected);
assert_eq!(iter.size_hint(), (expected, Some(expected)));
}
#[test]
fn into_iter_owned_collect_roundtrips_through_from_iter() {
let out = subtree_fixture();
let round: LayerAttribution = out.attribution.clone().into_iter().collect();
assert_eq!(round, out.attribution);
}
#[test]
fn into_iter_owned_reverse_walk_matches_iter_rev() {
let out = subtree_fixture();
let borrowed_rev: Vec<(Vec<String>, &'static str)> = out
.attribution
.iter()
.rev()
.map(|(p, l)| (p.to_vec(), l))
.collect();
let owned_rev: Vec<(Vec<String>, &'static str)> =
out.attribution.into_iter().rev().collect();
assert_eq!(borrowed_rev, owned_rev);
}
#[test]
fn into_iter_owned_by_value_for_loop_yields_owned_keys() {
let out = subtree_fixture();
let expected_len = out.attribution.len();
let mut collected: Vec<(Vec<String>, &'static str)> = Vec::new();
for (path, layer) in out.attribution {
collected.push((path, layer));
}
assert_eq!(collected.len(), expected_len);
let mut lex_sorted = collected.clone();
lex_sorted.sort_by(|a, b| a.0.cmp(&b.0));
assert_eq!(collected, lex_sorted);
}
#[test]
fn into_iter_owned_last_matches_iter_last() {
let out = subtree_fixture();
let borrow_last = out.attribution.iter().last().map(|(p, l)| (p.to_vec(), l));
let owned_last = out.attribution.into_iter().last();
assert_eq!(borrow_last, owned_last);
}
trait CloneBoxed {
fn clone_boxed(&self) -> Box<dyn DiscoveryLayer>;
}
impl CloneBoxed for Fixed {
fn clone_boxed(&self) -> Box<dyn DiscoveryLayer> {
Box::new(Fixed(self.0, self.1.clone()))
}
}
}