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!(a.is_sign_negative());

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!(!a.is_sign_negative());

assert_eq!(a.scale(), 2);

assert_eq!("92233720368547758.07", a.to_string());

let b = Decimal::new(i64::MIN, 2);

assert!(b.is_sign_negative());

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!(!a.is_sign_negative());

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!(a.is_sign_negative());

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!(!a.is_sign_negative());

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!(a.is_sign_negative());

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!(!a.is_sign_negative());

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!(a.is_sign_negative());

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());

}

}

#[cfg(feature = "borsh")]

mod borsh_tests {

use rust_decimal::Decimal;

use std::str::FromStr;

#[test]

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());

}

}

}

#[cfg(feature = "ndarray")]

mod ndarray_tests {

use rust_decimal::Decimal;

#[test]

fn it_can_do_scalar_ops_in_ndarray() {

use ndarray::Array1;

use num_traits::FromPrimitive;

let array_a = Array1::from(vec![

Decimal::from_f32(1.0).unwrap(),

Decimal::from_f32(2.0).unwrap(),

Decimal::from_f32(3.0).unwrap(),

]);

// Add

let output = array_a.clone() + Decimal::from_f32(5.0).unwrap();

let expectation = Array1::from(vec![

Decimal::from_f32(6.0).unwrap(),

Decimal::from_f32(7.0).unwrap(),

Decimal::from_f32(8.0).unwrap(),

]);

assert_eq!(output, expectation);

// Sub

let output = array_a.clone() - Decimal::from_f32(5.0).unwrap();

let expectation = Array1::from(vec![

Decimal::from_f32(-4.0).unwrap(),

Decimal::from_f32(-3.0).unwrap(),

Decimal::from_f32(-2.0).unwrap(),

]);

assert_eq!(output, expectation);

// Mul

let output = array_a.clone() * Decimal::from_f32(5.0).unwrap();

let expectation = Array1::from(vec![

Decimal::from_f32(5.0).unwrap(),

Decimal::from_f32(10.0).unwrap(),

Decimal::from_f32(15.0).unwrap(),

]);

assert_eq!(output, expectation);

// Div

let output = array_a / Decimal::from_f32(5.0).unwrap();

let expectation = Array1::from(vec![

Decimal::from_f32(0.2).unwrap(),

Decimal::from_f32(0.4).unwrap(),

Decimal::from_f32(0.6).unwrap(),

]);

assert_eq!(output, expectation);

}

}

#[cfg(feature = "rkyv")]

mod rkyv_tests {

use rust_decimal::Decimal;

use std::str::FromStr;

#[test]

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!("{dec:.9999}");

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!("{a:.9}"), "233.323223000");

assert_eq!(format!("{a:.0}"), "233");

assert_eq!(format!("{a:.2}"), "233.32");

assert_eq!(format!("{a:010.2}"), "0000233.32");

assert_eq!(format!("{a:0<10.2}"), "233.320000");

}

#[test]

fn it_formats_neg() {

let a = Decimal::from_str("-233.323223").unwrap();

assert_eq!(format!("{a}"), "-233.323223");

assert_eq!(format!("{a:.9}"), "-233.323223000");

assert_eq!(format!("{a:.0}"), "-233");

assert_eq!(format!("{a:.2}"), "-233.32");

assert_eq!(format!("{a:010.2}"), "-000233.32");

assert_eq!(format!("{a:0<10.2}"), "-233.32000");

}

#[test]

fn it_formats_small() {

let a = Decimal::from_str("0.2223").unwrap();

assert_eq!(format!("{a}"), "0.2223");

assert_eq!(format!("{a:.9}"), "0.222300000");

assert_eq!(format!("{a:.0}"), "0");

assert_eq!(format!("{a:.2}"), "0.22");

assert_eq!(format!("{a:010.2}"), "0000000.22");

assert_eq!(format!("{a:0<10.2}"), "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!("{a:.9}"), "0.002355470");

assert_eq!(format!("{a:.0}"), "0");

assert_eq!(format!("{a:.2}"), "0.00");

assert_eq!(format!("{a:010.2}"), "0000000.00");

assert_eq!(format!("{a:0<10.2}"), "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!("{a:.9}"), "-0.222300000");

assert_eq!(format!("{a:.0}"), "-0");

assert_eq!(format!("{a:.2}"), "-0.22");

assert_eq!(format!("{a:010.2}"), "-000000.22");

assert_eq!(format!("{a:0<10.2}"), "-0.2200000");

}

#[test]

fn it_formats_zero() {

let a = Decimal::from_str("0").unwrap();

assert_eq!(format!("{a}"), "0");

assert_eq!(format!("{a:.9}"), "0.000000000");

assert_eq!(format!("{a:.0}"), "0");

assert_eq!(format!("{a:.2}"), "0.00");

assert_eq!(format!("{a:010.2}"), "0000000.00");

assert_eq!(format!("{a:0<10.2}"), "0.00000000");

}

#[test]

fn it_formats_int() {

let a = Decimal::from_str("5").unwrap();

assert_eq!(format!("{a}"), "5");

assert_eq!(format!("{a:.9}"), "5.000000000");

assert_eq!(format!("{a:.0}"), "5");

assert_eq!(format!("{a:.2}"), "5.00");

assert_eq!(format!("{a:010.2}"), "0000005.00");

assert_eq!(format!("{a:0<10.2}"), "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!("{a:e}"), *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!("{a:05e}"), *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, precision) in expected_precision.iter().enumerate() {

assert_eq!(&format!("{:.prec$e}", Decimal::new(num, scale), prec = i), precision);

}

}

}

// 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}");

}

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} + {b}");

let result = b + a;

assert_eq!(c, result.to_string(), "{b} + {a}");

}

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} - {b}");

}

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} * {b}");

let result = b * a;

assert_eq!(c, result.to_string(), "{b} * {a}");

}

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} / {b}");

}

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} % {b}");

}

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} == {b}");

assert_eq!(c, b.eq(&a), "{b} == {a}");

}

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,

match c {

Less => "<",

Equal => "==",

Greater => ">",

},

b

);

}

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