Mirrors/rust
1
0
Fork 0
mirror of https://github.com/rust-lang/rust.git synced 2026-04-27 18:57:42 +03:00
Code Issues Packages Projects Releases Wiki Activity

test: Use a more consistent setup for iter and steps

Browse Source
This commit is contained in:
Trevor Gross
2026-04-07 04:16:09 -04:00
parent 5678e6187d
commit bbcba28cfc
3 changed files with 89 additions and 66 deletions
Download Patch File Download Diff File Expand all files Collapse all files
library/compiler-builtins/libm-test/src/generate/edge_cases.rs
+6 -10
View File
@@ -244,7 +244,7 @@ fn get_cases(ctx: &CheckCtx) -> (impl Iterator<Item = Self>, u64) {
let (iter1, steps1) = float_edge_cases::<Arg1<Op>>(ctx, 1);
let iter =
iter0.flat_map(move |first| iter1.clone().map(move |second| (first, second)));
let count = steps0.checked_mul(steps1).unwrap();
let count = steps0.strict_mul(steps1);
(iter, count)
}
}
@@ -263,11 +263,7 @@ fn get_cases(ctx: &CheckCtx) -> (impl Iterator<Item = Self>, u64) {
.flat_map(move |(first, second)| {
iter2.clone().map(move |third| (first, second, third))
});
let count = steps0
.checked_mul(steps1)
.unwrap()
.checked_mul(steps2)
.unwrap();
let count = steps0.strict_mul(steps1).strict_mul(steps2);
(iter, count)
}
@@ -283,7 +279,7 @@ fn get_cases(ctx: &CheckCtx) -> (impl Iterator<Item = Self>, u64) {
let iter =
iter0.flat_map(move |first| iter1.clone().map(move |second| (first, second)));
let count = steps0.checked_mul(steps1).unwrap();
let count = steps0.strict_mul(steps1);
(iter, count)
}
@@ -299,7 +295,7 @@ fn get_cases(ctx: &CheckCtx) -> (impl Iterator<Item = Self>, u64) {
let iter =
iter0.flat_map(move |first| iter1.clone().map(move |second| (first, second)));
let count = steps0.checked_mul(steps1).unwrap();
let count = steps0.strict_mul(steps1);
(iter, count)
}
@@ -336,7 +332,7 @@ fn get_cases(ctx: &CheckCtx) -> (impl Iterator<Item = Self>, u64) {
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();
let count = steps0.strict_mul(steps1);
(iter, count)
}
}
@@ -353,7 +349,7 @@ fn get_cases(ctx: &CheckCtx) -> (impl Iterator<Item = Self>, u64) {
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();
let count = steps0.strict_mul(steps1);
(iter, count)
}
}
library/compiler-builtins/libm-test/src/generate/random.rs
+38 -24
View File
@@ -33,7 +33,7 @@ pub trait RandomInput: Sized {
}
/// Generate a sequence of deterministically random floats.
fn random_floats<F: Float>(count: u64) -> impl Iterator<Item = F>
fn random_floats<F: Float>(count: u64) -> impl Iterator<Item = F> + Clone
where
StandardUniform: Distribution<F::Int>,
{
@@ -45,7 +45,7 @@ fn random_floats<F: Float>(count: u64) -> impl Iterator<Item = F>
}
/// Generate a sequence of deterministically random `i32`s within a specified range.
fn random_ints<I>(count: u64, range: RangeInclusive<I>) -> impl Iterator<Item = I>
fn random_ints<I>(count: u64, range: RangeInclusive<I>) -> impl Iterator<Item = I> + Clone
where
I: Int + SampleUniform,
{
@@ -67,9 +67,12 @@ impl RandomInput for ($fty, $fty) {
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)));
(iter, count0 * count1)
let iter0 = random_floats(count0);
let iter1 = random_floats(count1);
let iter =
iter0.flat_map(move |first| iter1.clone().map(move |second| (first, second)));
let count = count0.strict_mul(count1);
(iter, count)
}
}
@@ -78,12 +81,16 @@ 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);
let iter = random_floats(count0).flat_map(move |f1: $fty| {
random_floats(count1).flat_map(move |f2: $fty| {
random_floats(count2).map(move |f3: $fty| (f1, f2, f3))
})
});
(iter, count0 * count1 * count2)
let iter0 = random_floats(count0);
let iter1 = random_floats(count1);
let iter2 = random_floats(count2);
let iter = iter0
.flat_map(move |first| iter1.clone().map(move |second| (first, second)))
.flat_map(move |(first, second)| {
iter2.clone().map(move |third| (first, second, third))
});
let count = count0.strict_mul(count1).strict_mul(count2);
(iter, count)
}
}
@@ -92,9 +99,12 @@ 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::<i32>(ctx, 0).unwrap_or(full_range());
let iter = random_ints(count0, range0)
.flat_map(move |f1: i32| random_floats(count1).map(move |f2: $fty| (f1, f2)));
(iter, count0 * count1)
let iter0 = random_ints(count0, range0);
let iter1 = random_floats(count1);
let iter =
iter0.flat_map(move |first| iter1.clone().map(move |second| (first, second)));
let count = count0.strict_mul(count1);
(iter, count)
}
}
@@ -103,10 +113,12 @@ 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::<i32>(ctx, 1).unwrap_or(full_range());
let iter = random_floats(count0).flat_map(move |f1: $fty| {
random_ints(count1, range1.clone()).map(move |f2: i32| (f1, f2))
});
(iter, count0 * count1)
let iter0 = random_floats(count0);
let iter1 = random_ints(count1, range1.clone());
let iter =
iter0.flat_map(move |first| iter1.clone().map(move |second| (first, second)));
let count = count0.strict_mul(count1);
(iter, count)
}
}
};
@@ -136,9 +148,10 @@ fn get_cases(ctx: &CheckCtx) -> (impl Iterator<Item = Self>, u64) {
let count1 = iteration_count(ctx, 1);
let range0 = int_range::<$ity>(ctx, 0).unwrap_or(full_range());
let range1 = int_range::<$ity>(ctx, 1).unwrap_or(full_range());
let iter = random_ints(count0, range0).flat_map(move |f1: $ity| {
random_ints(count1, range1.clone()).map(move |f2: $ity| (f1, f2))
});
let iter0 = random_ints(count0, range0);
let iter1 = random_ints(count1, range1.clone());
let iter =
iter0.flat_map(move |first| iter1.clone().map(move |second| (first, second)));
(iter, count0 * count1)
}
}
@@ -152,9 +165,10 @@ fn get_cases(ctx: &CheckCtx) -> (impl Iterator<Item = Self>, u64) {
let count1 = iteration_count(ctx, 1);
let range0 = int_range::<$ity>(ctx, 0).unwrap_or(full_range());
let range1 = int_range::<u32>(ctx, 1).unwrap_or(full_range());
let iter = random_ints(count0, range0).flat_map(move |f1: $ity| {
random_ints(count1, range1.clone()).map(move |f2: u32| (f1, f2))
});
let iter0 = random_ints(count0, range0);
let iter1 = random_ints(count1, range1.clone());
let iter =
iter0.flat_map(move |first| iter1.clone().map(move |second| (first, second)));
(iter, count0 * count1)
}
}
library/compiler-builtins/libm-test/src/generate/spaced.rs
+45 -32
View File
@@ -83,11 +83,14 @@ fn total_value_count_int<I: Int>() -> Option<u64>
}
/// Returns an iterator of every possible value of type `F`.
fn exhaustive_float<F: Float>() -> impl Iterator<Item = F>
fn exhaustive_float<F: Float>() -> (impl Iterator<Item = F> + Clone, u64)
where
u64: TryFrom<F::Int>,
RangeInclusive<F::Int>: Iterator<Item = F::Int>,
{
(F::Int::MIN..=F::Int::MAX).map(|bits| F::from_bits(bits))
let count = total_value_count::<F>().expect("tried exhaustive with > u64::MAX items");
let iter = (F::Int::MIN..=F::Int::MAX).map(|bits| F::from_bits(bits));
(iter, count)
}
macro_rules! impl_spaced_input {
@@ -100,10 +103,10 @@ fn get_cases(ctx: &CheckCtx) -> (impl Iterator<Item = Self>, u64) {
let max_steps0 = iteration_count(ctx, 0);
// Unary tests: `f16` and `f32` may be exhaustive.
if let Some(steps0) = total_value_count::<Arg0<Op>>()
&& steps0 <= max_steps0
if let Some(exhaustive_steps0) = total_value_count::<Arg0<Op>>()
&& exhaustive_steps0 <= max_steps0
{
let iter0 = exhaustive_float();
let (iter0, steps0) = exhaustive_float();
let iter0 = iter0.map(|v| (v,));
return (EitherIter::A(iter0), steps0);
@@ -125,13 +128,16 @@ fn get_cases(ctx: &CheckCtx) -> (impl Iterator<Item = Self>, u64) {
let max_steps1 = iteration_count(ctx, 1);
// Binary test: `f16` may be exhaustive.
if let Some(steps0) = total_value_count::<Arg0<Op>>()
&& steps0 <= max_steps0
&& let Some(steps1) = total_value_count::<Arg1<Op>>()
&& steps1 <= max_steps1
if let Some(exhaustive_steps0) = total_value_count::<Arg0<Op>>()
&& exhaustive_steps0 <= max_steps0
&& let Some(exhaustive_steps1) = total_value_count::<Arg1<Op>>()
&& exhaustive_steps1 <= max_steps1
{
let iter = exhaustive_float()
.flat_map(|first| exhaustive_float().map(move |second| (first, second)));
let (iter0, steps0) = exhaustive_float();
let (iter1, steps1) = exhaustive_float();
let iter = iter0
.flat_map(move |first| iter1.clone().map(move |second| (first, second)));
let count = steps0.strict_mul(steps1);
return (EitherIter::A(iter), count);
@@ -160,18 +166,22 @@ fn get_cases(ctx: &CheckCtx) -> (impl Iterator<Item = Self>, u64) {
// Ternary test: `f16` may be exhaustive tested if `LIBM_EXTENSIVE_TESTS`
// is incresed.
if let Some(steps0) = total_value_count::<Arg0<Op>>()
&& steps0 <= max_steps0
&& let Some(steps1) = total_value_count::<Arg1<Op>>()
&& steps1 <= max_steps1
&& let Some(steps2) = total_value_count::<Arg2<Op>>()
&& steps2 <= max_steps2
if let Some(exhaustive_steps0) = total_value_count::<Arg0<Op>>()
&& exhaustive_steps0 <= max_steps0
&& let Some(exhaustive_steps1) = total_value_count::<Arg1<Op>>()
&& exhaustive_steps1 <= max_steps1
&& let Some(exhaustive_steps2) = total_value_count::<Arg2<Op>>()
&& exhaustive_steps2 <= max_steps2
{
let iter = exhaustive_float().flat_map(|first| {
exhaustive_float().flat_map(move |second| {
exhaustive_float().map(move |third| (first, second, third))
})
});
let (iter0, steps0) = exhaustive_float();
let (iter1, steps1) = exhaustive_float();
let (iter2, steps2) = exhaustive_float();
let iter = iter0
.flat_map(move |first| iter1.clone().map(move |second| (first, second)))
.flat_map(move |(first, second)| {
iter2.clone().map(move |third| (first, second, third))
});
let count = steps0.strict_mul(steps1).strict_mul(steps2);
return (EitherIter::A(iter), count);
@@ -202,15 +212,16 @@ fn get_cases(ctx: &CheckCtx) -> (impl Iterator<Item = Self>, u64) {
let max_steps0 = iteration_count(ctx, 0);
let max_steps1 = iteration_count(ctx, 1);
if let Some(steps0) = total_value_count_int::<Arg0<Op>>()
&& steps0 <= max_steps0
&& let Some(steps1) = total_value_count::<Arg1<Op>>()
&& steps1 <= max_steps1
if let Some(exhaustive_steps0) = total_value_count_int::<Arg0<Op>>()
&& exhaustive_steps0 <= max_steps0
&& let Some(exhaustive_steps1) = total_value_count::<Arg1<Op>>()
&& exhaustive_steps1 <= max_steps1
{
let (iter0, steps0) = linear_ints(range0, max_steps0);
let iter = iter0.flat_map(move |first| {
exhaustive_float().map(move |second| (first, second))
});
let (iter1, steps1) = exhaustive_float();
let iter = iter0
.flat_map(move |first| iter1.clone().map(move |second| (first, second)));
let count = steps0.strict_mul(steps1);
return (EitherIter::A(iter), count);
@@ -236,11 +247,13 @@ fn get_cases(ctx: &CheckCtx) -> (impl Iterator<Item = Self>, u64) {
let range1 = int_range(ctx, 1).unwrap_or(full_range());
let max_steps1 = iteration_count(ctx, 1);
if let Some(steps0) = total_value_count::<Arg0<Op>>()
&& steps0 <= max_steps0
if let Some(exhaustive_steps0) = total_value_count::<Arg0<Op>>()
&& exhaustive_steps0 <= max_steps0
{
let (iter0, steps0) = exhaustive_float();
let (iter1, steps1) = linear_ints(range1, max_steps1);
let iter = exhaustive_float()
let iter = iter0
.flat_map(move |first| iter1.clone().map(move |second| (first, second)));
let count = steps0.strict_mul(steps1);