milksad
/
rust-bitcoin-unsafe-fast
14
0
Fork 0
Code Issues Pull Requests Activity

Macroise the NumOpResult tests 

Macroise the tests improving coverage along the way.

Includes a TODO to remind us to do `Neg` more fully.
This commit is contained in:
Tobin C. Harding 2025-02-19 15:31:32 +11:00 committed by Andrew Poelstra
parent a44a9d31f6
commit 814685e551
No known key found for this signature in database
GPG Key ID: C588D63CE41B97C1
1 changed files with 90 additions and 141 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

221
units/src/amount/tests.rs
View File

@ -1196,13 +1196,10 @@ fn check_const() {
assert_eq!(Amount::MAX_MONEY.to_sat() as i64, SignedAmount::MAX_MONEY.to_sat()); assert_eq!(Amount::MAX_MONEY.to_sat() as i64, SignedAmount::MAX_MONEY.to_sat());
} }
// Verify we have implemented all combinations of ops for `Amount` and `SignedAmount`. // Sanity check than stdlib supports the set of reference combinations for the ops we want.
// It's easier to read this test that check the code.
#[test] #[test]
#[allow(clippy::op_ref)] // We are explicitly testing the references work with ops. #[allow(clippy::op_ref)] // We are explicitly testing the references work with ops.
fn amount_tyes_all_ops() { fn sanity_all_ops() {
// Sanity check than stdlib supports the set of reference combinations for the ops we want.
{
let x = 127; let x = 127;
let _ = x + x; let _ = x + x;
@ -1216,150 +1213,105 @@ fn amount_tyes_all_ops() {
let _ = &x - &x; let _ = &x - &x;
let _ = -x; let _ = -x;
} }
// Verify we have implemented all combinations of ops for the amount types and `NumOpResult` type.
// It's easier to read this test than check the code.
#[test]
#[allow(clippy::op_ref)] // We are explicitly testing the references work with ops.
fn num_op_result_ops() {
let sat = Amount::from_sat(1); let sat = Amount::from_sat(1);
let ssat = SignedAmount::from_sat(1); let ssat = SignedAmount::from_sat(1);
// Add
let _ = sat + sat;
let _ = &sat + sat;
let _ = sat + &sat;
let _ = &sat + &sat;
// let _ = ssat + sat;
// let _ = &ssat + sat;
// let _ = ssat + &sat;
// let _ = &ssat + &sat;
// let _ = sat + ssat;
// let _ = &sat + ssat;
// let _ = sat + &ssat;
// let _ = &sat + &ssat;
let _ = ssat + ssat;
let _ = &ssat + ssat;
let _ = ssat + &ssat;
let _ = &ssat + &ssat;
// Sub
let _ = sat - sat;
let _ = &sat - sat;
let _ = sat - &sat;
let _ = &sat - &sat;
// let _ = ssat - sat;
// let _ = &ssat - sat;
// let _ = ssat - &sat;
// let _ = &ssat - &sat;
// let _ = sat - ssat;
// let _ = &sat - ssat;
// let _ = sat - &ssat;
// let _ = &sat - &ssat;
let _ = ssat - ssat;
let _ = &ssat - ssat;
let _ = ssat - &ssat;
let _ = &ssat - &ssat;
// let _ = sat * sat; // Intentionally not supported.
// Mul
let _ = sat * 3;
let _ = sat * &3;
let _ = &sat * 3;
let _ = &sat * &3;
let _ = ssat * 3_i64; // Explicit type for the benefit of the reader.
let _ = ssat * &3;
let _ = &ssat * 3;
let _ = &ssat * &3;
// Div
let _ = sat / 3;
let _ = &sat / 3;
let _ = sat / &3;
let _ = &sat / &3;
let _ = ssat / 3_i64; // Explicit type for the benefit of the reader.
let _ = &ssat / 3;
let _ = ssat / &3;
let _ = &ssat / &3;
// Rem
let _ = sat % 3;
let _ = &sat % 3;
let _ = sat % &3;
let _ = &sat % &3;
let _ = ssat % 3;
let _ = &ssat % 3;
let _ = ssat % &3;
let _ = &ssat % &3;
// FIXME: Do we want to support this?
// let _ = sat / sat;
//
// "How many times does this amount go into that amount?" - seems
// like a reasonable question to ask.
// FIXME: Do we want to support these?
// let _ = -sat;
// let _ = -ssat;
}
// FIXME: Should we support this sort of thing?
// It will be a lot more code for possibly not that much benefit.
#[test]
fn can_ops_on_amount_and_signed_amount() {
// let res: NumOpResult<SignedAmount> = sat + ssat;
}
// Verify we have implemented all combinations of ops for the `NumOpResult` type.
// It's easier to read this test that check the code.
#[test]
#[allow(clippy::op_ref)] // We are explicitly testing the references work with ops.
fn amount_op_result_all_ops() {
let sat = Amount::from_sat(1);
// let ssat = SignedAmount::from_sat(1);
// Explicit type as sanity check. // Explicit type as sanity check.
let res: NumOpResult<Amount> = sat + sat; let res: NumOpResult<Amount> = sat + sat;
// let sres: NumOpResult<SignedAmount> = ssat + ssat; let sres: NumOpResult<SignedAmount> = ssat + ssat;
// Operations that where RHS is the result of another operation. macro_rules! check_op {
($(let _ = $lhs:ident $op:tt $rhs:ident);* $(;)?) => {
$(
let _ = $lhs $op $rhs;
let _ = &$lhs $op $rhs;
let _ = $lhs $op &$rhs;
let _ = &$lhs $op &$rhs;
)*
}
}
// We do not currently support division involving `NumOpResult` and an amount type.
check_op! {
// Operations where RHS is the result of another operation.
let _ = sat + res; let _ = sat + res;
let _ = &sat + res;
// let _ = sat + &res;
// let _ = &sat + &res;
let _ = sat - res; let _ = sat - res;
let _ = &sat - res; // let _ = sat / res;
// let _ = sat - &res; let _ = ssat + sres;
// let _ = &sat - &res; let _ = ssat - sres;
// let _ = ssat / sres;
// Operations that where LHS is the result of another operation. // Operations where LHS is the result of another operation.
let _ = res + sat; let _ = res + sat;
// let _ = &res + sat;
let _ = res + &sat;
// let _ = &res + &sat;
let _ = res - sat; let _ = res - sat;
// let _ = &res - sat; // let _ = res / sat;
let _ = res - &sat; let _ = sres + ssat;
// let _ = &res - &sat; let _ = sres - ssat;
// let _ = sres / ssat;
// Operations that where both sides are the result of another operation. // Operations that where both sides are the result of another operation.
let _ = res + res; let _ = res + res;
// let _ = &res + res;
// let _ = res + &res;
// let _ = &res + &res;
let _ = res - res; let _ = res - res;
// let _ = &res - res; // let _ = res / res;
// let _ = res - &res; let _ = sres + sres;
// let _ = &res - &res; let _ = sres - sres;
// let _ = sres / sres;
};
}
// Verify we have implemented all combinations of ops for the `NumOpResult` type and an integer.
// It's easier to read this test than check the code.
#[test]
#[allow(clippy::op_ref)] // We are explicitly testing the references work with ops.
fn num_op_result_ops_integer() {
let sat = Amount::from_sat(1);
let ssat = SignedAmount::from_sat(1);
// Explicit type as sanity check.
let res: NumOpResult<Amount> = sat + sat;
let sres: NumOpResult<SignedAmount> = ssat + ssat;
macro_rules! check_op {
($(let _ = $lhs:ident $op:tt $rhs:literal);* $(;)?) => {
$(
let _ = $lhs $op $rhs;
let _ = &$lhs $op $rhs;
let _ = $lhs $op &$rhs;
let _ = &$lhs $op &$rhs;
)*
}
}
check_op! {
// Operations on a `NumOpResult` and integer.
let _ = res * 3_u64; // Explicit type for the benefit of the reader.
let _ = res / 3;
let _ = res % 3;
let _ = sres * 3_i64; // Explicit type for the benefit of the reader.
let _ = sres / 3;
let _ = sres % 3;
};
}
// Verify we have implemented all `Neg` for the amount types.
#[test]
fn amount_op_result_neg() {
// TODO: Implement Neg all round.
// let sat = Amount::from_sat(1);
let ssat = SignedAmount::from_sat(1);
// let _ = -sat;
let _ = -ssat;
// let _ = -res;
// let _ = -sres;
} }
// Verify we have implemented all `Sum` for the `NumOpResult` type. // Verify we have implemented all `Sum` for the `NumOpResult` type.
@ -1373,7 +1325,4 @@ fn amount_op_result_sum() {
let _ = amounts.iter().sum::<NumOpResult<Amount>>(); let _ = amounts.iter().sum::<NumOpResult<Amount>>();
let _ = amount_refs.iter().copied().sum::<NumOpResult<Amount>>(); let _ = amount_refs.iter().copied().sum::<NumOpResult<Amount>>();
let _ = amount_refs.into_iter().sum::<NumOpResult<Amount>>(); let _ = amount_refs.into_iter().sum::<NumOpResult<Amount>>();
// FIXME: Should we support this? I don't think so (Tobin).
// let _ = amount_refs.iter().sum::<NumOpResult<&Amount>>();
} }