use serde::Serialize;
#[derive(Debug, Clone, Copy, Default, PartialEq, Eq)]
#[non_exhaustive]
pub enum CaseRequirement {
#[default]
Functional,
Exact,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize)]
pub struct CaseMetadata {
id: &'static str,
#[serde(skip_serializing_if = "Option::is_none")]
source_test: Option<&'static str>,
spec_references: &'static [&'static str],
#[serde(skip)]
requirement: CaseRequirement,
}
impl CaseMetadata {
pub(crate) const fn new(
id: &'static str,
source_test: &'static str,
spec_references: &'static [&'static str],
) -> Self {
Self {
id,
source_test: Some(source_test),
spec_references,
requirement: CaseRequirement::Functional,
}
}
pub const fn id(self) -> &'static str {
self.id
}
pub const fn source_test(self) -> Option<&'static str> {
self.source_test
}
pub(crate) const fn closure(
id: &'static str,
spec_references: &'static [&'static str],
) -> Self {
Self {
id,
source_test: None,
spec_references,
requirement: CaseRequirement::Functional,
}
}
pub(crate) const fn exact(id: &'static str, spec_references: &'static [&'static str]) -> Self {
Self {
id,
source_test: None,
spec_references,
requirement: CaseRequirement::Exact,
}
}
pub const fn spec_references(self) -> &'static [&'static str] {
self.spec_references
}
pub const fn requirement(self) -> CaseRequirement {
self.requirement
}
}
pub(crate) type CaseFn = fn();
#[derive(Clone, Copy)]
pub(crate) struct CaseDefinition {
pub metadata: CaseMetadata,
pub run: Option<CaseFn>,
pub skip_reason: Option<&'static str>,
}
impl CaseDefinition {
pub const fn new(metadata: CaseMetadata, run: CaseFn) -> Self {
Self {
metadata,
run: Some(run),
skip_reason: None,
}
}
pub const fn skipped(metadata: CaseMetadata, reason: &'static str) -> Self {
Self {
metadata,
run: None,
skip_reason: Some(reason),
}
}
}