Skip to content

Commit

Permalink
Macroise the NumOpResult tests
Browse files Browse the repository at this point in the history 
Macroise the tests improving coverage along the way.

Includes a TODO to remind us to do `Neg` more fully.
  • Loading branch information
@tcharding
tcharding committed Feb 19, 2025
1 parent c47de02 commit cb73032
Showing 1 changed file with 98 additions and 149 deletions.
247 changes: 98 additions & 149 deletions units/src/amount/tests.rs
View file
Original file line number Diff line number Diff line change
Expand Up @@ -1196,170 +1196,122 @@ fn check_const() {
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`.
// It's easier to read this test that check the code.
// Sanity check than stdlib supports the set of reference combinations for the ops we want.
#[test]
#[allow(clippy::op_ref)] // We are explicitly testing the references work with ops.
fn amount_tyes_all_ops() {
// Sanity check than stdlib supports the set of reference combinations for the ops we want.
{
let x = 127;
fn sanity_all_ops() {
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 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;
}
// 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:ident);* $(;)?) => {
$(
let _ = $lhs $op $rhs;
let _ = &$lhs $op $rhs;
let _ = $lhs $op &$rhs;
let _ = &$lhs $op &$rhs;
)*
}
}

// 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;
// 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 _ = ssat + sres;
let _ = ssat - sres;
// let _ = ssat / sres;

// Operations where LHS is the result of another operation.
let _ = res + sat;
let _ = res - sat;
// let _ = res / sat;
let _ = sres + ssat;
let _ = sres - ssat;
// let _ = sres / ssat;

// Operations that where both sides are the result of another operation.
let _ = res + res;
let _ = res - res;
// let _ = res / res;
let _ = sres + sres;
let _ = sres - sres;
// let _ = sres / sres;
};
}

// Verify we have implemented all combinations of ops for the `NumOpResult` type.
// It's easier to read this test that check the code.
// 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 amount_op_result_all_ops() {
fn num_op_result_ops_integer() {
let sat = Amount::from_sat(1);
// let ssat = SignedAmount::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;

// Operations that 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;

// Operations that 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;

// 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 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.
Expand All @@ -1373,7 +1325,4 @@ fn amount_op_result_sum() {
let _ = amounts.iter().sum::<NumOpResult<Amount>>();
let _ = amount_refs.iter().copied().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>>();
}

0 comments on commit cb73032

Please sign in to comment.