iterators3 tests dont check if errors are returned correctly

[lars-schumann]

Im currently doing rustlings and struggled with iterators3 and searched a solution, which i thought i found here.

It implements one of the functions to edit like this:

fn result_with_list() -> Result<Vec<i64>, DivisionError> { 
let numbers = vec![27, 297, 38502, 81];
   let division_results = numbers.into_iter().map(|n| divide(n, 27));
   division_results.filter(|x| x.is_ok()).collect()
}

which compiles and passes the implemented test but this didnt make any sense to me, as this can never return a correct Err variant, at "best" this would return and empty Vec, if every division returns an Err variant, which is, as far as i understand, not the intendet solution.

To remedy this, I would suggest adding test cases to cover this wrong solution, but since the functions that get tested here dont take any parameters, but instead have hardcoded values inside them, this would require changing their signature and passing in the vector of numbers to be divided.

Im new to rust, so please let me know if this isnt a real issue.

If this is indeed a real issue, im happy to suggest an updated version of this exercise.

[temanmd]

As I understand, there is not an issue.

My solution was:

// TODO: Calculate `a` divided by `b` if `a` is evenly divisible by `b`.
// Otherwise, return a suitable error.
fn divide(a: i64, b: i64) -> Result<i64, DivisionError> {
    match (a, b) {
        (_, 0) => Err(DivisionError::DivideByZero),
        (i64::MIN, -1) => Err(DivisionError::IntegerOverflow),
        _ if a % b != 0 => Err(DivisionError::NotDivisible),
        _ => Ok(a / b),
    }
}

// TODO: Add the correct return type and complete the function body.
// Desired output: `Ok([1, 11, 1426, 3])`
fn result_with_list() -> Result<Vec<i64>, DivisionError> {
    let numbers = [27, 297, 38502, 81];
    numbers.into_iter().map(|n| divide(n, 27)).collect()
}

// TODO: Add the correct return type and complete the function body.
// Desired output: `[Ok(1), Ok(11), Ok(1426), Ok(3)]`
fn list_of_results() -> Vec<Result<i64, DivisionError>> {
    let numbers = [27, 297, 38502, 81];
    numbers.into_iter().map(|n| divide(n, 27)).collect()
}

collect func is smart, its result is depends on that you want to return
result_with_list func returns Result<Vec<i64>, DivisionError> and collect() know it
list_of_results func returns Vec of Result and collect() know it again
check it https://doc.rust-lang.org/std/iter/trait.Iterator.html#method.collect

[lars-schumann]

Im not sure what your point is, my issue is that a simple "wrong" solution like the one I provided passes all tests.

[lars-schumann]

To check if errors are returned properly from the 2 functions, both the numbers and the divisor have to take on several different values, this is why I moved them to be parameters of the functions and added the appropriate test cases.