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

//! Tests for performance optimizations

use protest::generator::ConstantGenerator;
use protest::{ParallelConfig, Property, PropertyError, TestConfig, check, check_parallel};
use std::sync::Arc;
use std::sync::atomic::{AtomicUsize, Ordering};

// Test property that counts invocations
struct CountingProperty {
    counter: Arc<AtomicUsize>,
}

impl CountingProperty {
    fn new() -> (Self, Arc<AtomicUsize>) {
        let counter = Arc::new(AtomicUsize::new(0));
        (
            Self {
                counter: counter.clone(),
            },
            counter,
        )
    }
}

impl Property<i32> for CountingProperty {
    type Output = ();
    fn test(&self, _input: i32) -> Result<Self::Output, PropertyError> {
        self.counter.fetch_add(1, Ordering::SeqCst);
        Ok(())
    }
}

#[test]
fn test_parallel_execution_basic() {
    let generator = ConstantGenerator::new(42);
    let (property, counter) = CountingProperty::new();
    let config = TestConfig {
        iterations: 20,
        ..TestConfig::default()
    };
    let parallel_config = ParallelConfig {
        enabled: true,
        num_threads: 2,
        batch_size: 5,
    };

    let result = check_parallel(generator, property, config, parallel_config);

    assert!(result.is_ok());
    assert_eq!(counter.load(Ordering::SeqCst), 20);
}

#[test]
fn test_parallel_vs_sequential_performance() {
    let generator = ConstantGenerator::new(42);

    // Sequential test
    let (seq_property, seq_counter) = CountingProperty::new();
    let seq_result = check(generator.clone(), seq_property);
    assert!(seq_result.is_ok());
    assert_eq!(seq_counter.load(Ordering::SeqCst), 100); // Default iterations

    // Parallel test
    let (par_property, par_counter) = CountingProperty::new();
    let config = TestConfig {
        iterations: 100,
        ..TestConfig::default()
    };
    let parallel_config = ParallelConfig {
        enabled: true,
        num_threads: 4,
        batch_size: 10,
    };

    let par_result = check_parallel(generator, par_property, config, parallel_config);
    assert!(par_result.is_ok());
    assert_eq!(par_counter.load(Ordering::SeqCst), 100);
}

#[test]
fn test_parallel_config_defaults() {
    let config = ParallelConfig::default();
    assert!(config.enabled);
    assert!(config.num_threads > 0);
    assert_eq!(config.batch_size, 10);
}

#[test]
fn test_lazy_generator() {
    use protest::lazy;

    let lazy_gen = lazy(|| Box::new(ConstantGenerator::new(42)));
    let (property, counter) = CountingProperty::new();

    let result = check(lazy_gen, property);
    assert!(result.is_ok());
    assert_eq!(counter.load(Ordering::SeqCst), 100);
}

#[test]
fn test_streaming_shrink_strategy() {
    use protest::StreamingShrinkStrategy;

    let mut strategy = StreamingShrinkStrategy::<i32>::new(1); // 1MB limit

    assert!(strategy.within_memory_limit(1024)); // 1KB should be fine

    strategy.update_memory_usage(1024);
    assert!(!strategy.within_memory_limit(1024 * 1024)); // 1MB more would exceed limit

    strategy.reset_memory_usage();
    assert!(strategy.within_memory_limit(1024 * 1024)); // Should be fine after reset
}

// Note: Async parallel tests removed as check_async_parallel requires tokio::spawn
// The library now only provides check_async() for runtime-agnostic async testing
// Users can implement their own parallel async execution with their chosen runtime