Parameterization of const generics?

[janbridley]

Is there a clear-cut way to parameterize const generics? I see #207 mentions generic types, but I'm not sure if those solutions translate here - I haven't figured out a method by which rstest can pass const values. I have an example where I parameterize the dimension of a struct and would like to use the same test for multiple const generics

pub struct Sphere<const N: usize> {
    /// Radius of the sphere
    pub r: f64,
    pub center: [f64; N],
}

// ...

Currently, I parameterize tests with a declarative macro but I'm curious as to whether rstest provides a cleaner option:

    macro_rules! parameterize_dimension {
        ($test_body:ident, [$($dim:expr),*]) => {
            $(
                paste! {
                    #[test]
                    fn [< $test_body "_" $dim>]() {
                        const DIM: usize = $dim;
                        $test_body::<DIM>();
                    }
                }
            )*
        };
    }
    fn test_radius<const N: usize>() {
        let s = Sphere::<N>::from(1.0);
        assert_eq!(s.r, 1.0);
    }
    parameterize_vector_length!(test_radius, [0, 1, 2, 3, 4, 5]);

[la10736]

Hi, I've iterated a bit and that is the result:

use std::marker::PhantomData;

use rstest::rstest;

pub struct Sphere<const N: usize> {
    /// Radius of the sphere
    pub r: f64,
    pub center: [f64; N],
}

impl<const N: usize> From<f64> for Sphere<N> {
    fn from(value: f64) -> Self {
        Self {
            r: value,
            center: [0.0; N],
        }
    }
}

#[rstest]
#[case(PhantomData::<Sphere<1>>::default())]
#[case(PhantomData::<Sphere<2>>::default())]
#[case(PhantomData::<Sphere<3>>::default())]
fn test_radius<const N: usize>(#[case] _n: PhantomData<Sphere<N>>) {
    let s = Sphere::<N>::from(1.0);
    assert_eq!(s.r, 1.0);
}

#[rstest]
fn test_radius_2<const N: usize>(
    #[values(
    PhantomData::<Sphere<1>>::default(),
    PhantomData::<Sphere<2>>::default(),
    PhantomData::<Sphere<3>>::default(),
)]
    _n: PhantomData<Sphere<N>>,
) {
    let s = Sphere::<N>::from(1.0);
    assert_eq!(s.r, 1.0);
}


type Size<const N: usize> = PhantomData<Sphere<N>>;

#[rstest]
#[case(Size::<1>::default())]
#[case(Size::<2>::default())]
#[case(Size::<3>::default())]
fn test_radius_3<const N: usize>(#[case] _n: Size<N>) {
    let s = Sphere::<N>::from(1.0);
    assert_eq!(s.r, 1.0);
}

#[rstest]
fn test_radius_4<const N: usize>(
    #[values(
    Size::<1>::default(),
    Size::<2>::default(),
    Size::<3>::default(),
)]
    _n: PhantomData<Sphere<N>>,
) {
    let s = Sphere::<N>::from(1.0);
    assert_eq!(s.r, 1.0);
}


fn size<const N: usize>() -> Size<N> {
    Size::<N>::default()
}

#[rstest]
#[case(size::<1>())]
#[case(size::<2>())]
#[case(size::<3>())]
fn test_radius_5<const N: usize>(#[case] _n: Size<N>) {
    let s = Sphere::<N>::from(1.0);
    assert_eq!(s.r, 1.0);
}

#[rstest]
fn test_radius_6<const N: usize>(
    #[values(
    size::<1>(),
    size::<2>(),
    size::<3>(),
)]
    _n: PhantomData<Sphere<N>>,
) {
    let s = Sphere::<N>::from(1.0);
    assert_eq!(s.r, 1.0);
}