use "time"
class val PropertyParams is Stringable
"""
Parameters to control Property Execution.
* seed: the seed for the source of Randomness
* num_samples: the number of samples to produce from the property generator
* max_shrink_reductions: the maximum number of shrink reductions to accept
* max_generator_retries: the maximum number of retries to do if a generator
fails to generate a sample
* timeout: the timeout for the PonyTest runner, in nanoseconds
* async: if true the property is expected to finish asynchronously by calling
`PropertyHelper.complete(...)`
"""
let seed: U64
let num_samples: USize
let max_shrink_reductions: USize
let max_generator_retries: USize
let timeout: U64
let async: Bool
new val create(
num_samples': USize = 100,
seed': U64 = Time.millis(),
max_shrink_reductions': USize = 100,
max_generator_retries': USize = 5,
timeout': U64 = 60_000_000_000,
async': Bool = false)
=>
num_samples = num_samples'
seed = seed'
max_shrink_reductions = max_shrink_reductions'
max_generator_retries = max_generator_retries'
timeout = timeout'
async = async'
fun string(): String iso^ =>
recover
String()
.> append("Params(seed=")
.> append(seed.string())
.> append(")")
end
trait Property1[T]
"""
A property that consumes 1 argument of type `T`.
A property is defined by a [Generator](pony_check-Generator.md), returned by
the [`gen()`](pony_check-Property1.md#gen) method, and a
[`property`](pony_check-Property1#property) method that consumes the
generators' output and verifies a custom property with the help of a
[PropertyHelper](pony_check-PropertyHelper.md).
A property is verified if no failed assertion on
[PropertyHelper](pony_check-PropertyHelper.md) has been
reported for all the samples it consumed.
The property execution can be customized by returning a custom
[PropertyParams](pony_check-PropertyParams.md) from the
[`params()`](pony_check-Property1.md#params) method.
The [`gen()`](pony_check-Property1.md#gen) method is called exactly once to
instantiate the generator.
The generator produces
[PropertyParams.num_samples](pony_check-PropertyParams.md#num_samples)
samples and each is passed to the
[property](pony_check-Property1.md#property) method for verification.
If the property did not verify, the framework automatically shrinks the
failing sample by replaying the generator against mutated choice sequences.
The smallest counterexample found is reported to the user.
A [Property1](pony_check-Property1.md) can be run with
[Ponytest](pony_test--index.md).
To that end it needs to be wrapped into a
[Property1UnitTest](pony_check-Property1UnitTest.md).
"""
fun name(): String
"""
The name of the property used for reporting during execution.
"""
fun params(): PropertyParams =>
"""
Returns parameters to customize execution of this Property.
"""
PropertyParams
fun gen(): Generator[T]
"""
The [Generator](pony_check-Generator.md) used to produce samples to verify.
"""
fun ref property(arg1: T, h: PropertyHelper) ?
"""
A method verifying that a certain property holds for all given `arg1`
with the help of [PropertyHelper](pony_check-PropertyHelper.md) `h`.
"""
trait Property2[T1, T2] is Property1[(T1, T2)]
"""
A property with two generated arguments.
"""
fun gen1(): Generator[T1]
"""
The Generator for the first argument to your `property2`.
"""
fun gen2(): Generator[T2]
"""
The Generator for the second argument to your `property2`.
"""
fun gen(): Generator[(T1, T2)] =>
Generators.zip2[T1, T2](
gen1(),
gen2())
fun ref property(arg1: (T1, T2), h: PropertyHelper) ? =>
(let x, let y) = consume arg1
property2(consume x, consume y, h)?
fun ref property2(arg1: T1, arg2: T2, h: PropertyHelper) ?
"""
A method verifying that a certain property holds for all given
`arg1` and `arg2`
with the help of [PropertyHelper](pony_check-PropertyHelper.md) `h`.
"""
trait Property3[T1, T2, T3] is Property1[(T1, T2, T3)]
"""
A property with three generated arguments.
"""
fun gen1(): Generator[T1]
"""
The Generator for the first argument to your `property3` method.
"""
fun gen2(): Generator[T2]
"""
The Generator for the second argument to your `property3` method.
"""
fun gen3(): Generator[T3]
"""
The Generator for the third argument to your `property3` method.
"""
fun gen(): Generator[(T1, T2, T3)] =>
Generators.zip3[T1, T2, T3](
gen1(),
gen2(),
gen3())
fun ref property(arg1: (T1, T2, T3), h: PropertyHelper) ? =>
(let x, let y, let z) = consume arg1
property3(consume x, consume y, consume z, h)?
fun ref property3(arg1: T1, arg2: T2, arg3: T3, h: PropertyHelper) ?
"""
A method verifying that a certain property holds for all given
`arg1`,`arg2`, and `arg3`
with the help of [PropertyHelper](pony_check-PropertyHelper.md) `h`.
"""
trait Property4[T1, T2, T3, T4] is Property1[(T1, T2, T3, T4)]
"""
A property with four generated arguments.
"""
fun gen1(): Generator[T1]
"""
The Generator for the first argument to your `property4` method.
"""
fun gen2(): Generator[T2]
"""
The Generator for the second argument to your `property4` method.
"""
fun gen3(): Generator[T3]
"""
The Generator for the third argument to your `property4` method.
"""
fun gen4(): Generator[T4]
"""
The Generator for the fourth argument to your `property4` method.
"""
fun gen(): Generator[(T1, T2, T3, T4)] =>
Generators.zip4[T1, T2, T3, T4](
gen1(),
gen2(),
gen3(),
gen4())
fun ref property(arg1: (T1, T2, T3, T4), h: PropertyHelper) ? =>
(let x1, let x2, let x3, let x4) = consume arg1
property4(consume x1, consume x2, consume x3, consume x4, h)?
fun ref property4(arg1: T1, arg2: T2, arg3: T3, arg4: T4, h: PropertyHelper) ?
"""
A method verifying that a certain property holds for all given
`arg1`, `arg2`, `arg3`, and `arg4`
with the help of [PropertyHelper](pony_check-PropertyHelper.md) `h`.
"""