In this lesson, you will learn how to use property-based testing to verify that your generic logic remains correct across an infinite space of possible types.
The Limitation of Example-Based Testing
When you write a generic function like fn add<T: Add<Output=T>>(a: T, b: T) -> T, you might be tempted to test it only with i32 or f64. However, those examples only prove the logic works for those specific types. If your logic contains subtle assumptions about memory layout, overflow behavior, or trait implementations, simple unit tests might miss edge cases that only appear when the function is used with custom types.
Enter Property-Based Testing
Property-based testing, commonly implemented in Rust via the proptest crate, shifts the focus from testing examples to testing invariants. Instead of providing specific inputs, you define the properties that your generic function must always satisfy.
Consider a generic function that squares a number. Instead of checking if square(2) == 4, you define a property: "For any number x, square(x) must be non-negative."
proptest! {
#[test]
fn test_square_is_always_non_negative(x in any::<i32>()) {
let result = square(x); // Our generic logic
assert!(result >= 0);
}
}
Why This Matters for Generics
When your code is generic, it is essentially a blueprint. Property-based testing acts as a "stress test" for that blueprint. By using a library like proptest, you can inject a wide variety of inputs—including boundary values like i32::MAX, i32::MIN, or zero—automatically.
If your generic logic is constrained by a trait, you can write tests that generate random types implementing that trait, ensuring your code doesn't just work for your own types, but for any user-defined type that satisfies your trait bounds. This approach is invaluable for generic libraries where you cannot possibly know every type your users will pass into your functions. By verifying that your logic holds true across the entire range of valid input values, you achieve a level of robustness that manual unit tests simply cannot match.
Key Takeaway: Use property-based testing to verify invariants across an infinite range of inputs, ensuring your generic code remains correct regardless of the specific type provided.