Separating test input data & expected values?

[Sean D Matthews]

Say I have a struct for which a number of functions are implemented.

struct AStruct {
  a: f64,
  b: f64,
};

impl AStruct {
struct AStruct {
  a: f64,
  b: f64,
};

impl AStruct {
  fn custom_add(&self) -> f64 {
    self.a + self.b + 1f64
  }

  // .. and more
}

Now, I'd like to be able to create a template with a number of AStruct instantiations defined:

#[template] 
#[rstest]
#[case(AStruct{a: 1., b: 1.})] 
#[case(AStruct{a: 1., b: 2.})] 
// .. and more
fn base(s: AStruct) {}

Everything is fine so far. However, now I'd like to test the different operations using the AStruct instantiations that I've already defined. Can I do this with templates? Or is there another mechanism by which I could achieve this?

// How can I also apply a list of expected values here?
#[rstest]
#[apply(base)]
fn test_custom_add(s: AStruct, expected: f64) {}

[Michele d'Amico]

No, there isn't anything about that. If we find a nice way to express it I can add this to the backlog.

Anyway I found a workaround that could work in some cases.... but is really far from to be an elegant solution and it doesn't work in general cases:

use std::collections::HashMap;

use rstest::*;
use rstest_reuse::{self, *};

#[derive(PartialEq, Eq, Debug, Hash)]
struct AStruct {
    a: u32,
    b: u32,
}

impl AStruct {
    fn add(&self) -> u32 {
        self.a + self.b
    }

    fn mul(&self) -> u32 {
        self.a * self.b
    }
}

#[template]
#[rstest]
#[case(AStruct{a: 1, b: 1})]
#[case(AStruct{a: 2, b: 3})]
fn base(#[case] s: AStruct) {}

#[fixture]
#[once]
fn add_expected() -> HashMap<AStruct, u32> {
    let mut m = HashMap::new();
    m.insert(AStruct { a: 1, b: 1 }, 2);
    m.insert(AStruct { a: 2, b: 3 }, 5);
    m
}

#[apply(base)]
fn test_add(#[case] s: AStruct, add_expected: &HashMap<AStruct, u32>) {
    assert_eq!(s.add(), *add_expected.get(&s).unwrap());
}

#[fixture]
#[once]
fn mul_expected() -> HashMap<AStruct, u32> {
    let mut m = HashMap::new();
    m.insert(AStruct { a: 1, b: 1 }, 1);
    m.insert(AStruct { a: 2, b: 3 }, 6);
    m
}

#[apply(base)]
fn test_mul(#[case] s: AStruct, mul_expected: &HashMap<AStruct, u32>) {
    assert_eq!(s.mul(), *mul_expected.get(&s).unwrap());
}