A fuzzer for bool values.

A fuzzer for int values. It will never produce NaN, Infinity, or -Infinity.

It's possible for this fuzzer to generate any 32-bit integer, but it favors numbers between -50 and 50 and especially zero.

A fuzzer for int values within between a given minimum and maximum value, inclusive. Shrunken values will also be within the range.

A fuzzer for float values. It will never produce NaN, Infinity, or -Infinity.

It's possible for this fuzzer to generate any other floating-point value, but it favors numbers between -50 and 50, numbers between -1 and 1, and especially zero.

A fuzzer for float values within between a given minimum and maximum value, inclusive. Shrunken values will also be within the range.

A fuzzer for percentage values. Generates random floats between 0.0 and 1.0. It will test zero and one about 10% of the time each.

Generates random printable ASCII strings of up to 1000 characters.

Shorter strings are more common, especially the empty string.

Given a fuzzer of a type, create a fuzzer of a maybe for that type.

Given fuzzers for an error type and a success type, create a fuzzer for a result.

Given a fuzzer of a type, create a fuzzer of a list of that type. Generates random lists of varying length, favoring shorter lists.

Given a fuzzer of a type, create a fuzzer of an array of that type. Generates random arrays of varying length, favoring shorter arrays.

The representation of fuzzers is opaque. Conceptually, a Fuzzer a consists of a way to randomly generate values of type a, and a way to shrink those values.

Create a fuzzer that only and always returns the value provided, and performs no shrinking. This is hardly random, and so this function is best used as a helper when creating more complicated fuzzers.

Map a function over a fuzzer. This applies to both the generated and the shruken values.

Map over two fuzzers.

Map over three fuzzers.

Map over four fuzzers.

Map over five fuzzers.

Map over many fuzzers. This can act as mapN for N > 5.

Create a fuzzer based on the result of another fuzzer.

Create a new Fuzzer by providing a list of probabilistic weights to use with other fuzzers.

For example, to create a Fuzzer that has a 1/4 chance of generating an int between -1 and -100, and a 3/4 chance of generating one between 1 and 100, you could do this:

Fuzz.frequency
    [ ( 1, Fuzz.intRange -100 -1 )
    , ( 3, Fuzz.intRange 1 100 )
    ]

This returns a Result because it can fail in a few ways:

• If you provide an empy list of frequencies
• If any of the weights are less than 0
• If the weights sum to 0

Any of these will lead to a result of Err, with a String explaining what went wrong.

Calls frequency and handles Err results by crashing with the given error message.

This is useful in tests, where a crash will simply cause the test run to fail. There is no danger to a production system there.

Turn a tuple of fuzzers into a fuzzer of tuples.

Turn a 3-tuple of fuzzers into a fuzzer of 3-tuples.

Turn a 4-tuple of fuzzers into a fuzzer of 4-tuples.

Turn a 5-tuple of fuzzers into a fuzzer of 5-tuples.

Build a custom Fuzzer a by providing a Generator a and a Shrinker a. Generators are defined in mgold/elm-random-pcg, which is not core's Random module but has a compatible interface. Shrinkers are defined in elm-community/shrink.

Here is an example for a record:

import Random.Pcg as Random
import Shrink


type alias Position =
    { x : Int, y : Int }


position : Fuzzer Position
position =
    Fuzz.custom
        (Random.map2 Position (Random.int -100 100) (Random.int -100 100))
        (\{ x, y } -> Shrink.map Position (Shrink.int x) `Shrink.andMap` (Shrink.int y))

Here is an example for a custom union type, assuming there is already a genName : Generator String defined:

type Question
    = Name String
    | Age Int


question =
    let
        generator =
            Random.bool `Random.andThen` (\b ->
                if b then
                    Random.map Name genName
                else
                    Random.map Age (Random.int 0 120)
             )


        shrinker question =
            case question of
                Name n ->
                    Shrink.string n |> Shrink.map Name
                Age i ->
                    Shrink.int i |> Shrink.map Age
    in
        Fuzz.custom generator shrinker

It is not possible to extract the generator and shrinker from an existing fuzzer.

A fuzzer for char values. Generates random ascii chars disregarding the control characters.

A fuzzer for the unit value. Unit is a type with only one value, commonly used as a placeholder.

A fuzzer for order values.