relateby-pattern 0.4.2

Core pattern data structures
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
142
143
144
145
146

//! Property-based test generators for patterns
//!
//! This module provides property-based test generators for patterns using proptest.
//! Generators produce patterns with various structures (atomic, nested, deep, wide)
//! suitable for property testing.

#[cfg(test)]
use proptest::prelude::*;

#[cfg(test)]
use crate::Pattern;

/// Generate an arbitrary pattern with integer values
///
/// Generates patterns with:
/// - Values between -100 and 100
/// - Up to 10 elements per level
/// - Up to 5 levels of nesting
#[cfg(test)]
pub fn arbitrary_pattern_i32() -> impl Strategy<Value = Pattern<i32>> {
    let leaf = any::<i32>().prop_map(Pattern::point);

    leaf.prop_recursive(
        5,   // max_depth
        256, // desired_size
        10,  // max_elements per level
        |inner| {
            (any::<i32>(), prop::collection::vec(inner, 0..10))
                .prop_map(|(value, elements)| Pattern::pattern(value, elements))
        },
    )
}

/// Generate an arbitrary pattern with string values
///
/// Generates patterns with:
/// - String values (alphanumeric)
/// - Up to 10 elements per level
/// - Up to 5 levels of nesting
#[cfg(test)]
pub fn arbitrary_pattern_string() -> impl Strategy<Value = Pattern<String>> {
    let leaf = "[a-zA-Z0-9]{1,10}".prop_map(|s: String| Pattern::point(s));

    leaf.prop_recursive(
        5,   // max_depth
        256, // desired_size
        10,  // max_elements per level
        |inner| {
            ("[a-zA-Z0-9]{1,10}", prop::collection::vec(inner, 0..10))
                .prop_map(|(value, elements)| Pattern::pattern(value, elements))
        },
    )
}

/// Generate a pattern with Option values (for sequence testing)
///
/// Some values will be Some, others None, allowing testing of sequence operations
#[cfg(test)]
pub fn arbitrary_pattern_option() -> impl Strategy<Value = Pattern<Option<i32>>> {
    let leaf = any::<Option<i32>>().prop_map(Pattern::point);

    leaf.prop_recursive(
        5,   // max_depth
        256, // desired_size
        10,  // max_elements per level
        |inner| {
            (any::<Option<i32>>(), prop::collection::vec(inner, 0..10))
                .prop_map(|(value, elements)| Pattern::pattern(value, elements))
        },
    )
}

/// Generate a pattern with Result values (for sequence testing)
///
/// Some values will be Ok, others Err, allowing testing of sequence operations
#[cfg(test)]
pub fn arbitrary_pattern_result() -> impl Strategy<Value = Pattern<Result<i32, String>>> {
    let leaf = any::<Result<i32, String>>().prop_map(Pattern::point);

    leaf.prop_recursive(
        5,   // max_depth
        256, // desired_size
        10,  // max_elements per level
        |inner| {
            (
                any::<Result<i32, String>>(),
                prop::collection::vec(inner, 0..10),
            )
                .prop_map(|(value, elements)| Pattern::pattern(value, elements))
        },
    )
}

/// Generate a small atomic pattern (for quick tests)
#[cfg(test)]
pub fn atomic_pattern_i32() -> impl Strategy<Value = Pattern<i32>> {
    any::<i32>().prop_map(|v| Pattern::point(v))
}

/// Generate a shallow nested pattern (1-2 levels, for specific tests)
#[cfg(test)]
pub fn shallow_pattern_i32() -> impl Strategy<Value = Pattern<i32>> {
    let leaf = any::<i32>().prop_map(|v| Pattern::point(v));

    leaf.prop_recursive(
        2,  // max_depth (shallow)
        64, // desired_size (small)
        5,  // max_elements per level
        |inner| {
            (any::<i32>(), prop::collection::vec(inner, 0..5))
                .prop_map(|(value, elements)| Pattern::pattern(value, elements))
        },
    )
}

/// Generate a deep nested pattern (for stack safety tests)
#[cfg(test)]
pub fn deep_pattern_i32() -> impl Strategy<Value = Pattern<i32>> {
    let leaf = any::<i32>().prop_map(|v| Pattern::point(v));

    leaf.prop_recursive(
        20,  // max_depth (deep!)
        100, // desired_size
        3,   // max_elements per level (fewer to keep depth high)
        |inner| {
            (any::<i32>(), prop::collection::vec(inner, 0..3))
                .prop_map(|(value, elements)| Pattern::pattern(value, elements))
        },
    )
}

/// Generate a wide pattern (many siblings, for breadth tests)
#[cfg(test)]
pub fn wide_pattern_i32() -> impl Strategy<Value = Pattern<i32>> {
    let leaf = any::<i32>().prop_map(|v| Pattern::point(v));

    leaf.prop_recursive(
        3,    // max_depth (shallow to keep wide)
        1000, // desired_size (large)
        50,   // max_elements per level (many siblings!)
        |inner| {
            (any::<i32>(), prop::collection::vec(inner, 0..50))
                .prop_map(|(value, elements)| Pattern::pattern(value, elements))
        },
    )
}