---
hide:
  - toc
search:
  exclude: true
---
```````pony linenums="1"
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_rounds: the maximum rounds of shrinking to perform
  * 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_rounds: 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_rounds': USize = 10,
    max_generator_retries': USize = 5,
    timeout': U64 = 60_000_000_000,
    async': Bool = false)
  =>
    num_samples = num_samples'
    seed = seed'
    max_shrink_rounds = max_shrink_rounds'
    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 given sample is shrunken if the
  generator supports shrinking.
  The smallest shrunken sample will then be 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)]

  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)]

  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)]

  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`.
    """


```````