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
|
//! Support for configurable generation of arbitrary nix values
use proptest::{prelude::*, strategy::BoxedStrategy};
use std::{ffi::OsString, rc::Rc};
use super::{NixAttrs, NixList, NixString, Value};
#[derive(Clone)]
pub enum Parameters {
Strategy(BoxedStrategy<Value>),
Parameters {
generate_internal_values: bool,
generate_functions: bool,
generate_nested: bool,
},
}
impl Default for Parameters {
fn default() -> Self {
Self::Parameters {
generate_internal_values: false,
generate_functions: false,
generate_nested: true,
}
}
}
impl Arbitrary for Value {
type Parameters = Parameters;
type Strategy = BoxedStrategy<Self>;
fn arbitrary_with(args: Self::Parameters) -> Self::Strategy {
match args {
Parameters::Strategy(s) => s,
Parameters::Parameters {
generate_internal_values,
generate_functions,
generate_nested,
} => {
if generate_internal_values || generate_functions {
todo!("Generating internal values and functions not implemented yet")
} else if generate_nested {
non_internal_value().boxed()
} else {
leaf_value().boxed()
}
}
}
}
}
fn leaf_value() -> impl Strategy<Value = Value> {
use Value::*;
prop_oneof![
Just(Null),
any::<bool>().prop_map(Bool),
any::<i64>().prop_map(Integer),
any::<f64>().prop_map(Float),
any::<NixString>().prop_map(String),
any::<OsString>().prop_map(|s| Path(s.into())),
]
}
fn non_internal_value() -> impl Strategy<Value = Value> {
leaf_value().prop_recursive(10, 256, 10, |inner| {
prop_oneof![
any_with::<NixAttrs>((
Default::default(),
Default::default(),
Parameters::Strategy(inner.clone())
))
.prop_map(|a| Value::Attrs(Rc::new(a))),
any_with::<NixList>((Default::default(), Parameters::Strategy(inner)))
.prop_map(Value::List)
]
})
}
|
