Skip to content
This repository was archived by the owner on Apr 28, 2025. It is now read-only.

Commit fd7592e

Browse files
tgross35tgross35
committed
Commonize the signature for all instances of get_test_cases
In order to make these more interchangeable in more places, always return `(impl Iterator, u64)`. This will facilitate using other generators for extensive tests.
1 parent d655126 commit fd7592e

File tree

6 files changed

+45
-33
lines changed

6 files changed

+45
-33
lines changed

‎crates/libm-test/benches/random.rs

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -54,7 +54,7 @@ where
5454

5555
let ctx = CheckCtx::new(Op::IDENTIFIER, CheckBasis::Musl, GeneratorKind::Random);
5656
let benchvec: Vec<_> =
57-
random::get_test_cases::<Op::RustArgs>(&ctx).take(BENCH_ITER_ITEMS).collect();
57+
random::get_test_cases::<Op::RustArgs>(&ctx).0.take(BENCH_ITER_ITEMS).collect();
5858

5959
// Perform a sanity check that we are benchmarking the same thing
6060
// Don't test against musl if it is not available

‎crates/libm-test/examples/plot_domains.rs

Lines changed: 7 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -58,7 +58,13 @@ where
5858
let mut ctx = CheckCtx::new(Op::IDENTIFIER, CheckBasis::Mpfr, GeneratorKind::QuickSpaced);
5959
plot_one_generator(out_dir, &ctx, "logspace", config, spaced::get_test_cases::<Op>(&ctx).0);
6060
ctx.gen_kind = GeneratorKind::EdgeCases;
61-
plot_one_generator(out_dir, &ctx, "edge_cases", config, edge_cases::get_test_cases::<Op>(&ctx));
61+
plot_one_generator(
62+
out_dir,
63+
&ctx,
64+
"edge_cases",
65+
config,
66+
edge_cases::get_test_cases::<Op>(&ctx).0,
67+
);
6268
}
6369

6470
/// Plot the output of a single generator.

‎crates/libm-test/src/gen/edge_cases.rs

Lines changed: 16 additions & 13 deletions
Original file line numberDiff line numberDiff line change
@@ -9,7 +9,7 @@ use crate::{CheckCtx, FloatExt, MathOp, test_log};
99

1010
/// Generate a sequence of edge cases, e.g. numbers near zeroes and infiniteis.
1111
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);
1313
}
1414

1515
/// Create a list of values around interesting points (infinities, zeroes, NaNs).
@@ -140,32 +140,32 @@ macro_rules! impl_edge_case_input {
140140
where
141141
Op: MathOp<RustArgs = Self, FTy = $fty>,
142142
{
143-
fn get_cases(ctx: &CheckCtx) -> impl ExactSizeIterator<Item = Self> {
143+
fn get_cases(ctx: &CheckCtx) -> (impl Iterator<Item = Self>, u64) {
144144
let (iter0, steps0) = float_edge_cases::<Op>(ctx, 0);
145145
let iter0 = iter0.map(|v| (v,));
146-
KnownSize::new(iter0, steps0)
146+
(iter0, steps0)
147147
}
148148
}
149149

150150
impl<Op> EdgeCaseInput<Op> for ($fty, $fty)
151151
where
152152
Op: MathOp<RustArgs = Self, FTy = $fty>,
153153
{
154-
fn get_cases(ctx: &CheckCtx) -> impl ExactSizeIterator<Item = Self> {
154+
fn get_cases(ctx: &CheckCtx) -> (impl Iterator<Item = Self>, u64) {
155155
let (iter0, steps0) = float_edge_cases::<Op>(ctx, 0);
156156
let (iter1, steps1) = float_edge_cases::<Op>(ctx, 1);
157157
let iter =
158158
iter0.flat_map(move |first| iter1.clone().map(move |second| (first, second)));
159159
let count = steps0.checked_mul(steps1).unwrap();
160-
KnownSize::new(iter, count)
160+
(iter, count)
161161
}
162162
}
163163

164164
impl<Op> EdgeCaseInput<Op> for ($fty, $fty, $fty)
165165
where
166166
Op: MathOp<RustArgs = Self, FTy = $fty>,
167167
{
168-
fn get_cases(ctx: &CheckCtx) -> impl ExactSizeIterator<Item = Self> {
168+
fn get_cases(ctx: &CheckCtx) -> (impl Iterator<Item = Self>, u64) {
169169
let (iter0, steps0) = float_edge_cases::<Op>(ctx, 0);
170170
let (iter1, steps1) = float_edge_cases::<Op>(ctx, 1);
171171
let (iter2, steps2) = float_edge_cases::<Op>(ctx, 2);
@@ -177,39 +177,39 @@ macro_rules! impl_edge_case_input {
177177
});
178178
let count = steps0.checked_mul(steps1).unwrap().checked_mul(steps2).unwrap();
179179

180-
KnownSize::new(iter, count)
180+
(iter, count)
181181
}
182182
}
183183

184184
impl<Op> EdgeCaseInput<Op> for (i32, $fty)
185185
where
186186
Op: MathOp<RustArgs = Self, FTy = $fty>,
187187
{
188-
fn get_cases(ctx: &CheckCtx) -> impl ExactSizeIterator<Item = Self> {
188+
fn get_cases(ctx: &CheckCtx) -> (impl Iterator<Item = Self>, u64) {
189189
let (iter0, steps0) = int_edge_cases(ctx, 0);
190190
let (iter1, steps1) = float_edge_cases::<Op>(ctx, 1);
191191

192192
let iter =
193193
iter0.flat_map(move |first| iter1.clone().map(move |second| (first, second)));
194194
let count = steps0.checked_mul(steps1).unwrap();
195195

196-
KnownSize::new(iter, count)
196+
(iter, count)
197197
}
198198
}
199199

200200
impl<Op> EdgeCaseInput<Op> for ($fty, i32)
201201
where
202202
Op: MathOp<RustArgs = Self, FTy = $fty>,
203203
{
204-
fn get_cases(ctx: &CheckCtx) -> impl ExactSizeIterator<Item = Self> {
204+
fn get_cases(ctx: &CheckCtx) -> (impl Iterator<Item = Self>, u64) {
205205
let (iter0, steps0) = float_edge_cases::<Op>(ctx, 0);
206206
let (iter1, steps1) = int_edge_cases(ctx, 1);
207207

208208
let iter =
209209
iter0.flat_map(move |first| iter1.clone().map(move |second| (first, second)));
210210
let count = steps0.checked_mul(steps1).unwrap();
211211

212-
KnownSize::new(iter, count)
212+
(iter, count)
213213
}
214214
}
215215
};
@@ -224,10 +224,13 @@ impl_edge_case_input!(f128);
224224

225225
pub fn get_test_cases<Op>(
226226
ctx: &CheckCtx,
227-
) -> impl ExactSizeIterator<Item = Op::RustArgs> + use<'_, Op>
227+
) -> (impl Iterator<Item = Op::RustArgs> + Send + use<'_, Op>, u64)
228228
where
229229
Op: MathOp,
230230
Op::RustArgs: EdgeCaseInput<Op>,
231231
{
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)
233236
}

‎crates/libm-test/src/gen/random.rs

Lines changed: 17 additions & 14 deletions
Original file line numberDiff line numberDiff line change
@@ -26,8 +26,8 @@ pub(crate) static SEED: LazyLock<[u8; 32]> = LazyLock::new(|| {
2626
});
2727

2828
/// Generate a sequence of random values of this type.
29-
pub trait RandomInput {
30-
fn get_cases(ctx: &CheckCtx) -> impl ExactSizeIterator<Item = Self>;
29+
pub trait RandomInput: Sized {
30+
fn get_cases(ctx: &CheckCtx) -> (impl Iterator<Item = Self> + Send, u64);
3131
}
3232

3333
/// Generate a sequence of deterministically random floats.
@@ -51,25 +51,25 @@ fn random_ints(count: u64, range: RangeInclusive<i32>) -> impl Iterator<Item = i
5151
macro_rules! impl_random_input {
5252
($fty:ty) => {
5353
impl RandomInput for ($fty,) {
54-
fn get_cases(ctx: &CheckCtx) -> impl ExactSizeIterator<Item = Self> {
54+
fn get_cases(ctx: &CheckCtx) -> (impl Iterator<Item = Self>, u64) {
5555
let count = iteration_count(ctx, 0);
5656
let iter = random_floats(count).map(|f: $fty| (f,));
57-
KnownSize::new(iter, count)
57+
(iter, count)
5858
}
5959
}
6060

6161
impl RandomInput for ($fty, $fty) {
62-
fn get_cases(ctx: &CheckCtx) -> impl ExactSizeIterator<Item = Self> {
62+
fn get_cases(ctx: &CheckCtx) -> (impl Iterator<Item = Self>, u64) {
6363
let count0 = iteration_count(ctx, 0);
6464
let count1 = iteration_count(ctx, 1);
6565
let iter = random_floats(count0)
6666
.flat_map(move |f1: $fty| random_floats(count1).map(move |f2: $fty| (f1, f2)));
67-
KnownSize::new(iter, count0 * count1)
67+
(iter, count0 * count1)
6868
}
6969
}
7070

7171
impl RandomInput for ($fty, $fty, $fty) {
72-
fn get_cases(ctx: &CheckCtx) -> impl ExactSizeIterator<Item = Self> {
72+
fn get_cases(ctx: &CheckCtx) -> (impl Iterator<Item = Self>, u64) {
7373
let count0 = iteration_count(ctx, 0);
7474
let count1 = iteration_count(ctx, 1);
7575
let count2 = iteration_count(ctx, 2);
@@ -78,30 +78,30 @@ macro_rules! impl_random_input {
7878
random_floats(count2).map(move |f3: $fty| (f1, f2, f3))
7979
})
8080
});
81-
KnownSize::new(iter, count0 * count1 * count2)
81+
(iter, count0 * count1 * count2)
8282
}
8383
}
8484

8585
impl RandomInput for (i32, $fty) {
86-
fn get_cases(ctx: &CheckCtx) -> impl ExactSizeIterator<Item = Self> {
86+
fn get_cases(ctx: &CheckCtx) -> (impl Iterator<Item = Self>, u64) {
8787
let count0 = iteration_count(ctx, 0);
8888
let count1 = iteration_count(ctx, 1);
8989
let range0 = int_range(ctx, 0);
9090
let iter = random_ints(count0, range0)
9191
.flat_map(move |f1: i32| random_floats(count1).map(move |f2: $fty| (f1, f2)));
92-
KnownSize::new(iter, count0 * count1)
92+
(iter, count0 * count1)
9393
}
9494
}
9595

9696
impl RandomInput for ($fty, i32) {
97-
fn get_cases(ctx: &CheckCtx) -> impl ExactSizeIterator<Item = Self> {
97+
fn get_cases(ctx: &CheckCtx) -> (impl Iterator<Item = Self>, u64) {
9898
let count0 = iteration_count(ctx, 0);
9999
let count1 = iteration_count(ctx, 1);
100100
let range1 = int_range(ctx, 1);
101101
let iter = random_floats(count0).flat_map(move |f1: $fty| {
102102
random_ints(count1, range1.clone()).map(move |f2: i32| (f1, f2))
103103
});
104-
KnownSize::new(iter, count0 * count1)
104+
(iter, count0 * count1)
105105
}
106106
}
107107
};
@@ -117,6 +117,9 @@ impl_random_input!(f128);
117117
/// Create a test case iterator.
118118
pub fn get_test_cases<RustArgs: RandomInput>(
119119
ctx: &CheckCtx,
120-
) -> impl Iterator<Item = RustArgs> + use<'_, RustArgs> {
121-
RustArgs::get_cases(ctx)
120+
) -> (impl Iterator<Item = RustArgs> + Send + use<'_, RustArgs>, u64) {
121+
let (iter, count) = RustArgs::get_cases(ctx);
122+
123+
// Wrap in `KnownSize` so we get an assertion if the cuunt is wrong.
124+
(KnownSize::new(iter, count), count)
122125
}

‎crates/libm-test/tests/compare_built_musl.rs

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -39,7 +39,7 @@ macro_rules! musl_tests {
3939
fn [< musl_random_ $fn_name >]() {
4040
type Op = libm_test::op::$fn_name::Routine;
4141
let ctx = CheckCtx::new(Op::IDENTIFIER, BASIS, GeneratorKind::Random);
42-
let cases = random::get_test_cases::<<Op as MathOp>::RustArgs>(&ctx);
42+
let cases = random::get_test_cases::<<Op as MathOp>::RustArgs>(&ctx).0;
4343
musl_runner::<Op>(&ctx, cases, musl_math_sys::$fn_name);
4444
}
4545

@@ -48,7 +48,7 @@ macro_rules! musl_tests {
4848
fn [< musl_edge_case_ $fn_name >]() {
4949
type Op = libm_test::op::$fn_name::Routine;
5050
let ctx = CheckCtx::new(Op::IDENTIFIER, BASIS, GeneratorKind::EdgeCases);
51-
let cases = edge_cases::get_test_cases::<Op>(&ctx);
51+
let cases = edge_cases::get_test_cases::<Op>(&ctx).0;
5252
musl_runner::<Op>(&ctx, cases, musl_math_sys::$fn_name);
5353
}
5454

‎crates/libm-test/tests/multiprecision.rs

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -29,7 +29,7 @@ macro_rules! mp_tests {
2929
fn [< mp_random_ $fn_name >]() {
3030
type Op = libm_test::op::$fn_name::Routine;
3131
let ctx = CheckCtx::new(Op::IDENTIFIER, BASIS, GeneratorKind::Random);
32-
let cases = random::get_test_cases::<<Op as MathOp>::RustArgs>(&ctx);
32+
let cases = random::get_test_cases::<<Op as MathOp>::RustArgs>(&ctx).0;
3333
mp_runner::<Op>(&ctx, cases);
3434
}
3535

@@ -38,7 +38,7 @@ macro_rules! mp_tests {
3838
fn [< mp_edge_case_ $fn_name >]() {
3939
type Op = libm_test::op::$fn_name::Routine;
4040
let ctx = CheckCtx::new(Op::IDENTIFIER, BASIS, GeneratorKind::EdgeCases);
41-
let cases = edge_cases::get_test_cases::<Op>(&ctx);
41+
let cases = edge_cases::get_test_cases::<Op>(&ctx).0;
4242
mp_runner::<Op>(&ctx, cases);
4343
}
4444

0 commit comments

Comments
 (0)