rpn_cli/calc/

value.rs

use crate::calc::context::{Context, Format};
use crate::calc::meaning::{DeltaKind, Meaning};
use crate::error::{EngineError, MyError, MyResult};
use crate::util::number;
use crate::util::text::{create_padding, remove_char};
use crate::{combine_binary, combine_cast, combine_inner, regex};
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>>;
pub type ValueTuple = (String, String, Option<String>, Option<String>, Option<String>);

#[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 = number::format_ratio(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(DeltaKind::HMS));
            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) -> ValueTuple {
        if let Some(number) = &self.number {
            self.format_ratio(context, number)
        } else {
            self.create_tuple(String::from("NaN"), String::from(""))
        }
    }

    fn format_ratio(
        &self,
        context: &Context,
        number: &BigRational,
    ) -> ValueTuple {
        // Returns (integer, fraction, meaning, variable, comment).
        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(DeltaKind::HMS) {
            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);
            self.create_tuple(number, String::from(""))
        } 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 = number::format_ratio(&number);
            self.format_split(context, number)
        } else {
            let number = number::format_ratio(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,
    ) -> ValueTuple {
        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);
        self.create_tuple(integer, fraction)
    }

    fn create_tuple(
        &self,
        integer: String,
        fraction: String,
    ) -> ValueTuple {
        let meaning = self.meaning.get_symbol();
        let variable = self.variable.clone();
        let comment = self.comment.clone();
        (integer, fraction, meaning, variable, comment)
    }

    fn modify_integer(&self, context: &Context, number: &str) -> String {
        if Self::is_formattable(self.meaning) && 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::is_formattable(self.meaning) {
            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)
    }

    fn is_formattable(meaning: Meaning) -> bool {
        match meaning {
            Meaning::Delta(DeltaKind::HMS) => false,
            Meaning::Time => false,
            _ => true,
        }
    }

    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,
        function: fn(&BigRational) -> Option<BigRational>,
    ) -> ValueRef {
        if let Some(number) = &value.borrow().number {
            let meaning = value.borrow().meaning;
            let result = function(number);
            let result = Self::new(result).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_number) = &lhs.borrow().number {
            if let Some(rhs_number) = &rhs.borrow().number {
                let lhs_number = lhs.borrow().meaning.undo_meaning(&lhs_number);
                let rhs_number = rhs.borrow().meaning.undo_meaning(&rhs_number);
                let result_number = function(&lhs_number, &rhs_number)
                    .map(|number| meaning.redo_meaning(&number).into_owned());
                let result_value = Self::new(result_number).with_rounding().with_meaning(meaning);
                return Rc::new(RefCell::new(result_value));
            }
            return rhs;
        }
        lhs
    }

    // Cast  | Plain Delta Time  | Len   Area  Vol   Speed | Mass  Temp  Data
    // ------+-------------------+-------------------------+------------------
    // Plain | Plain Delta Time  | Len   Area  Vol   Speed | Mass  Temp  Data
    // Delta | Plain Delta -     | -     -     -     -     | -     -     -
    // Time  | Plain -     Time  | -     -     -     -     | -     -     -
    // ------+-------------------+-------------------------+------------------
    // Len   | Plain -     -     | Len   -     -     -     | -     -     -
    // Area  | Plain -     -     | -     Area  -     -     | -     -     -
    // Vol   | Plain -     -     | -     -     Vol   -     | -     -     -
    // Speed | Plain -     -     | -     -     -     Speed | -     -     -
    // ------+-------------------+-------------------------+------------------
    // Mass  | Plain -     -     | -     -     -     -     | Mass  -     -
    // Temp  | Plain -     -     | -     -     -     -     | -     Temp  -
    // Data  | Plain -     -     | -     -     -     -     | -     -     Data

    pub fn apply_meaning(&self, meaning: Meaning) -> MyResult<ValueRef> {
        let meaning = combine_cast!(
            self.meaning,
            meaning,
            combine_cast_value,
        )?;
        // Clone everything but the variable name.
        let number = self.number.as_ref().map(|number| {
            if self.meaning != Meaning::Plain && meaning != Meaning::Plain {
                let number = self.meaning.undo_meaning(number);
                let number = meaning.redo_meaning(&number);
                number.into_owned()
            } else {
                number.clone()
            }
        });
        let comment = self.comment.clone();
        let result = Self { number, meaning, variable: None, comment };
        let result = Rc::new(RefCell::new(result.with_rounding()));
        Ok(result)
    }

    // Add   | Plain Delta Time  | Len   Area  Vol   Speed | Mass  Temp  Data
    // ------+-------------------+-------------------------+------------------
    // Plain | Plain Delta Time  | Len   Area  Vol   Speed | Mass  Temp  Data
    // Delta | Delta Delta Time  | -     -     -     -     | -     -     -
    // Time  | Time  Time  -     | -     -     -     -     | -     -     -
    // ------+-------------------+-------------------------+------------------
    // Len   | Len   -     -     | Len   -     -     -     | -     -     -
    // Area  | Area  -     -     | -     Area  -     -     | -     -     -
    // Vol   | Vol   -     -     | -     -     Vol   -     | -     -     -
    // Speed | Speed -     -     | -     -     -     Speed | -     -     -
    // ------+-------------------+-------------------------+------------------
    // Mass  | Mass  -     -     | -     -     -     -     | Mass  -     -
    // Temp  | Temp  -     -     | -     -     -     -     | -     Temp  -
    // Data  | Data  -     -     | -     -     -     -     | -     -     Data

    pub fn calc_add(lhs: ValueRef, rhs: ValueRef) -> MyResult<ValueRef> {
        let meaning = combine_binary!(
            lhs.borrow().meaning,
            rhs.borrow().meaning,
            combine_add_time,
            combine_copy_left,
            combine_copy_right,
            combine_copy_same,
        )?;
        let result = Self::perform_binary(lhs, rhs, meaning, |x, y| x.checked_add(&y));
        Ok(result)
    }

    // Sub   | Plain Delta Time  | Len   Area  Vol   Speed | Mass  Temp  Data
    // ------+-------------------+-------------------------+------------------
    // Plain | Plain Delta -     | Len   Area  Vol   Speed | Mass  Temp  Data
    // Delta | Delta Delta -     | -     -     -     -     | -     -     -
    // Time  | Time  Time  Delta | -     -     -     -     | -     -     -
    // ------+-------------------+-------------------------+------------------
    // Len   | Len   -     -     | Len   -     -     -     | -     -     -
    // Area  | Area  -     -     | -     Area  -     -     | -     -     -
    // Vol   | Vol   -     -     | -     -     Vol   -     | -     -     -
    // Speed | Speed -     -     | -     -     -     Speed | -     -     -
    // ------+-------------------+-------------------------+------------------
    // Mass  | Mass  -     -     | -     -     -     -     | Mass  -     -
    // Temp  | Temp  -     -     | -     -     -     -     | -     Temp  -
    // Data  | Data  -     -     | -     -     -     -     | -     -     Data

    pub fn calc_sub(lhs: ValueRef, rhs: ValueRef) -> MyResult<ValueRef> {
        let meaning = combine_binary!(
            lhs.borrow().meaning,
            rhs.borrow().meaning,
            combine_sub_time,
            combine_copy_left,
            combine_copy_right,
            combine_copy_same,
        )?;
        let result = Self::perform_binary(lhs, rhs, meaning, |x, y| x.checked_sub(&y));
        Ok(result)
    }

    // Mul   | Plain Delta Time  | Len   Area  Vol   Speed | Mass  Temp  Data
    // ------+-------------------+-------------------------+------------------
    // Plain | Plain Delta -     | Len   Area  Vol   Speed | Mass  Temp  Data
    // Delta | Delta -     -     | -     -     -     Len   | -     -     -
    // Time  | -     -     -     | -     -     -     -     | -     -     -
    // ------+-------------------+-------------------------+------------------
    // Len   | Len   -     -     | Area  Vol   -     -     | -     -     -
    // Area  | Area  -     -     | Vol   -     -     -     | -     -     -
    // Vol   | Vol   -     -     | -     -     -     -     | -     -     -
    // Speed | Speed Len   -     | -     -     -     -     | -     -     -
    // ------+-------------------+-------------------------+------------------
    // Mass  | Mass  -     -     | -     -     -     -     | -     -     -
    // Temp  | Temp  -     -     | -     -     -     -     | -     -     -
    // Data  | Data  -     -     | -     -     -     -     | -     -     -

    pub fn calc_mul(lhs: ValueRef, rhs: ValueRef) -> MyResult<ValueRef> {
        let meaning = combine_binary!(
            lhs.borrow().meaning,
            rhs.borrow().meaning,
            combine_mul_unit,
            combine_copy_left,
            combine_copy_right,
        )?;
        let result = Self::perform_binary(lhs, rhs, meaning, |x, y| x.checked_mul(&y));
        Ok(result)
    }

    // Div   | Plain Delta Time  | Len   Area  Vol   Speed | Mass  Temp  Data
    // ------+-------------------+-------------------------+------------------
    // Plain | Plain -     -     | -     -     -     -     | -     -     -
    // Delta | Delta Plain -     | -     -     -     -     | -     -     -
    // Time  | -     -     -     | -     -     -     -     | -     -     -
    // ------+-------------------+-------------------------+------------------
    // Len   | Len   -     -     | Plain -     -     Delta | -     -     -
    // Area  | Area  -     -     | Len   Plain -     -     | -     -     -
    // Vol   | Vol   -     -     | Area  Len   Plain -     | -     -     -
    // Speed | Speed -     -     | -     -     -     Plain | -     -     -
    // ------+-------------------+-------------------------+------------------
    // Mass  | Mass  -     -     | -     -     -     -     | Plain -     -
    // Temp  | Temp  -     -     | -     -     -     -     | -     Plain -
    // Data  | Data  -     -     | -     -     -     -     | -     -     Plain

    pub fn calc_div(lhs: ValueRef, rhs: ValueRef) -> MyResult<ValueRef> {
        let meaning = combine_binary!(
            lhs.borrow().meaning,
            rhs.borrow().meaning,
            combine_div_unit,
            combine_copy_left,
        )?;
        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 = combine_binary!(
            lhs.borrow().meaning,
            rhs.borrow().meaning,
            combine_div_unit,
            combine_copy_left,
        )?;
        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)
    }

    // Neg   |
    // ------+-------
    // Plain | Plain
    // Delta | Delta
    // Time  | -
    // Other | Other

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

    // Inv   |
    // ------+-------
    // Plain | Plain
    // Delta | -
    // Time  | -
    // Other | -

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

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

    // Pow   | Plain Delta Time  | Other
    // ------+-------------------+-------
    // Plain | Plain -     -     | -
    // Delta | -     -     -     | -
    // Time  | -     -     -     | -
    // ------+-------------------+-------
    // Other | -     -     -     | -

    pub fn calc_pow(lhs: ValueRef, rhs: ValueRef) -> MyResult<ValueRef> {
        let meaning = combine_binary!(
            lhs.borrow().meaning,
            rhs.borrow().meaning,
            combine_only_plain,
        )?;
        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
    }

    // Sqrt  |
    // ------+-------
    // Plain | Plain
    // Delta | -
    // Time  | -
    // Other | -

    pub fn calc_sqrt(value: ValueRef) -> MyResult<ValueRef> {
        value.borrow().meaning.select_only_plain()?;
        let result = Self::perform_unary(value, 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,
        }
    }

    // And   | Plain Delta Time  | Other
    // ------+-------------------+-------
    // Plain | Plain -     -     | -
    // Delta | -     -     -     | -
    // Time  | -     -     -     | -
    // ------+-------------------+-------
    // Other | -     -     -     | -

    pub fn calc_and(lhs: ValueRef, rhs: ValueRef) -> MyResult<ValueRef> {
        let meaning = combine_binary!(
            lhs.borrow().meaning,
            rhs.borrow().meaning,
            combine_only_plain,
        )?;
        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 = combine_binary!(
            lhs.borrow().meaning,
            rhs.borrow().meaning,
            combine_only_plain,
        )?;
        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 = combine_binary!(
            lhs.borrow().meaning,
            rhs.borrow().meaning,
            combine_only_plain,
        )?;
        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 = combine_binary!(
            lhs.borrow().meaning,
            rhs.borrow().meaning,
            combine_only_plain,
        )?;
        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 = combine_binary!(
            lhs.borrow().meaning,
            rhs.borrow().meaning,
            combine_only_plain,
        )?;
        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)))
    }
}

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 meaning = self.meaning;
        let comment = self.comment.clone();
        Self { number, meaning, variable: None, comment }
    }
}

impl Debug for Value {
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        if let Some(number) = &self.number {
            write!(f, "{}", number::format_ratio(number))?;
        } else {
            write!(f, "NaN")?;
        }
        if self.meaning != Meaning::Plain {
            write!(f, " [{}]", self.meaning)?;
        }
        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, Format::*};
    use crate::calc::meaning::AreaKind::*;
    use crate::calc::meaning::DataKind::*;
    use crate::calc::meaning::DeltaKind::*;
    use crate::calc::meaning::LengthKind::*;
    use crate::calc::meaning::MassKind::*;
    use crate::calc::meaning::PrefixKind::*;
    use crate::calc::meaning::SpeedKind::*;
    use crate::calc::meaning::TempKind::*;
    use crate::calc::meaning::VolumeKind::*;
    use crate::calc::meaning::{Meaning, Meaning::*};
    use crate::calc::value::{Value, ValueRef};
    use crate::regex;
    use crate::util::number::create_ratio;
    use num::{BigRational, CheckedMul, CheckedSub, FromPrimitive, ToPrimitive};
    use pretty_assertions::assert_eq;
    use std::cell::RefCell;
    use std::rc::Rc;

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

    macro_rules! to_strings {
        ($($x:expr),*) => {
            ($($x.to_string()),*)
        };
    }

    #[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(Time), summer1);
        assert_eq!(create_value(1719791999000, 1000).with_meaning(Time), summer2);
        assert_eq!(create_value(1719791999999, 1000).with_meaning(Time), summer3);
        assert_eq!(create_value(1735689540000, 1000).with_meaning(Time), winter1);
        assert_eq!(create_value(1735689599000, 1000).with_meaning(Time), winter2);
        assert_eq!(create_value(1735689599999, 1000).with_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(Time), summer1);
        assert_eq!(create_value(1719791999000, 1000).with_meaning(Time), summer2);
        assert_eq!(create_value(1719791999999, 1000).with_meaning(Time), summer3);
        assert_eq!(create_value(1735689540000, 1000).with_meaning(Time), winter1);
        assert_eq!(create_value(1735689599000, 1000).with_meaning(Time), winter2);
        assert_eq!(create_value(1735689599999, 1000).with_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(Delta(HMS)), minutes1);
        assert_eq!(create_value(2096700, 1000).with_meaning(Delta(HMS)), minutes2);
        assert_eq!(create_value(2096789, 1000).with_meaning(Delta(HMS)), minutes3);
        assert_eq!(create_value(-2096000, 1000).with_meaning(Delta(HMS)), minutes4);
        assert_eq!(create_value(-2096700, 1000).with_meaning(Delta(HMS)), minutes5);
        assert_eq!(create_value(-2096789, 1000).with_meaning(Delta(HMS)), minutes6);
        assert_eq!(create_value(45296000, 1000).with_meaning(Delta(HMS)), hours1);
        assert_eq!(create_value(45296700, 1000).with_meaning(Delta(HMS)), hours2);
        assert_eq!(create_value(45296789, 1000).with_meaning(Delta(HMS)), hours3);
        assert_eq!(create_value(-45296000, 1000).with_meaning(Delta(HMS)), hours4);
        assert_eq!(create_value(-45296700, 1000).with_meaning(Delta(HMS)), hours5);
        assert_eq!(create_value(-45296789, 1000).with_meaning(Delta(HMS)), hours6);
        assert_eq!(create_value(822896000, 1000).with_meaning(Delta(HMS)), days1);
        assert_eq!(create_value(822896700, 1000).with_meaning(Delta(HMS)), days2);
        assert_eq!(create_value(822896789, 1000).with_meaning(Delta(HMS)), days3);
        assert_eq!(create_value(-822896000, 1000).with_meaning(Delta(HMS)), days4);
        assert_eq!(create_value(-822896700, 1000).with_meaning(Delta(HMS)), days5);
        assert_eq!(create_value(-822896789, 1000).with_meaning(Delta(HMS)), 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(Delta(HMS)), days1);
        assert_eq!(create_value(822896700, 1000).with_meaning(Delta(HMS)), days2);
        assert_eq!(create_value(822896789, 1000).with_meaning(Delta(HMS)), days3);
        assert_eq!(create_value(-822896000, 1000).with_meaning(Delta(HMS)), days4);
        assert_eq!(create_value(-822896700, 1000).with_meaning(Delta(HMS)), days5);
        assert_eq!(create_value(-822896789, 1000).with_meaning(Delta(HMS)), 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() {
        assert_eq!(to_strings!("0", ""), format_context(Base10, false, None, 0, 1));
        assert_eq!(to_strings!("1", ""), format_context(Base10, false, None, 1, 1));
        assert_eq!(to_strings!("12", ""), format_context(Base10, false, None, 12, 1));
        assert_eq!(to_strings!("123", ""), format_context(Base10, false, None, 123, 1));
        assert_eq!(to_strings!("1234", ""), format_context(Base10, false, None, 1234, 1));
        assert_eq!(to_strings!("12345", ""), format_context(Base10, false, None, 12345, 1));
        assert_eq!(to_strings!("123456", ""), format_context(Base10, false, None, 123456, 1));
        assert_eq!(to_strings!("1234567", ""), format_context(Base10, false, None, 1234567, 1));
        assert_eq!(to_strings!("12345678", ""), format_context(Base10, false, None, 12345678, 1));
        assert_eq!(to_strings!("123456789", ""), format_context(Base10, false, None, 123456789, 1));
        assert_eq!(to_strings!("-1", ""), format_context(Base10, false, None, -1, 1));
        assert_eq!(to_strings!("-12", ""), format_context(Base10, false, None, -12, 1));
        assert_eq!(to_strings!("-123", ""), format_context(Base10, false, None, -123, 1));
        assert_eq!(to_strings!("-1234", ""), format_context(Base10, false, None, -1234, 1));
        assert_eq!(to_strings!("-12345", ""), format_context(Base10, false, None, -12345, 1));
        assert_eq!(to_strings!("-123456", ""), format_context(Base10, false, None, -123456, 1));
        assert_eq!(to_strings!("-1234567", ""), format_context(Base10, false, None, -1234567, 1));
        assert_eq!(to_strings!("-12345678", ""), format_context(Base10, false, None, -12345678, 1));
        assert_eq!(to_strings!("-123456789", ""), format_context(Base10, false, None, -123456789, 1));
        assert_eq!(to_strings!("0", ".00001"), format_context(Base10, false, None, 1, 100000));
        assert_eq!(to_strings!("0", ".0001"), format_context(Base10, false, None, 1, 10000));
        assert_eq!(to_strings!("0", ".001"), format_context(Base10, false, None, 1, 1000));
        assert_eq!(to_strings!("0", ".01"), format_context(Base10, false, None, 1, 100));
        assert_eq!(to_strings!("0", ".1"), format_context(Base10, false, None, 1, 10));
        assert_eq!(to_strings!("0", ".4994"), format_context(Base10, false, None, 49940, 100000));
        assert_eq!(to_strings!("0", ".49949"), format_context(Base10, false, None, 49949, 100000));
        assert_eq!(to_strings!("0", ".4995"), format_context(Base10, false, None, 49950, 100000));
        assert_eq!(to_strings!("0", ".49951"), format_context(Base10, false, None, 49951, 100000));
        assert_eq!(to_strings!("0", ".9"), format_context(Base10, false, None, 9, 10));
        assert_eq!(to_strings!("0", ".99"), format_context(Base10, false, None, 99, 100));
        assert_eq!(to_strings!("0", ".999"), format_context(Base10, false, None, 999, 1000));
        assert_eq!(to_strings!("0", ".9999"), format_context(Base10, false, None, 9999, 10000));
        assert_eq!(to_strings!("0", ".99999"), format_context(Base10, false, None, 99999, 100000));
        assert_eq!(to_strings!("-0", ".00001"), format_context(Base10, false, None, -1, 100000));
        assert_eq!(to_strings!("-0", ".0001"), format_context(Base10, false, None, -1, 10000));
        assert_eq!(to_strings!("-0", ".001"), format_context(Base10, false, None, -1, 1000));
        assert_eq!(to_strings!("-0", ".01"), format_context(Base10, false, None, -1, 100));
        assert_eq!(to_strings!("-0", ".1"), format_context(Base10, false, None, -1, 10));
        assert_eq!(to_strings!("-0", ".4994"), format_context(Base10, false, None, -49940, 100000));
        assert_eq!(to_strings!("-0", ".49949"), format_context(Base10, false, None, -49949, 100000));
        assert_eq!(to_strings!("-0", ".4995"), format_context(Base10, false, None, -49950, 100000));
        assert_eq!(to_strings!("-0", ".49951"), format_context(Base10, false, None, -49951, 100000));
        assert_eq!(to_strings!("-0", ".9"), format_context(Base10, false, None, -9, 10));
        assert_eq!(to_strings!("-0", ".99"), format_context(Base10, false, None, -99, 100));
        assert_eq!(to_strings!("-0", ".999"), format_context(Base10, false, None, -999, 1000));
        assert_eq!(to_strings!("-0", ".9999"), format_context(Base10, false, None, -9999, 10000));
        assert_eq!(to_strings!("-0", ".99999"), format_context(Base10, false, None, -99999, 100000));
    }

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

    #[test]
    fn test_decimal_is_formatted_with_precision() {
        assert_eq!(to_strings!("0", ".000"), format_context(Base10, false, Some(3), 0, 1));
        assert_eq!(to_strings!("1", ".000"), format_context(Base10, false, Some(3), 1, 1));
        assert_eq!(to_strings!("12", ".000"), format_context(Base10, false, Some(3), 12, 1));
        assert_eq!(to_strings!("123", ".000"), format_context(Base10, false, Some(3), 123, 1));
        assert_eq!(to_strings!("1234", ".000"), format_context(Base10, false, Some(3), 1234, 1));
        assert_eq!(to_strings!("12345", ".000"), format_context(Base10, false, Some(3), 12345, 1));
        assert_eq!(to_strings!("123456", ".000"), format_context(Base10, false, Some(3), 123456, 1));
        assert_eq!(to_strings!("1234567", ".000"), format_context(Base10, false, Some(3), 1234567, 1));
        assert_eq!(to_strings!("12345678", ".000"), format_context(Base10, false, Some(3), 12345678, 1));
        assert_eq!(to_strings!("123456789", ".000"), format_context(Base10, false, Some(3), 123456789, 1));
        assert_eq!(to_strings!("-1", ".000"), format_context(Base10, false, Some(3), -1, 1));
        assert_eq!(to_strings!("-12", ".000"), format_context(Base10, false, Some(3), -12, 1));
        assert_eq!(to_strings!("-123", ".000"), format_context(Base10, false, Some(3), -123, 1));
        assert_eq!(to_strings!("-1234", ".000"), format_context(Base10, false, Some(3), -1234, 1));
        assert_eq!(to_strings!("-12345", ".000"), format_context(Base10, false, Some(3), -12345, 1));
        assert_eq!(to_strings!("-123456", ".000"), format_context(Base10, false, Some(3), -123456, 1));
        assert_eq!(to_strings!("-1234567", ".000"), format_context(Base10, false, Some(3), -1234567, 1));
        assert_eq!(to_strings!("-12345678", ".000"), format_context(Base10, false, Some(3), -12345678, 1));
        assert_eq!(to_strings!("-123456789", ".000"), format_context(Base10, false, Some(3), -123456789, 1));
        assert_eq!(to_strings!("0", ".000"), format_context(Base10, false, Some(3), 1, 100000));
        assert_eq!(to_strings!("0", ".000"), format_context(Base10, false, Some(3), 1, 10000));
        assert_eq!(to_strings!("0", ".001"), format_context(Base10, false, Some(3), 1, 1000));
        assert_eq!(to_strings!("0", ".010"), format_context(Base10, false, Some(3), 1, 100));
        assert_eq!(to_strings!("0", ".100"), format_context(Base10, false, Some(3), 1, 10));
        assert_eq!(to_strings!("0", ".499"), format_context(Base10, false, Some(3), 49940, 100000));
        assert_eq!(to_strings!("0", ".499"), format_context(Base10, false, Some(3), 49949, 100000));
        assert_eq!(to_strings!("0", ".500"), format_context(Base10, false, Some(3), 49950, 100000));
        assert_eq!(to_strings!("0", ".500"), format_context(Base10, false, Some(3), 49951, 100000));
        assert_eq!(to_strings!("0", ".900"), format_context(Base10, false, Some(3), 9, 10));
        assert_eq!(to_strings!("0", ".990"), format_context(Base10, false, Some(3), 99, 100));
        assert_eq!(to_strings!("0", ".999"), format_context(Base10, false, Some(3), 999, 1000));
        assert_eq!(to_strings!("1", ".000"), format_context(Base10, false, Some(3), 9999, 10000));
        assert_eq!(to_strings!("1", ".000"), format_context(Base10, false, Some(3), 99999, 100000));
        assert_eq!(to_strings!("0", ".000"), format_context(Base10, false, Some(3), -1, 100000));
        assert_eq!(to_strings!("0", ".000"), format_context(Base10, false, Some(3), -1, 10000));
        assert_eq!(to_strings!("-0", ".001"), format_context(Base10, false, Some(3), -1, 1000));
        assert_eq!(to_strings!("-0", ".010"), format_context(Base10, false, Some(3), -1, 100));
        assert_eq!(to_strings!("-0", ".100"), format_context(Base10, false, Some(3), -1, 10));
        assert_eq!(to_strings!("-0", ".499"), format_context(Base10, false, Some(3), -49940, 100000));
        assert_eq!(to_strings!("-0", ".499"), format_context(Base10, false, Some(3), -49949, 100000));
        assert_eq!(to_strings!("-0", ".500"), format_context(Base10, false, Some(3), -49950, 100000));
        assert_eq!(to_strings!("-0", ".500"), format_context(Base10, false, Some(3), -49951, 100000));
        assert_eq!(to_strings!("-0", ".900"), format_context(Base10, false, Some(3), -9, 10));
        assert_eq!(to_strings!("-0", ".990"), format_context(Base10, false, Some(3), -99, 100));
        assert_eq!(to_strings!("-0", ".999"), format_context(Base10, false, Some(3), -999, 1000));
        assert_eq!(to_strings!("-1", ".000"), format_context(Base10, false, Some(3), -9999, 10000));
        assert_eq!(to_strings!("-1", ".000"), format_context(Base10, false, Some(3), -99999, 100000));
    }

    #[test]
    fn test_recurring_is_formatted_with_precision() {
        let expected = regex!(r"^\.6+$");
        let value = create_value(2, 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(".666667"), format(Some(6)));
        assert_eq!(expected.is_match(&format(None)), true);
    }

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

    #[test]
    fn test_hexadecimal_is_formatted_with_separator() {
        assert_eq!(to_strings!("0x,00000000,00000000,00000000", ""), format_context(Base16(3), true, None, 0, 1));
        assert_eq!(to_strings!("0x,00000000,00000000,00000001", ""), format_context(Base16(3), true, None, 1, 1));
        assert_eq!(to_strings!("0x,00000000,00000000,7ffffffe", ""), format_context(Base16(3), true, None, 2147483646, 1));
        assert_eq!(to_strings!("0x,00000000,00000000,7fffffff", ""), format_context(Base16(3), true, None, 2147483647, 1));
        assert_eq!(to_strings!("0x,00000000,00000000,80000000", ""), format_context(Base16(3), true, None, 2147483648, 1));
        assert_eq!(to_strings!("0x,00000000,00000000,80000001", ""), format_context(Base16(3), true, None, 2147483649, 1));
        assert_eq!(to_strings!("0x,00000000,00000000,fffffffe", ""), format_context(Base16(3), true, None, 4294967294, 1));
        assert_eq!(to_strings!("0x,00000000,00000000,ffffffff", ""), format_context(Base16(3), true, None, 4294967295, 1));
        assert_eq!(to_strings!("0x,00000000,00000001,00000000", ""), format_context(Base16(3), true, None, 4294967296, 1));
        assert_eq!(to_strings!("0x,00000000,00000001,00000001", ""), format_context(Base16(3), true, None, 4294967297, 1));
        assert_eq!(to_strings!("0x,00000000,7fffffff,fffffffe", ""), format_context(Base16(3), true, None, 9223372036854775806, 1));
        assert_eq!(to_strings!("0x,00000000,7fffffff,ffffffff", ""), format_context(Base16(3), true, None, 9223372036854775807, 1));
        assert_eq!(to_strings!("0x,00000000,80000000,00000000", ""), format_context(Base16(3), true, None, 9223372036854775808, 1));
        assert_eq!(to_strings!("0x,00000000,80000000,00000001", ""), format_context(Base16(3), true, None, 9223372036854775809, 1));
        assert_eq!(to_strings!("0x,00000000,ffffffff,fffffffe", ""), format_context(Base16(3), true, None, 18446744073709551614, 1));
        assert_eq!(to_strings!("0x,00000000,ffffffff,ffffffff", ""), format_context(Base16(3), true, None, 18446744073709551615, 1));
        assert_eq!(to_strings!("0x,00000001,00000000,00000000", ""), format_context(Base16(3), true, None, 18446744073709551616, 1));
        assert_eq!(to_strings!("0x,00000001,00000000,00000001", ""), format_context(Base16(3), true, None, 18446744073709551617, 1));
        assert_eq!(to_strings!("0x,ffffffff,00000000,00000000", ""), format_context(Base16(3), true, None, -18446744073709551616, 1));
        assert_eq!(to_strings!("0x,ffffffff,00000000,00000001", ""), format_context(Base16(3), true, None, -18446744073709551615, 1));
        assert_eq!(to_strings!("0x,ffffffff,80000000,00000000", ""), format_context(Base16(3), true, None, -9223372036854775808, 1));
        assert_eq!(to_strings!("0x,ffffffff,80000000,00000001", ""), format_context(Base16(3), true, None, -9223372036854775807, 1));
        assert_eq!(to_strings!("0x,ffffffff,ffffffff,00000000", ""), format_context(Base16(3), true, None, -4294967296, 1));
        assert_eq!(to_strings!("0x,ffffffff,ffffffff,00000001", ""), format_context(Base16(3), true, None, -4294967295, 1));
        assert_eq!(to_strings!("0x,ffffffff,ffffffff,80000000", ""), format_context(Base16(3), true, None, -2147483648, 1));
        assert_eq!(to_strings!("0x,ffffffff,ffffffff,80000001", ""), format_context(Base16(3), true, None, -2147483647, 1));
        assert_eq!(to_strings!("0x,ffffffff,ffffffff,fffffffe", ""), format_context(Base16(3), true, None, -2, 1));
        assert_eq!(to_strings!("0x,ffffffff,ffffffff,ffffffff", ""), format_context(Base16(3), true, None, -1, 1));
    }

    #[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_as_iso_8601() {
        assert_eq!(to_strings!("2024-06-30T12:00:00", ".000Z", ""), format_meaning(Time, 1719748800000, 1000));
        assert_eq!(to_strings!("2024-06-30T12:00:00", ".987Z", ""), format_meaning(Time, 1719748800987, 1000));
        assert_eq!(to_strings!("2024-12-31T12:00:00", ".000Z", ""), format_meaning(Time, 1735646400000, 1000));
        assert_eq!(to_strings!("2024-12-31T12:00:00", ".987Z", ""), format_meaning(Time, 1735646400987, 1000));
    }

    #[test]
    fn test_delta_is_formatted_as_iso_8601() {
        assert_eq!(to_strings!("00", ".000", ""), format_meaning(Delta(HMS), 0, 1));
        assert_eq!(to_strings!("59", ".999", ""), format_meaning(Delta(HMS), 59999, 1000));
        assert_eq!(to_strings!("01:00", ".000", ""), format_meaning(Delta(HMS), 60000, 1000));
        assert_eq!(to_strings!("59:59", ".999", ""), format_meaning(Delta(HMS), 3599999, 1000));
        assert_eq!(to_strings!("01:00:00", ".000", ""), format_meaning(Delta(HMS), 3600000, 1000));
        assert_eq!(to_strings!("23:59:59", ".999", ""), format_meaning(Delta(HMS), 86399999, 1000));
        assert_eq!(to_strings!("1T00:00:00", ".000", ""), format_meaning(Delta(HMS), 86400000, 1000));
        assert_eq!(to_strings!("100T00:00:00", ".000", ""), format_meaning(Delta(HMS), 8640000000, 1000));
        assert_eq!(to_strings!("-59", ".999", ""), format_meaning(Delta(HMS), -59999, 1000));
        assert_eq!(to_strings!("-01:00", ".000", ""), format_meaning(Delta(HMS), -60000, 1000));
        assert_eq!(to_strings!("-59:59", ".999", ""), format_meaning(Delta(HMS), -3599999, 1000));
        assert_eq!(to_strings!("-01:00:00", ".000", ""), format_meaning(Delta(HMS), -3600000, 1000));
        assert_eq!(to_strings!("-23:59:59", ".999", ""), format_meaning(Delta(HMS), -86399999, 1000));
        assert_eq!(to_strings!("-1T00:00:00", ".000", ""), format_meaning(Delta(HMS), -86400000, 1000));
        assert_eq!(to_strings!("-100T00:00:00", ".000", ""), format_meaning(Delta(HMS), -8640000000, 1000));
    }

    #[test]
    fn test_prefix_is_formatted_with_unit() {
        assert_eq!(to_strings!("1", "", "Qm"), format_meaning(Length(Metre(Quetta)), 1, 1));
        assert_eq!(to_strings!("1", "", "Rm"), format_meaning(Length(Metre(Ronna)), 1, 1));
        assert_eq!(to_strings!("1", "", "Ym"), format_meaning(Length(Metre(Yotta)), 1, 1));
        assert_eq!(to_strings!("1", "", "Zm"), format_meaning(Length(Metre(Zetta)), 1, 1));
        assert_eq!(to_strings!("1", "", "Em"), format_meaning(Length(Metre(Exa)), 1, 1));
        assert_eq!(to_strings!("1", "", "Pm"), format_meaning(Length(Metre(Peta)), 1, 1));
        assert_eq!(to_strings!("1", "", "Tm"), format_meaning(Length(Metre(Tera)), 1, 1));
        assert_eq!(to_strings!("1", "", "Gm"), format_meaning(Length(Metre(Giga)), 1, 1));
        assert_eq!(to_strings!("1", "", "Mm"), format_meaning(Length(Metre(Mega)), 1, 1));
        assert_eq!(to_strings!("1", "", "km"), format_meaning(Length(Metre(Kilo)), 1, 1));
        assert_eq!(to_strings!("1", "", "hm"), format_meaning(Length(Metre(Hecto)), 1, 1));
        assert_eq!(to_strings!("1", "", "dam"), format_meaning(Length(Metre(Deca)), 1, 1));
        assert_eq!(to_strings!("1", "", "m"), format_meaning(Length(Metre(Unit)), 1, 1));
        assert_eq!(to_strings!("1", "", "dm"), format_meaning(Length(Metre(Deci)), 1, 1));
        assert_eq!(to_strings!("1", "", "cm"), format_meaning(Length(Metre(Centi)), 1, 1));
        assert_eq!(to_strings!("1", "", "mm"), format_meaning(Length(Metre(Milli)), 1, 1));
        assert_eq!(to_strings!("1", "", "um"), format_meaning(Length(Metre(Micro)), 1, 1));
        assert_eq!(to_strings!("1", "", "nm"), format_meaning(Length(Metre(Nano)), 1, 1));
        assert_eq!(to_strings!("1", "", "pm"), format_meaning(Length(Metre(Pico)), 1, 1));
        assert_eq!(to_strings!("1", "", "fm"), format_meaning(Length(Metre(Femto)), 1, 1));
        assert_eq!(to_strings!("1", "", "am"), format_meaning(Length(Metre(Atto)), 1, 1));
        assert_eq!(to_strings!("1", "", "zm"), format_meaning(Length(Metre(Zepto)), 1, 1));
        assert_eq!(to_strings!("1", "", "ym"), format_meaning(Length(Metre(Yocto)), 1, 1));
        assert_eq!(to_strings!("1", "", "rm"), format_meaning(Length(Metre(Ronto)), 1, 1));
        assert_eq!(to_strings!("1", "", "qm"), format_meaning(Length(Metre(Quecto)), 1, 1));
    }

    #[test]
    fn test_delta_is_formatted_with_unit() {
        assert_eq!(to_strings!("1", "", "s"), format_meaning(Delta(Second(Unit)), 1, 1));
        assert_eq!(to_strings!("1", "", "ms"), format_meaning(Delta(Second(Milli)), 1, 1));
        assert_eq!(to_strings!("1", "", "minute"), format_meaning(Delta(Minute), 1, 1));
        assert_eq!(to_strings!("1", "", "hour"), format_meaning(Delta(Hour), 1, 1));
        assert_eq!(to_strings!("1", "", "day"), format_meaning(Delta(Day), 1, 1));
        assert_eq!(to_strings!("1", "", "week"), format_meaning(Delta(Week), 1, 1));
        assert_eq!(to_strings!("1", "", "month"), format_meaning(Delta(Month), 1, 1));
        assert_eq!(to_strings!("1", "", "year"), format_meaning(Delta(Year), 1, 1));
    }

    #[test]
    fn test_length_is_formatted_with_unit() {
        assert_eq!(to_strings!("1", "", "m"), format_meaning(Length(Metre(Unit)), 1, 1));
        assert_eq!(to_strings!("1", "", "km"), format_meaning(Length(Metre(Kilo)), 1, 1));
        assert_eq!(to_strings!("1", "", "inch"), format_meaning(Length(Inch), 1, 1));
        assert_eq!(to_strings!("1", "", "foot"), format_meaning(Length(Foot), 1, 1));
        assert_eq!(to_strings!("1", "", "yard"), format_meaning(Length(Yard), 1, 1));
        assert_eq!(to_strings!("1", "", "mile"), format_meaning(Length(Mile), 1, 1));
    }

    #[test]
    fn test_area_is_formatted_with_unit() {
        assert_eq!(to_strings!("1", "", "m^2"), format_meaning(Area(Square(Metre(Unit))), 1, 1));
        assert_eq!(to_strings!("1", "", "km^2"), format_meaning(Area(Square(Metre(Kilo))), 1, 1));
        assert_eq!(to_strings!("1", "", "mile^2"), format_meaning(Area(Square(Mile)), 1, 1));
        assert_eq!(to_strings!("1", "", "hectare"), format_meaning(Area(Hectare), 1, 1));
        assert_eq!(to_strings!("1", "", "acre"), format_meaning(Area(Acre), 1, 1));
    }

    #[test]
    fn test_volume_is_formatted_with_unit() {
        assert_eq!(to_strings!("1", "", "m^3"), format_meaning(Volume(Cubic(Metre(Unit))), 1, 1));
        assert_eq!(to_strings!("1", "", "km^3"), format_meaning(Volume(Cubic(Metre(Kilo))), 1, 1));
        assert_eq!(to_strings!("1", "", "mile^3"), format_meaning(Volume(Cubic(Mile)), 1, 1));
        assert_eq!(to_strings!("1", "", "l"), format_meaning(Volume(Litre(Unit)), 1, 1));
        assert_eq!(to_strings!("1", "", "ml"), format_meaning(Volume(Litre(Milli)), 1, 1));
        assert_eq!(to_strings!("1", "", "tsp"), format_meaning(Volume(Tsp), 1, 1));
        assert_eq!(to_strings!("1", "", "tbsp"), format_meaning(Volume(Tbsp), 1, 1));
        assert_eq!(to_strings!("1", "", "floz"), format_meaning(Volume(Floz), 1, 1));
        assert_eq!(to_strings!("1", "", "pint"), format_meaning(Volume(Pint), 1, 1));
        assert_eq!(to_strings!("1", "", "quart"), format_meaning(Volume(Quart), 1, 1));
        assert_eq!(to_strings!("1", "", "gallon"), format_meaning(Volume(Gallon), 1, 1));
        assert_eq!(to_strings!("1", "", "barrel"), format_meaning(Volume(Barrel), 1, 1));
    }

    #[test]
    fn test_speed_is_formatted_with_unit() {
        assert_eq!(to_strings!("1", "", "m/s"), format_meaning(Speed(Ratio(Metre(Unit), Second(Unit))), 1, 1));
        assert_eq!(to_strings!("1", "", "m/hour"), format_meaning(Speed(Ratio(Metre(Unit), Hour)), 1, 1));
        assert_eq!(to_strings!("1", "", "km/s"), format_meaning(Speed(Ratio(Metre(Kilo), Second(Unit))), 1, 1));
        assert_eq!(to_strings!("1", "", "km/hour"), format_meaning(Speed(Ratio(Metre(Kilo), Hour)), 1, 1));
        assert_eq!(to_strings!("1", "", "mile/s"), format_meaning(Speed(Ratio(Mile, Second(Unit))), 1, 1));
        assert_eq!(to_strings!("1", "", "mile/hour"), format_meaning(Speed(Ratio(Mile, Hour)), 1, 1));
        assert_eq!(to_strings!("1", "", "mach"), format_meaning(Speed(Mach), 1, 1));
        assert_eq!(to_strings!("1", "", "light"), format_meaning(Speed(Light), 1, 1));
    }

    #[test]
    fn test_mass_is_formatted_with_unit() {
        assert_eq!(to_strings!("1", "", "g"), format_meaning(Mass(Gram(Unit)), 1, 1));
        assert_eq!(to_strings!("1", "", "kg"), format_meaning(Mass(Gram(Kilo)), 1, 1));
        assert_eq!(to_strings!("1", "", "ounce"), format_meaning(Mass(Ounce), 1, 1));
        assert_eq!(to_strings!("1", "", "pound"), format_meaning(Mass(Pound), 1, 1));
        assert_eq!(to_strings!("1", "", "stone"), format_meaning(Mass(Stone), 1, 1));
        assert_eq!(to_strings!("1", "", "ton"), format_meaning(Mass(Ton), 1, 1));
    }

    #[test]
    fn test_temp_is_formatted_with_unit() {
        assert_eq!(to_strings!("1", "", "K"), format_meaning(Temp(Kelvin(Unit)), 1, 1));
        assert_eq!(to_strings!("1", "", "mK"), format_meaning(Temp(Kelvin(Milli)), 1, 1));
        assert_eq!(to_strings!("1", "", "C"), format_meaning(Temp(Celsius), 1, 1));
        assert_eq!(to_strings!("1", "", "F"), format_meaning(Temp(Fahrenheit), 1, 1));
        assert_eq!(to_strings!("1", "", "R"), format_meaning(Temp(Rankine), 1, 1));
    }

    #[test]
    fn test_data_is_formatted_with_unit() {
        assert_eq!(to_strings!("1", "", "B"), format_meaning(Data(Byte(Unit)), 1, 1));
        assert_eq!(to_strings!("1", "", "kB"), format_meaning(Data(Byte(Kilo)), 1, 1));
        assert_eq!(to_strings!("1", "", "bit"), format_meaning(Data(Bit), 1, 1));
    }

    #[test]
    fn test_decimal_is_formatted_from_nan() {
        let expected = (String::from("NaN"), String::from(""), None, 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());
    }

    #[test]
    fn test_plain_values_are_cast_to_unit() {
        assert_eq!(test_apply_meaning(Plain, Plain), Some(create_ratio(1, 1)));
        assert_eq!(test_apply_meaning(Plain, Time), Some(create_ratio(1, 1)));
        assert_eq!(test_apply_meaning(Plain, Delta(Hour)), Some(create_ratio(1, 1)));
        assert_eq!(test_apply_meaning(Plain, Length(Mile)), Some(create_ratio(1, 1)));
        assert_eq!(test_apply_meaning(Plain, Area(Acre)), Some(create_ratio(1, 1)));
        assert_eq!(test_apply_meaning(Plain, Volume(Pint)), Some(create_ratio(1, 1)));
        assert_eq!(test_apply_meaning(Plain, Speed(Light)), Some(create_ratio(1, 1)));
        assert_eq!(test_apply_meaning(Plain, Mass(Ounce)), Some(create_ratio(1, 1)));
        assert_eq!(test_apply_meaning(Plain, Temp(Rankine)), Some(create_ratio(1, 1)));
        assert_eq!(test_apply_meaning(Plain, Data(Bit)), Some(create_ratio(1, 1)));
    }

    #[test]
    fn test_unit_values_are_cast_to_plain() {
        assert_eq!(test_apply_meaning(Plain, Plain), Some(create_ratio(1, 1)));
        assert_eq!(test_apply_meaning(Time, Plain), Some(create_ratio(1, 1)));
        assert_eq!(test_apply_meaning(Delta(Hour), Plain), Some(create_ratio(1, 1)));
        assert_eq!(test_apply_meaning(Length(Mile), Plain), Some(create_ratio(1, 1)));
        assert_eq!(test_apply_meaning(Area(Acre), Plain), Some(create_ratio(1, 1)));
        assert_eq!(test_apply_meaning(Volume(Pint), Plain), Some(create_ratio(1, 1)));
        assert_eq!(test_apply_meaning(Speed(Light), Plain), Some(create_ratio(1, 1)));
        assert_eq!(test_apply_meaning(Mass(Ounce), Plain), Some(create_ratio(1, 1)));
        assert_eq!(test_apply_meaning(Temp(Rankine), Plain), Some(create_ratio(1, 1)));
        assert_eq!(test_apply_meaning(Data(Bit), Plain), Some(create_ratio(1, 1)));
    }

    #[test]
    fn test_unit_values_are_cast_to_unit() {
        assert_eq!(test_apply_meaning(Delta(Hour), Delta(Second(Unit))), Some(create_ratio(3600, 1)));
        assert_eq!(test_apply_meaning(Length(Mile), Length(Metre(Unit))), Some(create_ratio(16093440, 10000)));
        assert_eq!(test_apply_meaning(Area(Acre), Area(Square(Metre(Unit)))), Some(create_ratio(40468564224, 10000000)));
        assert_eq!(test_apply_meaning(Volume(Pint), Volume(Cubic(Metre(Unit)))), Some(create_ratio(568261250, 1000000000000)));
        assert_eq!(test_apply_meaning(Speed(Light), Speed(Ratio(Metre(Unit), Second(Unit)))), Some(create_ratio(299792458, 1)));
        assert_eq!(test_apply_meaning(Mass(Ounce), Mass(Gram(Unit))), Some(create_ratio(28349523125, 1000000000)));
        assert_eq!(test_apply_meaning(Temp(Rankine), Temp(Kelvin(Unit))), Some(create_ratio(5, 9)));
        assert_eq!(test_apply_meaning(Data(Bit), Data(Byte(Unit))), Some(create_ratio(1, 8)));
    }

    fn test_apply_meaning(old: Meaning, new: Meaning) -> Option<BigRational> {
        let value = create_value(1, 1).with_meaning(old);
        let result = value.apply_meaning(new).ok()?;
        let result = result.borrow().number.clone();
        result
    }

    #[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_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_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_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_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_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_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_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_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_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_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_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_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_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_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());
    }

    fn format_context(
        format: Format,
        sep: bool,
        dp: Option<u8>,
        numer: i128,
        denom: i128,
    ) -> (String, String) {
        let context = Context::new()
            .with_format(format)
            .with_sep(sep)
            .with_dp(dp);
        let (integer, fraction, _, _, _) = create_value(numer, denom)
            .to_strings(&context);
        (integer, fraction)
    }

    fn format_meaning(
        meaning: Meaning,
        numer: i128,
        denom: i128,
    ) -> (String, String, String) {
        let context = Context::new();
        let (integer, fraction, symbol, _, _) = create_value(numer, denom)
            .with_meaning(meaning)
            .to_strings(&context);
        let symbol = symbol.unwrap_or_else(String::new);
        (integer, fraction, symbol)
    }

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

    pub fn create_ref(numer: i128, denom: i128) -> ValueRef {
        let value = create_value(numer, denom);
        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) -> Value {
        Value::from_string(number).unwrap()
    }

    pub fn parse_ref(number: &str) -> ValueRef {
        let value = parse_value(number);
        Rc::new(RefCell::new(value))
    }

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

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

    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))
    }
}