use std::fmt;
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum CorrectnessError {
PredicateFailed {
message: String,
},
EmptyString {
param: String,
},
WhitespaceString {
param: String,
},
NonAsciiString {
param: String,
value: String,
},
NotPositive {
param: String,
value: String,
type_name: &'static str,
},
OutOfRange {
param: String,
value: String,
min: String,
max: String,
},
}
impl fmt::Display for CorrectnessError {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
Self::PredicateFailed { message } => write!(f, "condition failed: {message}"),
Self::EmptyString { param } => write!(f, "invalid string for '{param}', was empty"),
Self::WhitespaceString { param } => {
write!(f, "invalid string for '{param}', was all whitespace")
}
Self::NonAsciiString { param, value } => write!(
f,
"invalid string for '{param}' contained a non-ASCII char, was '{value}'"
),
Self::NotPositive {
param,
value,
type_name,
} => write!(f, "invalid {type_name} for '{param}' not positive, was {value}"),
Self::OutOfRange {
param,
value,
min,
max,
} => write!(
f,
"invalid value for '{param}' out of range [{min}, {max}], was {value}"
),
}
}
}
impl std::error::Error for CorrectnessError {}
pub type CorrectnessResult<T> = Result<T, CorrectnessError>;
pub fn check_predicate_true(cond: bool, message: impl Into<String>) -> CorrectnessResult<()> {
if cond {
Ok(())
} else {
Err(CorrectnessError::PredicateFailed {
message: message.into(),
})
}
}
pub fn check_positive_usize(value: usize, param: &str) -> CorrectnessResult<()> {
if value > 0 {
Ok(())
} else {
Err(CorrectnessError::NotPositive {
param: param.to_string(),
value: value.to_string(),
type_name: "usize",
})
}
}
pub fn check_positive_u64(value: u64, param: &str) -> CorrectnessResult<()> {
if value > 0 {
Ok(())
} else {
Err(CorrectnessError::NotPositive {
param: param.to_string(),
value: value.to_string(),
type_name: "u64",
})
}
}
pub fn check_non_empty_str(value: &str, param: &str) -> CorrectnessResult<()> {
if value.is_empty() {
Err(CorrectnessError::EmptyString {
param: param.to_string(),
})
} else {
Ok(())
}
}
pub fn check_not_blank_str(value: &str, param: &str) -> CorrectnessResult<()> {
check_non_empty_str(value, param)?;
if value.trim().is_empty() {
Err(CorrectnessError::WhitespaceString {
param: param.to_string(),
})
} else {
Ok(())
}
}
pub fn check_ascii_str(value: &str, param: &str) -> CorrectnessResult<()> {
if value.is_ascii() {
Ok(())
} else {
Err(CorrectnessError::NonAsciiString {
param: param.to_string(),
value: value.to_string(),
})
}
}
pub fn check_in_range_f64(value: f64, min: f64, max: f64, param: &str) -> CorrectnessResult<()> {
if value.is_nan() || value < min || value > max {
Err(CorrectnessError::OutOfRange {
param: param.to_string(),
value: value.to_string(),
min: min.to_string(),
max: max.to_string(),
})
} else {
Ok(())
}
}
pub fn check_in_range_usize(value: usize, min: usize, max: usize, param: &str) -> CorrectnessResult<()> {
if value < min || value > max {
Err(CorrectnessError::OutOfRange {
param: param.to_string(),
value: value.to_string(),
min: min.to_string(),
max: max.to_string(),
})
} else {
Ok(())
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn predicate_true_ok_and_err() {
assert!(check_predicate_true(true, "x").is_ok());
let e = check_predicate_true(false, "delay must be non-zero").unwrap_err();
assert_eq!(e.to_string(), "condition failed: delay must be non-zero");
}
#[test]
fn positive_checks() {
assert!(check_positive_usize(1, "n").is_ok());
assert!(matches!(
check_positive_usize(0, "capacity"),
Err(CorrectnessError::NotPositive { .. })
));
assert!(check_positive_u64(7, "jitter").is_ok());
assert!(check_positive_u64(0, "jitter").is_err());
}
#[test]
fn string_checks() {
assert!(check_non_empty_str("a", "s").is_ok());
assert!(check_non_empty_str("", "s").is_err());
assert!(check_not_blank_str(" ", "s").is_err());
assert!(check_not_blank_str(" a ", "s").is_ok());
assert!(check_ascii_str("abc*", "s").is_ok());
assert!(check_ascii_str("中文", "s").is_err());
}
#[test]
fn range_checks() {
assert!(check_in_range_f64(2.0, 1.0, 100.0, "factor").is_ok());
assert!(check_in_range_f64(150.0, 1.0, 100.0, "factor").is_err());
assert!(check_in_range_f64(f64::NAN, 1.0, 100.0, "factor").is_err());
assert!(check_in_range_usize(5, 1, 5, "n").is_ok());
assert!(check_in_range_usize(6, 1, 5, "n").is_err());
}
}