`include Core_kernel.Quickcheck.Quickcheck_configured`
`include Core_kernel.Quickcheck_intf.Quickcheck_config`
`val default_seed : Core_kernel.Quickcheck_intf.seed`

`default_seed` is used initialize the pseudo-random generator that chooses random values from generators, in each test that is not provided its own seed.

`val default_sizes : Core_kernel__.Import.int Core_kernel.Sequence.t`

`default_sizes` determines the default sequence of sizes used in generating values.

`val default_trial_count : Core_kernel__.Import.int`

`default_trial_count` determines the number of trials per test, except in tests that explicitly override it.

`val default_can_generate_trial_count : Core_kernel__.Import.int`

`default_can_generate_trial_count` determines the number of trials used in attempts to generate satisfying values, except in tests that explicitly override it.

`val default_shrink_attempts : Core_kernel.Quickcheck_intf.shrink_attempts`

`default_shrink_attempts` determines the number of attempts at shrinking when running `test` or `iter` with `~shrinker` and without `~shrink_attempts`

`type 'a gen`````
`type 'a shr`````
`val random_value : ?⁠seed:Core_kernel.Quickcheck_intf.seed ‑> ?⁠size:Core_kernel__.Import.int ‑> 'a gen ‑> 'a`

`random_value gen` produces a single value chosen from `gen` using `seed`.

`val iter : ?⁠seed:Core_kernel.Quickcheck_intf.seed ‑> ?⁠sizes:Core_kernel__.Import.int Core_kernel.Sequence.t ‑> ?⁠trials:Core_kernel__.Import.int ‑> 'a gen ‑> f:('a ‑> Core_kernel__.Import.unit) ‑> Core_kernel__.Import.unit`

`iter gen ~f` runs `f` on up to `trials` different values generated by `gen`. It stops successfully after `trials` successful trials or if `gen` runs out of values. It raises an exception if `f` raises an exception.

`val test : ?⁠seed:Core_kernel.Quickcheck_intf.seed ‑> ?⁠sizes:Core_kernel__.Import.int Core_kernel.Sequence.t ‑> ?⁠trials:Core_kernel__.Import.int ‑> ?⁠shrinker:'a shr ‑> ?⁠shrink_attempts:Core_kernel.Quickcheck_intf.shrink_attempts ‑> ?⁠sexp_of:('a ‑> Base.Sexp.t) ‑> ?⁠examples:'a Core_kernel__.Import.list ‑> 'a gen ‑> f:('a ‑> Core_kernel__.Import.unit) ‑> Core_kernel__.Import.unit`

`test gen ~f` is like `iter`, with optional concrete `examples` that are tested before values from `gen`, and additional information provided on failure. If `f` raises an exception and `sexp_of` is provided, the exception is re-raised with a description of the random input that triggered the failure. If `f` raises an exception and `shrinker` is provided, it will be used to attempt to shrink the value that caused the exception with re-raising behaving the same as for unshrunk inputs.

`val test_or_error : ?⁠seed:Core_kernel.Quickcheck_intf.seed ‑> ?⁠sizes:Core_kernel__.Import.int Core_kernel.Sequence.t ‑> ?⁠trials:Core_kernel__.Import.int ‑> ?⁠shrinker:'a shr ‑> ?⁠shrink_attempts:Core_kernel.Quickcheck_intf.shrink_attempts ‑> ?⁠sexp_of:('a ‑> Base.Sexp.t) ‑> ?⁠examples:'a Core_kernel__.Import.list ‑> 'a gen ‑> f:('a ‑> Core_kernel__.Import.unit Core_kernel.Or_error.t) ‑> Core_kernel__.Import.unit Core_kernel.Or_error.t`

`test_or_error` is like `test`, except failure is determined using `Or_error.t`. Any exceptions raised by `f` are not caught.

`val test_can_generate : ?⁠seed:Core_kernel.Quickcheck_intf.seed ‑> ?⁠sizes:Core_kernel__.Import.int Core_kernel.Sequence.t ‑> ?⁠trials:Core_kernel__.Import.int ‑> ?⁠sexp_of:('a ‑> Base.Sexp.t) ‑> 'a gen ‑> f:('a ‑> Core_kernel__.Import.bool) ‑> Core_kernel__.Import.unit`

`test_can_generate gen ~f` is useful for testing `gen` values, to make sure they can generate useful examples. It tests `gen` by generating up to `trials` values and passing them to `f`. Once a value satisfies `f`, the iteration stops. If no values satisfy `f`, `test_can_generate` raises an exception. If `sexp_of` is provided, the exception includes all of the generated values.

`val test_distinct_values : ?⁠seed:Core_kernel.Quickcheck_intf.seed ‑> ?⁠sizes:Core_kernel__.Import.int Core_kernel.Sequence.t ‑> ?⁠sexp_of:('a ‑> Base.Sexp.t) ‑> 'a gen ‑> trials:Core_kernel__.Import.int ‑> distinct_values:Core_kernel__.Import.int ‑> compare:('a ‑> 'a ‑> Core_kernel__.Import.int) ‑> Core_kernel__.Import.unit`

`test_distinct_values gen` is useful for testing `gen` values, to make sure they create sufficient distinct values. It tests `gen` by generating up to `trials` values and making sure at least `distinct_values` of the resulting values are unique with respect to `compare`. If too few distinct values are generated, `test_distinct_values` raises an exception. If `sexp_of` is provided, the exception includes the values generated.

`val random_sequence : ?⁠seed:Core_kernel.Quickcheck_intf.seed ‑> ?⁠sizes:Core_kernel__.Import.int Core_kernel.Sequence.t ‑> 'a gen ‑> 'a Core_kernel.Sequence.t`

`random_sequence ~seed gen` produces a sequence of values chosen from `gen`.

`val async_test : ?⁠seed:Core_kernel.Quickcheck.seed ‑> ?⁠trials:int ‑> ?⁠sexp_of:('a ‑> Core_kernel.Sexp.t) ‑> 'a Core_kernel.Quickcheck.Generator.t ‑> f:('a ‑> unit Async_kernel.Deferred.t) ‑> unit Async_kernel.Deferred.t`

Like `test`, but for asynchronous tests.