use alloc::rc::Rc;
use core::cell::RefCell;
use crate::error::Error;
#[derive(Clone, Debug, PartialEq)]
pub struct Unknown {
pub status: Rc<RefCell<Result<(), Error>>>,
pub unknown: Rc<RefCell<f64>>,
}
impl Unknown {
pub(crate) fn new() -> Self {
Unknown {
status: Rc::new(RefCell::new(Ok(()))),
unknown: Rc::new(RefCell::new(0.)),
}
}
pub(crate) fn new_with_value(unknown: Rc<RefCell<f64>>) -> Self {
Unknown {
status: Rc::new(RefCell::new(Ok(()))),
unknown,
}
}
pub fn get_status(&self) -> Result<(), Error> {
self.status.borrow().clone()
}
pub fn set_status(&self, status: Result<(), Error>) {
let current = self.status.borrow().clone();
*self.status.borrow_mut() = current.and(status);
}
}
#[cfg(test)]
mod tests {
use super::*;
#[allow(unused_imports)]
use alloc::format;
#[allow(unused_imports)]
use alloc::string::ToString;
#[test]
fn test_unknown_default_initialization() {
let u = Unknown::new();
assert_eq!(u.get_status(), Ok(()));
assert_eq!(*u.unknown.borrow(), 0.0);
}
#[test]
fn test_unknown_new_with_value() {
let cell = Rc::new(RefCell::new(12.5));
let u = Unknown::new_with_value(cell.clone());
assert_eq!(u.get_status(), Ok(()));
assert_eq!(*u.unknown.borrow(), 12.5);
*cell.borrow_mut() = 99.0;
assert_eq!(*u.unknown.borrow(), 99.0);
}
#[test]
fn test_unknown_shared_cell_mutation() {
let u1 = Unknown::new();
let u2 = u1.clone();
*u1.unknown.borrow_mut() = 42.0;
assert_eq!(*u2.unknown.borrow(), 42.0);
u2.set_status(Err(Error::DivisionByZero));
assert_eq!(u1.get_status(), Err(Error::DivisionByZero));
}
#[test]
fn test_unknown_error_latching_ok_does_not_clear() {
let u = Unknown::new();
assert_eq!(u.get_status(), Ok(()));
u.set_status(Err(Error::DivisionByZero));
assert_eq!(u.get_status(), Err(Error::DivisionByZero));
u.set_status(Ok(()));
assert_eq!(u.get_status(), Err(Error::DivisionByZero));
}
#[test]
fn test_unknown_error_latching_first_error_kept() {
let u = Unknown::new();
u.set_status(Err(Error::SquareForbidden));
assert_eq!(u.get_status(), Err(Error::SquareForbidden));
u.set_status(Err(Error::UnknownInDenominator));
assert_eq!(u.get_status(), Err(Error::SquareForbidden));
}
#[test]
fn test_unknown_partial_eq() {
let cell1 = Rc::new(RefCell::new(5.0));
let cell2 = Rc::new(RefCell::new(5.0));
let cell3 = Rc::new(RefCell::new(6.0));
let u1 = Unknown::new_with_value(cell1);
let u2 = Unknown::new_with_value(cell2);
let u3 = Unknown::new_with_value(cell3);
assert_eq!(u1, u2);
assert_ne!(u1, u3);
u1.set_status(Err(Error::NoUnknown));
assert_ne!(u1, u2);
}
}