use mockall::predicate::eq;
use mockall::Sequence;
use nearly::{
    NearlyEqEps, NearlyEqTol, NearlyEqUlps, NearlyOrdEps, NearlyOrdTol, NearlyOrdUlps, Tolerance,
};
use paste::paste;

mod common;
use common::{MockLhs, Rhs};

macro_rules! lhs_type {
    (1) => {
        (MockLhs,)
    };
    (2) => {
        (MockLhs, MockLhs)
    };
    (3) => {
        (MockLhs, MockLhs, MockLhs)
    };
    (4) => {
        (MockLhs, MockLhs, MockLhs, MockLhs)
    };
    (5) => {
        (MockLhs, MockLhs, MockLhs, MockLhs, MockLhs)
    };
    (6) => {
        (MockLhs, MockLhs, MockLhs, MockLhs, MockLhs, MockLhs)
    };
    (7) => {
        (
            MockLhs, MockLhs, MockLhs, MockLhs, MockLhs, MockLhs, MockLhs,
        )
    };
    (8) => {
        (
            MockLhs, MockLhs, MockLhs, MockLhs, MockLhs, MockLhs, MockLhs, MockLhs,
        )
    };
    (9) => {
        (
            MockLhs, MockLhs, MockLhs, MockLhs, MockLhs, MockLhs, MockLhs, MockLhs, MockLhs,
        )
    };
    (10) => {
        (
            MockLhs, MockLhs, MockLhs, MockLhs, MockLhs, MockLhs, MockLhs, MockLhs, MockLhs,
            MockLhs,
        )
    };
    (11) => {
        (
            MockLhs, MockLhs, MockLhs, MockLhs, MockLhs, MockLhs, MockLhs, MockLhs, MockLhs,
            MockLhs, MockLhs,
        )
    };
    (12) => {
        (
            MockLhs, MockLhs, MockLhs, MockLhs, MockLhs, MockLhs, MockLhs, MockLhs, MockLhs,
            MockLhs, MockLhs, MockLhs,
        )
    };
}

macro_rules! rhs_type {
    (1) => {
        (Rhs,)
    };
    (2) => {
        (Rhs, Rhs)
    };
    (3) => {
        (Rhs, Rhs, Rhs)
    };
    (4) => {
        (Rhs, Rhs, Rhs, Rhs)
    };
    (5) => {
        (Rhs, Rhs, Rhs, Rhs, Rhs)
    };
    (6) => {
        (Rhs, Rhs, Rhs, Rhs, Rhs, Rhs)
    };
    (7) => {
        (Rhs, Rhs, Rhs, Rhs, Rhs, Rhs, Rhs)
    };
    (8) => {
        (Rhs, Rhs, Rhs, Rhs, Rhs, Rhs, Rhs, Rhs)
    };
    (9) => {
        (Rhs, Rhs, Rhs, Rhs, Rhs, Rhs, Rhs, Rhs, Rhs)
    };
    (10) => {
        (Rhs, Rhs, Rhs, Rhs, Rhs, Rhs, Rhs, Rhs, Rhs, Rhs)
    };
    (11) => {
        (Rhs, Rhs, Rhs, Rhs, Rhs, Rhs, Rhs, Rhs, Rhs, Rhs, Rhs)
    };
    (12) => {
        (Rhs, Rhs, Rhs, Rhs, Rhs, Rhs, Rhs, Rhs, Rhs, Rhs, Rhs, Rhs)
    };
}

macro_rules! lhs_value {
    (1) => {
        (MockLhs::new(),)
    };
    (2) => {
        (MockLhs::new(), MockLhs::new())
    };
    (3) => {
        (MockLhs::new(), MockLhs::new(), MockLhs::new())
    };
    (4) => {
        (
            MockLhs::new(),
            MockLhs::new(),
            MockLhs::new(),
            MockLhs::new(),
        )
    };
    (5) => {
        (
            MockLhs::new(),
            MockLhs::new(),
            MockLhs::new(),
            MockLhs::new(),
            MockLhs::new(),
        )
    };
    (6) => {
        (
            MockLhs::new(),
            MockLhs::new(),
            MockLhs::new(),
            MockLhs::new(),
            MockLhs::new(),
            MockLhs::new(),
        )
    };
    (7) => {
        (
            MockLhs::new(),
            MockLhs::new(),
            MockLhs::new(),
            MockLhs::new(),
            MockLhs::new(),
            MockLhs::new(),
            MockLhs::new(),
        )
    };
    (8) => {
        (
            MockLhs::new(),
            MockLhs::new(),
            MockLhs::new(),
            MockLhs::new(),
            MockLhs::new(),
            MockLhs::new(),
            MockLhs::new(),
            MockLhs::new(),
        )
    };
    (9) => {
        (
            MockLhs::new(),
            MockLhs::new(),
            MockLhs::new(),
            MockLhs::new(),
            MockLhs::new(),
            MockLhs::new(),
            MockLhs::new(),
            MockLhs::new(),
            MockLhs::new(),
        )
    };
    (10) => {
        (
            MockLhs::new(),
            MockLhs::new(),
            MockLhs::new(),
            MockLhs::new(),
            MockLhs::new(),
            MockLhs::new(),
            MockLhs::new(),
            MockLhs::new(),
            MockLhs::new(),
            MockLhs::new(),
        )
    };
    (11) => {
        (
            MockLhs::new(),
            MockLhs::new(),
            MockLhs::new(),
            MockLhs::new(),
            MockLhs::new(),
            MockLhs::new(),
            MockLhs::new(),
            MockLhs::new(),
            MockLhs::new(),
            MockLhs::new(),
            MockLhs::new(),
        )
    };
    (12) => {
        (
            MockLhs::new(),
            MockLhs::new(),
            MockLhs::new(),
            MockLhs::new(),
            MockLhs::new(),
            MockLhs::new(),
            MockLhs::new(),
            MockLhs::new(),
            MockLhs::new(),
            MockLhs::new(),
            MockLhs::new(),
            MockLhs::new(),
        )
    };
}

macro_rules! rhs_value {
    (1) => {
        (Rhs(0),)
    };
    (2) => {
        (Rhs(0), Rhs(1))
    };
    (3) => {
        (Rhs(0), Rhs(1), Rhs(2))
    };
    (4) => {
        (Rhs(0), Rhs(1), Rhs(2), Rhs(3))
    };
    (5) => {
        (Rhs(0), Rhs(1), Rhs(2), Rhs(3), Rhs(4))
    };
    (6) => {
        (Rhs(0), Rhs(1), Rhs(2), Rhs(3), Rhs(4), Rhs(5))
    };
    (7) => {
        (Rhs(0), Rhs(1), Rhs(2), Rhs(3), Rhs(4), Rhs(5), Rhs(6))
    };
    (8) => {
        (
            Rhs(0),
            Rhs(1),
            Rhs(2),
            Rhs(3),
            Rhs(4),
            Rhs(5),
            Rhs(6),
            Rhs(7),
        )
    };
    (9) => {
        (
            Rhs(0),
            Rhs(1),
            Rhs(2),
            Rhs(3),
            Rhs(4),
            Rhs(5),
            Rhs(6),
            Rhs(7),
            Rhs(8),
        )
    };
    (10) => {
        (
            Rhs(0),
            Rhs(1),
            Rhs(2),
            Rhs(3),
            Rhs(4),
            Rhs(5),
            Rhs(6),
            Rhs(7),
            Rhs(8),
            Rhs(9),
        )
    };
    (11) => {
        (
            Rhs(0),
            Rhs(1),
            Rhs(2),
            Rhs(3),
            Rhs(4),
            Rhs(5),
            Rhs(6),
            Rhs(7),
            Rhs(8),
            Rhs(9),
            Rhs(10),
        )
    };
    (12) => {
        (
            Rhs(0),
            Rhs(1),
            Rhs(2),
            Rhs(3),
            Rhs(4),
            Rhs(5),
            Rhs(6),
            Rhs(7),
            Rhs(8),
            Rhs(9),
            Rhs(10),
            Rhs(11),
        )
    };
}

macro_rules! expect_call {
    ($tuple: ident, $seq: ident, $func: ident, $ret: expr, $tol: expr, $idx: tt) => {
        expect_call!(@impl $tuple, $seq, $func, $ret, $tol, $idx);
    };
    ($tuple: ident, $seq: ident, $func: ident, $ret: expr, $tol: expr, $idx: tt $( $idx_tail: tt )+) => {
        expect_call!($tuple, $seq, $func, $ret, $tol, $( $idx_tail )+);
        expect_call!(@impl $tuple, $seq, $func, $ret, $tol, $idx);
    };
    (@impl $tuple: ident, $seq: ident, $func: ident, $ret: expr, $tol: expr, $( $idx: tt )+) => {
        $($tuple.$idx.$func()
            .with(eq(Rhs($idx)), eq($tol))
            .times(1)
            .in_sequence(&mut $seq)
            .return_const($ret))+;
    }
}

macro_rules! expect_no_call {
    ($tuple: ident, $func: ident, $idx: tt) => {
        expect_no_call!(@impl $tuple, $func, $idx);
    };
    ($tuple: ident, $func: ident, $idx: tt $( $idx_tail: tt )+) => {
        expect_no_call!($tuple, $func, $( $idx_tail )+);
        expect_no_call!(@impl $tuple, $func, $idx);
    };
    (@impl $tuple: ident, $func: ident, $( $idx: tt )+) => {
        $($tuple.$idx.$func().times(0);)+
    }
}

macro_rules! checkpoint {
    ($tuple: ident, $idx: tt) => {
        checkpoint!(@impl $tuple, $idx);
    };
    ($tuple: ident, $idx: tt $( $idx_tail: tt )+) => {
        checkpoint!($tuple, $( $idx_tail )+);
        checkpoint!(@impl $tuple, $idx);
    };
    (@impl $tuple: ident, $( $idx: tt )+) => {
        $($tuple.$idx.checkpoint();)+
    }
}

macro_rules! impl_test {
    ($tol_fn: ident, $tol: expr) => {
        impl_test_fn!($tol_fn, $tol, eq);
        impl_test_fn!($tol_fn, $tol, lt);
        impl_test_fn!($tol_fn, $tol, le);
        impl_test_fn!($tol_fn, $tol, gt);
        impl_test_fn!($tol_fn, $tol, ge);
    };
}

macro_rules! impl_test_fn {
    ($tol_fn: ident, $tol: expr, $fn: ident) => {
        paste! {
            #[test]
            fn [<nearly_ $fn _ $tol_fn _tuple_1>]() {
                let mut a: lhs_type!(1) = lhs_value!(1);
                let b: rhs_type!(1) = rhs_value!(1);
                let mut seq = Sequence::new();

                expect_call!(a, seq, [<expect_nearly_ $fn _ $tol_fn>], true, $tol, 0);
                assert!(a.[<nearly_ $fn _ $tol_fn>](&b, &$tol));
                checkpoint!(a, 0);

                expect_call!(a, seq, [<expect_nearly_ $fn _ $tol_fn>], false, $tol, 0);
                assert!(!a.[<nearly_ $fn _ $tol_fn>](&b, &$tol));
                checkpoint!(a, 0);
            }

            #[test]
            fn [<nearly_ $fn _ $tol_fn _tuple_2>]() {
                let mut a: lhs_type!(2) = lhs_value!(2);
                let b: rhs_type!(2) = rhs_value!(2);
                let mut seq = Sequence::new();

                expect_call!(a, seq, [<expect_nearly_ $fn _ $tol_fn>], true, $tol, 0 1);
                assert!(a.[<nearly_ $fn _ $tol_fn>](&b, &$tol));
                checkpoint!(a, 0 1);

                expect_call!(a, seq, [<expect_nearly_ $fn _ $tol_fn>], false, $tol, 1);
                expect_no_call!(a, [<expect_nearly_ $fn _ $tol_fn>], 0);
                assert!(!a.[<nearly_ $fn _ $tol_fn>](&b, &$tol));
                checkpoint!(a, 0 1);

                expect_call!(a, seq, [<expect_nearly_ $fn _ $tol_fn>], true, $tol, 1);
                expect_call!(a, seq, [<expect_nearly_ $fn _ $tol_fn>], false, $tol, 0);
                assert!(!a.[<nearly_ $fn _ $tol_fn>](&b, &$tol));
                checkpoint!(a, 0 1);
            }

            #[test]
            fn [<nearly_ $fn _ $tol_fn _tuple_3>]() {
                let mut a: lhs_type!(3) = lhs_value!(3);
                let b: rhs_type!(3) = rhs_value!(3);
                let mut seq = Sequence::new();

                expect_call!(a, seq, [<expect_nearly_ $fn _ $tol_fn>], true, $tol, 0 1 2);
                assert!(a.[<nearly_ $fn _ $tol_fn>](&b, &$tol));
                checkpoint!(a, 0 1 2);

                expect_call!(a, seq, [<expect_nearly_ $fn _ $tol_fn>], false, $tol, 2);
                expect_no_call!(a, [<expect_nearly_ $fn _ $tol_fn>], 0 1);
                assert!(!a.[<nearly_ $fn _ $tol_fn>](&b, &$tol));
                checkpoint!(a, 0 1 2);

                expect_call!(a, seq, [<expect_nearly_ $fn _ $tol_fn>], true, $tol, 2);
                expect_call!(a, seq, [<expect_nearly_ $fn _ $tol_fn>], false, $tol, 1);
                expect_no_call!(a, [<expect_nearly_ $fn _ $tol_fn>], 0);
                assert!(!a.[<nearly_ $fn _ $tol_fn>](&b, &$tol));
                checkpoint!(a, 0 1 2);

                expect_call!(a, seq, [<expect_nearly_ $fn _ $tol_fn>], true, $tol, 1 2);
                expect_call!(a, seq, [<expect_nearly_ $fn _ $tol_fn>], false, $tol, 0);
                assert!(!a.[<nearly_ $fn _ $tol_fn>](&b, &$tol));
                checkpoint!(a, 0 1 2);
            }

            #[test]
            fn [<nearly_ $fn _ $tol_fn _tuple_4>]() {
                let mut a: lhs_type!(4) = lhs_value!(4);
                let b: rhs_type!(4) = rhs_value!(4);
                let mut seq = Sequence::new();

                expect_call!(a, seq, [<expect_nearly_ $fn _ $tol_fn>], true, $tol, 0 1 2 3);
                assert!(a.[<nearly_ $fn _ $tol_fn>](&b, &$tol));
                checkpoint!(a, 0 1 2 3);

                expect_call!(a, seq, [<expect_nearly_ $fn _ $tol_fn>], false, $tol, 3);
                expect_no_call!(a, [<expect_nearly_ $fn _ $tol_fn>], 0 1 2);
                assert!(!a.[<nearly_ $fn _ $tol_fn>](&b, &$tol));
                checkpoint!(a, 0 1 2 3);

                expect_call!(a, seq, [<expect_nearly_ $fn _ $tol_fn>], true, $tol, 3);
                expect_call!(a, seq, [<expect_nearly_ $fn _ $tol_fn>], false, $tol, 2);
                expect_no_call!(a, [<expect_nearly_ $fn _ $tol_fn>], 0 1);
                assert!(!a.[<nearly_ $fn _ $tol_fn>](&b, &$tol));
                checkpoint!(a, 0 1 2 3);

                expect_call!(a, seq, [<expect_nearly_ $fn _ $tol_fn>], true, $tol, 2 3);
                expect_call!(a, seq, [<expect_nearly_ $fn _ $tol_fn>], false, $tol, 1);
                expect_no_call!(a, [<expect_nearly_ $fn _ $tol_fn>], 0);
                assert!(!a.[<nearly_ $fn _ $tol_fn>](&b, &$tol));
                checkpoint!(a, 0 1 2 3);

                expect_call!(a, seq, [<expect_nearly_ $fn _ $tol_fn>], true, $tol, 1 2 3);
                expect_call!(a, seq, [<expect_nearly_ $fn _ $tol_fn>], false, $tol, 0);
                assert!(!a.[<nearly_ $fn _ $tol_fn>](&b, &$tol));
                checkpoint!(a, 0 1 2 3);
            }

            #[test]
            fn [<nearly_ $fn _ $tol_fn _tuple_5>]() {
                let mut a: lhs_type!(5) = lhs_value!(5);
                let b: rhs_type!(5) = rhs_value!(5);
                let mut seq = Sequence::new();

                expect_call!(a, seq, [<expect_nearly_ $fn _ $tol_fn>], true, $tol, 0 1 2 3 4);
                assert!(a.[<nearly_ $fn _ $tol_fn>](&b, &$tol));
                checkpoint!(a, 0 1 2 3 4);

                expect_call!(a, seq, [<expect_nearly_ $fn _ $tol_fn>], false, $tol, 4);
                expect_no_call!(a, [<expect_nearly_ $fn _ $tol_fn>], 0 1 2 3);
                assert!(!a.[<nearly_ $fn _ $tol_fn>](&b, &$tol));
                checkpoint!(a, 0 1 2 3 4);

                expect_call!(a, seq, [<expect_nearly_ $fn _ $tol_fn>], true, $tol, 4);
                expect_call!(a, seq, [<expect_nearly_ $fn _ $tol_fn>], false, $tol, 3);
                expect_no_call!(a, [<expect_nearly_ $fn _ $tol_fn>], 0 1 2);
                assert!(!a.[<nearly_ $fn _ $tol_fn>](&b, &$tol));
                checkpoint!(a, 0 1 2 3 4);

                expect_call!(a, seq, [<expect_nearly_ $fn _ $tol_fn>], true, $tol, 3 4);
                expect_call!(a, seq, [<expect_nearly_ $fn _ $tol_fn>], false, $tol, 2);
                expect_no_call!(a, [<expect_nearly_ $fn _ $tol_fn>], 0 1);
                assert!(!a.[<nearly_ $fn _ $tol_fn>](&b, &$tol));
                checkpoint!(a, 0 1 2 3 4);

                expect_call!(a, seq, [<expect_nearly_ $fn _ $tol_fn>], true, $tol, 2 3 4);
                expect_call!(a, seq, [<expect_nearly_ $fn _ $tol_fn>], false, $tol, 1);
                expect_no_call!(a, [<expect_nearly_ $fn _ $tol_fn>], 0);
                assert!(!a.[<nearly_ $fn _ $tol_fn>](&b, &$tol));
                checkpoint!(a, 0 1 2 3 4);

                expect_call!(a, seq, [<expect_nearly_ $fn _ $tol_fn>], true, $tol, 1 2 3 4);
                expect_call!(a, seq, [<expect_nearly_ $fn _ $tol_fn>], false, $tol, 0);
                assert!(!a.[<nearly_ $fn _ $tol_fn>](&b, &$tol));
                checkpoint!(a, 0 1 2 3 4);
            }

            #[test]
            fn [<nearly_ $fn _ $tol_fn _tuple_6>]() {
                let mut a: lhs_type!(6) = lhs_value!(6);
                let b: rhs_type!(6) = rhs_value!(6);
                let mut seq = Sequence::new();

                expect_call!(a, seq, [<expect_nearly_ $fn _ $tol_fn>], true, $tol, 0 1 2 3 4 5);
                assert!(a.[<nearly_ $fn _ $tol_fn>](&b, &$tol));
                checkpoint!(a, 0 1 2 3 4 5);

                expect_call!(a, seq, [<expect_nearly_ $fn _ $tol_fn>], false, $tol, 5);
                expect_no_call!(a, [<expect_nearly_ $fn _ $tol_fn>], 0 1 2 3 4);
                assert!(!a.[<nearly_ $fn _ $tol_fn>](&b, &$tol));
                checkpoint!(a, 0 1 2 3 4 5);

                expect_call!(a, seq, [<expect_nearly_ $fn _ $tol_fn>], true, $tol, 5);
                expect_call!(a, seq, [<expect_nearly_ $fn _ $tol_fn>], false, $tol, 4);
                expect_no_call!(a, [<expect_nearly_ $fn _ $tol_fn>], 0 1 2 3);
                assert!(!a.[<nearly_ $fn _ $tol_fn>](&b, &$tol));
                checkpoint!(a, 0 1 2 3 4 5);

                expect_call!(a, seq, [<expect_nearly_ $fn _ $tol_fn>], true, $tol, 4 5);
                expect_call!(a, seq, [<expect_nearly_ $fn _ $tol_fn>], false, $tol, 3);
                expect_no_call!(a, [<expect_nearly_ $fn _ $tol_fn>], 0 1 2);
                assert!(!a.[<nearly_ $fn _ $tol_fn>](&b, &$tol));
                checkpoint!(a, 0 1 2 3 4 5);

                expect_call!(a, seq, [<expect_nearly_ $fn _ $tol_fn>], true, $tol, 3 4 5);
                expect_call!(a, seq, [<expect_nearly_ $fn _ $tol_fn>], false, $tol, 2);
                expect_no_call!(a, [<expect_nearly_ $fn _ $tol_fn>], 0 1);
                assert!(!a.[<nearly_ $fn _ $tol_fn>](&b, &$tol));
                checkpoint!(a, 0 1 2 3 4 5);

                expect_call!(a, seq, [<expect_nearly_ $fn _ $tol_fn>], true, $tol, 2 3 4 5);
                expect_call!(a, seq, [<expect_nearly_ $fn _ $tol_fn>], false, $tol, 1);
                expect_no_call!(a, [<expect_nearly_ $fn _ $tol_fn>], 0);
                assert!(!a.[<nearly_ $fn _ $tol_fn>](&b, &$tol));
                checkpoint!(a, 0 1 2 3 4 5);

                expect_call!(a, seq, [<expect_nearly_ $fn _ $tol_fn>], true, $tol, 1 2 3 4 5);
                expect_call!(a, seq, [<expect_nearly_ $fn _ $tol_fn>], false, $tol, 0);
                assert!(!a.[<nearly_ $fn _ $tol_fn>](&b, &$tol));
                checkpoint!(a, 0 1 2 3 4 5);
            }

            #[test]
            fn [<nearly_ $fn _ $tol_fn _tuple_7>]() {
                let mut a: lhs_type!(7) = lhs_value!(7);
                let b: rhs_type!(7) = rhs_value!(7);
                let mut seq = Sequence::new();

                expect_call!(a, seq, [<expect_nearly_ $fn _ $tol_fn>], true, $tol, 0 1 2 3 4 5 6);
                assert!(a.[<nearly_ $fn _ $tol_fn>](&b, &$tol));
                checkpoint!(a, 0 1 2 3 4 5 6);

                expect_call!(a, seq, [<expect_nearly_ $fn _ $tol_fn>], false, $tol, 6);
                expect_no_call!(a, [<expect_nearly_ $fn _ $tol_fn>], 0 1 2 3 4 5);
                assert!(!a.[<nearly_ $fn _ $tol_fn>](&b, &$tol));
                checkpoint!(a, 0 1 2 3 4 5 6);

                expect_call!(a, seq, [<expect_nearly_ $fn _ $tol_fn>], true, $tol, 6);
                expect_call!(a, seq, [<expect_nearly_ $fn _ $tol_fn>], false, $tol, 5);
                expect_no_call!(a, [<expect_nearly_ $fn _ $tol_fn>], 0 1 2 3 4);
                assert!(!a.[<nearly_ $fn _ $tol_fn>](&b, &$tol));
                checkpoint!(a, 0 1 2 3 4 5 6);

                expect_call!(a, seq, [<expect_nearly_ $fn _ $tol_fn>], true, $tol, 5 6);
                expect_call!(a, seq, [<expect_nearly_ $fn _ $tol_fn>], false, $tol, 4);
                expect_no_call!(a, [<expect_nearly_ $fn _ $tol_fn>], 0 1 2 3);
                assert!(!a.[<nearly_ $fn _ $tol_fn>](&b, &$tol));
                checkpoint!(a, 0 1 2 3 4 5 6);

                expect_call!(a, seq, [<expect_nearly_ $fn _ $tol_fn>], true, $tol, 4 5 6);
                expect_call!(a, seq, [<expect_nearly_ $fn _ $tol_fn>], false, $tol, 3);
                expect_no_call!(a, [<expect_nearly_ $fn _ $tol_fn>], 0 1 2);
                assert!(!a.[<nearly_ $fn _ $tol_fn>](&b, &$tol));
                checkpoint!(a, 0 1 2 3 4 5 6);

                expect_call!(a, seq, [<expect_nearly_ $fn _ $tol_fn>], true, $tol, 3 4 5 6);
                expect_call!(a, seq, [<expect_nearly_ $fn _ $tol_fn>], false, $tol, 2);
                expect_no_call!(a, [<expect_nearly_ $fn _ $tol_fn>], 0 1);
                assert!(!a.[<nearly_ $fn _ $tol_fn>](&b, &$tol));
                checkpoint!(a, 0 1 2 3 4 5 6);

                expect_call!(a, seq, [<expect_nearly_ $fn _ $tol_fn>], true, $tol, 2 3 4 5 6);
                expect_call!(a, seq, [<expect_nearly_ $fn _ $tol_fn>], false, $tol, 1);
                expect_no_call!(a, [<expect_nearly_ $fn _ $tol_fn>], 0);
                assert!(!a.[<nearly_ $fn _ $tol_fn>](&b, &$tol));
                checkpoint!(a, 0 1 2 3 4 5 6);

                expect_call!(a, seq, [<expect_nearly_ $fn _ $tol_fn>], true, $tol, 1 2 3 4 5 6);
                expect_call!(a, seq, [<expect_nearly_ $fn _ $tol_fn>], false, $tol, 0);
                assert!(!a.[<nearly_ $fn _ $tol_fn>](&b, &$tol));
                checkpoint!(a, 0 1 2 3 4 5 6);
            }

            #[test]
            fn [<nearly_ $fn _ $tol_fn _tuple_8>]() {
                let mut a: lhs_type!(8) = lhs_value!(8);
                let b: rhs_type!(8) = rhs_value!(8);
                let mut seq = Sequence::new();

                expect_call!(a, seq, [<expect_nearly_ $fn _ $tol_fn>], true, $tol, 0 1 2 3 4 5 6 7);
                assert!(a.[<nearly_ $fn _ $tol_fn>](&b, &$tol));
                checkpoint!(a, 0 1 2 3 4 5 6 7);

                expect_call!(a, seq, [<expect_nearly_ $fn _ $tol_fn>], false, $tol, 7);
                expect_no_call!(a, [<expect_nearly_ $fn _ $tol_fn>], 0 1 2 3 4 5 6);
                assert!(!a.[<nearly_ $fn _ $tol_fn>](&b, &$tol));
                checkpoint!(a, 0 1 2 3 4 5 6 7);

                expect_call!(a, seq, [<expect_nearly_ $fn _ $tol_fn>], true, $tol, 7);
                expect_call!(a, seq, [<expect_nearly_ $fn _ $tol_fn>], false, $tol, 6);
                expect_no_call!(a, [<expect_nearly_ $fn _ $tol_fn>], 0 1 2 3 4 5);
                assert!(!a.[<nearly_ $fn _ $tol_fn>](&b, &$tol));
                checkpoint!(a, 0 1 2 3 4 5 6 7);

                expect_call!(a, seq, [<expect_nearly_ $fn _ $tol_fn>], true, $tol, 6 7);
                expect_call!(a, seq, [<expect_nearly_ $fn _ $tol_fn>], false, $tol, 5);
                expect_no_call!(a, [<expect_nearly_ $fn _ $tol_fn>], 0 1 2 3 4);
                assert!(!a.[<nearly_ $fn _ $tol_fn>](&b, &$tol));
                checkpoint!(a, 0 1 2 3 4 5 6 7);

                expect_call!(a, seq, [<expect_nearly_ $fn _ $tol_fn>], true, $tol, 5 6 7);
                expect_call!(a, seq, [<expect_nearly_ $fn _ $tol_fn>], false, $tol, 4);
                expect_no_call!(a, [<expect_nearly_ $fn _ $tol_fn>], 0 1 2 3);
                assert!(!a.[<nearly_ $fn _ $tol_fn>](&b, &$tol));
                checkpoint!(a, 0 1 2 3 4 5 6 7);

                expect_call!(a, seq, [<expect_nearly_ $fn _ $tol_fn>], true, $tol, 4 5 6 7);
                expect_call!(a, seq, [<expect_nearly_ $fn _ $tol_fn>], false, $tol, 3);
                expect_no_call!(a, [<expect_nearly_ $fn _ $tol_fn>], 0 1 2);
                assert!(!a.[<nearly_ $fn _ $tol_fn>](&b, &$tol));
                checkpoint!(a, 0 1 2 3 4 5 6 7);

                expect_call!(a, seq, [<expect_nearly_ $fn _ $tol_fn>], true, $tol, 3 4 5 6 7);
                expect_call!(a, seq, [<expect_nearly_ $fn _ $tol_fn>], false, $tol, 2);
                expect_no_call!(a, [<expect_nearly_ $fn _ $tol_fn>], 0 1);
                assert!(!a.[<nearly_ $fn _ $tol_fn>](&b, &$tol));
                checkpoint!(a, 0 1 2 3 4 5 6 7);

                expect_call!(a, seq, [<expect_nearly_ $fn _ $tol_fn>], true, $tol, 2 3 4 5 6 7);
                expect_call!(a, seq, [<expect_nearly_ $fn _ $tol_fn>], false, $tol, 1);
                expect_no_call!(a, [<expect_nearly_ $fn _ $tol_fn>], 0);
                assert!(!a.[<nearly_ $fn _ $tol_fn>](&b, &$tol));
                checkpoint!(a, 0 1 2 3 4 5 6 7);

                expect_call!(a, seq, [<expect_nearly_ $fn _ $tol_fn>], true, $tol, 1 2 3 4 5 6 7);
                expect_call!(a, seq, [<expect_nearly_ $fn _ $tol_fn>], false, $tol, 0);
                assert!(!a.[<nearly_ $fn _ $tol_fn>](&b, &$tol));
                checkpoint!(a, 0 1 2 3 4 5 6 7);
            }

            #[test]
            fn [<nearly_ $fn _ $tol_fn _tuple_9>]() {
                let mut a: lhs_type!(9) = lhs_value!(9);
                let b: rhs_type!(9) = rhs_value!(9);
                let mut seq = Sequence::new();

                expect_call!(a, seq, [<expect_nearly_ $fn _ $tol_fn>], true, $tol, 0 1 2 3 4 5 6 7 8);
                assert!(a.[<nearly_ $fn _ $tol_fn>](&b, &$tol));
                checkpoint!(a, 0 1 2 3 4 5 6 7 8);

                expect_call!(a, seq, [<expect_nearly_ $fn _ $tol_fn>], false, $tol, 8);
                expect_no_call!(a, [<expect_nearly_ $fn _ $tol_fn>], 0 1 2 3 4 5 6 7);
                assert!(!a.[<nearly_ $fn _ $tol_fn>](&b, &$tol));
                checkpoint!(a, 0 1 2 3 4 5 6 7 8);

                expect_call!(a, seq, [<expect_nearly_ $fn _ $tol_fn>], true, $tol, 8);
                expect_call!(a, seq, [<expect_nearly_ $fn _ $tol_fn>], false, $tol, 7);
                expect_no_call!(a, [<expect_nearly_ $fn _ $tol_fn>], 0 1 2 3 4 5 6);
                assert!(!a.[<nearly_ $fn _ $tol_fn>](&b, &$tol));
                checkpoint!(a, 0 1 2 3 4 5 6 7 8);

                expect_call!(a, seq, [<expect_nearly_ $fn _ $tol_fn>], true, $tol, 7 8);
                expect_call!(a, seq, [<expect_nearly_ $fn _ $tol_fn>], false, $tol, 6);
                expect_no_call!(a, [<expect_nearly_ $fn _ $tol_fn>], 0 1 2 3 4 5);
                assert!(!a.[<nearly_ $fn _ $tol_fn>](&b, &$tol));
                checkpoint!(a, 0 1 2 3 4 5 6 7 8);

                expect_call!(a, seq, [<expect_nearly_ $fn _ $tol_fn>], true, $tol, 6 7 8);
                expect_call!(a, seq, [<expect_nearly_ $fn _ $tol_fn>], false, $tol, 5);
                expect_no_call!(a, [<expect_nearly_ $fn _ $tol_fn>], 0 1 2 3 4);
                assert!(!a.[<nearly_ $fn _ $tol_fn>](&b, &$tol));
                checkpoint!(a, 0 1 2 3 4 5 6 7 8);

                expect_call!(a, seq, [<expect_nearly_ $fn _ $tol_fn>], true, $tol, 5 6 7 8);
                expect_call!(a, seq, [<expect_nearly_ $fn _ $tol_fn>], false, $tol, 4);
                expect_no_call!(a, [<expect_nearly_ $fn _ $tol_fn>], 0 1 2 3);
                assert!(!a.[<nearly_ $fn _ $tol_fn>](&b, &$tol));
                checkpoint!(a, 0 1 2 3 4 5 6 7 8);

                expect_call!(a, seq, [<expect_nearly_ $fn _ $tol_fn>], true, $tol, 4 5 6 7 8);
                expect_call!(a, seq, [<expect_nearly_ $fn _ $tol_fn>], false, $tol, 3);
                expect_no_call!(a, [<expect_nearly_ $fn _ $tol_fn>], 0 1 2);
                assert!(!a.[<nearly_ $fn _ $tol_fn>](&b, &$tol));
                checkpoint!(a, 0 1 2 3 4 5 6 7 8);

                expect_call!(a, seq, [<expect_nearly_ $fn _ $tol_fn>], true, $tol, 3 4 5 6 7 8);
                expect_call!(a, seq, [<expect_nearly_ $fn _ $tol_fn>], false, $tol, 2);
                expect_no_call!(a, [<expect_nearly_ $fn _ $tol_fn>], 0 1);
                assert!(!a.[<nearly_ $fn _ $tol_fn>](&b, &$tol));
                checkpoint!(a, 0 1 2 3 4 5 6 7 8);

                expect_call!(a, seq, [<expect_nearly_ $fn _ $tol_fn>], true, $tol, 2 3 4 5 6 7 8);
                expect_call!(a, seq, [<expect_nearly_ $fn _ $tol_fn>], false, $tol, 1);
                expect_no_call!(a, [<expect_nearly_ $fn _ $tol_fn>], 0);
                assert!(!a.[<nearly_ $fn _ $tol_fn>](&b, &$tol));
                checkpoint!(a, 0 1 2 3 4 5 6 7 8);

                expect_call!(a, seq, [<expect_nearly_ $fn _ $tol_fn>], true, $tol, 1 2 3 4 5 6 7 8);
                expect_call!(a, seq, [<expect_nearly_ $fn _ $tol_fn>], false, $tol, 0);
                assert!(!a.[<nearly_ $fn _ $tol_fn>](&b, &$tol));
                checkpoint!(a, 0 1 2 3 4 5 6 7 8);
            }

            #[test]
            fn [<nearly_ $fn _ $tol_fn _tuple_10>]() {
                let mut a: lhs_type!(10) = lhs_value!(10);
                let b: rhs_type!(10) = rhs_value!(10);
                let mut seq = Sequence::new();

                expect_call!(a, seq, [<expect_nearly_ $fn _ $tol_fn>], true, $tol, 0 1 2 3 4 5 6 7 8 9);
                assert!(a.[<nearly_ $fn _ $tol_fn>](&b, &$tol));
                checkpoint!(a, 0 1 2 3 4 5 6 7 8 9);

                expect_call!(a, seq, [<expect_nearly_ $fn _ $tol_fn>], false, $tol, 9);
                expect_no_call!(a, [<expect_nearly_ $fn _ $tol_fn>], 0 1 2 3 4 5 6 7 8);
                assert!(!a.[<nearly_ $fn _ $tol_fn>](&b, &$tol));
                checkpoint!(a, 0 1 2 3 4 5 6 7 8 9);

                expect_call!(a, seq, [<expect_nearly_ $fn _ $tol_fn>], true, $tol, 9);
                expect_call!(a, seq, [<expect_nearly_ $fn _ $tol_fn>], false, $tol, 8);
                expect_no_call!(a, [<expect_nearly_ $fn _ $tol_fn>], 0 1 2 3 4 5 6 7);
                assert!(!a.[<nearly_ $fn _ $tol_fn>](&b, &$tol));
                checkpoint!(a, 0 1 2 3 4 5 6 7 8 9);

                expect_call!(a, seq, [<expect_nearly_ $fn _ $tol_fn>], true, $tol, 8 9);
                expect_call!(a, seq, [<expect_nearly_ $fn _ $tol_fn>], false, $tol, 7);
                expect_no_call!(a, [<expect_nearly_ $fn _ $tol_fn>], 0 1 2 3 4 5 6);
                assert!(!a.[<nearly_ $fn _ $tol_fn>](&b, &$tol));
                checkpoint!(a, 0 1 2 3 4 5 6 7 8 9);

                expect_call!(a, seq, [<expect_nearly_ $fn _ $tol_fn>], true, $tol, 7 8 9);
                expect_call!(a, seq, [<expect_nearly_ $fn _ $tol_fn>], false, $tol, 6);
                expect_no_call!(a, [<expect_nearly_ $fn _ $tol_fn>], 0 1 2 3 4 5);
                assert!(!a.[<nearly_ $fn _ $tol_fn>](&b, &$tol));
                checkpoint!(a, 0 1 2 3 4 5 6 7 8 9);

                expect_call!(a, seq, [<expect_nearly_ $fn _ $tol_fn>], true, $tol, 6 7 8 9);
                expect_call!(a, seq, [<expect_nearly_ $fn _ $tol_fn>], false, $tol, 5);
                expect_no_call!(a, [<expect_nearly_ $fn _ $tol_fn>], 0 1 2 3 4);
                assert!(!a.[<nearly_ $fn _ $tol_fn>](&b, &$tol));
                checkpoint!(a, 0 1 2 3 4 5 6 7 8 9);

                expect_call!(a, seq, [<expect_nearly_ $fn _ $tol_fn>], true, $tol, 5 6 7 8 9);
                expect_call!(a, seq, [<expect_nearly_ $fn _ $tol_fn>], false, $tol, 4);
                expect_no_call!(a, [<expect_nearly_ $fn _ $tol_fn>], 0 1 2 3);
                assert!(!a.[<nearly_ $fn _ $tol_fn>](&b, &$tol));
                checkpoint!(a, 0 1 2 3 4 5 6 7 8 9);

                expect_call!(a, seq, [<expect_nearly_ $fn _ $tol_fn>], true, $tol, 4 5 6 7 8 9);
                expect_call!(a, seq, [<expect_nearly_ $fn _ $tol_fn>], false, $tol, 3);
                expect_no_call!(a, [<expect_nearly_ $fn _ $tol_fn>], 0 1 2);
                assert!(!a.[<nearly_ $fn _ $tol_fn>](&b, &$tol));
                checkpoint!(a, 0 1 2 3 4 5 6 7 8 9);

                expect_call!(a, seq, [<expect_nearly_ $fn _ $tol_fn>], true, $tol, 3 4 5 6 7 8 9);
                expect_call!(a, seq, [<expect_nearly_ $fn _ $tol_fn>], false, $tol, 2);
                expect_no_call!(a, [<expect_nearly_ $fn _ $tol_fn>], 0 1);
                assert!(!a.[<nearly_ $fn _ $tol_fn>](&b, &$tol));
                checkpoint!(a, 0 1 2 3 4 5 6 7 8 9);

                expect_call!(a, seq, [<expect_nearly_ $fn _ $tol_fn>], true, $tol, 2 3 4 5 6 7 8 9);
                expect_call!(a, seq, [<expect_nearly_ $fn _ $tol_fn>], false, $tol, 1);
                expect_no_call!(a, [<expect_nearly_ $fn _ $tol_fn>], 0);
                assert!(!a.[<nearly_ $fn _ $tol_fn>](&b, &$tol));
                checkpoint!(a, 0 1 2 3 4 5 6 7 8 9);

                expect_call!(a, seq, [<expect_nearly_ $fn _ $tol_fn>], true, $tol, 1 2 3 4 5 6 7 8 9);
                expect_call!(a, seq, [<expect_nearly_ $fn _ $tol_fn>], false, $tol, 0);
                assert!(!a.[<nearly_ $fn _ $tol_fn>](&b, &$tol));
                checkpoint!(a, 0 1 2 3 4 5 6 7 8 9);
            }

            #[test]
            fn [<nearly_ $fn _ $tol_fn _tuple_11>]() {
                let mut a: lhs_type!(11) = lhs_value!(11);
                let b: rhs_type!(11) = rhs_value!(11);
                let mut seq = Sequence::new();

                expect_call!(a, seq, [<expect_nearly_ $fn _ $tol_fn>], true, $tol, 0 1 2 3 4 5 6 7 8 9 10);
                assert!(a.[<nearly_ $fn _ $tol_fn>](&b, &$tol));
                checkpoint!(a, 0 1 2 3 4 5 6 7 8 9 10);

                expect_call!(a, seq, [<expect_nearly_ $fn _ $tol_fn>], false, $tol, 10);
                expect_no_call!(a, [<expect_nearly_ $fn _ $tol_fn>], 0 1 2 3 4 5 6 7 8 9);
                assert!(!a.[<nearly_ $fn _ $tol_fn>](&b, &$tol));
                checkpoint!(a, 0 1 2 3 4 5 6 7 8 9 10);

                expect_call!(a, seq, [<expect_nearly_ $fn _ $tol_fn>], true, $tol, 10);
                expect_call!(a, seq, [<expect_nearly_ $fn _ $tol_fn>], false, $tol, 9);
                expect_no_call!(a, [<expect_nearly_ $fn _ $tol_fn>], 0 1 2 3 4 5 6 7 8);
                assert!(!a.[<nearly_ $fn _ $tol_fn>](&b, &$tol));
                checkpoint!(a, 0 1 2 3 4 5 6 7 8 9 10);

                expect_call!(a, seq, [<expect_nearly_ $fn _ $tol_fn>], true, $tol, 9 10);
                expect_call!(a, seq, [<expect_nearly_ $fn _ $tol_fn>], false, $tol, 8);
                expect_no_call!(a, [<expect_nearly_ $fn _ $tol_fn>], 0 1 2 3 4 5 6 7);
                assert!(!a.[<nearly_ $fn _ $tol_fn>](&b, &$tol));
                checkpoint!(a, 0 1 2 3 4 5 6 7 8 9 10);

                expect_call!(a, seq, [<expect_nearly_ $fn _ $tol_fn>], true, $tol, 8 9 10);
                expect_call!(a, seq, [<expect_nearly_ $fn _ $tol_fn>], false, $tol, 7);
                expect_no_call!(a, [<expect_nearly_ $fn _ $tol_fn>], 0 1 2 3 4 5 6);
                assert!(!a.[<nearly_ $fn _ $tol_fn>](&b, &$tol));
                checkpoint!(a, 0 1 2 3 4 5 6 7 8 9 10);

                expect_call!(a, seq, [<expect_nearly_ $fn _ $tol_fn>], true, $tol, 7 8 9 10);
                expect_call!(a, seq, [<expect_nearly_ $fn _ $tol_fn>], false, $tol, 6);
                expect_no_call!(a, [<expect_nearly_ $fn _ $tol_fn>], 0 1 2 3 4 5);
                assert!(!a.[<nearly_ $fn _ $tol_fn>](&b, &$tol));
                checkpoint!(a, 0 1 2 3 4 5 6 7 8 9 10);

                expect_call!(a, seq, [<expect_nearly_ $fn _ $tol_fn>], true, $tol, 6 7 8 9 10);
                expect_call!(a, seq, [<expect_nearly_ $fn _ $tol_fn>], false, $tol, 5);
                expect_no_call!(a, [<expect_nearly_ $fn _ $tol_fn>], 0 1 2 3 4);
                assert!(!a.[<nearly_ $fn _ $tol_fn>](&b, &$tol));
                checkpoint!(a, 0 1 2 3 4 5 6 7 8 9 10);

                expect_call!(a, seq, [<expect_nearly_ $fn _ $tol_fn>], true, $tol, 5 6 7 8 9 10);
                expect_call!(a, seq, [<expect_nearly_ $fn _ $tol_fn>], false, $tol, 4);
                expect_no_call!(a, [<expect_nearly_ $fn _ $tol_fn>], 0 1 2 3);
                assert!(!a.[<nearly_ $fn _ $tol_fn>](&b, &$tol));
                checkpoint!(a, 0 1 2 3 4 5 6 7 8 9 10);

                expect_call!(a, seq, [<expect_nearly_ $fn _ $tol_fn>], true, $tol, 4 5 6 7 8 9 10);
                expect_call!(a, seq, [<expect_nearly_ $fn _ $tol_fn>], false, $tol, 3);
                expect_no_call!(a, [<expect_nearly_ $fn _ $tol_fn>], 0 1 2);
                assert!(!a.[<nearly_ $fn _ $tol_fn>](&b, &$tol));
                checkpoint!(a, 0 1 2 3 4 5 6 7 8 9 10);

                expect_call!(a, seq, [<expect_nearly_ $fn _ $tol_fn>], true, $tol, 3 4 5 6 7 8 9 10);
                expect_call!(a, seq, [<expect_nearly_ $fn _ $tol_fn>], false, $tol, 2);
                expect_no_call!(a, [<expect_nearly_ $fn _ $tol_fn>], 0 1);
                assert!(!a.[<nearly_ $fn _ $tol_fn>](&b, &$tol));
                checkpoint!(a, 0 1 2 3 4 5 6 7 8 9 10);

                expect_call!(a, seq, [<expect_nearly_ $fn _ $tol_fn>], true, $tol, 2 3 4 5 6 7 8 9 10);
                expect_call!(a, seq, [<expect_nearly_ $fn _ $tol_fn>], false, $tol, 1);
                expect_no_call!(a, [<expect_nearly_ $fn _ $tol_fn>], 0);
                assert!(!a.[<nearly_ $fn _ $tol_fn>](&b, &$tol));
                checkpoint!(a, 0 1 2 3 4 5 6 7 8 9 10);

                expect_call!(a, seq, [<expect_nearly_ $fn _ $tol_fn>], true, $tol, 1 2 3 4 5 6 7 8 9 10);
                expect_call!(a, seq, [<expect_nearly_ $fn _ $tol_fn>], false, $tol, 0);
                assert!(!a.[<nearly_ $fn _ $tol_fn>](&b, &$tol));
                checkpoint!(a, 0 1 2 3 4 5 6 7 8 9 10);
            }

            #[test]
            fn [<nearly_ $fn _ $tol_fn _tuple_12>]() {
                let mut a: lhs_type!(12) = lhs_value!(12);
                let b: rhs_type!(12) = rhs_value!(12);
                let mut seq = Sequence::new();

                expect_call!(a, seq, [<expect_nearly_ $fn _ $tol_fn>], true, $tol, 0 1 2 3 4 5 6 7 8 9 10 11);
                assert!(a.[<nearly_ $fn _ $tol_fn>](&b, &$tol));
                checkpoint!(a, 0 1 2 3 4 5 6 7 8 9 10 11);

                expect_call!(a, seq, [<expect_nearly_ $fn _ $tol_fn>], false, $tol, 11);
                expect_no_call!(a, [<expect_nearly_ $fn _ $tol_fn>], 0 1 2 3 4 5 6 7 8 9 10);
                assert!(!a.[<nearly_ $fn _ $tol_fn>](&b, &$tol));
                checkpoint!(a, 0 1 2 3 4 5 6 7 8 9 10 11);

                expect_call!(a, seq, [<expect_nearly_ $fn _ $tol_fn>], true, $tol, 11);
                expect_call!(a, seq, [<expect_nearly_ $fn _ $tol_fn>], false, $tol, 10);
                expect_no_call!(a, [<expect_nearly_ $fn _ $tol_fn>], 0 1 2 3 4 5 6 7 8 9);
                assert!(!a.[<nearly_ $fn _ $tol_fn>](&b, &$tol));
                checkpoint!(a, 0 1 2 3 4 5 6 7 8 9 10 11);

                expect_call!(a, seq, [<expect_nearly_ $fn _ $tol_fn>], true, $tol, 10 11);
                expect_call!(a, seq, [<expect_nearly_ $fn _ $tol_fn>], false, $tol, 9);
                expect_no_call!(a, [<expect_nearly_ $fn _ $tol_fn>], 0 1 2 3 4 5 6 7 8);
                assert!(!a.[<nearly_ $fn _ $tol_fn>](&b, &$tol));
                checkpoint!(a, 0 1 2 3 4 5 6 7 8 9 10 11);

                expect_call!(a, seq, [<expect_nearly_ $fn _ $tol_fn>], true, $tol, 9 10 11);
                expect_call!(a, seq, [<expect_nearly_ $fn _ $tol_fn>], false, $tol, 8);
                expect_no_call!(a, [<expect_nearly_ $fn _ $tol_fn>], 0 1 2 3 4 5 6 7);
                assert!(!a.[<nearly_ $fn _ $tol_fn>](&b, &$tol));
                checkpoint!(a, 0 1 2 3 4 5 6 7 8 9 10 11);

                expect_call!(a, seq, [<expect_nearly_ $fn _ $tol_fn>], true, $tol, 8 9 10 11);
                expect_call!(a, seq, [<expect_nearly_ $fn _ $tol_fn>], false, $tol, 7);
                expect_no_call!(a, [<expect_nearly_ $fn _ $tol_fn>], 0 1 2 3 4 5 6);
                assert!(!a.[<nearly_ $fn _ $tol_fn>](&b, &$tol));
                checkpoint!(a, 0 1 2 3 4 5 6 7 8 9 10 11);

                expect_call!(a, seq, [<expect_nearly_ $fn _ $tol_fn>], true, $tol, 7 8 9 10 11);
                expect_call!(a, seq, [<expect_nearly_ $fn _ $tol_fn>], false, $tol, 6);
                expect_no_call!(a, [<expect_nearly_ $fn _ $tol_fn>], 0 1 2 3 4 5);
                assert!(!a.[<nearly_ $fn _ $tol_fn>](&b, &$tol));
                checkpoint!(a, 0 1 2 3 4 5 6 7 8 9 10 11);

                expect_call!(a, seq, [<expect_nearly_ $fn _ $tol_fn>], true, $tol, 6 7 8 9 10 11);
                expect_call!(a, seq, [<expect_nearly_ $fn _ $tol_fn>], false, $tol, 5);
                expect_no_call!(a, [<expect_nearly_ $fn _ $tol_fn>], 0 1 2 3 4);
                assert!(!a.[<nearly_ $fn _ $tol_fn>](&b, &$tol));
                checkpoint!(a, 0 1 2 3 4 5 6 7 8 9 10 11);

                expect_call!(a, seq, [<expect_nearly_ $fn _ $tol_fn>], true, $tol, 5 6 7 8 9 10 11);
                expect_call!(a, seq, [<expect_nearly_ $fn _ $tol_fn>], false, $tol, 4);
                expect_no_call!(a, [<expect_nearly_ $fn _ $tol_fn>], 0 1 2 3);
                assert!(!a.[<nearly_ $fn _ $tol_fn>](&b, &$tol));
                checkpoint!(a, 0 1 2 3 4 5 6 7 8 9 10 11);

                expect_call!(a, seq, [<expect_nearly_ $fn _ $tol_fn>], true, $tol, 4 5 6 7 8 9 10 11);
                expect_call!(a, seq, [<expect_nearly_ $fn _ $tol_fn>], false, $tol, 3);
                expect_no_call!(a, [<expect_nearly_ $fn _ $tol_fn>], 0 1 2);
                assert!(!a.[<nearly_ $fn _ $tol_fn>](&b, &$tol));
                checkpoint!(a, 0 1 2 3 4 5 6 7 8 9 10 11);

                expect_call!(a, seq, [<expect_nearly_ $fn _ $tol_fn>], true, $tol, 3 4 5 6 7 8 9 10 11);
                expect_call!(a, seq, [<expect_nearly_ $fn _ $tol_fn>], false, $tol, 2);
                expect_no_call!(a, [<expect_nearly_ $fn _ $tol_fn>], 0 1);
                assert!(!a.[<nearly_ $fn _ $tol_fn>](&b, &$tol));
                checkpoint!(a, 0 1 2 3 4 5 6 7 8 9 10 11);

                expect_call!(a, seq, [<expect_nearly_ $fn _ $tol_fn>], true, $tol, 2 3 4 5 6 7 8 9 10 11);
                expect_call!(a, seq, [<expect_nearly_ $fn _ $tol_fn>], false, $tol, 1);
                expect_no_call!(a, [<expect_nearly_ $fn _ $tol_fn>], 0);
                assert!(!a.[<nearly_ $fn _ $tol_fn>](&b, &$tol));
                checkpoint!(a, 0 1 2 3 4 5 6 7 8 9 10 11);

                expect_call!(a, seq, [<expect_nearly_ $fn _ $tol_fn>], true, $tol, 1 2 3 4 5 6 7 8 9 10 11);
                expect_call!(a, seq, [<expect_nearly_ $fn _ $tol_fn>], false, $tol, 0);
                assert!(!a.[<nearly_ $fn _ $tol_fn>](&b, &$tol));
                checkpoint!(a, 0 1 2 3 4 5 6 7 8 9 10 11);
            }
        }
    };
}

impl_test!(eps, 0.1);
impl_test!(ulps, 5);
impl_test!(tol, Tolerance::<MockLhs, Rhs>::new(0.1, 5));