#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
#[non_exhaustive]
pub enum NoTree {
UnknownClass,
NoEntry,
NoReleaseRoot,
NoVersion,
}
const _: () = crate::send_sync::<NoTree>();
impl NoTree {
#[must_use]
pub fn exception(self) -> &'static str {
match self {
Self::UnknownClass => "KeyError",
Self::NoEntry => "ValueError",
Self::NoReleaseRoot => "AssertionError",
Self::NoVersion => "NotImplementedError",
}
}
}
#[cfg(test)]
mod tests {
use std::sync::Arc;
use super::NoTree;
use crate::provider::{ProviderChain, ProviderError, TreeRequest, TypeTreeProvider};
use crate::typetree::Tree;
use crate::version::UnityVersion;
#[derive(Debug)]
struct Says(Option<NoTree>);
impl TypeTreeProvider for Says {
fn name(&self) -> &'static str {
"says"
}
fn tree(&self, _: &TreeRequest<'_>) -> Result<Option<Arc<Tree>>, ProviderError> {
Ok(None)
}
fn why_none(&self, _: i32, _: Option<&UnityVersion>) -> Option<NoTree> {
self.0
}
}
#[derive(Debug)]
struct Silent;
impl TypeTreeProvider for Silent {
fn name(&self) -> &'static str {
"silent"
}
fn tree(&self, _: &TreeRequest<'_>) -> Result<Option<Arc<Tree>>, ProviderError> {
Ok(None)
}
}
fn chain(providers: Vec<Arc<dyn TypeTreeProvider>>) -> ProviderChain {
ProviderChain::new(providers)
}
#[test]
fn the_chains_reason_is_the_last_stated() {
let v = UnityVersion::from_packed(2 << 48);
let key = || -> Arc<dyn TypeTreeProvider> { Arc::new(Says(Some(NoTree::UnknownClass))) };
let value = || -> Arc<dyn TypeTreeProvider> { Arc::new(Says(Some(NoTree::NoEntry))) };
let why = |c: &ProviderChain| (c.why_none(7, Some(&v)), c.why_none(7, None));
let both = |w: Option<NoTree>| (w, w);
assert_eq!(why(&chain(vec![])), both(None));
assert_eq!(why(&chain(vec![Arc::new(Silent)])), both(None));
assert_eq!(
why(&chain(vec![key(), value()])),
both(Some(NoTree::NoEntry))
);
assert_eq!(
why(&chain(vec![value(), key()])),
both(Some(NoTree::UnknownClass))
);
let last_silent = chain(vec![key(), Arc::new(Silent)]);
assert_eq!(why(&last_silent), both(Some(NoTree::UnknownClass)));
}
}