protest 1.1.0

An ergonomic, powerful, and feature-rich property testing library with minimal boilerplate.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141

//! Simple example: Vector reverse property
//!
//! This example demonstrates a classic property-based test:
//! reversing a vector twice should return the original vector.

use protest::{
    Property, PropertyError, PropertyTestBuilder, check,
    primitives::{IntGenerator, VecGenerator},
};

// Property: reversing a vector twice returns the original
struct DoubleReverseProperty;

impl Property<Vec<i32>> for DoubleReverseProperty {
    type Output = ();

    fn test(&self, input: Vec<i32>) -> Result<Self::Output, PropertyError> {
        let original = input.clone();
        let mut reversed_once = input;

        // Reverse once
        reversed_once.reverse();

        // Reverse again
        reversed_once.reverse();

        // Should be back to original
        if reversed_once == original {
            Ok(())
        } else {
            Err(PropertyError::property_failed(format!(
                "Double reverse failed: {:?} != {:?}",
                reversed_once, original
            )))
        }
    }
}

fn main() {
    println!("Testing: reverse(reverse(vec)) == vec");
    println!("=====================================");

    // Create a generator for vectors of integers
    let generator = VecGenerator::new(
        IntGenerator::new(-100, 100), // Generate integers from -100 to 100
        0,                            // Minimum vector length
        20,                           // Maximum vector length
    );

    // Run the property test
    match check(generator, DoubleReverseProperty) {
        Ok(success) => {
            println!("✓ Property passed! Tested {} vectors", success.iterations);
            println!("  All vectors satisfied: reverse(reverse(v)) == v");
        }
        Err(failure) => {
            println!("✗ Property failed: {}", failure.error);
            println!("  Original vector: {:?}", failure.original_input);
            if let Some(shrunk) = failure.shrunk_input {
                println!("  Minimal failing case: {:?}", shrunk);
            }
        }
    }

    // Let's also test with more iterations and statistics
    println!("\nRunning extended test with statistics...");

    let result = PropertyTestBuilder::new()
        .iterations(1000)
        .enable_statistics()
        .run(
            VecGenerator::new(IntGenerator::new(-1000, 1000), 0, 50),
            DoubleReverseProperty,
        );

    match result {
        Ok(success) => {
            println!("✓ Extended test passed! {} iterations", success.iterations);

            if let Some(stats) = success.stats {
                println!("  Generated {} vectors total", stats.total_generated);
                println!(
                    "  Average generation time: {:?}",
                    stats.performance_metrics.average_generation_time
                );

                // Show some collection statistics
                if let Some(collection_stats) =
                    stats.coverage_info.collection_coverage.values().next()
                {
                    println!("  Vector size statistics:");
                    println!("    Average size: {:.1}", collection_stats.average_size);
                    println!(
                        "    Size range: [{}, {}]",
                        collection_stats.min_size, collection_stats.max_size
                    );
                }
            }
        }
        Err(failure) => {
            println!("✗ Extended test failed: {}", failure.error);
        }
    }

    // Test edge cases explicitly
    println!("\nTesting specific edge cases...");

    // Empty vector
    test_specific_case(vec![], "empty vector");

    // Single element
    test_specific_case(vec![42], "single element");

    // Two elements
    test_specific_case(vec![1, 2], "two elements");

    // Palindrome (should be same when reversed)
    test_specific_case(vec![1, 2, 3, 2, 1], "palindrome");

    println!("\n=== Summary ===");
    println!("The property 'reverse(reverse(v)) == v' should always hold for any vector.");
    println!("This is because reversing is its own inverse operation.");
    println!("Property-based testing helps us verify this across many random cases!");
}

fn test_specific_case(vec: Vec<i32>, description: &str) {
    let original = vec.clone();
    let mut test_vec = vec;

    test_vec.reverse();
    test_vec.reverse();

    if test_vec == original {
        println!("  ✓ {} case passed", description);
    } else {
        println!(
            "  ✗ {} case failed: {:?} != {:?}",
            description, test_vec, original
        );
    }
}