Abstract class able to generate values on type T

The values generated by an instance of Arbitrary can be previewed - with sample - or classified - with statistics.

Remarks

Since 0.0.7

Type Parameters

  • T

Hierarchy

  • Arbitrary

Constructors

Methods

  • Check if a given value could be pass to shrink without providing any context.

    In general, canShrinkWithoutContext is not designed to be called for each shrink but rather on very special cases. Its usage must be restricted to canShrinkWithoutContext or in the rare* contexts of a shrink method being called without any context. In this ill-formed case of shrink, canShrinkWithoutContext could be used or called if needed.

    *we fall in that case when fast-check is asked to shrink a value that has been provided manually by the user, in other words: a value not coming from a call to generate or a normal shrink with context.

    Returns

    true if and only if the value could have been generated by this instance

    Remarks

    Since 3.0.0

    Parameters

    • value: unknown

      Value to be assessed

    Returns value is T

  • Create another arbitrary by mapping a value from a base Arbirary using the provided fmapper Values produced by the new arbitrary are the result of the arbitrary generated by applying fmapper to a value

    Example

    const arrayAndLimitArbitrary = fc.nat().chain((c: number) => fc.tuple( fc.array(fc.nat(c)), fc.constant(c)));
    

    Returns

    New arbitrary of new type

    Remarks

    Since 1.2.0

    Type Parameters

    • U

    Parameters

    • chainer: ((t: T) => Arbitrary<U>)

      Chain function, to produce a new Arbitrary using a value from another Arbitrary

    Returns Arbitrary<U>

  • Create another arbitrary by filtering values against predicate

    All the values produced by the resulting arbitrary satisfy predicate(value) == true

    Be aware that using filter may highly impact the time required to generate a valid entry

    Example

    const integerGenerator: Arbitrary<number> = ...;
    const evenIntegerGenerator: Arbitrary<number> = integerGenerator.filter(e => e % 2 === 0);
    // new Arbitrary only keeps even values

    Returns

    New arbitrary filtered using predicate

    Remarks

    Since 1.23.0

    Type Parameters

    • U

    Parameters

    • refinement: ((t: T) => t is U)

      Predicate, to test each produced element. Return true to keep the element, false otherwise

        • (t: T): t is U
        • Parameters

          • t: T

          Returns t is U

    Returns Arbitrary<U>

  • Create another arbitrary by filtering values against predicate

    All the values produced by the resulting arbitrary satisfy predicate(value) == true

    Be aware that using filter may highly impact the time required to generate a valid entry

    Example

    const integerGenerator: Arbitrary<number> = ...;
    const evenIntegerGenerator: Arbitrary<number> = integerGenerator.filter(e => e % 2 === 0);
    // new Arbitrary only keeps even values

    Returns

    New arbitrary filtered using predicate

    Remarks

    Since 0.0.1

    Parameters

    • predicate: ((t: T) => boolean)

      Predicate, to test each produced element. Return true to keep the element, false otherwise

        • (t: T): boolean
        • Parameters

          • t: T

          Returns boolean

    Returns Arbitrary<T>

  • Generate a value of type T along with its context (if any) based on the provided random number generator

    Returns

    Random value of type T and its context

    Remarks

    Since 0.0.1 (return type changed in 3.0.0)

    Parameters

    • mrng: Random

      Random number generator

    • biasFactor: undefined | number

      If taken into account 1 value over biasFactor must be biased. Either integer value greater or equal to 2 (bias) or undefined (no bias)

    Returns Value<T>

  • Create another arbitrary by mapping all produced values using the provided mapper Values produced by the new arbitrary are the result of applying mapper value by value

    Example

    const rgbChannels: Arbitrary<{r:number,g:number,b:number}> = ...;
    const color: Arbitrary<string> = rgbChannels.map(ch => `#${(ch.r*65536 + ch.g*256 + ch.b).toString(16).padStart(6, '0')}`);
    // transform an Arbitrary producing {r,g,b} integers into an Arbitrary of '#rrggbb'

    Returns

    New arbitrary with mapped elements

    Remarks

    Since 0.0.1

    Type Parameters

    • U

    Parameters

    • mapper: ((t: T) => U)

      Map function, to produce a new element based on an old one

        • (t: T): U
        • Parameters

          • t: T

          Returns U

    • Optional unmapper: ((possiblyU: unknown) => T)

      Optional unmap function, it will never be used except when shrinking user defined values. Must throw if value is not compatible (since 3.0.0)

        • (possiblyU: unknown): T
        • Parameters

          • possiblyU: unknown

          Returns T

    Returns Arbitrary<U>

  • Shrink a value of type T, may rely on the context previously provided to shrink efficiently

    Must never be called with possibly invalid values and no context without ensuring that such call is legal by calling canShrinkWithoutContext first on the value.

    Returns

    Stream of shrinks for value based on context (if provided)

    Remarks

    Since 3.0.0

    Parameters

    • value: T

      The value to shrink

    • context: unknown

      Its associated context (the one returned by generate) or undefined if no context but canShrinkWithoutContext(value) === true

    Returns Stream<Value<T>>

Generated using TypeDoc