Quelle  decimal_tests.rs   Sprache: unbekannt

mod macros;

use core::{cmp::Ordering::*, str::FromStr};
use num_traits::{Inv, Signed, ToPrimitive};
use rust_decimal::{Decimal, Error, RoundingStrategy};

#[test]
#[cfg(feature = "c-repr")]
fn layout_is_correct() {
    assert_eq!(std::mem::size_of::<Decimal>(), std::mem::size_of::<u128>());
}

#[test]
fn it_can_extract_the_mantissa() {
    let tests = [
        ("1", 1i128, 0),
        ("1.123456", 1123456i128, 6),
        ("-0.123456", -123456i128, 6),
    ];
    for &(input, mantissa, scale) in &tests {
        let num = Decimal::from_str(input).unwrap();
        assert_eq!(num.mantissa(), mantissa, "Mantissa for {}", input);
        assert_eq!(num.scale(), scale, "Scale for {}", input);
    }
}

// Parsing

#[test]
fn it_creates_a_new_negative_decimal() {
    let a = Decimal::new(-100, 2);
    assert_eq!(a.is_sign_negative(), true);
    assert_eq!(a.scale(), 2);
    assert_eq!("-1.00", a.to_string());
}

#[test]
fn it_creates_a_new_decimal_using_numeric_boundaries() {
    let a = Decimal::new(i64::MAX, 2);
    assert_eq!(a.is_sign_negative(), false);
    assert_eq!(a.scale(), 2);
    assert_eq!("92233720368547758.07", a.to_string());

    let b = Decimal::new(i64::MIN, 2);
    assert_eq!(b.is_sign_negative(), true);
    assert_eq!(b.scale(), 2);
    assert_eq!("-92233720368547758.08", b.to_string());
}

#[test]
fn it_parses_empty_string() {
    assert!(Decimal::from_str("").is_err());
    assert!(Decimal::from_str(" ").is_err());
}

#[test]
fn it_parses_positive_int_string() {
    let a = Decimal::from_str("233").unwrap();
    assert_eq!(a.is_sign_negative(), false);
    assert_eq!(a.scale(), 0);
    assert_eq!("233", a.to_string());
}

#[test]
fn it_parses_negative_int_string() {
    let a = Decimal::from_str("-233").unwrap();
    assert_eq!(a.is_sign_negative(), true);
    assert_eq!(a.scale(), 0);
    assert_eq!("-233", a.to_string());
}

#[test]
fn it_parses_positive_float_string() {
    let a = Decimal::from_str("233.323223").unwrap();
    assert_eq!(a.is_sign_negative(), false);
    assert_eq!(a.scale(), 6);
    assert_eq!("233.323223", a.to_string());
}

#[test]
fn it_parses_negative_float_string() {
    let a = Decimal::from_str("-233.43343").unwrap();
    assert_eq!(a.is_sign_negative(), true);
    assert_eq!(a.scale(), 5);
    assert_eq!("-233.43343", a.to_string());
}

#[test]
fn it_parses_positive_tiny_float_string() {
    let a = Decimal::from_str(".000001").unwrap();
    assert_eq!(a.is_sign_negative(), false);
    assert_eq!(a.scale(), 6);
    assert_eq!("0.000001", a.to_string());
}

#[test]
fn it_parses_negative_tiny_float_string() {
    let a = Decimal::from_str("-0.000001").unwrap();
    assert_eq!(a.is_sign_negative(), true);
    assert_eq!(a.scale(), 6);
    assert_eq!("-0.000001", a.to_string());
}

#[test]
fn it_parses_big_integer_string() {
    let a = Decimal::from_str("79228162514264337593543950330").unwrap();
    assert_eq!("79228162514264337593543950330", a.to_string());
}

#[test]
fn it_parses_big_float_string() {
    let a = Decimal::from_str("79.228162514264337593543950330").unwrap();
    assert_eq!("79.228162514264337593543950330", a.to_string());
}

#[test]
fn it_can_serialize_deserialize() {
    let tests = [
        "12.3456789",
        "5233.9008808150288439427720175",
        "-5233.9008808150288439427720175",
    ];
    for test in &tests {
        let a = Decimal::from_str(test).unwrap();
        let bytes = a.serialize();
        let b = Decimal::deserialize(bytes);
        assert_eq!(test.to_string(), b.to_string());
    }
}

#[test]
#[cfg(feature = "borsh")]
fn it_can_serialize_deserialize_borsh() {
    let tests = [
        "12.3456789",
        "5233.9008808150288439427720175",
        "-5233.9008808150288439427720175",
    ];
    for test in &tests {
        let a = Decimal::from_str(test).unwrap();
        let mut bytes: Vec<u8> = Vec::new();
        borsh::BorshSerialize::serialize(&a, &mut bytes).unwrap();
        let b: Decimal = borsh::BorshDeserialize::deserialize(&mut bytes.as_slice()).unwrap();
        assert_eq!(test.to_string(), b.to_string());
        let bytes = borsh::try_to_vec_with_schema(&a);
        assert!(bytes.is_ok(), "try_to_vec_with_schema.is_ok()");
        let bytes = bytes.unwrap();
        let result = borsh::try_from_slice_with_schema(&bytes);
        assert!(result.is_ok(), "try_from_slice_with_schema.is_ok()");
        let b: Decimal = result.unwrap();
        assert_eq!(test.to_string(), b.to_string());
    }
}

#[test]
#[cfg(feature = "rkyv")]
fn it_can_serialize_deserialize_rkyv() {
    use rkyv::Deserialize;
    let tests = [
        "12.3456789",
        "5233.9008808150288439427720175",
        "-5233.9008808150288439427720175",
    ];
    for test in &tests {
        let a = Decimal::from_str(test).unwrap();
        let bytes = rkyv::to_bytes::<_, 256>(&a).unwrap();

        #[cfg(feature = "rkyv-safe")]
        {
            let archived = rkyv::check_archived_root::<Decimal>(&bytes[..]).unwrap();
            assert_eq!(archived, &a);
        }

        let archived = unsafe { rkyv::archived_root::<Decimal>(&bytes[..]) };
        assert_eq!(archived, &a);

        let deserialized: Decimal = archived.deserialize(&mut rkyv::Infallible).unwrap();
        assert_eq!(deserialized, a);
    }
}

#[test]
fn it_can_deserialize_unbounded_values() {
    // Mantissa for these: 19393111376951473493673267553
    let tests = [
        (
            [1u8, 0, 28, 206, 97, 81, 216, 182, 20, 30, 165, 78, 18, 155, 169, 62],
            // Scale 28: -1.9393111376951473493673267553
            "-1.9393111376951473493673267553",
        ),
        (
            [1u8, 0, 29, 206, 97, 81, 216, 182, 20, 30, 165, 78, 18, 155, 169, 62],
            // Scale 29: -0.19393111376951473493673267553
            "-0.1939311137695147349367326755",
        ),
        (
            [1u8, 0, 30, 206, 97, 81, 216, 182, 20, 30, 165, 78, 18, 155, 169, 62],
            // Scale 30: -0.019393111376951473493673267553
            "-0.0193931113769514734936732676",
        ),
        (
            [1u8, 0, 31, 206, 97, 81, 216, 182, 20, 30, 165, 78, 18, 155, 169, 62],
            // Scale 31: -0.0019393111376951473493673267553
            "-0.0019393111376951473493673268",
        ),
    ];
    for &(bytes, expected) in &tests {
        let dec = Decimal::deserialize(bytes);
        let string = format!("{:.9999}", dec);
        let dec2 = Decimal::from_str(&string).unwrap();
        assert_eq!(dec, dec2);
        assert_eq!(dec.to_string(), expected, "dec.to_string()");
        assert_eq!(dec2.to_string(), expected, "dec2.to_string()");
    }
}

// Formatting

#[test]
fn it_formats() {
    let a = Decimal::from_str("233.323223").unwrap();
    assert_eq!(format!("{}", a), "233.323223");
    assert_eq!(format!("{:.9}", a), "233.323223000");
    assert_eq!(format!("{:.0}", a), "233");
    assert_eq!(format!("{:.2}", a), "233.32");
    assert_eq!(format!("{:010.2}", a), "0000233.32");
    assert_eq!(format!("{:0<10.2}", a), "233.320000");
}
#[test]
fn it_formats_neg() {
    let a = Decimal::from_str("-233.323223").unwrap();
    assert_eq!(format!("{}", a), "-233.323223");
    assert_eq!(format!("{:.9}", a), "-233.323223000");
    assert_eq!(format!("{:.0}", a), "-233");
    assert_eq!(format!("{:.2}", a), "-233.32");
    assert_eq!(format!("{:010.2}", a), "-000233.32");
    assert_eq!(format!("{:0<10.2}", a), "-233.32000");
}
#[test]
fn it_formats_small() {
    let a = Decimal::from_str("0.2223").unwrap();
    assert_eq!(format!("{}", a), "0.2223");
    assert_eq!(format!("{:.9}", a), "0.222300000");
    assert_eq!(format!("{:.0}", a), "0");
    assert_eq!(format!("{:.2}", a), "0.22");
    assert_eq!(format!("{:010.2}", a), "0000000.22");
    assert_eq!(format!("{:0<10.2}", a), "0.22000000");
}
#[test]
fn it_formats_small_leading_zeros() {
    let a = Decimal::from_str("0.0023554701772169").unwrap();
    assert_eq!(format!("{}", a), "0.0023554701772169");
    assert_eq!(format!("{:.9}", a), "0.002355470");
    assert_eq!(format!("{:.0}", a), "0");
    assert_eq!(format!("{:.2}", a), "0.00");
    assert_eq!(format!("{:010.2}", a), "0000000.00");
    assert_eq!(format!("{:0<10.2}", a), "0.00000000");
}
#[test]
fn it_formats_small_neg() {
    let a = Decimal::from_str("-0.2223").unwrap();
    assert_eq!(format!("{}", a), "-0.2223");
    assert_eq!(format!("{:.9}", a), "-0.222300000");
    assert_eq!(format!("{:.0}", a), "-0");
    assert_eq!(format!("{:.2}", a), "-0.22");
    assert_eq!(format!("{:010.2}", a), "-000000.22");
    assert_eq!(format!("{:0<10.2}", a), "-0.2200000");
}

#[test]
fn it_formats_zero() {
    let a = Decimal::from_str("0").unwrap();
    assert_eq!(format!("{}", a), "0");
    assert_eq!(format!("{:.9}", a), "0.000000000");
    assert_eq!(format!("{:.0}", a), "0");
    assert_eq!(format!("{:.2}", a), "0.00");
    assert_eq!(format!("{:010.2}", a), "0000000.00");
    assert_eq!(format!("{:0<10.2}", a), "0.00000000");
}

#[test]
fn it_formats_int() {
    let a = Decimal::from_str("5").unwrap();
    assert_eq!(format!("{}", a), "5");
    assert_eq!(format!("{:.9}", a), "5.000000000");
    assert_eq!(format!("{:.0}", a), "5");
    assert_eq!(format!("{:.2}", a), "5.00");
    assert_eq!(format!("{:010.2}", a), "0000005.00");
    assert_eq!(format!("{:0<10.2}", a), "5.00000000");
}

#[test]
fn it_formats_lower_exp() {
    let tests = [
        ("0.00001", "1e-5"),
        ("-0.00001", "-1e-5"),
        ("42.123", "4.2123e1"),
        ("-42.123", "-4.2123e1"),
        ("100", "1e2"),
    ];
    for (value, expected) in &tests {
        let a = Decimal::from_str(value).unwrap();
        assert_eq!(&format!("{:e}", a), *expected, "format!(\"{{:e}}\", {})", a);
    }
}

#[test]
fn it_formats_lower_exp_padding() {
    let tests = [
        ("0.00001", "01e-5"),
        ("-0.00001", "-1e-5"),
        ("42.123", "4.2123e1"),
        ("-42.123", "-4.2123e1"),
        ("100", "001e2"),
    ];
    for (value, expected) in &tests {
        let a = Decimal::from_str(value).unwrap();
        assert_eq!(&format!("{:05e}", a), *expected, "format!(\"{{:05e}}\", {})", a);
    }
}

#[test]
fn it_formats_scientific_precision() {
    for (num, scale, expected_no_precision, expected_precision) in [
        (
            123456,
            10,
            "1.23456e-5",
            [
                "1e-5",
                "1.2e-5",
                "1.23e-5",
                "1.234e-5",
                "1.2345e-5",
                "1.23456e-5",
                "1.234560e-5",
                "1.2345600e-5",
            ],
        ),
        (
            123456,
            0,
            "1.23456e5",
            [
                "1e5",
                "1.2e5",
                "1.23e5",
                "1.234e5",
                "1.2345e5",
                "1.23456e5",
                "1.234560e5",
                "1.2345600e5",
            ],
        ),
        (
            1,
            0,
            "1e0",
            [
                "1e0",
                "1.0e0",
                "1.00e0",
                "1.000e0",
                "1.0000e0",
                "1.00000e0",
                "1.000000e0",
                "1.0000000e0",
            ],
        ),
        (
            -123456,
            10,
            "-1.23456e-5",
            [
                "-1e-5",
                "-1.2e-5",
                "-1.23e-5",
                "-1.234e-5",
                "-1.2345e-5",
                "-1.23456e-5",
                "-1.234560e-5",
                "-1.2345600e-5",
            ],
        ),
        (
            -100000,
            10,
            "-1e-5",
            [
                "-1e-5",
                "-1.0e-5",
                "-1.00e-5",
                "-1.000e-5",
                "-1.0000e-5",
                "-1.00000e-5",
                "-1.000000e-5",
                "-1.0000000e-5",
            ],
        ),
    ] {
        assert_eq!(format!("{:e}", Decimal::new(num, scale)), expected_no_precision);
        for i in 0..expected_precision.len() {
            assert_eq!(
                format!("{:.prec$e}", Decimal::new(num, scale), prec = i),
                expected_precision[i]
            );
        }
    }
}

// Negation
#[test]
fn it_negates_decimals() {
    fn neg(a: &str, b: &str) {
        let a = Decimal::from_str(a).unwrap();
        let result = -a;
        assert_eq!(b, result.to_string(), "- {}", a.to_string());
    }

    let tests = &[
        ("1", "-1"),
        ("2", "-2"),
        ("2454495034", "-2454495034"),
        ("0.1", "-0.1"),
        ("11.815126050420168067226890757", "-11.815126050420168067226890757"),
    ];

    for &(a, b) in tests {
        neg(a, b);
        neg(b, a);
    }
}

// Addition

#[test]
fn it_can_add_simple() {
    // This is the most basic test for addition, intended largely for micro-optimization.
    let two = Decimal::ONE + Decimal::ONE;
    assert_eq!(two.to_u32(), Some(2));
}

#[test]
fn it_adds_decimals() {
    fn add(a: &str, b: &str, c: &str) {
        let a = Decimal::from_str(a).unwrap();
        let b = Decimal::from_str(b).unwrap();
        let result = a + b;
        assert_eq!(c, result.to_string(), "{} + {}", a.to_string(), b.to_string());
        let result = b + a;
        assert_eq!(c, result.to_string(), "{} + {}", b.to_string(), a.to_string());
    }

    let tests = &[
        ("0", "0", "0"),
        ("0", "-0", "0"),
        ("-0", "0", "0"),
        ("-0", "-0", "0"),
        ("2", "3", "5"),
        ("2454495034", "3451204593", "5905699627"),
        ("24544.95034", ".3451204593", "24545.2954604593"),
        (".1", ".1", "0.2"),
        (".10", ".1", "0.20"),
        (".1", "-.1", "0.0"),
        ("0", "1.001", "1.001"),
        ("2", "-3", "-1"),
        ("-2", "3", "1"),
        ("-2", "-3", "-5"),
        ("3", "-2", "1"),
        ("-3", "2", "-1"),
        ("1.234", "2.4567", "3.6907"),
        (
            "11.815126050420168067226890757",
            "0.6386554621848739495798319328",
            "12.453781512605042016806722690",
        ),
        (
            "-11.815126050420168067226890757",
            "0.6386554621848739495798319328",
            "-11.176470588235294117647058824",
        ),
        (
            "11.815126050420168067226890757",
            "-0.6386554621848739495798319328",
            "11.176470588235294117647058824",
        ),
        (
            "-11.815126050420168067226890757",
            "-0.6386554621848739495798319328",
            "-12.453781512605042016806722690",
        ),
        (
            "11815126050420168067226890757",
            "0.4386554621848739495798319328",
            "11815126050420168067226890757",
        ),
        (
            "-11815126050420168067226890757",
            "0.4386554621848739495798319328",
            "-11815126050420168067226890757",
        ),
        (
            "11815126050420168067226890757",
            "-0.4386554621848739495798319328",
            "11815126050420168067226890757",
        ),
        (
            "-11815126050420168067226890757",
            "-0.4386554621848739495798319328",
            "-11815126050420168067226890757",
        ),
        (
            "0.0872727272727272727272727272",
            "843.65000000",
            "843.7372727272727272727272727",
        ),
        (
            "7314.6229858868828353570724702",
            "1000",
            // Overflow causes this to round
            "8314.622985886882835357072470",
        ),
        (
            "108053.27500000000000000000000",
            "0.00000000000000000000000",
            "108053.27500000000000000000000",
        ),
        (
            "108053.27500000000000000000000",
            // This zero value has too high precision and will be trimmed
            "0.000000000000000000000000",
            "108053.27500000000000000000000",
        ),
        (
            "108053.27500000000000000000000",
            // This value has too high precision and will be rounded
            "0.000000000000000000000001",
            "108053.27500000000000000000000",
        ),
        (
            "108053.27500000000000000000000",
            // This value has too high precision and will be rounded
            "0.000000000000000000000005",
            either!("108053.27500000000000000000000", "108053.27500000000000000000001"),
        ),
        (
            "8097370036018690744.2590371109596744091",
            "3807285637671831400.15346897797550749555",
            "11904655673690522144.412506089",
        ),
    ];
    for &(a, b, c) in tests {
        add(a, b, c);
    }
}

#[test]
fn it_can_addassign() {
    let mut a = Decimal::from_str("1.01").unwrap();
    let b = Decimal::from_str("0.99").unwrap();
    a += b;
    assert_eq!("2.00", a.to_string());

    a += &b;
    assert_eq!("2.99", a.to_string());

    let mut c = &mut a;
    c += b;
    assert_eq!("3.98", a.to_string());

    let mut c = &mut a;
    c += &b;
    assert_eq!("4.97", a.to_string());
}

// Subtraction

#[test]
fn it_subtracts_decimals() {
    fn sub(a: &str, b: &str, c: &str) {
        let a = Decimal::from_str(a).unwrap();
        let b = Decimal::from_str(b).unwrap();
        let result = a - b;
        assert_eq!(c, result.to_string(), "{} - {}", a.to_string(), b.to_string());
    }

    let tests = &[
        ("0", "0", "0"),
        ("0", "-0", "0"),
        ("-0", "0", "0"),
        ("-0", "-0", "0"),
        ("2", "3", "-1"),
        ("3451204593", "2323322332", "1127882261"),
        ("24544.95034", ".3451204593", "24544.6052195407"),
        (".1", ".1", "0.0"),
        (".1", "-.1", "0.2"),
        ("1.001", "0", "1.001"),
        ("2", "-3", "5"),
        ("-2", "3", "-5"),
        ("-2", "-3", "1"),
        ("3", "-2", "5"),
        ("-3", "2", "-5"),
        ("1.234", "2.4567", "-1.2227"),
        ("844.13000000", "843.65000000", "0.48000000"),
        ("79228162514264337593543950335", "79228162514264337593543950335", "0"), // 0xFFFF_FFFF_FFFF_FFFF_FFF_FFFF - 0xFFFF_FFFF_FFFF_FFFF_FFF_FFFF
        ("79228162514264337593543950335", "0", "79228162514264337593543950335"),
        ("79228162514264337593543950335", "79228162514264337593543950333", "2"),
        ("4951760157141521099596496896", "1", "4951760157141521099596496895"), // 0x1000_0000_0000_0000_0000_0000 - 1 = 0x0FFF_FFFF_FFFF_FFFF_FFF_FFFF
        ("79228162514264337593543950334", "79228162514264337593543950335", "-1"),
        ("1", "4951760157141521099596496895", "-4951760157141521099596496894"),
        ("18446744073709551615", "-18446744073709551615", "36893488147419103230"), // 0xFFFF_FFFF_FFFF_FFFF - -0xFFFF_FFFF_FFFF_FFFF
    ];
    for &(a, b, c) in tests {
        sub(a, b, c);
    }
}

#[test]
fn it_can_subassign() {
    let mut a = Decimal::from_str("1.01").unwrap();
    let b = Decimal::from_str("0.51").unwrap();
    a -= b;
    assert_eq!("0.50", a.to_string());

    a -= &b;
    assert_eq!("-0.01", a.to_string());

    let mut c = &mut a;
    c -= b;
    assert_eq!("-0.52", a.to_string());

    let mut c = &mut a;
    c -= &b;
    assert_eq!("-1.03", a.to_string());
}

// Multiplication

#[test]
fn it_multiplies_decimals() {
    fn mul(a: &str, b: &str, c: &str) {
        let a = Decimal::from_str(a).unwrap();
        let b = Decimal::from_str(b).unwrap();
        let result = a * b;
        assert_eq!(c, result.to_string(), "{} * {}", a.to_string(), b.to_string());
        let result = b * a;
        assert_eq!(c, result.to_string(), "{} * {}", b.to_string(), a.to_string());
    }

    let tests = &[
        ("2", "3", "6"),
        ("2454495034", "3451204593", "8470964534836491162"),
        ("24544.95034", ".3451204593", "8470.964534836491162"),
        (".1", ".1", "0.01"),
        ("0", "1.001", "0"),
        ("2", "-3", "-6"),
        ("-2", "3", "-6"),
        ("-2", "-3", "6"),
        ("1", "2.01", "2.01"),
        ("1.0", "2.01", "2.010"), // Scale is always additive
        (
            "0.00000000000000001",
            "0.00000000000000001",
            "0.0000000000000000000000000000",
        ),
        ("0.0000000000000000000000000001", "0.0000000000000000000000000001", "0"),
        (
            "0.6386554621848739495798319328",
            "11.815126050420168067226890757",
            "7.5457947885036367488171739292",
        ),
        (
            "2123456789012345678901234567.8",
            "11.815126050420168067226890757",
            "25088909624801327937270048761",
        ),
        (
            "2123456789012345678901234567.8",
            "-11.815126050420168067226890757",
            "-25088909624801327937270048761",
        ),
        (
            "2.1234567890123456789012345678",
            "2.1234567890123456789012345678",
            "4.5090687348026215523554336227",
        ),
        (
            "0.48000000",
            "0.1818181818181818181818181818",
            either!("0.0872727272727272727272727273", "0.0872727272727272727272727272"),
        ),
    ];
    for &(a, b, c) in tests {
        mul(a, b, c);
    }
}

#[test]
#[should_panic(expected = "Multiplication overflowed")]
fn it_panics_when_multiply_with_overflow() {
    let a = Decimal::from_str("2000000000000000000001").unwrap();
    let b = Decimal::from_str("3000000000000000000001").unwrap();
    let _ = a * b;
}

#[test]
fn it_can_mulassign() {
    let mut a = Decimal::from_str("1.25").unwrap();
    let b = Decimal::from_str("0.01").unwrap();

    a *= b;
    assert_eq!("0.0125", a.to_string());

    a *= &b;
    assert_eq!("0.000125", a.to_string());

    let mut c = &mut a;
    c *= b;
    assert_eq!("0.00000125", a.to_string());

    let mut c = &mut a;
    c *= &b;
    assert_eq!("0.0000000125", a.to_string());
}

// Division

#[test]
fn it_divides_decimals() {
    fn div(a: &str, b: &str, c: &str) {
        let a = Decimal::from_str(a).unwrap();
        let b = Decimal::from_str(b).unwrap();
        let result = a / b;
        assert_eq!(c, result.to_string(), "{} / {}", a.to_string(), b.to_string());
    }

    let tests = &[
        ("6", "3", "2"),
        ("10", "2", "5"),
        ("2.2", "1.1", "2"),
        ("-2.2", "-1.1", "2"),
        ("12.88", "5.6", "2.3"),
        (
            "1023427554493",
            "43432632",
            either!("23563.562864276795382789603909", "23563.562864276795382789603908"),
        ),
        ("10000", "3", "3333.3333333333333333333333333"),
        ("2", "3", "0.6666666666666666666666666667"),
        ("1", "3", "0.3333333333333333333333333333"),
        ("-2", "3", "-0.6666666666666666666666666667"),
        ("2", "-3", "-0.6666666666666666666666666667"),
        ("-2", "-3", "0.6666666666666666666666666667"),
        (
            "1234.5678",
            "0.1234567890123456",
            either!("9999.99926999999982999953127", "9999.999269999999829999531269"),
        ),
        ("1234.567890123456789012345678", "1.234567890123456789012345678", "1000"),
        (
            "32.91625929004387114334488",
            "3.27629537",
            either!("10.046792359274942644546996384", "10.046792359274942644546996383"),
        ),
        ("5000", "1000.26957490549", "4.9986524887277738570721416846"),
        ("6142.6941216127122745222131114", "2", "3071.3470608063561372611065557"),
        (
            "3071.3470608063561372611065557",
            "1228.87000756",
            either!("2.4993262443638869285360708423", "2.4993262443638869285360708422"),
        ),
        (
            "590.3274854004009467754255123",
            "53.68997202826239",
            "10.995116277759516850521689988",
        ),
    ];
    for &(a, b, c) in tests {
        div(a, b, c);
    }
}

#[test]
#[should_panic(expected = "Division by zero")]
fn it_can_divide_by_zero() {
    let a = Decimal::from_str("2").unwrap();
    let _ = a / Decimal::ZERO;
}

#[test]
fn it_can_divassign() {
    let mut a = Decimal::from_str("1.25").unwrap();
    let b = Decimal::from_str("0.01").unwrap();

    a /= b;
    assert_eq!("125", a.to_string());

    a /= &b;
    assert_eq!("12500", a.to_string());

    let mut c = &mut a;
    c /= b;
    assert_eq!("1250000", a.to_string());

    let mut c = &mut a;
    c /= &b;
    assert_eq!("125000000", a.to_string());
}

// Modulus and Remainder are not the same thing!
// https://math.stackexchange.com/q/801962/82277

#[test]
fn it_rems_decimals() {
    fn rem(a: &str, b: &str, c: &str) {
        let a = Decimal::from_str(a).unwrap();
        let b = Decimal::from_str(b).unwrap();
        // a = qb + r
        let result = a % b;
        assert_eq!(c, result.to_string(), "{} % {}", a.to_string(), b.to_string());
    }

    let tests = &[
        ("2", "3", "2"),
        ("-2", "3", "-2"),
        ("2", "-3", "2"),
        ("-2", "-3", "-2"),
        ("6", "3", "0"),
        ("42.2", "11.9", "6.5"),
        ("2.1", "3", "2.1"),
        ("2", "3.1", "2"),
        ("2.0", "3.1", "2.0"),
        ("4", "3.1", "0.9"),
        ("2", "2", "0"),
        ("2", "-2", "0"),
        // Legacy keeps sign from lhs operand
        ("-2", "2", "0"),
        ("-2", "-2", "0"),
    ];
    for &(a, b, c) in tests {
        rem(a, b, c);
    }
}

#[test]
fn it_can_remassign() {
    let mut a = Decimal::from_str("5").unwrap();
    let b = Decimal::from_str("2").unwrap();

    a %= b;
    assert_eq!("1", a.to_string());

    a %= &b;
    assert_eq!("1", a.to_string());

    let mut c = &mut a;
    c %= b;
    assert_eq!("1", a.to_string());

    let mut c = &mut a;
    c %= &b;
    assert_eq!("1", a.to_string());
}

#[test]
fn it_eqs_decimals() {
    fn eq(a: &str, b: &str, c: bool) {
        let a = Decimal::from_str(a).unwrap();
        let b = Decimal::from_str(b).unwrap();
        assert_eq!(c, a.eq(&b), "{} == {}", a.to_string(), b.to_string());
        assert_eq!(c, b.eq(&a), "{} == {}", b.to_string(), a.to_string());
    }

    let tests = &[
        ("1", "1", true),
        ("1", "-1", false),
        ("1", "1.00", true),
        ("1.2345000000000", "1.2345", true),
        ("1.0000000000000000000000000000", "1.0000000000000000000000000000", true),
        (
            "1.0000000000000000000000000001",
            "1.0000000000000000000000000000",
            false,
        ),
    ];
    for &(a, b, c) in tests {
        eq(a, b, c);
    }
}

#[test]
fn it_cmps_decimals() {
    fn cmp(a: &str, b: &str, c: core::cmp::Ordering) {
        let a = Decimal::from_str(a).unwrap();
        let b = Decimal::from_str(b).unwrap();
        assert_eq!(
            c,
            a.cmp(&b),
            "{} {} {}",
            a.to_string(),
            match c {
                Less => "<",
                Equal => "==",
                Greater => ">",
            },
            b.to_string()
        );
    }

    let tests = &[
        ("1", "1", Equal),
        ("1", "-1", Greater),
        ("1", "1.00", Equal),
        ("1.2345000000000", "1.2345", Equal),
        (
            "1.0000000000000000000000000001",
            "1.0000000000000000000000000000",
            Greater,
        ),
        ("1.0000000000000000000000000000", "1.0000000000000000000000000001", Less),
        ("-1", "100", Less),
        ("-100", "1", Less),
        ("0", "0.5", Less),
        ("0.5", "0", Greater),
        ("100", "0.0098", Greater),
        ("1000000000000000", "999000000000000.0001", Greater),
        ("2.0001", "2.0001", Equal),
        (
            "11.815126050420168067226890757",
            "0.6386554621848739495798319328",
            Greater,
        ),
        ("0.6386554621848739495798319328", "11.815126050420168067226890757", Less),
        ("-0.5", "-0.01", Less),
        ("-0.5", "-0.1", Less),
        ("-0.01", "-0.5", Greater),
        ("-0.1", "-0.5", Greater),
        // 000 equality
        ("0.00000000", "0.00000000", Equal),
        // 000 000 same scale
        ("0.00000000", "0.00000000", Equal),
        ("-0.00000000", "0.00000000", Equal),
        ("0.00000000", "-0.00000000", Equal),
        ("-0.00000000", "-0.00000000", Equal),
        // 000 000 different scale
        ("0.000000000", "0.00000000000000000000000", Equal),
        ("-0.000000000", "0.00000000000000000000000", Equal),
        ("0.000000000", "-0.00000000000000000000000", Equal),
        ("-0.000000000", "-0.00000000000000000000000", Equal),
        // 000 100 same scale
        ("0.00000000", "6.56792910", Less),
        ("-0.00000000", "6.56792910", Less),
        ("0.00000000", "-6.56792910", Greater),
        ("-0.00000000", "-6.56792910", Greater),
        // 000 100 different scale
        ("0.0000000000000000000", "0.00000000000000001916236746", Less),
        ("-0.0000000000000000000", "0.00000000000000001916236746", Less),
        ("0.0000000000000000000", "-0.00000000000000001916236746", Greater),
        ("-0.0000000000000000000", "-0.00000000000000001916236746", Greater),
        // 000 010 same scale
        ("0.00000000", "49037796231.72571136", Less),
        ("-0.00000000", "49037796231.72571136", Less),
        ("0.00000000", "-49037796231.72571136", Greater),
        ("-0.00000000", "-49037796231.72571136", Greater),
        // 000 010 different scale
        ("0", "14459264155.12895488", Less),
        ("-0", "14459264155.12895488", Less),
        ("0", "-14459264155.12895488", Greater),
        ("-0", "-14459264155.12895488", Greater),
        // 000 110 same scale
        ("0.00000000", "38675108055.09052783", Less),
        ("-0.00000000", "38675108055.09052783", Less),
        ("0.00000000", "-38675108055.09052783", Greater),
        ("-0.00000000", "-38675108055.09052783", Greater),
        // 000 110 different scale
        ("0.00", "1495767034080324868", Less),
        ("-0.00", "1495767034080324868", Less),
        ("0.00", "-1495767034080324868", Greater),
        ("-0.00", "-1495767034080324868", Greater),
        // 000 001 same scale
        ("0.00000000", "359299289270893106016.81305600", Less),
        ("-0.00000000", "359299289270893106016.81305600", Less),
        ("0.00000000", "-359299289270893106016.81305600", Greater),
        ("-0.00000000", "-359299289270893106016.81305600", Greater),
        // 000 001 different scale
        ("0.00000000000000000000000000", "261631091689.9518486763536384", Less),
        ("-0.00000000000000000000000000", "261631091689.9518486763536384", Less),
        (
            "0.00000000000000000000000000",
            "-261631091689.9518486763536384",
            Greater,
        ),
        (
            "-0.00000000000000000000000000",
            "-261631091689.9518486763536384",
            Greater,
        ),
        // 000 101 same scale
        ("0.00000000", "184137107696737410476.63166815", Less),
        ("-0.00000000", "184137107696737410476.63166815", Less),
        ("0.00000000", "-184137107696737410476.63166815", Greater),
        ("-0.00000000", "-184137107696737410476.63166815", Greater),
        // 000 101 different scale
        ("0.000000000", "2286857871088.7514840434334478", Less),
        ("-0.000000000", "2286857871088.7514840434334478", Less),
        ("0.000000000", "-2286857871088.7514840434334478", Greater),
        ("-0.000000000", "-2286857871088.7514840434334478", Greater),
        // 000 011 same scale
        ("0.00000000", "169194696640288819908.07715840", Less),
        ("-0.00000000", "169194696640288819908.07715840", Less),
        ("0.00000000", "-169194696640288819908.07715840", Greater),
        ("-0.00000000", "-169194696640288819908.07715840", Greater),
        // 000 011 different scale
        ("0.00000000", "2757550691.7650076909569048576", Less),
        ("-0.00000000", "2757550691.7650076909569048576", Less),
        ("0.00000000", "-2757550691.7650076909569048576", Greater),
        ("-0.00000000", "-2757550691.7650076909569048576", Greater),
        // 000 111 same scale
        ("0.00000000", "133610725292915899001.10059212", Less),
        ("-0.00000000", "133610725292915899001.10059212", Less),
        ("0.00000000", "-133610725292915899001.10059212", Greater),
        ("-0.00000000", "-133610725292915899001.10059212", Greater),
        // 000 111 different scale
        ("0.00000000000000000000", "86.25432767926620368822165265", Less),
        ("-0.00000000000000000000", "86.25432767926620368822165265", Less),
        ("0.00000000000000000000", "-86.25432767926620368822165265", Greater),
        ("-0.00000000000000000000", "-86.25432767926620368822165265", Greater),
        // 100 equality
        ("0.0000000000598992228", "0.0000000000598992228", Equal),
        // 100 000 same scale
        ("0.0000000000598992228", "0.0000000000000000000", Greater),
        ("-0.0000000000598992228", "0.0000000000000000000", Less),
        ("0.0000000000598992228", "-0.0000000000000000000", Greater),
        ("-0.0000000000598992228", "-0.0000000000000000000", Less),
        // 100 000 different scale
        ("0.1797407597", "0.0000000000000000000", Greater),
        ("-0.1797407597", "0.0000000000000000000", Less),
        ("0.1797407597", "-0.0000000000000000000", Greater),
        ("-0.1797407597", "-0.0000000000000000000", Less),
        // 100 100 same scale
        ("0.0000000000598992228", "0.0000000000064510789", Greater),
        ("-0.0000000000598992228", "0.0000000000064510789", Less),
        ("0.0000000000598992228", "-0.0000000000064510789", Greater),
        ("-0.0000000000598992228", "-0.0000000000064510789", Less),
        // 100 100 different scale
        ("0.000000000000011217354", "0.0000000000217735186", Less),
        ("-0.000000000000011217354", "0.0000000000217735186", Less),
        ("0.000000000000011217354", "-0.0000000000217735186", Greater),
        ("-0.000000000000011217354", "-0.0000000000217735186", Greater),
        // 100 010 same scale
        ("0.0000000000598992228", "0.0659116848159129600", Less),
        ("-0.0000000000598992228", "0.0659116848159129600", Less),
        ("0.0000000000598992228", "-0.0659116848159129600", Greater),
        ("-0.0000000000598992228", "-0.0659116848159129600", Greater),
        // 100 010 different scale
        ("0.00042035421", "0.004709460588143575040", Less),
        ("-0.00042035421", "0.004709460588143575040", Less),
        ("0.00042035421", "-0.004709460588143575040", Greater),
        ("-0.00042035421", "-0.004709460588143575040", Greater),
        // 100 110 same scale
        ("0.0000000000598992228", "0.0755686585127091375", Less),
        ("-0.0000000000598992228", "0.0755686585127091375", Less),
        ("0.0000000000598992228", "-0.0755686585127091375", Greater),
        ("-0.0000000000598992228", "-0.0755686585127091375", Greater),
        // 100 110 different scale
        ("14872.94465", "1284707831905.854085", Less),
        ("-14872.94465", "1284707831905.854085", Less),
        ("14872.94465", "-1284707831905.854085", Greater),
        ("-14872.94465", "-1284707831905.854085", Greater),
        // 100 001 same scale
        ("0.0000000000598992228", "888767595.6145376468836286464", Less),
        ("-0.0000000000598992228", "888767595.6145376468836286464", Less),
        ("0.0000000000598992228", "-888767595.6145376468836286464", Greater),
        ("-0.0000000000598992228", "-888767595.6145376468836286464", Greater),
        // 100 001 different scale
        ("0.0002108155975", "36.07555527243968476014968832", Less),
        ("-0.0002108155975", "36.07555527243968476014968832", Less),
        ("0.0002108155975", "-36.07555527243968476014968832", Greater),
        ("-0.0002108155975", "-36.07555527243968476014968832", Greater),
        // 100 101 same scale
        ("0.0000000000598992228", "125730345.7412344676309569911", Less),
        ("-0.0000000000598992228", "125730345.7412344676309569911", Less),
        ("0.0000000000598992228", "-125730345.7412344676309569911", Greater),
        ("-0.0000000000598992228", "-125730345.7412344676309569911", Greater),
        // 100 101 different scale
        ("0.0000000000871576741", "1.7283925558865766140690239662", Less),
        ("-0.0000000000871576741", "1.7283925558865766140690239662", Less),
        ("0.0000000000871576741", "-1.7283925558865766140690239662", Greater),
        ("-0.0000000000871576741", "-1.7283925558865766140690239662", Greater),
        // 100 011 same scale
        ("0.0000000000598992228", "645513262.9193254090737451008", Less),
        ("-0.0000000000598992228", "645513262.9193254090737451008", Less),
        ("0.0000000000598992228", "-645513262.9193254090737451008", Greater),
        ("-0.0000000000598992228", "-645513262.9193254090737451008", Greater),
        // 100 011 different scale
        ("0.000000000000000760885021", "3718370638.2004059326675681280", Less),
        ("-0.000000000000000760885021", "3718370638.2004059326675681280", Less),
        ("0.000000000000000760885021", "-3718370638.2004059326675681280", Greater),
        (
            "-0.000000000000000760885021",
            "-3718370638.2004059326675681280",
            Greater,
        ),
        // 100 111 same scale
        ("0.0000000000598992228", "422482675.5515775479939306437", Less),
        ("-0.0000000000598992228", "422482675.5515775479939306437", Less),
        ("0.0000000000598992228", "-422482675.5515775479939306437", Greater),
        ("-0.0000000000598992228", "-422482675.5515775479939306437", Greater),
        // 100 111 different scale
        ("0.000000044182898", "25.452953262109919998605674045", Less),
        ("-0.000000044182898", "25.452953262109919998605674045", Less),
        ("0.000000044182898", "-25.452953262109919998605674045", Greater),
        ("-0.000000044182898", "-25.452953262109919998605674045", Greater),
        // 010 equality
        ("423.1744746042687488", "423.1744746042687488", Equal),
        // 010 000 same scale
        ("423.1744746042687488", "0.0000000000000000", Greater),
        ("-423.1744746042687488", "0.0000000000000000", Less),
        ("423.1744746042687488", "-0.0000000000000000", Greater),
        ("-423.1744746042687488", "-0.0000000000000000", Less),
        // 010 000 different scale
        ("9002354991.192604672", "0.00000000000000000000000000", Greater),
        ("-9002354991.192604672", "0.00000000000000000000000000", Less),
        ("9002354991.192604672", "-0.00000000000000000000000000", Greater),
        ("-9002354991.192604672", "-0.00000000000000000000000000", Less),
        // 010 100 same scale
        ("423.1744746042687488", "0.0000000981820809", Greater),
        ("-423.1744746042687488", "0.0000000981820809", Less),
        ("423.1744746042687488", "-0.0000000981820809", Greater),
        ("-423.1744746042687488", "-0.0000000981820809", Less),
        // 010 100 different scale
        ("4327019125101559.808", "0.00484846050", Greater),
        ("-4327019125101559.808", "0.00484846050", Less),
        ("4327019125101559.808", "-0.00484846050", Greater),
        ("-4327019125101559.808", "-0.00484846050", Less),
        // 010 010 same scale
        ("423.1744746042687488", "786.9082854590775296", Less),
        ("-423.1744746042687488", "786.9082854590775296", Less),
        ("423.1744746042687488", "-786.9082854590775296", Greater),
        ("-423.1744746042687488", "-786.9082854590775296", Greater),
        // 010 010 different scale
        ("793.0067125291450368", "0.0001587297248335626240", Greater),
        ("-793.0067125291450368", "0.0001587297248335626240", Less),
        ("793.0067125291450368", "-0.0001587297248335626240", Greater),
        ("-793.0067125291450368", "-0.0001587297248335626240", Less),
        // 010 110 same scale
        ("423.1744746042687488", "300.0541360230572049", Greater),
        ("-423.1744746042687488", "300.0541360230572049", Less),
        ("423.1744746042687488", "-300.0541360230572049", Greater),
        ("-423.1744746042687488", "-300.0541360230572049", Less),
        // 010 110 different scale
        ("90627.2042582540288", "4472414566654924.741", Less),
        ("-90627.2042582540288", "4472414566654924.741", Less),
        ("90627.2042582540288", "-4472414566654924.741", Greater),
        ("-90627.2042582540288", "-4472414566654924.741", Greater),
        // 010 001 same scale
        ("423.1744746042687488", "3960577151543.5796707636412416", Less),
        ("-423.1744746042687488", "3960577151543.5796707636412416", Less),
        ("423.1744746042687488", "-3960577151543.5796707636412416", Greater),
        ("-423.1744746042687488", "-3960577151543.5796707636412416", Greater),
        // 010 001 different scale
        ("0.000008867461591822499840", "185286.04378228713249986052096", Less),
        ("-0.000008867461591822499840", "185286.04378228713249986052096", Less),
        ("0.000008867461591822499840", "-185286.04378228713249986052096", Greater),
        (
            "-0.000008867461591822499840",
            "-185286.04378228713249986052096",
            Greater,
        ),
        // 010 101 same scale
        ("423.1744746042687488", "2825958416017.6213507229869501", Less),
        ("-423.1744746042687488", "2825958416017.6213507229869501", Less),
        ("423.1744746042687488", "-2825958416017.6213507229869501", Greater),
        ("-423.1744746042687488", "-2825958416017.6213507229869501", Greater),
        // 010 101 different scale
        ("0.01901870767742648320", "37662082383021542232.529651212", Less),
        ("-0.01901870767742648320", "37662082383021542232.529651212", Less),
        ("0.01901870767742648320", "-37662082383021542232.529651212", Greater),
        ("-0.01901870767742648320", "-37662082383021542232.529651212", Greater),
        // 010 011 same scale
        ("423.1744746042687488", "3628063966991.6759417059016704", Less),
        ("-423.1744746042687488", "3628063966991.6759417059016704", Less),
        ("423.1744746042687488", "-3628063966991.6759417059016704", Greater),
        ("-423.1744746042687488", "-3628063966991.6759417059016704", Greater),
        // 010 011 different scale
        ("45359904.32470925312", "2.4203452488052342918570049536", Greater),
        ("-45359904.32470925312", "2.4203452488052342918570049536", Less),
        ("45359904.32470925312", "-2.4203452488052342918570049536", Greater),
        ("-45359904.32470925312", "-2.4203452488052342918570049536", Less),
        // 010 111 same scale
        ("423.1744746042687488", "2629665172331.9610693820109120", Less),
        ("-423.1744746042687488", "2629665172331.9610693820109120", Less),
        ("423.1744746042687488", "-2629665172331.9610693820109120", Greater),
        ("-423.1744746042687488", "-2629665172331.9610693820109120", Greater),
        // 010 111 different scale
        ("0.0006420803252266205184", "8172.032417576265900588945489", Less),
        ("-0.0006420803252266205184", "8172.032417576265900588945489", Less),
        ("0.0006420803252266205184", "-8172.032417576265900588945489", Greater),
        ("-0.0006420803252266205184", "-8172.032417576265900588945489", Greater),
        // 110 equality
        ("844.5530620517286511", "844.5530620517286511", Equal),
        // 110 000 same scale
        ("844.5530620517286511", "0.0000000000000000", Greater),
        ("-844.5530620517286511", "0.0000000000000000", Less),
        ("844.5530620517286511", "-0.0000000000000000", Greater),
        ("-844.5530620517286511", "-0.0000000000000000", Less),
        // 110 000 different scale
        ("3285.530033386074797", "0.00000000000000000000", Greater),
        ("-3285.530033386074797", "0.00000000000000000000", Less),
        ("3285.530033386074797", "-0.00000000000000000000", Greater),
        ("-3285.530033386074797", "-0.00000000000000000000", Less),
        // 110 100 same scale
        ("844.5530620517286511", "0.0000001953470063", Greater),
        ("-844.5530620517286511", "0.0000001953470063", Less),
        ("844.5530620517286511", "-0.0000001953470063", Greater),
        ("-844.5530620517286511", "-0.0000001953470063", Less),
        // 110 100 different scale
        ("371284.0210972493371", "0.000000000000001307794657", Greater),
        ("-371284.0210972493371", "0.000000000000001307794657", Less),
        ("371284.0210972493371", "-0.000000000000001307794657", Greater),
        ("-371284.0210972493371", "-0.000000000000001307794657", Less),
        // 110 010 same scale
        ("844.5530620517286511", "612.1542773033140224", Greater),
        ("-844.5530620517286511", "612.1542773033140224", Less),
        ("844.5530620517286511", "-612.1542773033140224", Greater),
        ("-844.5530620517286511", "-612.1542773033140224", Less),
        // 110 010 different scale
        ("0.00004869219159821525572", "23341676485159.15776", Less),
        ("-0.00004869219159821525572", "23341676485159.15776", Less),
        ("0.00004869219159821525572", "-23341676485159.15776", Greater),
        ("-0.00004869219159821525572", "-23341676485159.15776", Greater),
        // 110 110 same scale
        ("844.5530620517286511", "326.6132818317622015", Greater),
        ("-844.5530620517286511", "326.6132818317622015", Less),
        ("844.5530620517286511", "-326.6132818317622015", Greater),
        ("-844.5530620517286511", "-326.6132818317622015", Less),
        // 110 110 different scale
        ("4752139369958.820619", "1330851022882027.972", Less),
        ("-4752139369958.820619", "1330851022882027.972", Less),
        ("4752139369958.820619", "-1330851022882027.972", Greater),
        ("-4752139369958.820619", "-1330851022882027.972", Greater),
        // 110 001 same scale
        ("844.5530620517286511", "3585610241942.1922435648192512", Less),
        ("-844.5530620517286511", "3585610241942.1922435648192512", Less),
        ("844.5530620517286511", "-3585610241942.1922435648192512", Greater),
        ("-844.5530620517286511", "-3585610241942.1922435648192512", Greater),
        // 110 001 different scale
        ("539313715923.4424678", "12410950080603997079634706432", Less),
        ("-539313715923.4424678", "12410950080603997079634706432", Less),
        ("539313715923.4424678", "-12410950080603997079634706432", Greater),
        ("-539313715923.4424678", "-12410950080603997079634706432", Greater),
        // 110 101 same scale
        ("844.5530620517286511", "1947825396031.6933708908343230", Less),
        ("-844.5530620517286511", "1947825396031.6933708908343230", Less),
        ("844.5530620517286511", "-1947825396031.6933708908343230", Greater),
        ("-844.5530620517286511", "-1947825396031.6933708908343230", Greater),
        // 110 101 different scale
        ("0.2301405445512525317", "245433629587.71206426704897154", Less),
        ("-0.2301405445512525317", "245433629587.71206426704897154", Less),
        ("0.2301405445512525317", "-245433629587.71206426704897154", Greater),
        ("-0.2301405445512525317", "-245433629587.71206426704897154", Greater),
        // 110 011 same scale
        ("844.5530620517286511", "3637850451015.0843464291450880", Less),
        ("-844.5530620517286511", "3637850451015.0843464291450880", Less),
        ("844.5530620517286511", "-3637850451015.0843464291450880", Greater),
        ("-844.5530620517286511", "-3637850451015.0843464291450880", Greater),
        // 110 011 different scale
        ("0.00000000717944802566514691", "18143443615.480512395717115904", Less),
        ("-0.00000000717944802566514691", "18143443615.480512395717115904", Less),
        (
            "0.00000000717944802566514691",
            "-18143443615.480512395717115904",
            Greater,
        ),
        (
            "-0.00000000717944802566514691",
            "-18143443615.480512395717115904",
            Greater,
        ),
        // 110 111 same scale
        ("844.5530620517286511", "2738424264600.4917875777303163", Less),
        ("-844.5530620517286511", "2738424264600.4917875777303163", Less),
        ("844.5530620517286511", "-2738424264600.4917875777303163", Greater),
        ("-844.5530620517286511", "-2738424264600.4917875777303163", Greater),
        // 110 111 different scale
        ("0.0000000007762706076409491335", "2489879185787497651.6458518595", Less),
        (
            "-0.0000000007762706076409491335",
            "2489879185787497651.6458518595",
            Less,
        ),
        (
            "0.0000000007762706076409491335",
            "-2489879185787497651.6458518595",
            Greater,
        ),
        (
            "-0.0000000007762706076409491335",
            "-2489879185787497651.6458518595",
            Greater,
        ),
        // 001 equality
        ("316007568232.9263258873102336", "316007568232.9263258873102336", Equal),
        // 001 000 same scale
        ("316007568232.9263258873102336", "0.0000000000000000", Greater),
        ("-316007568232.9263258873102336", "0.0000000000000000", Less),
        ("316007568232.9263258873102336", "-0.0000000000000000", Greater),
        ("-316007568232.9263258873102336", "-0.0000000000000000", Less),
        // 001 000 different scale
        ("3522055990024364385815547084.8", "0.000000000000", Greater),
        ("-3522055990024364385815547084.8", "0.000000000000", Less),
        ("3522055990024364385815547084.8", "-0.000000000000", Greater),
        ("-3522055990024364385815547084.8", "-0.000000000000", Less),
        // 001 100 same scale
        ("316007568232.9263258873102336", "0.0000001073412971", Greater),
        ("-316007568232.9263258873102336", "0.0000001073412971", Less),
        ("316007568232.9263258873102336", "-0.0000001073412971", Greater),
        ("-316007568232.9263258873102336", "-0.0000001073412971", Less),
        // 001 100 different scale
        ("1319006.0491408208640440532992", "0.00000000000000611866432", Greater),
        ("-1319006.0491408208640440532992", "0.00000000000000611866432", Less),
        ("1319006.0491408208640440532992", "-0.00000000000000611866432", Greater),
        ("-1319006.0491408208640440532992", "-0.00000000000000611866432", Less),
        // 001 010 same scale
        ("316007568232.9263258873102336", "159.1054215143227392", Greater),
        ("-316007568232.9263258873102336", "159.1054215143227392", Less),
        ("316007568232.9263258873102336", "-159.1054215143227392", Greater),
        ("-316007568232.9263258873102336", "-159.1054215143227392", Less),
        // 001 010 different scale
        ("2470144.7146711063666704252928", "211.0186916505714688", Greater),
        ("-2470144.7146711063666704252928", "211.0186916505714688", Less),
        ("2470144.7146711063666704252928", "-211.0186916505714688", Greater),
        ("-2470144.7146711063666704252928", "-211.0186916505714688", Less),
        // 001 110 same scale
        ("316007568232.9263258873102336", "15.1186658969096112", Greater),
        ("-316007568232.9263258873102336", "15.1186658969096112", Less),
        ("316007568232.9263258873102336", "-15.1186658969096112", Greater),
        ("-316007568232.9263258873102336", "-15.1186658969096112", Less),
        // 001 110 different scale
        ("3840504199004148630832.3360768", "7581138850996748864", Greater),
        ("-3840504199004148630832.3360768", "7581138850996748864", Less),
        ("3840504199004148630832.3360768", "-7581138850996748864", Greater),
        ("-3840504199004148630832.3360768", "-7581138850996748864", Less),
        // 001 001 same scale
        ("316007568232.9263258873102336", "810157633226.6053390856880128", Less),
        ("-316007568232.9263258873102336", "810157633226.6053390856880128", Less),
        (
            "316007568232.9263258873102336",
            "-810157633226.6053390856880128",
            Greater,
        ),
        (
            "-316007568232.9263258873102336",
            "-810157633226.6053390856880128",
            Greater,
        ),
        // 001 001 different scale
        ("1951046382014.4037956952260608", "3626102772868740412010083.1232", Less),
        (
            "-1951046382014.4037956952260608",
            "3626102772868740412010083.1232",
            Less,
        ),
        (
            "1951046382014.4037956952260608",
            "-3626102772868740412010083.1232",
            Greater,
        ),
        (
            "-1951046382014.4037956952260608",
            "-3626102772868740412010083.1232",
            Greater,
        ),
        // 001 101 same scale
        ("316007568232.9263258873102336", "3258394380359.1965879291312453", Less),
        ("-316007568232.9263258873102336", "3258394380359.1965879291312453", Less),
        (
            "316007568232.9263258873102336",
            "-3258394380359.1965879291312453",
            Greater,
        ),
        (
            "-316007568232.9263258873102336",
            "-3258394380359.1965879291312453",
            Greater,
        ),
        // 001 101 different scale
        (
            "17580513970289834.943527780352",
            "3.7977957031395371036126086595",
            Greater,
        ),
        (
            "-17580513970289834.943527780352",
            "3.7977957031395371036126086595",
            Less,
        ),
        (
            "17580513970289834.943527780352",
            "-3.7977957031395371036126086595",
            Greater,
        ),
        (
            "-17580513970289834.943527780352",
            "-3.7977957031395371036126086595",
            Less,
        ),
        // 001 011 same scale
        ("316007568232.9263258873102336", "1154574080460.9867510617997312", Less),
        ("-316007568232.9263258873102336", "1154574080460.9867510617997312", Less),
        (
            "316007568232.9263258873102336",
            "-1154574080460.9867510617997312",
            Greater,
        ),
        (
            "-316007568232.9263258873102336",
            "-1154574080460.9867510617997312",
            Greater,
        ),
        // 001 011 different scale
        ("2008379587.5525351789031325696", "32824109460554.341800487157760", Less),
        (
            "-2008379587.5525351789031325696",
            "32824109460554.341800487157760",
            Less,
        ),
        (
            "2008379587.5525351789031325696",
            "-32824109460554.341800487157760",
            Greater,
        ),
        (
            "-2008379587.5525351789031325696",
            "-32824109460554.341800487157760",
            Greater,
        ),
        // 001 111 same scale
        ("316007568232.9263258873102336", "2816795479724.6069787794805311", Less),
        ("-316007568232.9263258873102336", "2816795479724.6069787794805311", Less),
        (
            "316007568232.9263258873102336",
            "-2816795479724.6069787794805311",
            Greater,
        ),
        (
            "-316007568232.9263258873102336",
            "-2816795479724.6069787794805311",
            Greater,
        ),
        // 001 111 different scale
        (
            "3536806574745420013541890.4576",
            "9793146.81730411145833529126",
            Greater,
        ),
        ("-3536806574745420013541890.4576", "9793146.81730411145833529126", Less),
        (
            "3536806574745420013541890.4576",
            "-9793146.81730411145833529126",
            Greater,
        ),
        ("-3536806574745420013541890.4576", "-9793146.81730411145833529126", Less),
        // 101 equality
        (
            "254208186622762823842.71629992",
            "254208186622762823842.71629992",
            Equal,
        ),
        // 101 000 same scale
        ("254208186622762823842.71629992", "0.00000000", Greater),
        ("-254208186622762823842.71629992", "0.00000000", Less),
        ("254208186622762823842.71629992", "-0.00000000", Greater),
        ("-254208186622762823842.71629992", "-0.00000000", Less),
        // 101 000 different scale
        ("975421950664039.3614304091804", "0.0000000000000000", Greater),
        ("-975421950664039.3614304091804", "0.0000000000000000", Less),
        ("975421950664039.3614304091804", "-0.0000000000000000", Greater),
        ("-975421950664039.3614304091804", "-0.0000000000000000", Less),
        // 101 100 same scale
        ("254208186622762823842.71629992", "10.74141379", Greater),
        ("-254208186622762823842.71629992", "10.74141379", Less),
        ("254208186622762823842.71629992", "-10.74141379", Greater),
        ("-254208186622762823842.71629992", "-10.74141379", Less),
        // 101 100 different scale
        ("2552221405032275.8358630506229", "0.000000000000000592656995", Greater),
        ("-2552221405032275.8358630506229", "0.000000000000000592656995", Less),
        ("2552221405032275.8358630506229", "-0.000000000000000592656995", Greater),
        ("-2552221405032275.8358630506229", "-0.000000000000000592656995", Less),
        // 101 010 same scale
        ("254208186622762823842.71629992", "62767493748.48499712", Greater),
        ("-254208186622762823842.71629992", "62767493748.48499712", Less),
        ("254208186622762823842.71629992", "-62767493748.48499712", Greater),
        ("-254208186622762823842.71629992", "-62767493748.48499712", Less),
        // 101 010 different scale
        ("197346074219.25327589999174264", "0.7623493575178715136", Greater),
        ("-197346074219.25327589999174264", "0.7623493575178715136", Less),
        ("197346074219.25327589999174264", "-0.7623493575178715136", Greater),
        ("-197346074219.25327589999174264", "-0.7623493575178715136", Less),
        // 101 110 same scale
        ("254208186622762823842.71629992", "76597126194.51389094", Greater),
        ("-254208186622762823842.71629992", "76597126194.51389094", Less),
        ("254208186622762823842.71629992", "-76597126194.51389094", Greater),
        ("-254208186622762823842.71629992", "-76597126194.51389094", Less),
        // 101 110 different scale
        ("25899773651648.380071130043467", "61306258142804903.38", Less),
        ("-25899773651648.380071130043467", "61306258142804903.38", Less),
        ("25899773651648.380071130043467", "-61306258142804903.38", Greater),
        ("-25899773651648.380071130043467", "-61306258142804903.38", Greater),
        // 101 001 same scale
        (
            "254208186622762823842.71629992",
            "83547191565151621967.28086528",
            Greater,
        ),
        ("-254208186622762823842.71629992", "83547191565151621967.28086528", Less),
        (
            "254208186622762823842.71629992",
            "-83547191565151621967.28086528",
            Greater,
        ),
        (
            "-254208186622762823842.71629992",
            "-83547191565151621967.28086528",
            Less,
        ),
        // 101 001 different scale
        ("244762.90302171293318719286219", "9964072.600255221193011888128", Less),
        ("-244762.90302171293318719286219", "9964072.600255221193011888128", Less),
        (
            "244762.90302171293318719286219",
            "-9964072.600255221193011888128",
            Greater,
        ),
        (
            "-244762.90302171293318719286219",
            "-9964072.600255221193011888128",
            Greater,
        ),
        // 101 101 same scale
        (
            "254208186622762823842.71629992",
            "106541875981662806348.63716235",
            Greater,
        ),
        (
            "-254208186622762823842.71629992",
            "106541875981662806348.63716235",
            Less,
        ),
        (
            "254208186622762823842.71629992",
            "-106541875981662806348.63716235",
            Greater,
        ),
        (
            "-254208186622762823842.71629992",
            "-106541875981662806348.63716235",
            Less,
        ),
        // 101 101 different scale
        ("362319.18250030256385507568342", "3619454249020577423546109236", Less),
        ("-362319.18250030256385507568342", "3619454249020577423546109236", Less),
        (
            "362319.18250030256385507568342",
            "-3619454249020577423546109236",
            Greater,
        ),
        (
            "-362319.18250030256385507568342",
            "-3619454249020577423546109236",
            Greater,
        ),
        // 101 011 same scale
        (
            "254208186622762823842.71629992",
            "156781478378762688050.06557184",
            Greater,
        ),
        (
            "-254208186622762823842.71629992",
            "156781478378762688050.06557184",
            Less,
        ),
        (
            "254208186622762823842.71629992",
            "-156781478378762688050.06557184",
            Greater,
        ),
        (
            "-254208186622762823842.71629992",
            "-156781478378762688050.06557184",
            Less,
        ),
        // 101 011 different scale
        ("2486073465266.0337130589931876", "153874906950888902858.19691008", Less),
        (
            "-2486073465266.0337130589931876",
            "153874906950888902858.19691008",
            Less,
        ),
        (
            "2486073465266.0337130589931876",
            "-153874906950888902858.19691008",
            Greater,
        ),
        (
            "-2486073465266.0337130589931876",
            "-153874906950888902858.19691008",
            Greater,
        ),
        // 101 111 same scale
        (
            "254208186622762823842.71629992",
            "10101645723744656462.08148676",
            Greater,
        ),
        ("-254208186622762823842.71629992", "10101645723744656462.08148676", Less),
        (
            "254208186622762823842.71629992",
            "-10101645723744656462.08148676",
            Greater,
        ),
        (
            "-254208186622762823842.71629992",
            "-10101645723744656462.08148676",
            Less,
        ),
        // 101 111 different scale
        ("14107601965.909635434653634526", "111238758546502973973477.99454", Less),
        (
            "-14107601965.909635434653634526",
            "111238758546502973973477.99454",
            Less,
        ),
        (
            "14107601965.909635434653634526",
            "-111238758546502973973477.99454",
            Greater,
        ),
        (
            "-14107601965.909635434653634526",
            "-111238758546502973973477.99454",
            Greater,
        ),
        // 011 equality
        (
            "272322.48219624218537039495168",
            "272322.48219624218537039495168",
            Equal,
        ),
        // 011 000 same scale
        ("272322.48219624218537039495168", "0.00000000000000000000000", Greater),
        ("-272322.48219624218537039495168", "0.00000000000000000000000", Less),
        ("272322.48219624218537039495168", "-0.00000000000000000000000", Greater),
        ("-272322.48219624218537039495168", "-0.00000000000000000000000", Less),
        // 011 000 different scale
        ("3214885516.0787854158246969344", "0.00000000000000000", Greater),
        ("-3214885516.0787854158246969344", "0.00000000000000000", Less),
        ("3214885516.0787854158246969344", "-0.00000000000000000", Greater),
        ("-3214885516.0787854158246969344", "-0.00000000000000000", Less),
        // 011 100 same scale
        ("272322.48219624218537039495168", "0.00000000000000379487994", Greater),
        ("-272322.48219624218537039495168", "0.00000000000000379487994", Less),
        ("272322.48219624218537039495168", "-0.00000000000000379487994", Greater),
        ("-272322.48219624218537039495168", "-0.00000000000000379487994", Less),
        // 011 100 different scale
        ("388166715906.19371912596291584", "0.000000000000001996700736", Greater),
        ("-388166715906.19371912596291584", "0.000000000000001996700736", Less),
        ("388166715906.19371912596291584", "-0.000000000000001996700736", Greater),
        ("-388166715906.19371912596291584", "-0.000000000000001996700736", Less),
        // 011 010 same scale
        ("272322.48219624218537039495168", "0.00000175873997328613376", Greater),
        ("-272322.48219624218537039495168", "0.00000175873997328613376", Less),
        ("272322.48219624218537039495168", "-0.00000175873997328613376", Greater),
        ("-272322.48219624218537039495168", "-0.00000175873997328613376", Less),
        // 011 010 different scale
        (
            "17963864.0946434527121637376",
            "0.0000000001112699367808040960",
            Greater,
        ),
        ("-17963864.0946434527121637376", "0.0000000001112699367808040960", Less),
        (
            "17963864.0946434527121637376",
            "-0.0000000001112699367808040960",
            Greater,
        ),
        ("-17963864.0946434527121637376", "-0.0000000001112699367808040960", Less),
        // 011 110 same scale
        ("272322.48219624218537039495168", "0.00009168252278596474115", Greater),
        ("-272322.48219624218537039495168", "0.00009168252278596474115", Less),
        ("272322.48219624218537039495168", "-0.00009168252278596474115", Greater),
        ("-272322.48219624218537039495168", "-0.00009168252278596474115", Less),
        // 011 110 different scale
        ("3.1530040332824324172729548800", "0.05636139104712652784", Greater),
        ("-3.1530040332824324172729548800", "0.05636139104712652784", Less),
        ("3.1530040332824324172729548800", "-0.05636139104712652784", Greater),
        ("-3.1530040332824324172729548800", "-0.05636139104712652784", Less),
        // 011 001 same scale
        (
            "272322.48219624218537039495168",
            "78956.15667671475190631497728",
            Greater,
        ),
        ("-272322.48219624218537039495168", "78956.15667671475190631497728", Less),
        (
            "272322.48219624218537039495168",
            "-78956.15667671475190631497728",
            Greater,
        ),
--> --------------------

--> maximum size reached

--> --------------------