rpn_cli/calc/

value.rs

use crate::calc::context::{Context, Format};
use crate::calc::meaning::Meaning;
use crate::error::MyResult;
use crate::regex;
use crate::util::text::{create_padding, remove_char};
use big_rational_str::BigRationalExt;
use chrono::{DateTime, Duration, NaiveDateTime};
use itertools::Itertools;
use num::traits::Inv;
use num::*;
use regex::{Captures, Match};
use std::cell::RefCell;
use std::cmp::Ordering;
use std::fmt::{Debug, Formatter};
use std::iter::zip;
use std::ops::{BitAnd, BitOr, BitXor, Div, Mul, Sub};
use std::rc::Rc;
use std::time::SystemTime;

pub type ValueRef = Rc<RefCell<Value>>;

#[derive(PartialEq)]
pub struct Value {
    pub number: Option<BigRational>,
    pub meaning: Meaning,
    pub variable: Option<String>,
    pub comment: Option<String>,
}

const CHUNK_DIGITS: usize = 8;
const CHUNK_VALUE: usize = 0x1_0000_0000;
const ROUNDING_LIMIT: usize = 6;

// noinspection RsLift
impl Value {
    pub const fn new(number: Option<BigRational>) -> Self {
        Self {
            number,
            meaning: Meaning::Plain,
            variable: None,
            comment: None,
        }
    }

    pub fn with_meaning(mut self, meaning: Meaning) -> Self {
        self.meaning = meaning;
        self
    }

    pub fn set_meaning(&mut self, meaning: Meaning) {
        self.meaning = meaning;
    }

    pub fn with_variable(mut self, variable: &str) -> Self {
        self.variable = Some(String::from(variable));
        self
    }

    pub fn set_variable(&mut self, variable: &str) {
        self.variable = Some(String::from(variable));
    }

    pub fn with_comment(mut self, comment: &str) -> Self {
        self.comment = Some(String::from(comment));
        self
    }

    pub fn set_comment(&mut self, comment: &str) {
        self.comment = Some(String::from(comment));
    }

    fn with_rounding(mut self) -> Self {
        if let Some(number) = &self.number {
            if let Some(multiplier) = Self::measure_multiplier(number) {
                if let Some(number) = number.checked_mul(&multiplier) {
                    let number = number.round();
                    if let Some(number) = number.checked_div(&multiplier) {
                        self.number = Some(number);
                    }
                }
            }
        }
        self
    }

    fn measure_multiplier(number: &BigRational) -> Option<BigRational> {
        let string = big_rational_str::big_rational_ref_to_string(number);
        if let Some(period) = string.find('.') {
            let string = remove_char(&string, period);
            for offset in 1..=ROUNDING_LIMIT {
                if let Some((start, count)) = Self::measure_offset(&string, offset) {
                    if let Some(start) = start.checked_sub(period) {
                        if let Some(remain) = string.len().checked_sub(start + count) {
                            if remain >= count * 2 {
                                let multiplier = BigInt::from(10)
                                    .pow(start as u32);
                                let multiplier = BigInt::from(10)
                                    .pow(offset as u32)
                                    .sub(&BigInt::from(1))
                                    .mul(&multiplier);
                                return Some(BigRational::from_integer(multiplier));
                            }
                        }
                    }
                }
            }
        }
        None
    }

    // Span:      <------->
    // Left:  19994564564564564832246034753933155512726838401327...
    // Right: 94564564564564832246034753933155512726838401327630...

    fn measure_offset(string: &str, offset: usize) -> Option<(usize, usize)> {
        let left = string.chars();
        let right = string.chars().skip(offset);
        let mut span = None;
        for (index, (left, right)) in zip(left, right).enumerate() {
            if let Some((start, count)) = span {
                if left == right {
                    span = Some((start, count + 1));
                } else if count >= ROUNDING_LIMIT {
                    return span;
                } else {
                    span = None;
                }
            } else {
                if left == right {
                    span = Some((index, 0));
                }
            }
        }
        None
    }

    pub fn from_string(number: &str) -> MyResult<Self> {
        if number.starts_with("0x") || number.starts_with("0X") {
            Self::from_hexadecimal(&number[2..])
        } else if let Some(value) = Self::from_time(number) {
            Ok(value)
        } else if let Some(value) = Self::from_delta(number) {
            Ok(value)
        } else if let Some(number) = number.strip_prefix(".") {
            let number = format!("0.{}", number);
            Self::from_decimal(&number)
        } else if let Some(number) = number.strip_prefix("-.") {
            let number = format!("-0.{}", number);
            Self::from_decimal(&number)
        } else {
            Self::from_decimal(number)
        }
    }

    fn from_time(time: &str) -> Option<Self> {
        if let Some(time) = Self::parse_time(time) {
            let numer = time.and_utc().timestamp_millis();
            let numer = BigInt::from(numer);
            let denom = BigInt::from(1000);
            let number = BigRational::new(numer, denom);
            let value = Self::new(Some(number)).with_meaning(Meaning::Time);
            return Some(value);
        }
        None
    }

    fn parse_time(time: &str) -> Option<NaiveDateTime> {
        let regex = regex!(r#"^(\d+-\d+-\d+T\d+:\d+(:\d+(\.\d+)?)?)Z?$"#);
        if let Some(captures) = regex.captures(time) {
            let time = captures.get(1).as_ref().map(Match::as_str).unwrap_or_default();
            let format = if captures.get(2).is_none() {
                "%Y-%m-%dT%H:%M"
            } else if captures.get(3).is_none() {
                "%Y-%m-%dT%H:%M:%S"
            } else {
                "%Y-%m-%dT%H:%M:%S%.f" // "%.f" not ".%f"
            };
            return NaiveDateTime::parse_from_str(time, format).ok();
        }
        None
    }

    fn from_delta(delta: &str) -> Option<Self> {
        if let Some(delta) = Self::parse_delta(delta) {
            let numer = delta.num_milliseconds();
            let numer = BigInt::from(numer);
            let denom = BigInt::from(1000);
            let number = BigRational::new(numer, denom);
            let value = Self::new(Some(number)).with_meaning(Meaning::Delta);
            return Some(value);
        }
        None
    }

    fn parse_delta(delta: &str) -> Option<Duration> {
        let regex = regex!(r#"^(-)?(?:(?:(\d+)[T:])?(\d+):)?(\d+):(\d+)(?:\.(\d+))?$"#);
        if let Some(captures) = regex.captures(delta) {
            let negative = captures.get(1).is_some();
            let days = Self::parse_capture(&captures, 2, None);
            let hours = Self::parse_capture(&captures, 3, None) + (days * 24);
            let minutes = Self::parse_capture(&captures, 4, None) + (hours * 60);
            let seconds = Self::parse_capture(&captures, 5, None) + (minutes * 60);
            let nanos = Self::parse_capture(&captures, 6, Some(9)) + (seconds * 1_000_000_000);
            let delta = Duration::nanoseconds(nanos);
            let delta = if negative { -delta } else { delta };
            return Some(delta);
        }
        None
    }

    fn parse_capture(captures: &Captures, index: usize, expected: Option<usize>) -> i64 {
        if let Some(capture) = captures.get(index) {
            let number = capture.as_str().parse::<i64>().unwrap_or_default();
            if let Some(expected) = expected {
                let length = capture.as_str().len();
                if let Some(diff) = expected.checked_sub(length) {
                    return number * pow(10, diff);
                }
                if let Some(diff) = length.checked_sub(expected) {
                    return number / pow(10, diff);
                }
            }
            return number;
        }
        0
    }

    fn from_decimal(number: &str) -> MyResult<Self> {
        let number = number.replace(&[',', '_'], "");
        let number = BigRational::from_dec_str(&number)?;
        let value = Self::new(Some(number));
        Ok(value)
    }

    fn from_hexadecimal(number: &str) -> MyResult<Self> {
        let number = number.replace(&[',', '_'], "");
        let number = BigInt::from_str_radix(&number, 16)?;
        let number = BigRational::from_integer(number);
        let value = Self::new(Some(number));
        Ok(value)
    }

    pub fn to_strings(&self, context: &Context) -> (String, String, Option<String>, Option<String>) {
        if let Some(number) = &self.number {
            self.format_ratio(context, number)
        } else {
            (String::from("NaN"), String::from(""), self.variable.clone(), self.comment.clone())
        }
    }

    fn format_ratio(
        &self,
        context: &Context,
        number: &BigRational,
    ) -> (String, String, Option<String>, Option<String>) {
        if self.meaning == Meaning::Time {
            let number = number * BigInt::from(1000);
            let number = number.to_i64().unwrap_or_default();
            let number = Self::format_time(number);
            self.format_split(context, number)
        } else if self.meaning == Meaning::Delta {
            let number = number * BigInt::from(1000);
            let number = number.to_i64().unwrap_or_default();
            let number = Self::format_delta(number);
            self.format_split(context, number)
        } else if let Format::Base16(chunks) = context.format {
            let number = number.to_integer();
            let number = Self::format_hexadecimal(number, chunks, context.sep);
            (number, String::from(""), self.variable.clone(), self.comment.clone())
        } else if let Some(dp) = context.dp {
            let power = BigInt::from(10).pow(dp as u32);
            let number = number.mul(&power).round().div(&power);
            let number = big_rational_str::big_rational_to_string(number);
            self.format_split(context, number)
        } else {
            let number = big_rational_str::big_rational_ref_to_string(number);
            self.format_split(context, number)
        }
    }

    fn format_time(millis: i64) -> String {
        let time = DateTime::from_timestamp_millis(millis).unwrap_or_default();
        time.format("%Y-%m-%dT%H:%M:%S%.3fZ").to_string()
    }

    fn format_delta(millis: i64) -> String {
        let (minus, millis) = (if millis < 0 { "-" } else { "" }, abs(millis));
        let (seconds, millis) = (millis / 1000, millis % 1000);
        let (minutes, seconds) = (seconds / 60, seconds % 60);
        let (hours, minutes) = (minutes / 60, minutes % 60);
        let (days, hours) = (hours / 24, hours % 24);
        if days != 0 {
            format!("{}{}T{:02}:{:02}:{:02}.{:03}", minus, days, hours, minutes, seconds, millis)
        } else if hours != 0 {
            format!("{}{:02}:{:02}:{:02}.{:03}", minus, hours, minutes, seconds, millis)
        } else if minutes != 0 {
            format!("{}{:02}:{:02}.{:03}", minus, minutes, seconds, millis)
        } else {
            format!("{}{:02}.{:03}", minus, seconds, millis)
        }
    }

    fn format_hexadecimal(
        mut number: BigInt,
        chunks: usize,
        sep: bool,
    ) -> String {
        if number.is_negative() {
            let range = BigInt::from(CHUNK_VALUE).pow(chunks as u32);
            number += range;
        }
        let number = format!("{:x}", number);
        let padding = create_padding('0', chunks * CHUNK_DIGITS, number.len(), 0);
        if sep {
            let number = format!("{}{}", padding, number);
            let chunks = number.as_bytes()
                .chunks(CHUNK_DIGITS)
                .map(std::str::from_utf8);
            std::iter::once(Ok("0x"))
                .chain(chunks)
                .collect::<Result<Vec<&str>, _>>()
                .unwrap_or_default()
                .join(",")
        } else {
            format!("0x{}{}", padding, number)
        }
    }

    fn format_split(
        &self,
        context: &Context,
        number: String,
    ) -> (String, String, Option<String>, Option<String>) {
        let index = number.find('.').unwrap_or(number.len());
        let (integer, fraction) = number.split_at(index);
        let integer = self.modify_integer(context, integer);
        let fraction = self.modify_fraction(context, fraction);
        (integer, fraction, self.variable.clone(), self.comment.clone())
    }

    fn modify_integer(&self, context: &Context, number: &str) -> String {
        if self.meaning == Meaning::Plain && context.sep {
            let index = if number.starts_with('-') { 1 } else { 0 };
            let (sign, number) = number.split_at(index);
            let number = number.as_bytes()
                .rchunks(3)
                .rev()
                .map(std::str::from_utf8)
                .collect::<Result<Vec<&str>, _>>()
                .unwrap_or_default()
                .join(",");
            return format!("{}{}", sign, number);
        }
        String::from(number)
    }

    fn modify_fraction(&self, context: &Context, number: &str) -> String {
        if self.meaning == Meaning::Plain {
            if let Some(dp) = context.dp {
                if !number.is_empty() || dp > 0 {
                    let index = if number.starts_with('.') { 1 } else { 0 };
                    let number = &number[index..];
                    let dp = dp as usize;
                    return ".".chars()
                        .chain(number.chars().take(dp))
                        .chain(std::iter::repeat('0'))
                        .take(dp + 1)
                        .collect::<String>();
                }
            }
        }
        String::from(number)
    }

    pub fn measure_hexadecimal(&self) -> usize {
        if let Some(number) = &self.number {
            let number = number.to_integer();
            Self::count_hexadecimal(number)
        } else {
            1
        }
    }

    fn count_hexadecimal(mut number: BigInt) -> usize {
        if number.is_negative() {
            number = number.abs() - 1;
        }
        let count = number.iter_u32_digits().count().max(1);
        let chunk = number.iter_u32_digits().last().unwrap_or_default();
        if chunk & 0x80000000 != 0 { count + 1 } else { count }
    }

    fn perform_unary(
        value: ValueRef,
        meaning: Meaning,
        function: fn(&BigRational) -> Option<BigRational>,
    ) -> ValueRef {
        if let Some(number) = &value.borrow().number {
            let result = Self::new(function(number)).with_rounding().with_meaning(meaning);
            return Rc::new(RefCell::new(result));
        }
        value
    }

    fn perform_binary(
        lhs: ValueRef,
        rhs: ValueRef,
        meaning: Meaning,
        function: fn(&BigRational, &BigRational) -> Option<BigRational>,
    ) -> ValueRef {
        if let Some(lhs) = &lhs.borrow().number {
            if let Some(rhs) = &rhs.borrow().number {
                let result = Self::new(function(lhs, rhs)).with_rounding().with_meaning(meaning);
                return Rc::new(RefCell::new(result));
            }
            return rhs;
        }
        lhs
    }

    //       | Plain Delta Time
    // ------+------------------
    // Plain | Plain Delta Time
    // Delta | Delta Delta Time
    // Time  | Time  Time    -

    pub fn calc_add(lhs: ValueRef, rhs: ValueRef) -> MyResult<ValueRef> {
        let meaning = lhs.borrow().meaning.combine(rhs.borrow().meaning, Meaning::pdt, Meaning::ddt, Meaning::ttx)?;
        let result = Self::perform_binary(lhs, rhs, meaning, |x, y| x.checked_add(&y));
        Ok(result)
    }

    //       | Plain Delta Time
    // ------+------------------
    // Plain | Plain Delta   -
    // Delta | Delta Delta   -
    // Time  | Time  Time  Delta

    pub fn calc_sub(lhs: ValueRef, rhs: ValueRef) -> MyResult<ValueRef> {
        let meaning = lhs.borrow().meaning.combine(rhs.borrow().meaning, Meaning::pdx, Meaning::ddx, Meaning::ttd)?;
        let result = Self::perform_binary(lhs, rhs, meaning, |x, y| x.checked_sub(&y));
        Ok(result)
    }

    //       | Plain Delta Time
    // ------+------------------
    // Plain | Plain Delta   -
    // Delta | Delta   -     -
    // Time  |   -     -     -

    pub fn calc_mul(lhs: ValueRef, rhs: ValueRef) -> MyResult<ValueRef> {
        let meaning = lhs.borrow().meaning.combine(rhs.borrow().meaning, Meaning::pdx, Meaning::dxx, Meaning::xxx)?;
        let result = Self::perform_binary(lhs, rhs, meaning, |x, y| x.checked_mul(&y));
        Ok(result)
    }

    //       | Plain Delta Time
    // ------+------------------
    // Plain | Plain   -     -
    // Delta | Delta   -     -
    // Time  |   -     -     -

    pub fn calc_div(lhs: ValueRef, rhs: ValueRef) -> MyResult<ValueRef> {
        let meaning = lhs.borrow().meaning.combine(rhs.borrow().meaning, Meaning::pxx, Meaning::dxx, Meaning::xxx)?;
        let result = Self::perform_binary(lhs, rhs, meaning, |x, y| x.checked_div(&y));
        Ok(result)
    }

    pub fn calc_mod(lhs: ValueRef, rhs: ValueRef) -> MyResult<ValueRef> {
        let meaning = lhs.borrow().meaning.combine(rhs.borrow().meaning, Meaning::pxx, Meaning::dxx, Meaning::xxx)?;
        let result = Self::perform_binary(lhs, rhs, meaning, Self::checked_mod);
        Ok(result)
    }

    fn checked_mod(lhs: &BigRational, rhs: &BigRational) -> Option<BigRational> {
        lhs.checked_div(rhs)
            .map(|result| &result - result.to_integer())
            .map(|result| result * rhs)
    }

    // Plain | Plain
    // Delta | Delta
    // Time  |   -

    pub fn calc_neg(value: ValueRef) -> MyResult<ValueRef> {
        let meaning = value.borrow().meaning.pdx()?;
        let result = Self::perform_unary(value, meaning, |x| Some(-x));
        Ok(result)
    }

    // Plain | Plain
    // Delta |   -
    // Time  |   -

    pub fn calc_inv(value: ValueRef) -> MyResult<ValueRef> {
        let meaning = value.borrow().meaning.pxx()?;
        let result = Self::perform_unary(value, meaning, Self::checked_inv);
        Ok(result)
    }

    fn checked_inv(number: &BigRational) -> Option<BigRational> {
        if number.is_zero() { None } else { Some(number.inv()) }
    }

    //       | Plain Delta Time
    // ------+------------------
    // Plain | Plain   -     -
    // Delta |   -     -     -
    // Time  |   -     -     -

    pub fn calc_pow(lhs: ValueRef, rhs: ValueRef) -> MyResult<ValueRef> {
        let meaning = lhs.borrow().meaning.combine(rhs.borrow().meaning, Meaning::pxx, Meaning::xxx, Meaning::xxx)?;
        let result = Self::perform_binary(lhs, rhs, meaning, Self::checked_pow);
        Ok(result)
    }

    fn checked_pow(lhs: &BigRational, rhs: &BigRational) -> Option<BigRational> {
        if rhs.is_integer() {
            if let Some(rhs) = rhs.to_i32() {
                return Some(lhs.pow(rhs));
            }
        } else {
            if let Some(lhs) = lhs.to_f64() {
                if let Some(rhs) = rhs.to_f64() {
                    let result = f64::powf(lhs, rhs);
                    return BigRational::from_f64(result);
                }
            }
        }
        None
    }

    // Plain | Plain
    // Delta |   -
    // Time  |   -

    pub fn calc_sqrt(value: ValueRef) -> MyResult<ValueRef> {
        let meaning = value.borrow().meaning.pxx()?;
        let result = Self::perform_unary(value, meaning, Self::checked_sqrt);
        Ok(result)
    }

    fn checked_sqrt(number: &BigRational) -> Option<BigRational> {
        if let Some(number) = number.to_f64() {
            let result = number.sqrt();
            return BigRational::from_f64(result);
        }
        None
    }

    pub fn calc_sum(values: Vec<ValueRef>) -> MyResult<ValueRef> {
        let mut result = BigRational::from(BigInt::zero());
        for value in values {
            if let Some(number) = &value.borrow().number {
                result += number;
            }
        }
        let result = Self::new(Some(result)).with_rounding();
        Ok(Rc::new(RefCell::new(result)))
    }

    pub fn calc_prod(values: Vec<ValueRef>) -> MyResult<ValueRef> {
        let mut result = BigRational::from(BigInt::one());
        for value in values {
            if let Some(number) = &value.borrow().number {
                result *= number;
            }
        }
        let result = Self::new(Some(result)).with_rounding();
        Ok(Rc::new(RefCell::new(result)))
    }

    pub fn calc_seq(start: ValueRef, stop: ValueRef) -> MyResult<Vec<ValueRef>> {
        let mut values = Vec::new();
        let meaning = start.borrow().meaning;
        if let Some(start) = &start.borrow().number {
            if let Some(stop) = &stop.borrow().number {
                let step = BigRational::one();
                Self::inner_step(&mut values, meaning, start, &step, stop);
            }
        }
        Ok(values)
    }

    pub fn calc_step(start: ValueRef, step: ValueRef, stop: ValueRef) -> MyResult<Vec<ValueRef>> {
        let mut values = Vec::new();
        let meaning = start.borrow().meaning;
        if let Some(start) = &start.borrow().number {
            if let Some(step) = &step.borrow().number {
                if let Some(stop) = &stop.borrow().number {
                    let step = step.abs();
                    Self::inner_step(&mut values, meaning, start, &step, stop);
                }
            }
        }
        Ok(values)
    }

    fn inner_step(
        values: &mut Vec<ValueRef>,
        meaning: Meaning,
        start: &BigRational,
        step: &BigRational,
        stop: &BigRational,
    ) {
        let mut number = start.clone();
        Self::inner_push(values, meaning, &number);
        if step.is_positive() {
            if number <= *stop {
                loop {
                    number += step;
                    if number > *stop { break }
                    Self::inner_push(values, meaning, &number);
                }
            } else {
                loop {
                    number -= step;
                    if number < *stop { break }
                    Self::inner_push(values, meaning, &number);
                }
            }
        }
    }

    fn inner_push(
        values: &mut Vec<ValueRef>,
        meaning: Meaning,
        number: &BigRational,
    ) {
        let number = number.clone();
        let value = Self::new(Some(number)).with_meaning(meaning);
        values.push(Rc::new(RefCell::new(value)));
    }

    pub fn sort_seq(values: Vec<ValueRef>) -> MyResult<Vec<ValueRef>> {
        let results = values.into_iter().sorted_by(Self::cmp_values).collect();
        Ok(results)
    }

    pub fn rev_seq(values: Vec<ValueRef>) -> MyResult<Vec<ValueRef>> {
        let results = values.into_iter().rev().collect();
        Ok(results)
    }

    fn cmp_values(lhs: &ValueRef, rhs: &ValueRef) -> Ordering {
        let lhs = &lhs.borrow().number;
        let rhs = &rhs.borrow().number;
        match (lhs, rhs) {
            (Some(lhs), Some(rhs)) => BigRational::cmp(lhs, rhs),
            (Some(_), None) => Ordering::Greater,
            (None, Some(_)) => Ordering::Less,
            (None, None) => Ordering::Equal,
        }
    }

    //       | Plain Delta Time
    // ------+------------------
    // Plain | Plain   -     -
    // Delta |   -     -     -
    // Time  |   -     -     -

    pub fn calc_and(lhs: ValueRef, rhs: ValueRef) -> MyResult<ValueRef> {
        let meaning = lhs.borrow().meaning.combine(rhs.borrow().meaning, Meaning::pxx, Meaning::xxx, Meaning::xxx)?;
        let result = Self::perform_binary(lhs, rhs, meaning, Self::checked_and);
        Ok(result)
    }

    pub fn calc_or(lhs: ValueRef, rhs: ValueRef) -> MyResult<ValueRef> {
        let meaning = lhs.borrow().meaning.combine(rhs.borrow().meaning, Meaning::pxx, Meaning::xxx, Meaning::xxx)?;
        let result = Self::perform_binary(lhs, rhs, meaning, Self::checked_or);
        Ok(result)
    }

    pub fn calc_xor(lhs: ValueRef, rhs: ValueRef) -> MyResult<ValueRef> {
        let meaning = lhs.borrow().meaning.combine(rhs.borrow().meaning, Meaning::pxx, Meaning::xxx, Meaning::xxx)?;
        let result = Self::perform_binary(lhs, rhs, meaning, Self::checked_xor);
        Ok(result)
    }

    fn checked_and(lhs: &BigRational, rhs: &BigRational) -> Option<BigRational> {
        let lhs = lhs.to_integer();
        let rhs = rhs.to_integer();
        let result = lhs.bitand(rhs);
        Some(BigRational::from(result))
    }

    fn checked_or(lhs: &BigRational, rhs: &BigRational) -> Option<BigRational> {
        let lhs = lhs.to_integer();
        let rhs = rhs.to_integer();
        let result = lhs.bitor(rhs);
        Some(BigRational::from(result))
    }

    fn checked_xor(lhs: &BigRational, rhs: &BigRational) -> Option<BigRational> {
        let lhs = lhs.to_integer();
        let rhs = rhs.to_integer();
        let result = lhs.bitxor(rhs);
        Some(BigRational::from(result))
    }

    pub fn calc_shl(lhs: ValueRef, rhs: ValueRef) -> MyResult<ValueRef> {
        let meaning = lhs.borrow().meaning.combine(rhs.borrow().meaning, Meaning::pxx, Meaning::xxx, Meaning::xxx)?;
        let result = Self::perform_binary(lhs, rhs, meaning, |x, y| Self::checked_shl(x, y));
        Ok(result)
    }

    pub fn calc_shr(lhs: ValueRef, rhs: ValueRef) -> MyResult<ValueRef> {
        let meaning = lhs.borrow().meaning.combine(rhs.borrow().meaning, Meaning::pxx, Meaning::xxx, Meaning::xxx)?;
        let result = Self::perform_binary(lhs, rhs, meaning, |x, y| Self::checked_shr(x, y));
        Ok(result)
    }

    fn checked_shl(lhs: &BigRational, rhs: &BigRational) -> Option<BigRational> {
        if let Some(rhs) = rhs.to_i32() {
            let two = BigRational::new(BigInt::from(2), BigInt::from(1));
            Some(lhs * two.pow(rhs))
        } else {
            None
        }
    }

    fn checked_shr(lhs: &BigRational, rhs: &BigRational) -> Option<BigRational> {
        if let Some(rhs) = rhs.to_i32() {
            let two = BigRational::new(BigInt::from(2), BigInt::from(1));
            Some(lhs * two.pow(-rhs))
        } else {
            None
        }
    }

    pub fn calc_now(time: &Option<SystemTime>) -> MyResult<ValueRef> {
        let time = time.unwrap_or_else(SystemTime::now)
            .duration_since(SystemTime::UNIX_EPOCH)
            .unwrap_or_default()
            .as_millis();
        let numer = BigInt::from(time);
        let denom = BigInt::from(1000);
        let number = BigRational::new(numer, denom);
        let result = Self::new(Some(number)).with_meaning(Meaning::Time);
        Ok(Rc::new(RefCell::new(result)))
    }

    pub fn cast_plain(value: ValueRef) -> MyResult<ValueRef> {
        let result = value.borrow().clone().with_meaning(Meaning::Plain);
        Ok(Rc::new(RefCell::new(result)))
    }

    pub fn cast_delta(value: ValueRef) -> MyResult<ValueRef> {
        let result = value.borrow().clone().with_meaning(Meaning::Delta);
        Ok(Rc::new(RefCell::new(result)))
    }

    pub fn cast_time(value: ValueRef) -> MyResult<ValueRef> {
        let result = value.borrow().clone().with_meaning(Meaning::Time);
        Ok(Rc::new(RefCell::new(result)))
    }
}

impl Default for Value {
    fn default() -> Self {
        Self::new(Some(BigRational::zero()))
    }
}

impl Clone for Value {
    fn clone(&self) -> Self {
        // Clone everything but the variable name.
        let number = self.number.clone();
        let mut value = Self::new(number);
        value.meaning = self.meaning;
        value.comment = self.comment.clone();
        value
    }
}

impl Debug for Value {
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        if let Some(number) = &self.number {
            write!(f, "{}", big_rational_str::big_rational_ref_to_string(number))?;
        } else {
            write!(f, "NaN")?;
        }
        match self.meaning {
            Meaning::Plain => (),
            Meaning::Delta => write!(f, " [delta]")?,
            Meaning::Time => write!(f, " [time]")?,
        }
        if let Some(variable) = &self.variable {
            write!(f, " = {}", variable)?;
        }
        if let Some(comment) = &self.comment {
            write!(f, " # {}", comment)?;
        }
        Ok(())
    }
}

// noinspection DuplicatedCode
#[cfg(test)]
pub mod tests {
    use crate::calc::context::{Context, Format};
    use crate::calc::meaning::Meaning;
    use crate::calc::value::{Value, ValueRef};
    use crate::error::{EngineError, MyError, MyResult};
    use crate::regex;
    use num::{BigInt, BigRational, CheckedMul, CheckedSub, FromPrimitive, ToPrimitive};
    use pretty_assertions::assert_eq;
    use regex::Match;
    use std::cell::RefCell;
    use std::rc::Rc;

    const VALUE_NAN: Value = Value::new(None);

    #[test]
    fn test_decimal_is_created_from_string_no_separator() {
        assert_eq!(create_value(0, 1), Value::from_string("0").unwrap());
        assert_eq!(create_value(123456789, 1), Value::from_string("123456789").unwrap());
        assert_eq!(create_value(-123456789, 1), Value::from_string("-123456789").unwrap());
        assert_eq!(create_value(123456789, 100), Value::from_string("1234567.89").unwrap());
        assert_eq!(create_value(-123456789, 100), Value::from_string("-1234567.89").unwrap());
        assert_eq!(create_value(999, 1000), Value::from_string(".999").unwrap());
        assert_eq!(create_value(-999, 1000), Value::from_string("-.999").unwrap());
        assert!(Value::from_string("").is_err());
        assert!(Value::from_string("foo").is_err());
    }

    #[test]
    fn test_decimal_is_created_from_string_with_separator() {
        assert_eq!(create_value(123456789, 1), Value::from_string("123,456,789").unwrap());
        assert_eq!(create_value(123456789, 1), Value::from_string("123_456_789").unwrap());
        assert_eq!(create_value(-123456789, 1), Value::from_string("-123,456,789").unwrap());
        assert_eq!(create_value(-123456789, 1), Value::from_string("-123_456_789").unwrap());
        assert_eq!(create_value(123456789, 100), Value::from_string("1,234,567.89").unwrap());
        assert_eq!(create_value(123456789, 100), Value::from_string("1_234_567.89").unwrap());
        assert_eq!(create_value(-123456789, 100), Value::from_string("-1,234,567.89").unwrap());
        assert_eq!(create_value(-123456789, 100), Value::from_string("-1_234_567.89").unwrap());
    }

    #[test]
    fn test_hexadecimal_is_created_from_lowercase_no_separator() {
        assert_eq!(create_value(0, 1), Value::from_string("0x0").unwrap());
        assert_eq!(create_value(0xffff, 1), Value::from_string("0xffff").unwrap());
        assert_eq!(create_value(0xffffffff, 1), Value::from_string("0xffffffff").unwrap());
        assert_eq!(create_value(0xffffffffffff, 1), Value::from_string("0xffffffffffff").unwrap());
        assert_eq!(create_value(0x0123456789abcdef, 1), Value::from_string("0x0123456789abcdef").unwrap());
        assert!(Value::from_string("0x").is_err());
        assert!(Value::from_string("0xfoo").is_err());
    }

    #[test]
    fn test_hexadecimal_is_created_from_uppercase_no_separator() {
        assert_eq!(create_value(0, 1), Value::from_string("0X0").unwrap());
        assert_eq!(create_value(0xffff, 1), Value::from_string("0XFFFF").unwrap());
        assert_eq!(create_value(0xffffffff, 1), Value::from_string("0XFFFFFFFF").unwrap());
        assert_eq!(create_value(0xffffffffffff, 1), Value::from_string("0XFFFFFFFFFFFF").unwrap());
        assert_eq!(create_value(0x0123456789abcdef, 1), Value::from_string("0X0123456789ABCDEF").unwrap());
        assert!(Value::from_string("0X").is_err());
        assert!(Value::from_string("0XFOO").is_err());
    }

    #[test]
    fn test_hexadecimal_is_created_from_lowercase_with_separator() {
        assert_eq!(create_value(0, 1), Value::from_string("0x_0").unwrap());
        assert_eq!(create_value(0xffff, 1), Value::from_string("0x_ffff").unwrap());
        assert_eq!(create_value(0xffffffff, 1), Value::from_string("0x_ffff_ffff").unwrap());
        assert_eq!(create_value(0xffffffffffff, 1), Value::from_string("0x,ffff,ffff,ffff").unwrap());
        assert_eq!(create_value(0x0123456789abcdef, 1), Value::from_string("0x,0123,4567,89ab,cdef").unwrap());
        assert!(Value::from_string("0x_").is_err());
        assert!(Value::from_string("0x,foo").is_err());
    }

    #[test]
    fn test_hexadecimal_is_created_from_uppercase_with_separator() {
        assert_eq!(create_value(0, 1), Value::from_string("0X_0").unwrap());
        assert_eq!(create_value(0xffff, 1), Value::from_string("0X_FFFF").unwrap());
        assert_eq!(create_value(0xffffffff, 1), Value::from_string("0X_FFFF_FFFF").unwrap());
        assert_eq!(create_value(0xffffffffffff, 1), Value::from_string("0X,FFFF,FFFF,FFFF").unwrap());
        assert_eq!(create_value(0x0123456789abcdef, 1), Value::from_string("0X,0123,4567,89AB,CDEF").unwrap());
        assert!(Value::from_string("0X_").is_err());
        assert!(Value::from_string("0X,FOO").is_err());
    }

    #[test]
    fn test_time_is_created_from_string_no_zulu() {
        let summer1 = Value::from_string("2024-06-30T23:59").unwrap();
        let summer2 = Value::from_string("2024-06-30T23:59:59").unwrap();
        let summer3 = Value::from_string("2024-06-30T23:59:59.999").unwrap();
        let winter1 = Value::from_string("2024-12-31T23:59").unwrap();
        let winter2 = Value::from_string("2024-12-31T23:59:59").unwrap();
        let winter3 = Value::from_string("2024-12-31T23:59:59.999").unwrap();
        assert_eq!(create_value(1719791940000, 1000).with_meaning(Meaning::Time), summer1);
        assert_eq!(create_value(1719791999000, 1000).with_meaning(Meaning::Time), summer2);
        assert_eq!(create_value(1719791999999, 1000).with_meaning(Meaning::Time), summer3);
        assert_eq!(create_value(1735689540000, 1000).with_meaning(Meaning::Time), winter1);
        assert_eq!(create_value(1735689599000, 1000).with_meaning(Meaning::Time), winter2);
        assert_eq!(create_value(1735689599999, 1000).with_meaning(Meaning::Time), winter3);
    }

    #[test]
    fn test_time_is_created_from_string_with_zulu() {
        let summer1 = Value::from_string("2024-06-30T23:59Z").unwrap();
        let summer2 = Value::from_string("2024-06-30T23:59:59Z").unwrap();
        let summer3 = Value::from_string("2024-06-30T23:59:59.999Z").unwrap();
        let winter1 = Value::from_string("2024-12-31T23:59Z").unwrap();
        let winter2 = Value::from_string("2024-12-31T23:59:59Z").unwrap();
        let winter3 = Value::from_string("2024-12-31T23:59:59.999Z").unwrap();
        assert_eq!(create_value(1719791940000, 1000).with_meaning(Meaning::Time), summer1);
        assert_eq!(create_value(1719791999000, 1000).with_meaning(Meaning::Time), summer2);
        assert_eq!(create_value(1719791999999, 1000).with_meaning(Meaning::Time), summer3);
        assert_eq!(create_value(1735689540000, 1000).with_meaning(Meaning::Time), winter1);
        assert_eq!(create_value(1735689599000, 1000).with_meaning(Meaning::Time), winter2);
        assert_eq!(create_value(1735689599999, 1000).with_meaning(Meaning::Time), winter3);
    }

    #[test]
    fn test_delta_is_created_from_string_old_format() {
        let minutes1 = Value::from_string("34:56").unwrap();
        let minutes2 = Value::from_string("34:56.7").unwrap();
        let minutes3 = Value::from_string("34:56.789").unwrap();
        let minutes4 = Value::from_string("-34:56").unwrap();
        let minutes5 = Value::from_string("-34:56.7").unwrap();
        let minutes6 = Value::from_string("-34:56.789").unwrap();
        let hours1 = Value::from_string("12:34:56").unwrap();
        let hours2 = Value::from_string("12:34:56.7").unwrap();
        let hours3 = Value::from_string("12:34:56.789").unwrap();
        let hours4 = Value::from_string("-12:34:56").unwrap();
        let hours5 = Value::from_string("-12:34:56.7").unwrap();
        let hours6 = Value::from_string("-12:34:56.789").unwrap();
        let days1 = Value::from_string("9:12:34:56").unwrap();
        let days2 = Value::from_string("9:12:34:56.7").unwrap();
        let days3 = Value::from_string("9:12:34:56.789").unwrap();
        let days4 = Value::from_string("-9:12:34:56").unwrap();
        let days5 = Value::from_string("-9:12:34:56.7").unwrap();
        let days6 = Value::from_string("-9:12:34:56.789").unwrap();
        assert_eq!(create_value(2096000, 1000).with_meaning(Meaning::Delta), minutes1);
        assert_eq!(create_value(2096700, 1000).with_meaning(Meaning::Delta), minutes2);
        assert_eq!(create_value(2096789, 1000).with_meaning(Meaning::Delta), minutes3);
        assert_eq!(create_value(-2096000, 1000).with_meaning(Meaning::Delta), minutes4);
        assert_eq!(create_value(-2096700, 1000).with_meaning(Meaning::Delta), minutes5);
        assert_eq!(create_value(-2096789, 1000).with_meaning(Meaning::Delta), minutes6);
        assert_eq!(create_value(45296000, 1000).with_meaning(Meaning::Delta), hours1);
        assert_eq!(create_value(45296700, 1000).with_meaning(Meaning::Delta), hours2);
        assert_eq!(create_value(45296789, 1000).with_meaning(Meaning::Delta), hours3);
        assert_eq!(create_value(-45296000, 1000).with_meaning(Meaning::Delta), hours4);
        assert_eq!(create_value(-45296700, 1000).with_meaning(Meaning::Delta), hours5);
        assert_eq!(create_value(-45296789, 1000).with_meaning(Meaning::Delta), hours6);
        assert_eq!(create_value(822896000, 1000).with_meaning(Meaning::Delta), days1);
        assert_eq!(create_value(822896700, 1000).with_meaning(Meaning::Delta), days2);
        assert_eq!(create_value(822896789, 1000).with_meaning(Meaning::Delta), days3);
        assert_eq!(create_value(-822896000, 1000).with_meaning(Meaning::Delta), days4);
        assert_eq!(create_value(-822896700, 1000).with_meaning(Meaning::Delta), days5);
        assert_eq!(create_value(-822896789, 1000).with_meaning(Meaning::Delta), days6);
    }

    #[test]
    fn test_delta_is_created_from_string_new_format() {
        let days1 = Value::from_string("9T12:34:56").unwrap();
        let days2 = Value::from_string("9T12:34:56.7").unwrap();
        let days3 = Value::from_string("9T12:34:56.789").unwrap();
        let days4 = Value::from_string("-9T12:34:56").unwrap();
        let days5 = Value::from_string("-9T12:34:56.7").unwrap();
        let days6 = Value::from_string("-9T12:34:56.789").unwrap();
        assert_eq!(create_value(822896000, 1000).with_meaning(Meaning::Delta), days1);
        assert_eq!(create_value(822896700, 1000).with_meaning(Meaning::Delta), days2);
        assert_eq!(create_value(822896789, 1000).with_meaning(Meaning::Delta), days3);
        assert_eq!(create_value(-822896000, 1000).with_meaning(Meaning::Delta), days4);
        assert_eq!(create_value(-822896700, 1000).with_meaning(Meaning::Delta), days5);
        assert_eq!(create_value(-822896789, 1000).with_meaning(Meaning::Delta), days6);
    }

    #[test]
    fn test_value_with_repeating_zero_or_nine_is_rounded() {
        let number1 = fudge_ratio(create_ratio(17, 8)).and_then(opposite_ratio); // 1.874999999999999801...
        let number2 = fudge_ratio(create_ratio(16, 8)).and_then(opposite_ratio); // 1.999999999999999726...
        let number3 = fudge_ratio(create_ratio(16, 8)); // 2.000000000000000273...
        let number4 = fudge_ratio(create_ratio(17, 8)); // 2.125000000000000198...
        assert_eq!(create_value(15, 8), Value::new(number1).with_rounding());
        assert_eq!(create_value(16, 8), Value::new(number2).with_rounding());
        assert_eq!(create_value(16, 8), Value::new(number3).with_rounding());
        assert_eq!(create_value(17, 8), Value::new(number4).with_rounding());
    }

    #[test]
    fn test_value_with_repeating_one_to_eight_is_rounded() {
        let number1 = fudge_ratio(create_ratio(908992, 9000)); // 100.999111111111094...
        let number2 = fudge_ratio(create_ratio(1088924, 99000)); // 10.999232323232323771...
        let number3 = fudge_ratio(create_ratio(1997457, 999000)); // 1.999456456456456483...
        let number4 = fudge_ratio(create_ratio(19995891, 9999000)); // 1.999789078907890437...
        assert_eq!(create_value(908992, 9000), Value::new(number1).with_rounding());
        assert_eq!(create_value(1088924, 99000), Value::new(number2).with_rounding());
        assert_eq!(create_value(1997457, 999000), Value::new(number3).with_rounding());
        assert_eq!(create_value(19995891, 9999000), Value::new(number4).with_rounding());
    }

    #[test]
    fn test_decimal_is_formatted_with_default() {
        let context = Context::new();
        assert_eq!((String::from("0"), String::from(""), None, None), create_value(0, 1).to_strings(&context));
        assert_eq!((String::from("1"), String::from(""), None, None), create_value(1, 1).to_strings(&context));
        assert_eq!((String::from("12"), String::from(""), None, None), create_value(12, 1).to_strings(&context));
        assert_eq!((String::from("123"), String::from(""), None, None), create_value(123, 1).to_strings(&context));
        assert_eq!((String::from("1234"), String::from(""), None, None), create_value(1234, 1).to_strings(&context));
        assert_eq!((String::from("12345"), String::from(""), None, None), create_value(12345, 1).to_strings(&context));
        assert_eq!((String::from("123456"), String::from(""), None, None), create_value(123456, 1).to_strings(&context));
        assert_eq!((String::from("1234567"), String::from(""), None, None), create_value(1234567, 1).to_strings(&context));
        assert_eq!((String::from("12345678"), String::from(""), None, None), create_value(12345678, 1).to_strings(&context));
        assert_eq!((String::from("123456789"), String::from(""), None, None), create_value(123456789, 1).to_strings(&context));
        assert_eq!((String::from("-1"), String::from(""), None, None), create_value(-1, 1).to_strings(&context));
        assert_eq!((String::from("-12"), String::from(""), None, None), create_value(-12, 1).to_strings(&context));
        assert_eq!((String::from("-123"), String::from(""), None, None), create_value(-123, 1).to_strings(&context));
        assert_eq!((String::from("-1234"), String::from(""), None, None), create_value(-1234, 1).to_strings(&context));
        assert_eq!((String::from("-12345"), String::from(""), None, None), create_value(-12345, 1).to_strings(&context));
        assert_eq!((String::from("-123456"), String::from(""), None, None), create_value(-123456, 1).to_strings(&context));
        assert_eq!((String::from("-1234567"), String::from(""), None, None), create_value(-1234567, 1).to_strings(&context));
        assert_eq!((String::from("-12345678"), String::from(""), None, None), create_value(-12345678, 1).to_strings(&context));
        assert_eq!((String::from("-123456789"), String::from(""), None, None), create_value(-123456789, 1).to_strings(&context));
        assert_eq!((String::from("0"), String::from(".00001"), None, None), create_value(1, 100000).to_strings(&context));
        assert_eq!((String::from("0"), String::from(".0001"), None, None), create_value(1, 10000).to_strings(&context));
        assert_eq!((String::from("0"), String::from(".001"), None, None), create_value(1, 1000).to_strings(&context));
        assert_eq!((String::from("0"), String::from(".01"), None, None), create_value(1, 100).to_strings(&context));
        assert_eq!((String::from("0"), String::from(".1"), None, None), create_value(1, 10).to_strings(&context));
        assert_eq!((String::from("0"), String::from(".4994"), None, None), create_value(49940, 100000).to_strings(&context));
        assert_eq!((String::from("0"), String::from(".49949"), None, None), create_value(49949, 100000).to_strings(&context));
        assert_eq!((String::from("0"), String::from(".4995"), None, None), create_value(49950, 100000).to_strings(&context));
        assert_eq!((String::from("0"), String::from(".49951"), None, None), create_value(49951, 100000).to_strings(&context));
        assert_eq!((String::from("0"), String::from(".9"), None, None), create_value(9, 10).to_strings(&context));
        assert_eq!((String::from("0"), String::from(".99"), None, None), create_value(99, 100).to_strings(&context));
        assert_eq!((String::from("0"), String::from(".999"), None, None), create_value(999, 1000).to_strings(&context));
        assert_eq!((String::from("0"), String::from(".9999"), None, None), create_value(9999, 10000).to_strings(&context));
        assert_eq!((String::from("0"), String::from(".99999"), None, None), create_value(99999, 100000).to_strings(&context));
        assert_eq!((String::from("-0"), String::from(".00001"), None, None), create_value(-1, 100000).to_strings(&context));
        assert_eq!((String::from("-0"), String::from(".0001"), None, None), create_value(-1, 10000).to_strings(&context));
        assert_eq!((String::from("-0"), String::from(".001"), None, None), create_value(-1, 1000).to_strings(&context));
        assert_eq!((String::from("-0"), String::from(".01"), None, None), create_value(-1, 100).to_strings(&context));
        assert_eq!((String::from("-0"), String::from(".1"), None, None), create_value(-1, 10).to_strings(&context));
        assert_eq!((String::from("-0"), String::from(".4994"), None, None), create_value(-49940, 100000).to_strings(&context));
        assert_eq!((String::from("-0"), String::from(".49949"), None, None), create_value(-49949, 100000).to_strings(&context));
        assert_eq!((String::from("-0"), String::from(".4995"), None, None), create_value(-49950, 100000).to_strings(&context));
        assert_eq!((String::from("-0"), String::from(".49951"), None, None), create_value(-49951, 100000).to_strings(&context));
        assert_eq!((String::from("-0"), String::from(".9"), None, None), create_value(-9, 10).to_strings(&context));
        assert_eq!((String::from("-0"), String::from(".99"), None, None), create_value(-99, 100).to_strings(&context));
        assert_eq!((String::from("-0"), String::from(".999"), None, None), create_value(-999, 1000).to_strings(&context));
        assert_eq!((String::from("-0"), String::from(".9999"), None, None), create_value(-9999, 10000).to_strings(&context));
        assert_eq!((String::from("-0"), String::from(".99999"), None, None), create_value(-99999, 100000).to_strings(&context));
    }

    #[test]
    fn test_decimal_is_formatted_with_separator() {
        let context = Context::new().with_sep(true);
        assert_eq!((String::from("0"), String::from(""), None, None), create_value(0, 1).to_strings(&context));
        assert_eq!((String::from("1"), String::from(""), None, None), create_value(1, 1).to_strings(&context));
        assert_eq!((String::from("12"), String::from(""), None, None), create_value(12, 1).to_strings(&context));
        assert_eq!((String::from("123"), String::from(""), None, None), create_value(123, 1).to_strings(&context));
        assert_eq!((String::from("1,234"), String::from(""), None, None), create_value(1234, 1).to_strings(&context));
        assert_eq!((String::from("12,345"), String::from(""), None, None), create_value(12345, 1).to_strings(&context));
        assert_eq!((String::from("123,456"), String::from(""), None, None), create_value(123456, 1).to_strings(&context));
        assert_eq!((String::from("1,234,567"), String::from(""), None, None), create_value(1234567, 1).to_strings(&context));
        assert_eq!((String::from("12,345,678"), String::from(""), None, None), create_value(12345678, 1).to_strings(&context));
        assert_eq!((String::from("123,456,789"), String::from(""), None, None), create_value(123456789, 1).to_strings(&context));
        assert_eq!((String::from("-1"), String::from(""), None, None), create_value(-1, 1).to_strings(&context));
        assert_eq!((String::from("-12"), String::from(""), None, None), create_value(-12, 1).to_strings(&context));
        assert_eq!((String::from("-123"), String::from(""), None, None), create_value(-123, 1).to_strings(&context));
        assert_eq!((String::from("-1,234"), String::from(""), None, None), create_value(-1234, 1).to_strings(&context));
        assert_eq!((String::from("-12,345"), String::from(""), None, None), create_value(-12345, 1).to_strings(&context));
        assert_eq!((String::from("-123,456"), String::from(""), None, None), create_value(-123456, 1).to_strings(&context));
        assert_eq!((String::from("-1,234,567"), String::from(""), None, None), create_value(-1234567, 1).to_strings(&context));
        assert_eq!((String::from("-12,345,678"), String::from(""), None, None), create_value(-12345678, 1).to_strings(&context));
        assert_eq!((String::from("-123,456,789"), String::from(""), None, None), create_value(-123456789, 1).to_strings(&context));
        assert_eq!((String::from("0"), String::from(".00001"), None, None), create_value(1, 100000).to_strings(&context));
        assert_eq!((String::from("0"), String::from(".0001"), None, None), create_value(1, 10000).to_strings(&context));
        assert_eq!((String::from("0"), String::from(".001"), None, None), create_value(1, 1000).to_strings(&context));
        assert_eq!((String::from("0"), String::from(".01"), None, None), create_value(1, 100).to_strings(&context));
        assert_eq!((String::from("0"), String::from(".1"), None, None), create_value(1, 10).to_strings(&context));
        assert_eq!((String::from("0"), String::from(".4994"), None, None), create_value(49940, 100000).to_strings(&context));
        assert_eq!((String::from("0"), String::from(".49949"), None, None), create_value(49949, 100000).to_strings(&context));
        assert_eq!((String::from("0"), String::from(".4995"), None, None), create_value(49950, 100000).to_strings(&context));
        assert_eq!((String::from("0"), String::from(".49951"), None, None), create_value(49951, 100000).to_strings(&context));
        assert_eq!((String::from("0"), String::from(".9"), None, None), create_value(9, 10).to_strings(&context));
        assert_eq!((String::from("0"), String::from(".99"), None, None), create_value(99, 100).to_strings(&context));
        assert_eq!((String::from("0"), String::from(".999"), None, None), create_value(999, 1000).to_strings(&context));
        assert_eq!((String::from("0"), String::from(".9999"), None, None), create_value(9999, 10000).to_strings(&context));
        assert_eq!((String::from("0"), String::from(".99999"), None, None), create_value(99999, 100000).to_strings(&context));
        assert_eq!((String::from("-0"), String::from(".00001"), None, None), create_value(-1, 100000).to_strings(&context));
        assert_eq!((String::from("-0"), String::from(".0001"), None, None), create_value(-1, 10000).to_strings(&context));
        assert_eq!((String::from("-0"), String::from(".001"), None, None), create_value(-1, 1000).to_strings(&context));
        assert_eq!((String::from("-0"), String::from(".01"), None, None), create_value(-1, 100).to_strings(&context));
        assert_eq!((String::from("-0"), String::from(".1"), None, None), create_value(-1, 10).to_strings(&context));
        assert_eq!((String::from("-0"), String::from(".4994"), None, None), create_value(-49940, 100000).to_strings(&context));
        assert_eq!((String::from("-0"), String::from(".49949"), None, None), create_value(-49949, 100000).to_strings(&context));
        assert_eq!((String::from("-0"), String::from(".4995"), None, None), create_value(-49950, 100000).to_strings(&context));
        assert_eq!((String::from("-0"), String::from(".49951"), None, None), create_value(-49951, 100000).to_strings(&context));
        assert_eq!((String::from("-0"), String::from(".9"), None, None), create_value(-9, 10).to_strings(&context));
        assert_eq!((String::from("-0"), String::from(".99"), None, None), create_value(-99, 100).to_strings(&context));
        assert_eq!((String::from("-0"), String::from(".999"), None, None), create_value(-999, 1000).to_strings(&context));
        assert_eq!((String::from("-0"), String::from(".9999"), None, None), create_value(-9999, 10000).to_strings(&context));
        assert_eq!((String::from("-0"), String::from(".99999"), None, None), create_value(-99999, 100000).to_strings(&context));
    }

    #[test]
    fn test_decimal_is_formatted_with_precision() {
        let context = Context::new().with_dp(Some(3));
        assert_eq!((String::from("0"), String::from(".000"), None, None), create_value(0, 1).to_strings(&context));
        assert_eq!((String::from("1"), String::from(".000"), None, None), create_value(1, 1).to_strings(&context));
        assert_eq!((String::from("12"), String::from(".000"), None, None), create_value(12, 1).to_strings(&context));
        assert_eq!((String::from("123"), String::from(".000"), None, None), create_value(123, 1).to_strings(&context));
        assert_eq!((String::from("1234"), String::from(".000"), None, None), create_value(1234, 1).to_strings(&context));
        assert_eq!((String::from("12345"), String::from(".000"), None, None), create_value(12345, 1).to_strings(&context));
        assert_eq!((String::from("123456"), String::from(".000"), None, None), create_value(123456, 1).to_strings(&context));
        assert_eq!((String::from("1234567"), String::from(".000"), None, None), create_value(1234567, 1).to_strings(&context));
        assert_eq!((String::from("12345678"), String::from(".000"), None, None), create_value(12345678, 1).to_strings(&context));
        assert_eq!((String::from("123456789"), String::from(".000"), None, None), create_value(123456789, 1).to_strings(&context));
        assert_eq!((String::from("-1"), String::from(".000"), None, None), create_value(-1, 1).to_strings(&context));
        assert_eq!((String::from("-12"), String::from(".000"), None, None), create_value(-12, 1).to_strings(&context));
        assert_eq!((String::from("-123"), String::from(".000"), None, None), create_value(-123, 1).to_strings(&context));
        assert_eq!((String::from("-1234"), String::from(".000"), None, None), create_value(-1234, 1).to_strings(&context));
        assert_eq!((String::from("-12345"), String::from(".000"), None, None), create_value(-12345, 1).to_strings(&context));
        assert_eq!((String::from("-123456"), String::from(".000"), None, None), create_value(-123456, 1).to_strings(&context));
        assert_eq!((String::from("-1234567"), String::from(".000"), None, None), create_value(-1234567, 1).to_strings(&context));
        assert_eq!((String::from("-12345678"), String::from(".000"), None, None), create_value(-12345678, 1).to_strings(&context));
        assert_eq!((String::from("-123456789"), String::from(".000"), None, None), create_value(-123456789, 1).to_strings(&context));
        assert_eq!((String::from("0"), String::from(".000"), None, None), create_value(1, 100000).to_strings(&context));
        assert_eq!((String::from("0"), String::from(".000"), None, None), create_value(1, 10000).to_strings(&context));
        assert_eq!((String::from("0"), String::from(".001"), None, None), create_value(1, 1000).to_strings(&context));
        assert_eq!((String::from("0"), String::from(".010"), None, None), create_value(1, 100).to_strings(&context));
        assert_eq!((String::from("0"), String::from(".100"), None, None), create_value(1, 10).to_strings(&context));
        assert_eq!((String::from("0"), String::from(".499"), None, None), create_value(49940, 100000).to_strings(&context));
        assert_eq!((String::from("0"), String::from(".499"), None, None), create_value(49949, 100000).to_strings(&context));
        assert_eq!((String::from("0"), String::from(".500"), None, None), create_value(49950, 100000).to_strings(&context));
        assert_eq!((String::from("0"), String::from(".500"), None, None), create_value(49951, 100000).to_strings(&context));
        assert_eq!((String::from("0"), String::from(".900"), None, None), create_value(9, 10).to_strings(&context));
        assert_eq!((String::from("0"), String::from(".990"), None, None), create_value(99, 100).to_strings(&context));
        assert_eq!((String::from("0"), String::from(".999"), None, None), create_value(999, 1000).to_strings(&context));
        assert_eq!((String::from("1"), String::from(".000"), None, None), create_value(9999, 10000).to_strings(&context));
        assert_eq!((String::from("1"), String::from(".000"), None, None), create_value(99999, 100000).to_strings(&context));
        assert_eq!((String::from("0"), String::from(".000"), None, None), create_value(-1, 100000).to_strings(&context));
        assert_eq!((String::from("0"), String::from(".000"), None, None), create_value(-1, 10000).to_strings(&context));
        assert_eq!((String::from("-0"), String::from(".001"), None, None), create_value(-1, 1000).to_strings(&context));
        assert_eq!((String::from("-0"), String::from(".010"), None, None), create_value(-1, 100).to_strings(&context));
        assert_eq!((String::from("-0"), String::from(".100"), None, None), create_value(-1, 10).to_strings(&context));
        assert_eq!((String::from("-0"), String::from(".499"), None, None), create_value(-49940, 100000).to_strings(&context));
        assert_eq!((String::from("-0"), String::from(".499"), None, None), create_value(-49949, 100000).to_strings(&context));
        assert_eq!((String::from("-0"), String::from(".500"), None, None), create_value(-49950, 100000).to_strings(&context));
        assert_eq!((String::from("-0"), String::from(".500"), None, None), create_value(-49951, 100000).to_strings(&context));
        assert_eq!((String::from("-0"), String::from(".900"), None, None), create_value(-9, 10).to_strings(&context));
        assert_eq!((String::from("-0"), String::from(".990"), None, None), create_value(-99, 100).to_strings(&context));
        assert_eq!((String::from("-0"), String::from(".999"), None, None), create_value(-999, 1000).to_strings(&context));
        assert_eq!((String::from("-1"), String::from(".000"), None, None), create_value(-9999, 10000).to_strings(&context));
        assert_eq!((String::from("-1"), String::from(".000"), None, None), create_value(-99999, 100000).to_strings(&context));
    }

    #[test]
    fn test_recurring_is_formatted_with_precision() {
        let value = create_value(1, 3);
        let format = |dp: Option<u8>| {
            let context = Context::new().with_dp(dp);
            let (_, fraction, _, _) = value.to_strings(&context);
            return fraction;
        };
        assert_eq!(String::from(""), format(Some(0)));
        assert_eq!(String::from(".333333"), format(Some(6)));
        assert_eq!(String::from(".(3)"), format(None));
    }

    #[test]
    fn test_hexadecimal_is_formatted_with_default() {
        let context = Context::new().with_format(Format::Base16(3));
        assert_eq!((String::from("0x000000000000000000000000"), String::from(""), None, None), create_value(0, 1).to_strings(&context));
        assert_eq!((String::from("0x000000000000000000000001"), String::from(""), None, None), create_value(1, 1).to_strings(&context));
        assert_eq!((String::from("0x00000000000000007ffffffe"), String::from(""), None, None), create_value(2147483646, 1).to_strings(&context));
        assert_eq!((String::from("0x00000000000000007fffffff"), String::from(""), None, None), create_value(2147483647, 1).to_strings(&context));
        assert_eq!((String::from("0x000000000000000080000000"), String::from(""), None, None), create_value(2147483648, 1).to_strings(&context));
        assert_eq!((String::from("0x000000000000000080000001"), String::from(""), None, None), create_value(2147483649, 1).to_strings(&context));
        assert_eq!((String::from("0x0000000000000000fffffffe"), String::from(""), None, None), create_value(4294967294, 1).to_strings(&context));
        assert_eq!((String::from("0x0000000000000000ffffffff"), String::from(""), None, None), create_value(4294967295, 1).to_strings(&context));
        assert_eq!((String::from("0x000000000000000100000000"), String::from(""), None, None), create_value(4294967296, 1).to_strings(&context));
        assert_eq!((String::from("0x000000000000000100000001"), String::from(""), None, None), create_value(4294967297, 1).to_strings(&context));
        assert_eq!((String::from("0x000000007ffffffffffffffe"), String::from(""), None, None), create_value(9223372036854775806, 1).to_strings(&context));
        assert_eq!((String::from("0x000000007fffffffffffffff"), String::from(""), None, None), create_value(9223372036854775807, 1).to_strings(&context));
        assert_eq!((String::from("0x000000008000000000000000"), String::from(""), None, None), create_value(9223372036854775808, 1).to_strings(&context));
        assert_eq!((String::from("0x000000008000000000000001"), String::from(""), None, None), create_value(9223372036854775809, 1).to_strings(&context));
        assert_eq!((String::from("0x00000000fffffffffffffffe"), String::from(""), None, None), create_value(18446744073709551614, 1).to_strings(&context));
        assert_eq!((String::from("0x00000000ffffffffffffffff"), String::from(""), None, None), create_value(18446744073709551615, 1).to_strings(&context));
        assert_eq!((String::from("0x000000010000000000000000"), String::from(""), None, None), create_value(18446744073709551616, 1).to_strings(&context));
        assert_eq!((String::from("0x000000010000000000000001"), String::from(""), None, None), create_value(18446744073709551617, 1).to_strings(&context));
        assert_eq!((String::from("0xffffffff0000000000000000"), String::from(""), None, None), create_value(-18446744073709551616, 1).to_strings(&context));
        assert_eq!((String::from("0xffffffff0000000000000001"), String::from(""), None, None), create_value(-18446744073709551615, 1).to_strings(&context));
        assert_eq!((String::from("0xffffffff8000000000000000"), String::from(""), None, None), create_value(-9223372036854775808, 1).to_strings(&context));
        assert_eq!((String::from("0xffffffff8000000000000001"), String::from(""), None, None), create_value(-9223372036854775807, 1).to_strings(&context));
        assert_eq!((String::from("0xffffffffffffffff00000000"), String::from(""), None, None), create_value(-4294967296, 1).to_strings(&context));
        assert_eq!((String::from("0xffffffffffffffff00000001"), String::from(""), None, None), create_value(-4294967295, 1).to_strings(&context));
        assert_eq!((String::from("0xffffffffffffffff80000000"), String::from(""), None, None), create_value(-2147483648, 1).to_strings(&context));
        assert_eq!((String::from("0xffffffffffffffff80000001"), String::from(""), None, None), create_value(-2147483647, 1).to_strings(&context));
        assert_eq!((String::from("0xfffffffffffffffffffffffe"), String::from(""), None, None), create_value(-2, 1).to_strings(&context));
        assert_eq!((String::from("0xffffffffffffffffffffffff"), String::from(""), None, None), create_value(-1, 1).to_strings(&context));
    }

    #[test]
    fn test_hexadecimal_is_formatted_with_separator() {
        let context = Context::new().with_format(Format::Base16(3)).with_sep(true);
        assert_eq!((String::from("0x,00000000,00000000,00000000"), String::from(""), None, None), create_value(0, 1).to_strings(&context));
        assert_eq!((String::from("0x,00000000,00000000,00000001"), String::from(""), None, None), create_value(1, 1).to_strings(&context));
        assert_eq!((String::from("0x,00000000,00000000,7ffffffe"), String::from(""), None, None), create_value(2147483646, 1).to_strings(&context));
        assert_eq!((String::from("0x,00000000,00000000,7fffffff"), String::from(""), None, None), create_value(2147483647, 1).to_strings(&context));
        assert_eq!((String::from("0x,00000000,00000000,80000000"), String::from(""), None, None), create_value(2147483648, 1).to_strings(&context));
        assert_eq!((String::from("0x,00000000,00000000,80000001"), String::from(""), None, None), create_value(2147483649, 1).to_strings(&context));
        assert_eq!((String::from("0x,00000000,00000000,fffffffe"), String::from(""), None, None), create_value(4294967294, 1).to_strings(&context));
        assert_eq!((String::from("0x,00000000,00000000,ffffffff"), String::from(""), None, None), create_value(4294967295, 1).to_strings(&context));
        assert_eq!((String::from("0x,00000000,00000001,00000000"), String::from(""), None, None), create_value(4294967296, 1).to_strings(&context));
        assert_eq!((String::from("0x,00000000,00000001,00000001"), String::from(""), None, None), create_value(4294967297, 1).to_strings(&context));
        assert_eq!((String::from("0x,00000000,7fffffff,fffffffe"), String::from(""), None, None), create_value(9223372036854775806, 1).to_strings(&context));
        assert_eq!((String::from("0x,00000000,7fffffff,ffffffff"), String::from(""), None, None), create_value(9223372036854775807, 1).to_strings(&context));
        assert_eq!((String::from("0x,00000000,80000000,00000000"), String::from(""), None, None), create_value(9223372036854775808, 1).to_strings(&context));
        assert_eq!((String::from("0x,00000000,80000000,00000001"), String::from(""), None, None), create_value(9223372036854775809, 1).to_strings(&context));
        assert_eq!((String::from("0x,00000000,ffffffff,fffffffe"), String::from(""), None, None), create_value(18446744073709551614, 1).to_strings(&context));
        assert_eq!((String::from("0x,00000000,ffffffff,ffffffff"), String::from(""), None, None), create_value(18446744073709551615, 1).to_strings(&context));
        assert_eq!((String::from("0x,00000001,00000000,00000000"), String::from(""), None, None), create_value(18446744073709551616, 1).to_strings(&context));
        assert_eq!((String::from("0x,00000001,00000000,00000001"), String::from(""), None, None), create_value(18446744073709551617, 1).to_strings(&context));
        assert_eq!((String::from("0x,ffffffff,00000000,00000000"), String::from(""), None, None), create_value(-18446744073709551616, 1).to_strings(&context));
        assert_eq!((String::from("0x,ffffffff,00000000,00000001"), String::from(""), None, None), create_value(-18446744073709551615, 1).to_strings(&context));
        assert_eq!((String::from("0x,ffffffff,80000000,00000000"), String::from(""), None, None), create_value(-9223372036854775808, 1).to_strings(&context));
        assert_eq!((String::from("0x,ffffffff,80000000,00000001"), String::from(""), None, None), create_value(-9223372036854775807, 1).to_strings(&context));
        assert_eq!((String::from("0x,ffffffff,ffffffff,00000000"), String::from(""), None, None), create_value(-4294967296, 1).to_strings(&context));
        assert_eq!((String::from("0x,ffffffff,ffffffff,00000001"), String::from(""), None, None), create_value(-4294967295, 1).to_strings(&context));
        assert_eq!((String::from("0x,ffffffff,ffffffff,80000000"), String::from(""), None, None), create_value(-2147483648, 1).to_strings(&context));
        assert_eq!((String::from("0x,ffffffff,ffffffff,80000001"), String::from(""), None, None), create_value(-2147483647, 1).to_strings(&context));
        assert_eq!((String::from("0x,ffffffff,ffffffff,fffffffe"), String::from(""), None, None), create_value(-2, 1).to_strings(&context));
        assert_eq!((String::from("0x,ffffffff,ffffffff,ffffffff"), String::from(""), None, None), create_value(-1, 1).to_strings(&context));
    }

    #[test]
    fn test_hexadecimal_is_measured_from_valid() {
        assert_eq!(1, create_value(0, 1).measure_hexadecimal()); // "00000000"
        assert_eq!(1, create_value(1, 1).measure_hexadecimal()); // "00000001"
        assert_eq!(1, create_value(2147483646, 1).measure_hexadecimal()); // "7ffffffe"
        assert_eq!(1, create_value(2147483647, 1).measure_hexadecimal()); // "7fffffff"
        assert_eq!(2, create_value(2147483648, 1).measure_hexadecimal()); // "00000000 80000000"
        assert_eq!(2, create_value(2147483649, 1).measure_hexadecimal()); // "00000000 80000001"
        assert_eq!(2, create_value(4294967294, 1).measure_hexadecimal()); // "00000000 fffffffe"
        assert_eq!(2, create_value(4294967295, 1).measure_hexadecimal()); // "00000000 ffffffff"
        assert_eq!(2, create_value(4294967296, 1).measure_hexadecimal()); // "00000001 00000000"
        assert_eq!(2, create_value(4294967297, 1).measure_hexadecimal()); // "00000001 00000001"
        assert_eq!(2, create_value(9223372036854775806, 1).measure_hexadecimal()); // "7fffffff fffffffe"
        assert_eq!(2, create_value(9223372036854775807, 1).measure_hexadecimal()); // "7fffffff ffffffff"
        assert_eq!(3, create_value(9223372036854775808, 1).measure_hexadecimal()); // "00000000 80000000 00000000"
        assert_eq!(3, create_value(9223372036854775809, 1).measure_hexadecimal()); // "00000000 80000000 00000001"
        assert_eq!(3, create_value(18446744073709551614, 1).measure_hexadecimal()); // "00000000 ffffffff fffffffe"
        assert_eq!(3, create_value(18446744073709551615, 1).measure_hexadecimal()); // "00000000 ffffffff ffffffff"
        assert_eq!(3, create_value(18446744073709551616, 1).measure_hexadecimal()); // "00000001 00000000 00000000"
        assert_eq!(3, create_value(18446744073709551617, 1).measure_hexadecimal()); // "00000001 00000000 00000001"
        assert_eq!(3, create_value(-18446744073709551616, 1).measure_hexadecimal()); // "ffffffff 00000000 00000000"
        assert_eq!(3, create_value(-18446744073709551615, 1).measure_hexadecimal()); // "ffffffff 00000000 00000001"
        assert_eq!(2, create_value(-9223372036854775808, 1).measure_hexadecimal()); // "80000000 00000000"
        assert_eq!(2, create_value(-9223372036854775807, 1).measure_hexadecimal()); // "80000000 00000001"
        assert_eq!(2, create_value(-4294967296, 1).measure_hexadecimal()); // "ffffffff 00000000"
        assert_eq!(2, create_value(-4294967295, 1).measure_hexadecimal()); // "ffffffff 00000001"
        assert_eq!(1, create_value(-2147483648, 1).measure_hexadecimal()); // "80000000"
        assert_eq!(1, create_value(-2147483647, 1).measure_hexadecimal()); // "80000001"
        assert_eq!(1, create_value(-2, 1).measure_hexadecimal()); // "fffffffe"
        assert_eq!(1, create_value(-1, 1).measure_hexadecimal()); // "ffffffff"
    }

    #[test]
    fn test_time_is_formatted_without_separator() {
        let context = Context::new().with_sep(true).with_dp(Some(6));
        assert_time("2024-06-30T12:00:00", ".000Z", create_value(1719748800000, 1000), &context);
        assert_time("2024-06-30T12:00:00", ".987Z", create_value(1719748800987, 1000), &context);
        assert_time("2024-12-31T12:00:00", ".000Z", create_value(1735646400000, 1000), &context);
        assert_time("2024-12-31T12:00:00", ".987Z", create_value(1735646400987, 1000), &context);
    }

    #[test]
    fn test_delta_is_formatted_without_separator() {
        let context = Context::new().with_sep(true).with_dp(Some(6));
        assert_delta("00", ".000", create_value(0, 1), &context);
        assert_delta("59", ".999", create_value(59999, 1000), &context);
        assert_delta("01:00", ".000", create_value(60000, 1000), &context);
        assert_delta("59:59", ".999", create_value(3599999, 1000), &context);
        assert_delta("01:00:00", ".000", create_value(3600000, 1000), &context);
        assert_delta("23:59:59", ".999", create_value(86399999, 1000), &context);
        assert_delta("1T00:00:00", ".000", create_value(86400000, 1000), &context);
        assert_delta("100T00:00:00", ".000", create_value(8640000000, 1000), &context);
        assert_delta("-59", ".999", create_value(-59999, 1000), &context);
        assert_delta("-01:00", ".000", create_value(-60000, 1000), &context);
        assert_delta("-59:59", ".999", create_value(-3599999, 1000), &context);
        assert_delta("-01:00:00", ".000", create_value(-3600000, 1000), &context);
        assert_delta("-23:59:59", ".999", create_value(-86399999, 1000), &context);
        assert_delta("-1T00:00:00", ".000", create_value(-86400000, 1000), &context);
        assert_delta("-100T00:00:00", ".000", create_value(-8640000000, 1000), &context);
    }

    fn assert_time(integer: &str, fraction: &str, value: Value, context: &Context) {
        let expected = (String::from(integer), String::from(fraction), None, None);
        let actual = value.with_meaning(Meaning::Time).to_strings(context);
        assert_eq!(expected, actual);
    }

    fn assert_delta(integer: &str, fraction: &str, value: Value, context: &Context) {
        let expected = (String::from(integer), String::from(fraction), None, None);
        let actual = value.with_meaning(Meaning::Delta).to_strings(context);
        assert_eq!(expected, actual);
    }

    #[test]
    fn test_decimal_is_formatted_from_nan() {
        let expected = (String::from("NaN"), String::from(""), None, None);
        let context = Context::new();
        let actual = VALUE_NAN.to_strings(&context);
        assert_eq!(expected, actual);
    }

    #[test]
    fn test_hexadecimal_is_measured_from_nan() {
        assert_eq!(1, VALUE_NAN.measure_hexadecimal());
    }

    //       | Plain Delta Time
    // ------+------------------
    // Plain | Plain Delta Time
    // Delta | Delta Delta Time
    // Time  | Time  Time    -

    #[test]
    fn test_plain_values_are_added_by_value() {
        assert_eq!(Value::calc_add(create_ref(55, 10), create_ref(25, 10)).ok(), Some(create_ref(8, 1)));
        assert_eq!(Value::calc_add(create_ref(55, 10), create_nan()).ok(), Some(create_nan()));
        assert_eq!(Value::calc_add(create_nan(), create_ref(25, 10)).ok(), Some(create_nan()));
        assert_eq!(Value::calc_add(create_nan(), create_nan()).ok(), Some(create_nan()));
    }

    #[test]
    fn test_plain_values_are_added_by_meaning() {
        assert_eq!(perform_binary_ok(Value::calc_add, Meaning::Plain, Meaning::Plain), Some(Meaning::Plain));
        assert_eq!(perform_binary_ok(Value::calc_add, Meaning::Plain, Meaning::Delta), Some(Meaning::Delta));
        assert_eq!(perform_binary_ok(Value::calc_add, Meaning::Plain, Meaning::Time), Some(Meaning::Time));
        assert_eq!(perform_binary_ok(Value::calc_add, Meaning::Delta, Meaning::Plain), Some(Meaning::Delta));
        assert_eq!(perform_binary_ok(Value::calc_add, Meaning::Delta, Meaning::Delta), Some(Meaning::Delta));
        assert_eq!(perform_binary_ok(Value::calc_add, Meaning::Delta, Meaning::Time), Some(Meaning::Time));
        assert_eq!(perform_binary_ok(Value::calc_add, Meaning::Time, Meaning::Plain), Some(Meaning::Time));
        assert_eq!(perform_binary_ok(Value::calc_add, Meaning::Time, Meaning::Delta), Some(Meaning::Time));
        assert_eq!(perform_binary_err(Value::calc_add, Meaning::Time, Meaning::Time), Some(EngineError::BadTimeOp));
    }

    //       | Plain Delta Time
    // ------+------------------
    // Plain | Plain Delta   -
    // Delta | Delta Delta   -
    // Time  | Time  Time  Delta

    #[test]
    fn test_plain_values_are_subtracted_by_value() {
        assert_eq!(Value::calc_sub(create_ref(55, 10), create_ref(25, 10)).ok(), Some(create_ref(3, 1)));
        assert_eq!(Value::calc_sub(create_ref(55, 10), create_nan()).ok(), Some(create_nan()));
        assert_eq!(Value::calc_sub(create_nan(), create_ref(25, 10)).ok(), Some(create_nan()));
        assert_eq!(Value::calc_sub(create_nan(), create_nan()).ok(), Some(create_nan()));
    }

    #[test]
    fn test_plain_values_are_subtracted_by_meaning() {
        assert_eq!(perform_binary_ok(Value::calc_sub, Meaning::Plain, Meaning::Plain), Some(Meaning::Plain));
        assert_eq!(perform_binary_ok(Value::calc_sub, Meaning::Plain, Meaning::Delta), Some(Meaning::Delta));
        assert_eq!(perform_binary_err(Value::calc_sub, Meaning::Plain, Meaning::Time), Some(EngineError::BadTimeOp));
        assert_eq!(perform_binary_ok(Value::calc_sub, Meaning::Delta, Meaning::Plain), Some(Meaning::Delta));
        assert_eq!(perform_binary_ok(Value::calc_sub, Meaning::Delta, Meaning::Delta), Some(Meaning::Delta));
        assert_eq!(perform_binary_err(Value::calc_sub, Meaning::Delta, Meaning::Time), Some(EngineError::BadTimeOp));
        assert_eq!(perform_binary_ok(Value::calc_sub, Meaning::Time, Meaning::Plain), Some(Meaning::Time));
        assert_eq!(perform_binary_ok(Value::calc_sub, Meaning::Time, Meaning::Delta), Some(Meaning::Time));
        assert_eq!(perform_binary_ok(Value::calc_sub, Meaning::Time, Meaning::Time), Some(Meaning::Delta));
    }

    //       | Plain Delta Time
    // ------+------------------
    // Plain | Plain Delta   -
    // Delta | Delta   -     -
    // Time  |   -     -     -

    #[test]
    fn test_plain_values_are_multiplied_by_value() {
        assert_eq!(Value::calc_mul(create_ref(55, 10), create_ref(25, 10)).ok(), Some(create_ref(1375, 100)));
        assert_eq!(Value::calc_mul(create_ref(55, 10), create_nan()).ok(), Some(create_nan()));
        assert_eq!(Value::calc_mul(create_nan(), create_ref(25, 10)).ok(), Some(create_nan()));
        assert_eq!(Value::calc_mul(create_nan(), create_nan()).ok(), Some(create_nan()));
    }

    #[test]
    fn test_plain_values_are_multiplied_by_meaning() {
        assert_eq!(perform_binary_ok(Value::calc_mul, Meaning::Plain, Meaning::Plain), Some(Meaning::Plain));
        assert_eq!(perform_binary_ok(Value::calc_mul, Meaning::Plain, Meaning::Delta), Some(Meaning::Delta));
        assert_eq!(perform_binary_err(Value::calc_mul, Meaning::Plain, Meaning::Time), Some(EngineError::BadTimeOp));
        assert_eq!(perform_binary_ok(Value::calc_mul, Meaning::Delta, Meaning::Plain), Some(Meaning::Delta));
        assert_eq!(perform_binary_err(Value::calc_mul, Meaning::Delta, Meaning::Delta), Some(EngineError::BadTimeOp));
        assert_eq!(perform_binary_err(Value::calc_mul, Meaning::Delta, Meaning::Time), Some(EngineError::BadTimeOp));
        assert_eq!(perform_binary_err(Value::calc_mul, Meaning::Time, Meaning::Plain), Some(EngineError::BadTimeOp));
        assert_eq!(perform_binary_err(Value::calc_mul, Meaning::Time, Meaning::Delta), Some(EngineError::BadTimeOp));
        assert_eq!(perform_binary_err(Value::calc_mul, Meaning::Time, Meaning::Time), Some(EngineError::BadTimeOp));
    }

    //       | Plain Delta Time
    // ------+------------------
    // Plain | Plain   -     -
    // Delta | Delta   -     -
    // Time  |   -     -     -

    #[test]
    fn test_plain_values_are_divided_by_value() {
        assert_eq!(Value::calc_div(create_ref(55, 10), create_ref(25, 10)).ok(), Some(create_ref(22, 10)));
        assert_eq!(Value::calc_div(create_ref(55, 10), create_nan()).ok(), Some(create_nan()));
        assert_eq!(Value::calc_div(create_nan(), create_ref(25, 10)).ok(), Some(create_nan()));
        assert_eq!(Value::calc_div(create_nan(), create_nan()).ok(), Some(create_nan()));
    }

    #[test]
    fn test_plain_values_are_divided_by_zero() {
        assert_eq!(Value::calc_div(create_ref(55, 10), create_ref(0, 1)).ok(), Some(create_nan()));
        assert_eq!(Value::calc_div(create_nan(), create_ref(0, 1)).ok(), Some(create_nan()));
    }

    #[test]
    fn test_plain_values_are_divided_by_meaning() {
        assert_eq!(perform_binary_ok(Value::calc_div, Meaning::Plain, Meaning::Plain), Some(Meaning::Plain));
        assert_eq!(perform_binary_err(Value::calc_div, Meaning::Plain, Meaning::Delta), Some(EngineError::BadTimeOp));
        assert_eq!(perform_binary_err(Value::calc_div, Meaning::Plain, Meaning::Time), Some(EngineError::BadTimeOp));
        assert_eq!(perform_binary_ok(Value::calc_div, Meaning::Delta, Meaning::Plain), Some(Meaning::Delta));
        assert_eq!(perform_binary_err(Value::calc_div, Meaning::Delta, Meaning::Delta), Some(EngineError::BadTimeOp));
        assert_eq!(perform_binary_err(Value::calc_div, Meaning::Delta, Meaning::Time), Some(EngineError::BadTimeOp));
        assert_eq!(perform_binary_err(Value::calc_div, Meaning::Time, Meaning::Plain), Some(EngineError::BadTimeOp));
        assert_eq!(perform_binary_err(Value::calc_div, Meaning::Time, Meaning::Delta), Some(EngineError::BadTimeOp));
        assert_eq!(perform_binary_err(Value::calc_div, Meaning::Time, Meaning::Time), Some(EngineError::BadTimeOp));
    }

    #[test]
    fn test_plain_values_are_remaindered_by_value() {
        assert_eq!(Value::calc_mod(create_ref(55, 10), create_ref(25, 10)).ok(), Some(create_ref(5, 10)));
        assert_eq!(Value::calc_mod(create_ref(55, 10), create_ref(-25, 10)).ok(), Some(create_ref(5, 10)));
        assert_eq!(Value::calc_mod(create_ref(-55, 10), create_ref(25, 10)).ok(), Some(create_ref(-5, 10)));
        assert_eq!(Value::calc_mod(create_ref(-55, 10), create_ref(-25, 10)).ok(), Some(create_ref(-5, 10)));
        assert_eq!(Value::calc_mod(create_ref(55, 10), create_nan()).ok(), Some(create_nan()));
        assert_eq!(Value::calc_mod(create_ref(-55, 10), create_nan()).ok(), Some(create_nan()));
        assert_eq!(Value::calc_mod(create_nan(), create_ref(25, 10)).ok(), Some(create_nan()));
        assert_eq!(Value::calc_mod(create_nan(), create_ref(-25, 10)).ok(), Some(create_nan()));
        assert_eq!(Value::calc_mod(create_nan(), create_nan()).ok(), Some(create_nan()));
    }

    #[test]
    fn test_plain_values_are_remaindered_by_zero() {
        assert_eq!(Value::calc_mod(create_ref(55, 10), create_ref(0, 1)).ok(), Some(create_nan()));
        assert_eq!(Value::calc_mod(create_nan(), create_ref(0, 1)).ok(), Some(create_nan()));
    }

    #[test]
    fn test_plain_values_are_remaindered_by_meaning() {
        assert_eq!(perform_binary_ok(Value::calc_mod, Meaning::Plain, Meaning::Plain), Some(Meaning::Plain));
        assert_eq!(perform_binary_err(Value::calc_mod, Meaning::Plain, Meaning::Delta), Some(EngineError::BadTimeOp));
        assert_eq!(perform_binary_err(Value::calc_mod, Meaning::Plain, Meaning::Time), Some(EngineError::BadTimeOp));
        assert_eq!(perform_binary_ok(Value::calc_mod, Meaning::Delta, Meaning::Plain), Some(Meaning::Delta));
        assert_eq!(perform_binary_err(Value::calc_mod, Meaning::Delta, Meaning::Delta), Some(EngineError::BadTimeOp));
        assert_eq!(perform_binary_err(Value::calc_mod, Meaning::Delta, Meaning::Time), Some(EngineError::BadTimeOp));
        assert_eq!(perform_binary_err(Value::calc_mod, Meaning::Time, Meaning::Plain), Some(EngineError::BadTimeOp));
        assert_eq!(perform_binary_err(Value::calc_mod, Meaning::Time, Meaning::Delta), Some(EngineError::BadTimeOp));
        assert_eq!(perform_binary_err(Value::calc_mod, Meaning::Time, Meaning::Time), Some(EngineError::BadTimeOp));
    }

    // Plain | Plain
    // Delta | Delta
    // Time  |   -

    #[test]
    fn test_plain_values_are_negated_by_value() {
        assert_eq!(Value::calc_neg(create_ref(5, 10)).ok(), Some(create_ref(-5, 10)));
        assert_eq!(Value::calc_neg(create_ref(-5, 10)).ok(), Some(create_ref(5, 10)));
        assert_eq!(Value::calc_neg(create_nan()).ok(), Some(create_nan()));
    }

    #[test]
    fn test_plain_values_are_negated_by_meaning() {
        assert_eq!(perform_unary_ok(Value::calc_neg, Meaning::Plain), Some(Meaning::Plain));
        assert_eq!(perform_unary_ok(Value::calc_neg, Meaning::Delta), Some(Meaning::Delta));
        assert_eq!(perform_unary_err(Value::calc_neg, Meaning::Time), Some(EngineError::BadTimeOp));
    }

    // Plain | Plain
    // Delta |   -
    // Time  |   -

    #[test]
    fn test_plain_values_are_inverted_if_valid() {
        assert_eq!(Value::calc_inv(create_ref(5, 10)).ok(), Some(create_ref(10, 5)));
        assert_eq!(Value::calc_inv(create_ref(-5, 10)).ok(), Some(create_ref(-10, 5)));
        assert_eq!(Value::calc_inv(create_nan()).ok(), Some(create_nan()));
    }

    #[test]
    fn test_plain_values_are_inverted_if_zero() {
        assert_eq!(Value::calc_inv(create_ref(0, 1)).ok(), Some(create_nan()));
    }

    #[test]
    fn test_plain_values_are_inverted_by_meaning() {
        assert_eq!(perform_unary_ok(Value::calc_inv, Meaning::Plain), Some(Meaning::Plain));
        assert_eq!(perform_unary_err(Value::calc_inv, Meaning::Delta), Some(EngineError::BadTimeOp));
        assert_eq!(perform_unary_err(Value::calc_inv, Meaning::Time), Some(EngineError::BadTimeOp));
    }

    //       | Plain Delta Time
    // ------+------------------
    // Plain | Plain   -     -
    // Delta |   -     -     -
    // Time  |   -     -     -

    #[test]
    fn test_plain_values_are_raised_to_integer_power() {
        assert_eq!(Value::calc_pow(create_ref(3, 1), create_ref(4, 1)).ok(), Some(create_ref(81, 1)));
        assert_eq!(Value::calc_pow(create_ref(3, 1), create_nan()).ok(), Some(create_nan()));
        assert_eq!(Value::calc_pow(create_nan(), create_ref(4, 1)).ok(), Some(create_nan()));
        assert_eq!(Value::calc_pow(create_nan(), create_nan()).ok(), Some(create_nan()));
    }

    #[test]
    fn test_plain_values_are_raised_to_fractional_power() {
        assert_eq!(Value::calc_pow(create_ref(3, 1), create_nan()).ok(), Some(create_nan()));
        assert_eq!(Value::calc_pow(create_nan(), create_ref(1, 2)).ok(), Some(create_nan()));
        assert_eq!(Value::calc_pow(create_nan(), create_nan()).ok(), Some(create_nan()));
    }

    #[test]
    fn test_plain_values_are_raised_by_meaning() {
        assert_eq!(perform_binary_ok(Value::calc_pow, Meaning::Plain, Meaning::Plain), Some(Meaning::Plain));
        assert_eq!(perform_binary_err(Value::calc_pow, Meaning::Plain, Meaning::Delta), Some(EngineError::BadTimeOp));
        assert_eq!(perform_binary_err(Value::calc_pow, Meaning::Plain, Meaning::Time), Some(EngineError::BadTimeOp));
        assert_eq!(perform_binary_err(Value::calc_pow, Meaning::Delta, Meaning::Plain), Some(EngineError::BadTimeOp));
        assert_eq!(perform_binary_err(Value::calc_pow, Meaning::Delta, Meaning::Delta), Some(EngineError::BadTimeOp));
        assert_eq!(perform_binary_err(Value::calc_pow, Meaning::Delta, Meaning::Time), Some(EngineError::BadTimeOp));
        assert_eq!(perform_binary_err(Value::calc_pow, Meaning::Time, Meaning::Plain), Some(EngineError::BadTimeOp));
        assert_eq!(perform_binary_err(Value::calc_pow, Meaning::Time, Meaning::Delta), Some(EngineError::BadTimeOp));
        assert_eq!(perform_binary_err(Value::calc_pow, Meaning::Time, Meaning::Time), Some(EngineError::BadTimeOp));
    }

    // Plain | Plain
    // Delta |   -
    // Time  |   -

    #[test]
    fn test_plain_values_have_square_root_if_positive() {
        assert_eq!(Value::calc_sqrt(create_nan()).ok(), Some(create_nan()));
    }

    #[test]
    fn test_plain_values_have_square_root_if_negative() {
        assert_eq!(Value::calc_sqrt(create_ref(-3, 1)).ok(), Some(create_nan()));
    }

    #[test]
    fn test_plain_values_have_square_root_by_meaning() {
        assert_eq!(perform_unary_ok(Value::calc_sqrt, Meaning::Plain), Some(Meaning::Plain));
        assert_eq!(perform_unary_err(Value::calc_sqrt, Meaning::Delta), Some(EngineError::BadTimeOp));
        assert_eq!(perform_unary_err(Value::calc_sqrt, Meaning::Time), Some(EngineError::BadTimeOp));
    }

    #[test]
    fn test_plain_values_are_summed() {
        assert_eq!(Some(create_ref(0, 1)), Value::calc_sum(vec![]).ok());
        assert_eq!(Some(create_ref(0, 1)), Value::calc_sum(vec![create_nan(), create_nan(), create_nan()]).ok());
        assert_eq!(Some(create_ref(25, 10)), Value::calc_sum(vec![create_ref(25, 10), create_nan(), create_nan()]).ok());
        assert_eq!(Some(create_ref(65, 10)), Value::calc_sum(vec![create_ref(25, 10), create_ref(4, 1), create_nan()]).ok());
        assert_eq!(Some(create_ref(120, 10)), Value::calc_sum(vec![create_ref(25, 10), create_ref(4, 1), create_ref(55, 10)]).ok());
    }

    #[test]
    fn test_plain_values_are_producted() {
        assert_eq!(Some(create_ref(1, 1)), Value::calc_prod(vec![]).ok());
        assert_eq!(Some(create_ref(1, 1)), Value::calc_prod(vec![create_nan(), create_nan(), create_nan()]).ok());
        assert_eq!(Some(create_ref(25, 10)), Value::calc_prod(vec![create_ref(25, 10), create_nan(), create_nan()]).ok());
        assert_eq!(Some(create_ref(100, 10)), Value::calc_prod(vec![create_ref(25, 10), create_ref(4, 1), create_nan()]).ok());
        assert_eq!(Some(create_ref(550, 10)), Value::calc_prod(vec![create_ref(25, 10), create_ref(4, 1), create_ref(55, 10)]).ok());
    }

    #[test]
    fn test_integer_sequences_are_generated_no_step() {
        let expected_inc = vec![
            create_ref(95, 10),
            create_ref(105, 10),
            create_ref(115, 10),
        ];
        let expected_same = vec![
            create_ref(105, 10),
        ];
        let expected_dec = vec![
            create_ref(115, 10),
            create_ref(105, 10),
            create_ref(95, 10),
        ];
        assert_eq!(Some(expected_inc), Value::calc_seq(create_ref(95, 10), create_ref(115, 10)).ok());
        assert_eq!(Some(expected_same), Value::calc_seq(create_ref(105, 10), create_ref(105, 10)).ok());
        assert_eq!(Some(expected_dec), Value::calc_seq(create_ref(115, 10), create_ref(95, 10)).ok());
    }

    #[test]
    fn test_integer_sequences_are_generated_with_step() {
        let expected_inc = vec![
            create_ref(0, 10),
            create_ref(5, 10),
            create_ref(10, 10),
        ];
        let expected_same = vec![
            create_ref(5, 10),
        ];
        let expected_dec = vec![
            create_ref(10, 10),
            create_ref(5, 10),
            create_ref(0, 10),
        ];
        assert_eq!(Some(expected_inc.clone()), Value::calc_step(create_ref(0, 10), create_ref(5, 10), create_ref(10, 10)).ok());
        assert_eq!(Some(expected_inc.clone()), Value::calc_step(create_ref(0, 10), create_ref(5, 10), create_ref(12, 10)).ok());
        assert_eq!(Some(expected_inc.clone()), Value::calc_step(create_ref(0, 10), create_ref(-5, 10), create_ref(10, 10)).ok());
        assert_eq!(Some(expected_inc.clone()), Value::calc_step(create_ref(0, 10), create_ref(-5, 10), create_ref(12, 10)).ok());
        assert_eq!(Some(expected_same.clone()), Value::calc_step(create_ref(5, 10), create_ref(0, 10), create_ref(10, 10)).ok());
        assert_eq!(Some(expected_same.clone()), Value::calc_step(create_ref(5, 10), create_ref(0, 10), create_ref(5, 10)).ok());
        assert_eq!(Some(expected_same.clone()), Value::calc_step(create_ref(5, 10), create_ref(0, 10), create_ref(0, 10)).ok());
        assert_eq!(Some(expected_dec.clone()), Value::calc_step(create_ref(10, 10), create_ref(5, 10), create_ref(0, 10)).ok());
        assert_eq!(Some(expected_dec.clone()), Value::calc_step(create_ref(10, 10), create_ref(5, 10), create_ref(-2, 10)).ok());
        assert_eq!(Some(expected_dec.clone()), Value::calc_step(create_ref(10, 10), create_ref(-5, 10), create_ref(0, 10)).ok());
        assert_eq!(Some(expected_dec.clone()), Value::calc_step(create_ref(10, 10), create_ref(-5, 10), create_ref(-2, 10)).ok());
    }

    #[test]
    fn test_stack_is_sorted() {
        let expected = vec![
            create_nan(),
            create_ref(-15, 10),
            create_ref(-10, 10),
            create_ref(-5, 10),
            create_ref(0, 10),
            create_ref(5, 10),
            create_ref(10, 10),
            create_ref(15, 10),
        ];
        let original = vec![
            create_ref(0, 10),
            create_ref(5, 10),
            create_ref(-5, 10),
            create_ref(10, 10),
            create_ref(-10, 10),
            create_ref(15, 10),
            create_ref(-15, 10),
            create_nan(),
        ];
        assert_eq!(Some(expected), Value::sort_seq(original).ok());
    }

    #[test]
    fn test_stack_is_reversed() {
        let expected = vec![
            create_nan(),
            create_ref(-15, 10),
            create_ref(15, 10),
            create_ref(-10, 10),
            create_ref(10, 10),
            create_ref(-5, 10),
            create_ref(5, 10),
            create_ref(0, 10),
        ];
        let original = vec![
            create_ref(0, 10),
            create_ref(5, 10),
            create_ref(-5, 10),
            create_ref(10, 10),
            create_ref(-10, 10),
            create_ref(15, 10),
            create_ref(-15, 10),
            create_nan(),
        ];
        assert_eq!(Some(expected), Value::rev_seq(original).ok());
    }

    //       | Plain Delta Time
    // ------+------------------
    // Plain | Plain   -     -
    // Delta |   -     -     -
    // Time  |   -     -     -

    #[test]
    fn test_plain_values_have_bitwise_and_by_value() {
        assert_eq!(Value::calc_and(create_ref(0xff00, 1), create_ref(0xf0f0, 1)).ok(), Some(create_ref(0xf000, 1)));
        assert_eq!(Value::calc_and(create_ref(0xff00, 1), create_nan()).ok(), Some(create_nan()));
        assert_eq!(Value::calc_and(create_nan(), create_ref(0xf0f0, 1)).ok(), Some(create_nan()));
        assert_eq!(Value::calc_and(create_nan(), create_nan()).ok(), Some(create_nan()));
    }

    #[test]
    fn test_plain_values_have_bitwise_and_by_meaning() {
        assert_eq!(perform_binary_ok(Value::calc_and, Meaning::Plain, Meaning::Plain), Some(Meaning::Plain));
        assert_eq!(perform_binary_err(Value::calc_and, Meaning::Plain, Meaning::Delta), Some(EngineError::BadTimeOp));
        assert_eq!(perform_binary_err(Value::calc_and, Meaning::Plain, Meaning::Time), Some(EngineError::BadTimeOp));
        assert_eq!(perform_binary_err(Value::calc_and, Meaning::Delta, Meaning::Plain), Some(EngineError::BadTimeOp));
        assert_eq!(perform_binary_err(Value::calc_and, Meaning::Delta, Meaning::Delta), Some(EngineError::BadTimeOp));
        assert_eq!(perform_binary_err(Value::calc_and, Meaning::Delta, Meaning::Time), Some(EngineError::BadTimeOp));
        assert_eq!(perform_binary_err(Value::calc_and, Meaning::Time, Meaning::Plain), Some(EngineError::BadTimeOp));
        assert_eq!(perform_binary_err(Value::calc_and, Meaning::Time, Meaning::Delta), Some(EngineError::BadTimeOp));
        assert_eq!(perform_binary_err(Value::calc_and, Meaning::Time, Meaning::Time), Some(EngineError::BadTimeOp));
    }

    #[test]
    fn test_plain_values_have_bitwise_or_by_value() {
        assert_eq!(Value::calc_or(create_ref(0xff00, 1), create_ref(0xf0f0, 1)).ok(), Some(create_ref(0xfff0, 1)));
        assert_eq!(Value::calc_or(create_ref(0xff00, 1), create_nan()).ok(), Some(create_nan()));
        assert_eq!(Value::calc_or(create_nan(), create_ref(0xf0f0, 1)).ok(), Some(create_nan()));
        assert_eq!(Value::calc_or(create_nan(), create_nan()).ok(), Some(create_nan()));
    }

    #[test]
    fn test_plain_values_have_bitwise_or_by_meaning() {
        assert_eq!(perform_binary_ok(Value::calc_or, Meaning::Plain, Meaning::Plain), Some(Meaning::Plain));
        assert_eq!(perform_binary_err(Value::calc_or, Meaning::Plain, Meaning::Delta), Some(EngineError::BadTimeOp));
        assert_eq!(perform_binary_err(Value::calc_or, Meaning::Plain, Meaning::Time), Some(EngineError::BadTimeOp));
        assert_eq!(perform_binary_err(Value::calc_or, Meaning::Delta, Meaning::Plain), Some(EngineError::BadTimeOp));
        assert_eq!(perform_binary_err(Value::calc_or, Meaning::Delta, Meaning::Delta), Some(EngineError::BadTimeOp));
        assert_eq!(perform_binary_err(Value::calc_or, Meaning::Delta, Meaning::Time), Some(EngineError::BadTimeOp));
        assert_eq!(perform_binary_err(Value::calc_or, Meaning::Time, Meaning::Plain), Some(EngineError::BadTimeOp));
        assert_eq!(perform_binary_err(Value::calc_or, Meaning::Time, Meaning::Delta), Some(EngineError::BadTimeOp));
        assert_eq!(perform_binary_err(Value::calc_or, Meaning::Time, Meaning::Time), Some(EngineError::BadTimeOp));
    }

    #[test]
    fn test_plain_values_have_bitwise_xor_by_value() {
        assert_eq!(Value::calc_xor(create_ref(0xff00, 1), create_ref(0xf0f0, 1)).ok(), Some(create_ref(0x0ff0, 1)));
        assert_eq!(Value::calc_xor(create_ref(0xff00, 1), create_nan()).ok(), Some(create_nan()));
        assert_eq!(Value::calc_xor(create_nan(), create_ref(0xf0f0, 1)).ok(), Some(create_nan()));
        assert_eq!(Value::calc_xor(create_nan(), create_nan()).ok(), Some(create_nan()));
    }

    #[test]
    fn test_plain_values_have_bitwise_xor_by_meaning() {
        assert_eq!(perform_binary_ok(Value::calc_xor, Meaning::Plain, Meaning::Plain), Some(Meaning::Plain));
        assert_eq!(perform_binary_err(Value::calc_xor, Meaning::Plain, Meaning::Delta), Some(EngineError::BadTimeOp));
        assert_eq!(perform_binary_err(Value::calc_xor, Meaning::Plain, Meaning::Time), Some(EngineError::BadTimeOp));
        assert_eq!(perform_binary_err(Value::calc_xor, Meaning::Delta, Meaning::Plain), Some(EngineError::BadTimeOp));
        assert_eq!(perform_binary_err(Value::calc_xor, Meaning::Delta, Meaning::Delta), Some(EngineError::BadTimeOp));
        assert_eq!(perform_binary_err(Value::calc_xor, Meaning::Delta, Meaning::Time), Some(EngineError::BadTimeOp));
        assert_eq!(perform_binary_err(Value::calc_xor, Meaning::Time, Meaning::Plain), Some(EngineError::BadTimeOp));
        assert_eq!(perform_binary_err(Value::calc_xor, Meaning::Time, Meaning::Delta), Some(EngineError::BadTimeOp));
        assert_eq!(perform_binary_err(Value::calc_xor, Meaning::Time, Meaning::Time), Some(EngineError::BadTimeOp));
    }

    #[test]
    fn test_plain_values_are_shifted_left_by_value() {
        assert_eq!(Value::calc_shl(create_ref(35, 10), create_ref(29, 10)).ok(), Some(create_ref(14, 1)));
        assert_eq!(Value::calc_shl(create_ref(-35, 10), create_ref(29, 10)).ok(), Some(create_ref(-14, 1)));
        assert_eq!(Value::calc_shl(create_ref(35, 10), create_ref(-29, 10)).ok(), Some(create_ref(875, 1000)));
        assert_eq!(Value::calc_shl(create_ref(-35, 10), create_ref(-29, 10)).ok(), Some(create_ref(-875, 1000)));
        assert_eq!(Value::calc_shl(create_ref(35, 10), create_nan()).ok(), Some(create_nan()));
        assert_eq!(Value::calc_shl(create_ref(-35, 10), create_nan()).ok(), Some(create_nan()));
        assert_eq!(Value::calc_shl(create_nan(), create_ref(29, 10)).ok(), Some(create_nan()));
        assert_eq!(Value::calc_shl(create_nan(), create_ref(-29, 10)).ok(), Some(create_nan()));
        assert_eq!(Value::calc_shl(create_nan(), create_nan()).ok(), Some(create_nan()));
    }

    #[test]
    fn test_plain_values_are_shifted_left_by_meaning() {
        assert_eq!(perform_binary_ok(Value::calc_shl, Meaning::Plain, Meaning::Plain), Some(Meaning::Plain));
        assert_eq!(perform_binary_err(Value::calc_shl, Meaning::Plain, Meaning::Delta), Some(EngineError::BadTimeOp));
        assert_eq!(perform_binary_err(Value::calc_shl, Meaning::Plain, Meaning::Time), Some(EngineError::BadTimeOp));
        assert_eq!(perform_binary_err(Value::calc_shl, Meaning::Delta, Meaning::Plain), Some(EngineError::BadTimeOp));
        assert_eq!(perform_binary_err(Value::calc_shl, Meaning::Delta, Meaning::Delta), Some(EngineError::BadTimeOp));
        assert_eq!(perform_binary_err(Value::calc_shl, Meaning::Delta, Meaning::Time), Some(EngineError::BadTimeOp));
        assert_eq!(perform_binary_err(Value::calc_shl, Meaning::Time, Meaning::Plain), Some(EngineError::BadTimeOp));
        assert_eq!(perform_binary_err(Value::calc_shl, Meaning::Time, Meaning::Delta), Some(EngineError::BadTimeOp));
        assert_eq!(perform_binary_err(Value::calc_shl, Meaning::Time, Meaning::Time), Some(EngineError::BadTimeOp));
    }

    #[test]
    fn test_plain_values_are_shifted_right_by_value() {
        assert_eq!(Value::calc_shr(create_ref(35, 10), create_ref(29, 10)).ok(), Some(create_ref(875, 1000)));
        assert_eq!(Value::calc_shr(create_ref(-35, 10), create_ref(29, 10)).ok(), Some(create_ref(-875, 1000)));
        assert_eq!(Value::calc_shr(create_ref(35, 10), create_ref(-29, 10)).ok(), Some(create_ref(14, 1)));
        assert_eq!(Value::calc_shr(create_ref(-35, 10), create_ref(-29, 10)).ok(), Some(create_ref(-14, 1)));
        assert_eq!(Value::calc_shr(create_ref(35, 10), create_nan()).ok(), Some(create_nan()));
        assert_eq!(Value::calc_shr(create_ref(-35, 10), create_nan()).ok(), Some(create_nan()));
        assert_eq!(Value::calc_shr(create_nan(), create_ref(29, 10)).ok(), Some(create_nan()));
        assert_eq!(Value::calc_shr(create_nan(), create_ref(-29, 10)).ok(), Some(create_nan()));
        assert_eq!(Value::calc_shr(create_nan(), create_nan()).ok(), Some(create_nan()));
    }

    #[test]
    fn test_plain_values_are_shifted_right_by_meaning() {
        assert_eq!(perform_binary_ok(Value::calc_shr, Meaning::Plain, Meaning::Plain), Some(Meaning::Plain));
        assert_eq!(perform_binary_err(Value::calc_shr, Meaning::Plain, Meaning::Delta), Some(EngineError::BadTimeOp));
        assert_eq!(perform_binary_err(Value::calc_shr, Meaning::Plain, Meaning::Time), Some(EngineError::BadTimeOp));
        assert_eq!(perform_binary_err(Value::calc_shr, Meaning::Delta, Meaning::Plain), Some(EngineError::BadTimeOp));
        assert_eq!(perform_binary_err(Value::calc_shr, Meaning::Delta, Meaning::Delta), Some(EngineError::BadTimeOp));
        assert_eq!(perform_binary_err(Value::calc_shr, Meaning::Delta, Meaning::Time), Some(EngineError::BadTimeOp));
        assert_eq!(perform_binary_err(Value::calc_shr, Meaning::Time, Meaning::Plain), Some(EngineError::BadTimeOp));
        assert_eq!(perform_binary_err(Value::calc_shr, Meaning::Time, Meaning::Delta), Some(EngineError::BadTimeOp));
        assert_eq!(perform_binary_err(Value::calc_shr, Meaning::Time, Meaning::Time), Some(EngineError::BadTimeOp));
    }

    fn perform_unary_ok(
        function: fn(ValueRef) -> MyResult<ValueRef>,
        meaning: Meaning,
    ) -> Option<Meaning> {
        let value = create_value(1, 1).with_meaning(meaning);
        let value = Rc::new(RefCell::new(value));
        let result = function(value);
        result.ok().map(get_meaning)
    }

    fn perform_unary_err(
        function: fn(ValueRef) -> MyResult<ValueRef>,
        meaning: Meaning,
    ) -> Option<EngineError> {
        let value = create_value(1, 1).with_meaning(meaning);
        let value = Rc::new(RefCell::new(value));
        let result = function(value);
        result.err().and_then(filter_error)
    }

    fn perform_binary_ok(
        function: fn(ValueRef, ValueRef) -> MyResult<ValueRef>,
        lhs: Meaning,
        rhs: Meaning,
    ) -> Option<Meaning> {
        let lhs = create_value(1, 1).with_meaning(lhs);
        let rhs = create_value(1, 1).with_meaning(rhs);
        let lhs = Rc::new(RefCell::new(lhs));
        let rhs = Rc::new(RefCell::new(rhs));
        let result = function(lhs, rhs);
        result.ok().map(get_meaning)
    }

    fn perform_binary_err(
        function: fn(ValueRef, ValueRef) -> MyResult<ValueRef>,
        lhs: Meaning,
        rhs: Meaning,
    ) -> Option<EngineError> {
        let lhs = create_value(1, 1).with_meaning(lhs);
        let rhs = create_value(1, 1).with_meaning(rhs);
        let lhs = Rc::new(RefCell::new(lhs));
        let rhs = Rc::new(RefCell::new(rhs));
        let result = function(lhs, rhs);
        result.err().and_then(filter_error)
    }

    fn get_meaning(value: ValueRef) -> Meaning {
        value.borrow().meaning
    }

    fn filter_error(error: MyError) -> Option<EngineError> {
        match error {
            MyError::Engine(error) => Some(error),
            _ => None,
        }
    }

    fn create_value(numer: i128, denom: i128) -> Value {
        let number = create_ratio(numer, denom);
        Value::new(Some(number))
    }

    fn create_ref(numer: i128, denom: i128) -> ValueRef {
        let number = create_ratio(numer, denom);
        let value = Value::new(Some(number));
        Rc::new(RefCell::new(value))
    }

    pub fn create_nan() -> ValueRef {
        let value = Value::new(None);
        Rc::new(RefCell::new(value))
    }

    pub fn parse_value(number: &str) -> ValueRef {
        let regex = regex!(r#"^(\S+)(?: \[(delta|time)\])?(?: = (\w+))?(?: # (.+))?$"#);
        let captures = regex.captures(number).unwrap();
        let number = captures.get(1).as_ref().map(Match::as_str).unwrap();
        let mut value = Value::from_string(number).unwrap();
        match captures.get(2).as_ref().map(Match::as_str) {
            Some("delta") => value.set_meaning(Meaning::Delta),
            Some("time") => value.set_meaning(Meaning::Time),
            _ => value.set_meaning(Meaning::Plain),
        }
        if let Some(variable) = captures.get(3).as_ref().map(Match::as_str) {
            value.set_variable(variable);
        }
        if let Some(comment) = captures.get(4).as_ref().map(Match::as_str) {
            value.set_comment(comment);
        }
        Rc::new(RefCell::new(value))
    }

    pub fn parse_values(numbers: Vec<&str>) -> Vec<ValueRef> {
        numbers.iter().map(|x| parse_value(x)).collect()
    }

    fn create_ratio(numer: i128, denom: i128) -> BigRational {
        let numer = BigInt::from(numer);
        let denom = BigInt::from(denom);
        BigRational::new(numer, denom)
    }

    fn fudge_ratio(number: BigRational) -> Option<BigRational> {
        number.to_f64()
            .map(f64::sqrt)
            .and_then(BigRational::from_f64)
            .and_then(square_ratio)
    }

    fn square_ratio(number: BigRational) -> Option<BigRational> {
        number.checked_mul(&number)
    }

    fn opposite_ratio(number: BigRational) -> Option<BigRational> {
        create_ratio(2, 1).checked_mul(&number.round()).and_then(|x| x.checked_sub(&number))
    }
}