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

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

@ -1196,170 +1196,122 @@ 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;
let _ = &x + x; let _ = &x + x;
let _ = x + &x; let _ = x + &x;
let _ = &x + &x; let _ = &x + &x;
let _ = x - x; let _ = x - x;
let _ = &x - x; let _ = &x - x;
let _ = x - &x; let _ = x - &x;
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 // Explicit type as sanity check.
let _ = sat + sat; let res: NumOpResult<Amount> = sat + sat;
let _ = &sat + sat; let sres: NumOpResult<SignedAmount> = ssat + ssat;
let _ = sat + &sat;
let _ = &sat + &sat;
// let _ = ssat + sat; macro_rules! check_op {
// let _ = &ssat + sat; ($(let _ = $lhs:ident $op:tt $rhs:ident);* $(;)?) => {
// let _ = ssat + &sat; $(
// let _ = &ssat + &sat; let _ = $lhs $op $rhs;
let _ = &$lhs $op $rhs;
let _ = $lhs $op &$rhs;
let _ = &$lhs $op &$rhs;
)*
}
}
// let _ = sat + ssat; // We do not currently support division involving `NumOpResult` and an amount type.
// let _ = &sat + ssat; check_op! {
// let _ = sat + &ssat; // Operations where RHS is the result of another operation.
// let _ = &sat + &ssat; let _ = sat + res;
let _ = sat - res;
// let _ = sat / res;
let _ = ssat + sres;
let _ = ssat - sres;
// let _ = ssat / sres;
let _ = ssat + ssat; // Operations where LHS is the result of another operation.
let _ = &ssat + ssat; let _ = res + sat;
let _ = ssat + &ssat; let _ = res - sat;
let _ = &ssat + &ssat; // let _ = res / sat;
let _ = sres + ssat;
let _ = sres - ssat;
// let _ = sres / ssat;
// Sub // Operations that where both sides are the result of another operation.
let _ = sat - sat; let _ = res + res;
let _ = &sat - sat; let _ = res - res;
let _ = sat - &sat; // let _ = res / res;
let _ = &sat - &sat; let _ = sres + sres;
let _ = sres - sres;
// let _ = ssat - sat; // let _ = sres / sres;
// 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? // Verify we have implemented all combinations of ops for the `NumOpResult` type and an integer.
// It will be a lot more code for possibly not that much benefit. // It's easier to read this test than check the code.
#[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] #[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_op_result_all_ops() { fn num_op_result_ops_integer() {
let sat = Amount::from_sat(1); let sat = Amount::from_sat(1);
// let ssat = SignedAmount::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 _ = sat + res; ($(let _ = $lhs:ident $op:tt $rhs:literal);* $(;)?) => {
let _ = &sat + res; $(
// let _ = sat + &res; let _ = $lhs $op $rhs;
// let _ = &sat + &res; 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 _ = sat - res; let _ = sres * 3_i64; // Explicit type for the benefit of the reader.
let _ = &sat - res; let _ = sres / 3;
// let _ = sat - &res; let _ = sres % 3;
// let _ = &sat - &res; };
}
// Operations that where LHS is the result of another operation. // Verify we have implemented all `Neg` for the amount types.
let _ = res + sat; #[test]
// let _ = &res + sat; fn amount_op_result_neg() {
let _ = res + &sat; // TODO: Implement Neg all round.
// let _ = &res + &sat;
let _ = res - sat; // let sat = Amount::from_sat(1);
// let _ = &res - sat; let ssat = SignedAmount::from_sat(1);
let _ = res - &sat;
// let _ = &res - &sat;
// Operations that where both sides are the result of another operation. // let _ = -sat;
let _ = res + res; let _ = -ssat;
// let _ = &res + res; // let _ = -res;
// let _ = res + &res; // let _ = -sres;
// let _ = &res + &res;
let _ = res - res;
// let _ = &res - res;
// let _ = res - &res;
// let _ = &res - &res;
} }
// 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>>();
} }