Parametrization?

[svenstaro]

Is there anything we can do to achieve parametrization of tests such as pytest has and rstest re-implements?

If not, take this as a feature suggestion. :)

In case you don't know what I mean: tests parametrization generates a bunch of test cases from an iterable of input parameters and injects the values into the tests.

[adaqus]

It would be really nice to have such feature. +1

[adaqus]

I can try to implement such a feature. It could meet following requirements:

• parametrized test can be based on it/test block,
• declare parameter names, whether they are mutable, eventually their type,
• declare each set of parameters, each set has its name which is used to generate final test function.

Example:

it "can add" for (a: usize, b: usize, expected: usize) [
    "1 and 2" => (1, 2, 3),
    "4 and 8" => (4, 8, 12)
] {
    assert_eq!(a + b, expected);
}

which will resolve to:

#[test]
fn can_add_1_and_2() {
    let a: usize = 1;
    let b: usize = 2;
    let expected: usize = 3;

    assert_eq!(a + b, expected);
}

#[test]
fn can_add_4_and_8() {
    let a: usize = 4;
    let b: usize = 8;
    let expected: usize = 12;

    assert_eq!(a + b, expected);
}

Example 2:

it "can push" for (mut v: Vec<usize>, to_push: usize, expected: Vec<usize>) [
    "some number" => (vec![1, 24], 2, vec![1, 24, 2]),
    "another number" => (vec![3, 15], 11, vec![3, 15, 11])
] {
    v.push(to_push);
    assert_eq!(v, expected);
}

which will resolve to:

#[test]
fn can_push_some_number() {
    let mut v: Vec<usize> = vec![1, 24];
    let to_push: usize = 2;
    let expected: Vec<usize> = vec![1, 24, 2];

    assert_eq!(v, expected);
}

#[test]
fn can_push_another_number() {
    let mut v: Vec<usize> = vec![3, 15];
    let to_push: usize = 11;
    let expected: Vec<usize> = vec![3, 15, 11];

    assert_eq!(v, expected);
}

[sagebind]

That would actually be amazing! The suggested syntax looks quite natural.

[adaqus]

@utkarshkukreti what do you think?