Commonize the signature for all instances of get_test_cases

tgross35 · tgross35 · commit fd7592ec1d0d · 2025-02-05T16:30:11.000-06:00
In order to make these more interchangeable in more places, always
return `(impl Iterator, u64)`. This will facilitate using other
generators for extensive tests.
diff --git a/crates/libm-test/benches/random.rs b/crates/libm-test/benches/random.rs
@@ -54,7 +54,7 @@ where
 
     let ctx = CheckCtx::new(Op::IDENTIFIER, CheckBasis::Musl, GeneratorKind::Random);
     let benchvec: Vec<_> =
-        random::get_test_cases::<Op::RustArgs>(&ctx).take(BENCH_ITER_ITEMS).collect();
+        random::get_test_cases::<Op::RustArgs>(&ctx).0.take(BENCH_ITER_ITEMS).collect();
 
     // Perform a sanity check that we are benchmarking the same thing
     // Don't test against musl if it is not available
diff --git a/crates/libm-test/examples/plot_domains.rs b/crates/libm-test/examples/plot_domains.rs
@@ -58,7 +58,13 @@ where
     let mut ctx = CheckCtx::new(Op::IDENTIFIER, CheckBasis::Mpfr, GeneratorKind::QuickSpaced);
     plot_one_generator(out_dir, &ctx, "logspace", config, spaced::get_test_cases::<Op>(&ctx).0);
     ctx.gen_kind = GeneratorKind::EdgeCases;
-    plot_one_generator(out_dir, &ctx, "edge_cases", config, edge_cases::get_test_cases::<Op>(&ctx));
+    plot_one_generator(
+        out_dir,
+        &ctx,
+        "edge_cases",
+        config,
+        edge_cases::get_test_cases::<Op>(&ctx).0,
+    );
 }
 
 /// Plot the output of a single generator.
diff --git a/crates/libm-test/src/gen/edge_cases.rs b/crates/libm-test/src/gen/edge_cases.rs
@@ -9,7 +9,7 @@ use crate::{CheckCtx, FloatExt, MathOp, test_log};
 
 /// Generate a sequence of edge cases, e.g. numbers near zeroes and infiniteis.
 pub trait EdgeCaseInput<Op> {
-    fn get_cases(ctx: &CheckCtx) -> impl ExactSizeIterator<Item = Self> + Send;
+    fn get_cases(ctx: &CheckCtx) -> (impl Iterator<Item = Self> + Send, u64);
 }
 
 /// Create a list of values around interesting points (infinities, zeroes, NaNs).
@@ -140,32 +140,32 @@ macro_rules! impl_edge_case_input {
         where
             Op: MathOp<RustArgs = Self, FTy = $fty>,
         {
-            fn get_cases(ctx: &CheckCtx) -> impl ExactSizeIterator<Item = Self> {
+            fn get_cases(ctx: &CheckCtx) -> (impl Iterator<Item = Self>, u64) {
                 let (iter0, steps0) = float_edge_cases::<Op>(ctx, 0);
                 let iter0 = iter0.map(|v| (v,));
-                KnownSize::new(iter0, steps0)
+                (iter0, steps0)
             }
         }
 
         impl<Op> EdgeCaseInput<Op> for ($fty, $fty)
         where
             Op: MathOp<RustArgs = Self, FTy = $fty>,
         {
-            fn get_cases(ctx: &CheckCtx) -> impl ExactSizeIterator<Item = Self> {
+            fn get_cases(ctx: &CheckCtx) -> (impl Iterator<Item = Self>, u64) {
                 let (iter0, steps0) = float_edge_cases::<Op>(ctx, 0);
                 let (iter1, steps1) = float_edge_cases::<Op>(ctx, 1);
                 let iter =
                     iter0.flat_map(move |first| iter1.clone().map(move |second| (first, second)));
                 let count = steps0.checked_mul(steps1).unwrap();
-                KnownSize::new(iter, count)
+                (iter, count)
             }
         }
 
         impl<Op> EdgeCaseInput<Op> for ($fty, $fty, $fty)
         where
             Op: MathOp<RustArgs = Self, FTy = $fty>,
         {
-            fn get_cases(ctx: &CheckCtx) -> impl ExactSizeIterator<Item = Self> {
+            fn get_cases(ctx: &CheckCtx) -> (impl Iterator<Item = Self>, u64) {
                 let (iter0, steps0) = float_edge_cases::<Op>(ctx, 0);
                 let (iter1, steps1) = float_edge_cases::<Op>(ctx, 1);
                 let (iter2, steps2) = float_edge_cases::<Op>(ctx, 2);
@@ -177,39 +177,39 @@ macro_rules! impl_edge_case_input {
                     });
                 let count = steps0.checked_mul(steps1).unwrap().checked_mul(steps2).unwrap();
 
-                KnownSize::new(iter, count)
+                (iter, count)
             }
         }
 
         impl<Op> EdgeCaseInput<Op> for (i32, $fty)
         where
             Op: MathOp<RustArgs = Self, FTy = $fty>,
         {
-            fn get_cases(ctx: &CheckCtx) -> impl ExactSizeIterator<Item = Self> {
+            fn get_cases(ctx: &CheckCtx) -> (impl Iterator<Item = Self>, u64) {
                 let (iter0, steps0) = int_edge_cases(ctx, 0);
                 let (iter1, steps1) = float_edge_cases::<Op>(ctx, 1);
 
                 let iter =
                     iter0.flat_map(move |first| iter1.clone().map(move |second| (first, second)));
                 let count = steps0.checked_mul(steps1).unwrap();
 
-                KnownSize::new(iter, count)
+                (iter, count)
             }
         }
 
         impl<Op> EdgeCaseInput<Op> for ($fty, i32)
         where
             Op: MathOp<RustArgs = Self, FTy = $fty>,
         {
-            fn get_cases(ctx: &CheckCtx) -> impl ExactSizeIterator<Item = Self> {
+            fn get_cases(ctx: &CheckCtx) -> (impl Iterator<Item = Self>, u64) {
                 let (iter0, steps0) = float_edge_cases::<Op>(ctx, 0);
                 let (iter1, steps1) = int_edge_cases(ctx, 1);
 
                 let iter =
                     iter0.flat_map(move |first| iter1.clone().map(move |second| (first, second)));
                 let count = steps0.checked_mul(steps1).unwrap();
 
-                KnownSize::new(iter, count)
+                (iter, count)
             }
         }
     };
@@ -224,10 +224,13 @@ impl_edge_case_input!(f128);
 
 pub fn get_test_cases<Op>(
     ctx: &CheckCtx,
-) -> impl ExactSizeIterator<Item = Op::RustArgs> + use<'_, Op>
+) -> (impl Iterator<Item = Op::RustArgs> + Send + use<'_, Op>, u64)
 where
     Op: MathOp,
     Op::RustArgs: EdgeCaseInput<Op>,
 {
-    Op::RustArgs::get_cases(ctx)
+    let (iter, count) = Op::RustArgs::get_cases(ctx);
+
+    // Wrap in `KnownSize` so we get an assertion if the cuunt is wrong.
+    (KnownSize::new(iter, count), count)
 }
diff --git a/crates/libm-test/src/gen/random.rs b/crates/libm-test/src/gen/random.rs
@@ -26,8 +26,8 @@ pub(crate) static SEED: LazyLock<[u8; 32]> = LazyLock::new(|| {
 });
 
 /// Generate a sequence of random values of this type.
-pub trait RandomInput {
-    fn get_cases(ctx: &CheckCtx) -> impl ExactSizeIterator<Item = Self>;
+pub trait RandomInput: Sized {
+    fn get_cases(ctx: &CheckCtx) -> (impl Iterator<Item = Self> + Send, u64);
 }
 
 /// Generate a sequence of deterministically random floats.
@@ -51,25 +51,25 @@ fn random_ints(count: u64, range: RangeInclusive<i32>) -> impl Iterator<Item = i
 macro_rules! impl_random_input {
     ($fty:ty) => {
         impl RandomInput for ($fty,) {
-            fn get_cases(ctx: &CheckCtx) -> impl ExactSizeIterator<Item = Self> {
+            fn get_cases(ctx: &CheckCtx) -> (impl Iterator<Item = Self>, u64) {
                 let count = iteration_count(ctx, 0);
                 let iter = random_floats(count).map(|f: $fty| (f,));
-                KnownSize::new(iter, count)
+                (iter, count)
             }
         }
 
         impl RandomInput for ($fty, $fty) {
-            fn get_cases(ctx: &CheckCtx) -> impl ExactSizeIterator<Item = Self> {
+            fn get_cases(ctx: &CheckCtx) -> (impl Iterator<Item = Self>, u64) {
                 let count0 = iteration_count(ctx, 0);
                 let count1 = iteration_count(ctx, 1);
                 let iter = random_floats(count0)
                     .flat_map(move |f1: $fty| random_floats(count1).map(move |f2: $fty| (f1, f2)));
-                KnownSize::new(iter, count0 * count1)
+                (iter, count0 * count1)
             }
         }
 
         impl RandomInput for ($fty, $fty, $fty) {
-            fn get_cases(ctx: &CheckCtx) -> impl ExactSizeIterator<Item = Self> {
+            fn get_cases(ctx: &CheckCtx) -> (impl Iterator<Item = Self>, u64) {
                 let count0 = iteration_count(ctx, 0);
                 let count1 = iteration_count(ctx, 1);
                 let count2 = iteration_count(ctx, 2);
@@ -78,30 +78,30 @@ macro_rules! impl_random_input {
                         random_floats(count2).map(move |f3: $fty| (f1, f2, f3))
                     })
                 });
-                KnownSize::new(iter, count0 * count1 * count2)
+                (iter, count0 * count1 * count2)
             }
         }
 
         impl RandomInput for (i32, $fty) {
-            fn get_cases(ctx: &CheckCtx) -> impl ExactSizeIterator<Item = Self> {
+            fn get_cases(ctx: &CheckCtx) -> (impl Iterator<Item = Self>, u64) {
                 let count0 = iteration_count(ctx, 0);
                 let count1 = iteration_count(ctx, 1);
                 let range0 = int_range(ctx, 0);
                 let iter = random_ints(count0, range0)
                     .flat_map(move |f1: i32| random_floats(count1).map(move |f2: $fty| (f1, f2)));
-                KnownSize::new(iter, count0 * count1)
+                (iter, count0 * count1)
             }
         }
 
         impl RandomInput for ($fty, i32) {
-            fn get_cases(ctx: &CheckCtx) -> impl ExactSizeIterator<Item = Self> {
+            fn get_cases(ctx: &CheckCtx) -> (impl Iterator<Item = Self>, u64) {
                 let count0 = iteration_count(ctx, 0);
                 let count1 = iteration_count(ctx, 1);
                 let range1 = int_range(ctx, 1);
                 let iter = random_floats(count0).flat_map(move |f1: $fty| {
                     random_ints(count1, range1.clone()).map(move |f2: i32| (f1, f2))
                 });
-                KnownSize::new(iter, count0 * count1)
+                (iter, count0 * count1)
             }
         }
     };
@@ -117,6 +117,9 @@ impl_random_input!(f128);
 /// Create a test case iterator.
 pub fn get_test_cases<RustArgs: RandomInput>(
     ctx: &CheckCtx,
-) -> impl Iterator<Item = RustArgs> + use<'_, RustArgs> {
-    RustArgs::get_cases(ctx)
+) -> (impl Iterator<Item = RustArgs> + Send + use<'_, RustArgs>, u64) {
+    let (iter, count) = RustArgs::get_cases(ctx);
+
+    // Wrap in `KnownSize` so we get an assertion if the cuunt is wrong.
+    (KnownSize::new(iter, count), count)
 }
diff --git a/crates/libm-test/tests/compare_built_musl.rs b/crates/libm-test/tests/compare_built_musl.rs
@@ -39,7 +39,7 @@ macro_rules! musl_tests {
             fn [< musl_random_ $fn_name >]() {
                 type Op = libm_test::op::$fn_name::Routine;
                 let ctx = CheckCtx::new(Op::IDENTIFIER, BASIS, GeneratorKind::Random);
-                let cases = random::get_test_cases::<<Op as MathOp>::RustArgs>(&ctx);
+                let cases = random::get_test_cases::<<Op as MathOp>::RustArgs>(&ctx).0;
                 musl_runner::<Op>(&ctx, cases, musl_math_sys::$fn_name);
             }
 
@@ -48,7 +48,7 @@ macro_rules! musl_tests {
             fn [< musl_edge_case_ $fn_name >]() {
                 type Op = libm_test::op::$fn_name::Routine;
                 let ctx = CheckCtx::new(Op::IDENTIFIER, BASIS, GeneratorKind::EdgeCases);
-                let cases = edge_cases::get_test_cases::<Op>(&ctx);
+                let cases = edge_cases::get_test_cases::<Op>(&ctx).0;
                 musl_runner::<Op>(&ctx, cases, musl_math_sys::$fn_name);
             }
 
diff --git a/crates/libm-test/tests/multiprecision.rs b/crates/libm-test/tests/multiprecision.rs
@@ -29,7 +29,7 @@ macro_rules! mp_tests {
             fn [< mp_random_ $fn_name >]() {
                 type Op = libm_test::op::$fn_name::Routine;
                 let ctx = CheckCtx::new(Op::IDENTIFIER, BASIS, GeneratorKind::Random);
-                let cases = random::get_test_cases::<<Op as MathOp>::RustArgs>(&ctx);
+                let cases = random::get_test_cases::<<Op as MathOp>::RustArgs>(&ctx).0;
                 mp_runner::<Op>(&ctx, cases);
             }
 
@@ -38,7 +38,7 @@ macro_rules! mp_tests {
             fn [< mp_edge_case_ $fn_name >]() {
                 type Op = libm_test::op::$fn_name::Routine;
                 let ctx = CheckCtx::new(Op::IDENTIFIER, BASIS, GeneratorKind::EdgeCases);
-                let cases = edge_cases::get_test_cases::<Op>(&ctx);
+                let cases = edge_cases::get_test_cases::<Op>(&ctx).0;
                 mp_runner::<Op>(&ctx, cases);
             }
 

Original file line number	Diff line number	Diff line change
`@@ -9,7 +9,7 @@ use crate::{CheckCtx, FloatExt, MathOp, test_log};`
`9`	`9`
`10`	`10`	`/// Generate a sequence of edge cases, e.g. numbers near zeroes and infiniteis.`
`11`	`11`	`pub trait EdgeCaseInput<Op> {`
`12`		`- fn get_cases(ctx: &CheckCtx) -> impl ExactSizeIterator<Item = Self> + Send;`
	`12`	`+ fn get_cases(ctx: &CheckCtx) -> (impl Iterator<Item = Self> + Send, u64);`
`13`	`13`	`}`
`14`	`14`
`15`	`15`	`/// Create a list of values around interesting points (infinities, zeroes, NaNs).`
`@@ -140,32 +140,32 @@ macro_rules! impl_edge_case_input {`
`140`	`140`	`where`
`141`	`141`	`Op: MathOp<RustArgs = Self, FTy = $fty>,`
`142`	`142`	`{`
`143`		`- fn get_cases(ctx: &CheckCtx) -> impl ExactSizeIterator<Item = Self> {`
	`143`	`+ fn get_cases(ctx: &CheckCtx) -> (impl Iterator<Item = Self>, u64) {`
`144`	`144`	`let (iter0, steps0) = float_edge_cases::<Op>(ctx, 0);`
`145`	`145`	`let iter0 = iter0.map(\|v\| (v,));`
`146`		`- KnownSize::new(iter0, steps0)`
	`146`	`+ (iter0, steps0)`
`147`	`147`	`}`
`148`	`148`	`}`
`149`	`149`
`150`	`150`	`impl<Op> EdgeCaseInput<Op> for ($fty, $fty)`
`151`	`151`	`where`
`152`	`152`	`Op: MathOp<RustArgs = Self, FTy = $fty>,`
`153`	`153`	`{`
`154`		`- fn get_cases(ctx: &CheckCtx) -> impl ExactSizeIterator<Item = Self> {`
	`154`	`+ fn get_cases(ctx: &CheckCtx) -> (impl Iterator<Item = Self>, u64) {`
`155`	`155`	`let (iter0, steps0) = float_edge_cases::<Op>(ctx, 0);`
`156`	`156`	`let (iter1, steps1) = float_edge_cases::<Op>(ctx, 1);`
`157`	`157`	`let iter =`
`158`	`158`	`iter0.flat_map(move \|first\| iter1.clone().map(move \|second\| (first, second)));`
`159`	`159`	`let count = steps0.checked_mul(steps1).unwrap();`
`160`		`- KnownSize::new(iter, count)`
	`160`	`+ (iter, count)`
`161`	`161`	`}`
`162`	`162`	`}`
`163`	`163`
`164`	`164`	`impl<Op> EdgeCaseInput<Op> for ($fty, $fty, $fty)`
`165`	`165`	`where`
`166`	`166`	`Op: MathOp<RustArgs = Self, FTy = $fty>,`
`167`	`167`	`{`
`168`		`- fn get_cases(ctx: &CheckCtx) -> impl ExactSizeIterator<Item = Self> {`
	`168`	`+ fn get_cases(ctx: &CheckCtx) -> (impl Iterator<Item = Self>, u64) {`
`169`	`169`	`let (iter0, steps0) = float_edge_cases::<Op>(ctx, 0);`
`170`	`170`	`let (iter1, steps1) = float_edge_cases::<Op>(ctx, 1);`
`171`	`171`	`let (iter2, steps2) = float_edge_cases::<Op>(ctx, 2);`
`@@ -177,39 +177,39 @@ macro_rules! impl_edge_case_input {`
`177`	`177`	`});`
`178`	`178`	`let count = steps0.checked_mul(steps1).unwrap().checked_mul(steps2).unwrap();`
`179`	`179`
`180`		`- KnownSize::new(iter, count)`
	`180`	`+ (iter, count)`
`181`	`181`	`}`
`182`	`182`	`}`
`183`	`183`
`184`	`184`	`impl<Op> EdgeCaseInput<Op> for (i32, $fty)`
`185`	`185`	`where`
`186`	`186`	`Op: MathOp<RustArgs = Self, FTy = $fty>,`
`187`	`187`	`{`
`188`		`- fn get_cases(ctx: &CheckCtx) -> impl ExactSizeIterator<Item = Self> {`
	`188`	`+ fn get_cases(ctx: &CheckCtx) -> (impl Iterator<Item = Self>, u64) {`
`189`	`189`	`let (iter0, steps0) = int_edge_cases(ctx, 0);`
`190`	`190`	`let (iter1, steps1) = float_edge_cases::<Op>(ctx, 1);`
`191`	`191`
`192`	`192`	`let iter =`
`193`	`193`	`iter0.flat_map(move \|first\| iter1.clone().map(move \|second\| (first, second)));`
`194`	`194`	`let count = steps0.checked_mul(steps1).unwrap();`
`195`	`195`
`196`		`- KnownSize::new(iter, count)`
	`196`	`+ (iter, count)`
`197`	`197`	`}`
`198`	`198`	`}`
`199`	`199`
`200`	`200`	`impl<Op> EdgeCaseInput<Op> for ($fty, i32)`
`201`	`201`	`where`
`202`	`202`	`Op: MathOp<RustArgs = Self, FTy = $fty>,`
`203`	`203`	`{`
`204`		`- fn get_cases(ctx: &CheckCtx) -> impl ExactSizeIterator<Item = Self> {`
	`204`	`+ fn get_cases(ctx: &CheckCtx) -> (impl Iterator<Item = Self>, u64) {`
`205`	`205`	`let (iter0, steps0) = float_edge_cases::<Op>(ctx, 0);`
`206`	`206`	`let (iter1, steps1) = int_edge_cases(ctx, 1);`
`207`	`207`
`208`	`208`	`let iter =`
`209`	`209`	`iter0.flat_map(move \|first\| iter1.clone().map(move \|second\| (first, second)));`
`210`	`210`	`let count = steps0.checked_mul(steps1).unwrap();`
`211`	`211`
`212`		`- KnownSize::new(iter, count)`
	`212`	`+ (iter, count)`
`213`	`213`	`}`
`214`	`214`	`}`
`215`	`215`	`};`
`@@ -224,10 +224,13 @@ impl_edge_case_input!(f128);`
`224`	`224`
`225`	`225`	`pub fn get_test_cases<Op>(`
`226`	`226`	`ctx: &CheckCtx,`
`227`		`-) -> impl ExactSizeIterator<Item = Op::RustArgs> + use<'_, Op>`
	`227`	`+) -> (impl Iterator<Item = Op::RustArgs> + Send + use<'_, Op>, u64)`
`228`	`228`	`where`
`229`	`229`	`Op: MathOp,`
`230`	`230`	`Op::RustArgs: EdgeCaseInput<Op>,`
`231`	`231`	`{`
`232`		`- Op::RustArgs::get_cases(ctx)`
	`232`	`+ let (iter, count) = Op::RustArgs::get_cases(ctx);`
	`233`	`+`
	`234`	+ // Wrap in `KnownSize` so we get an assertion if the cuunt is wrong.
	`235`	`+ (KnownSize::new(iter, count), count)`
`233`	`236`	`}`