fast-check

  • Version 3.19.0
  • Published
  • 1.23 MB
  • 1 dependency
  • MIT license

Install

npm i fast-check
yarn add fast-check
pnpm add fast-check

Overview

Property based testing framework for JavaScript (like QuickCheck)

Index

Variables

Functions

Classes

Interfaces

Enums

Type Aliases

Namespaces

Variables

variable asyncToStringMethod

const asyncToStringMethod: Symbol;
  • Use this symbol to define a custom serializer for your instances. Serializer must be a function returning a promise of string (see WithAsyncToStringMethod).

    Please note that: 1. It will only be useful for asynchronous properties. 2. It has to return barely instantly.

    Remarks

    Since 2.17.0

    Modifiers

    • @public

variable cloneMethod

const cloneMethod: Symbol;
  • Generated instances having a method [cloneMethod] will be automatically cloned whenever necessary

    This is pretty useful for statefull generated values. For instance, whenever you use a Stream you directly impact it. Implementing [cloneMethod] on the generated Stream would force the framework to clone it whenever it has to re-use it (mainly required for chrinking process)

    Remarks

    Since 1.8.0

    Modifiers

    • @public

variable toStringMethod

const toStringMethod: Symbol;
  • Use this symbol to define a custom serializer for your instances. Serializer must be a function returning a string (see WithToStringMethod).

    Remarks

    Since 2.17.0

    Modifiers

    • @public

Functions

function anything

anything: {
(): Arbitrary<unknown>;
(constraints: ObjectConstraints): Arbitrary<unknown>;
};
  • For any type of values

    You may use sample to preview the values that will be generated

    Remarks

    Since 0.0.7

    Example 1

    null, undefined, 42, 6.5, 'Hello', {}, {k: [{}, 1, 2]}

    Modifiers

    • @public
  • For any type of values following the constraints defined by settings

    You may use sample to preview the values that will be generated

    Parameter constraints

    Constraints to apply when building instances

    Remarks

    Since 0.0.7

    Example 1

    null, undefined, 42, 6.5, 'Hello', {}, {k: [{}, 1, 2]}

    Example 2

    // Using custom settings
    fc.anything({
    key: fc.char(),
    values: [fc.integer(10,20), fc.constant(42)],
    maxDepth: 2
    });
    // Can build entries such as:
    // - 19
    // - [{"2":12,"k":15,"A":42}]
    // - {"4":[19,13,14,14,42,11,20,11],"6":42,"7":16,"L":10,"'":[20,11],"e":[42,20,42,14,13,17]}
    // - [42,42,42]...

    Modifiers

    • @public

function array

array: <T>(arb: Arbitrary<T>, constraints?: ArrayConstraints) => Arbitrary<T[]>;
  • For arrays of values coming from arb

    Parameter arb

    Arbitrary used to generate the values inside the array

    Parameter constraints

    Constraints to apply when building instances (since 2.4.0)

    Remarks

    Since 0.0.1

    Modifiers

    • @public

function ascii

ascii: () => Arbitrary<string>;
  • For single ascii characters - char code between 0x00 (included) and 0x7f (included)

    Remarks

    Since 0.0.1

    Modifiers

    • @public

function asciiString

asciiString: (constraints?: StringSharedConstraints) => Arbitrary<string>;
  • For strings of ascii

    Parameter constraints

    Constraints to apply when building instances (since 2.4.0)

    Remarks

    Since 0.0.1

    Modifiers

    • @public

function assert

assert: {
<Ts>(property: IAsyncProperty<Ts>, params?: Parameters<Ts>): Promise<void>;
<Ts>(property: IProperty<Ts>, params?: Parameters<Ts>): void;
<Ts>(
property: IRawProperty<Ts, boolean>,
params?: Parameters<Ts>
): void | Promise<void>;
};
  • Run the property, throw in case of failure

    It can be called directly from describe/it blocks of Mocha. No meaningful results are produced in case of success.

    WARNING: Has to be awaited

    Parameter property

    Asynchronous property to be checked

    Parameter params

    Optional parameters to customize the execution

    Remarks

    Since 0.0.7

    Modifiers

    • @public
  • Run the property, throw in case of failure

    It can be called directly from describe/it blocks of Mocha. No meaningful results are produced in case of success.

    Parameter property

    Synchronous property to be checked

    Parameter params

    Optional parameters to customize the execution

    Remarks

    Since 0.0.1

    Modifiers

    • @public
  • Run the property, throw in case of failure

    It can be called directly from describe/it blocks of Mocha. No meaningful results are produced in case of success.

    WARNING: Returns a promise to be awaited if the property is asynchronous

    Parameter property

    Synchronous or asynchronous property to be checked

    Parameter params

    Optional parameters to customize the execution

    Remarks

    Since 0.0.7

    Modifiers

    • @public

function asyncDefaultReportMessage

asyncDefaultReportMessage: {
<Ts>(out: RunDetails<Ts> & { failed: false }): Promise<undefined>;
<Ts>(
out:
| (RunDetailsFailureProperty<Ts> & { failed: true })
| (RunDetailsFailureTooManySkips<Ts> & { failed: true })
| (RunDetailsFailureInterrupted<Ts> & { failed: true })
): Promise<string>;
<Ts>(out: RunDetails<Ts>): Promise<string>;
};
  • Format output of check using the default error reporting of assert

    Produce a string containing the formated error in case of failed run, undefined otherwise.

    Remarks

    Since 2.17.0

    Modifiers

    • @public

function asyncModelRun

asyncModelRun: <
Model extends object,
Real,
CheckAsync extends boolean,
InitialModel extends Model
>(
s: ModelRunSetup<InitialModel, Real> | ModelRunAsyncSetup<InitialModel, Real>,
cmds: Iterable<AsyncCommand<Model, Real, CheckAsync>>
) => Promise<void>;
  • Run asynchronous commands over a Model and the Real system

    Throw in case of inconsistency

    Parameter s

    Initial state provider

    Parameter cmds

    Asynchronous commands to be executed

    Remarks

    Since 1.5.0

    Modifiers

    • @public

function asyncProperty

asyncProperty: <Ts extends [unknown, ...unknown[]]>(
...args: [
...arbitraries: { [K in keyof Ts]: Arbitrary<Ts[K]> },
predicate: (...args: Ts) => Promise<boolean | void>
]
) => IAsyncPropertyWithHooks<Ts>;
  • Instantiate a new fast-check#IAsyncProperty

    Parameter predicate

    Assess the success of the property. Would be considered falsy if it throws or if its output evaluates to false

    Remarks

    Since 0.0.7

    Modifiers

    • @public

function asyncStringify

asyncStringify: <Ts>(value: Ts) => Promise<string>;
  • Convert any value to its fast-check string representation

    This asynchronous version is also able to dig into the status of Promise

    Parameter value

    Value to be converted into a string

    Remarks

    Since 2.17.0

    Modifiers

    • @public

function base64

base64: () => Arbitrary<string>;
  • For single base64 characters - A-Z, a-z, 0-9, + or /

    Remarks

    Since 0.0.1

    Modifiers

    • @public

function base64String

base64String: (constraints?: StringSharedConstraints) => Arbitrary<string>;
  • For base64 strings

    A base64 string will always have a length multiple of 4 (padded with =)

    Parameter constraints

    Constraints to apply when building instances (since 2.4.0)

    Remarks

    Since 0.0.1

    Modifiers

    • @public

function bigInt

bigInt: {
(): Arbitrary<bigint>;
(min: bigint, max: bigint): Arbitrary<bigint>;
(constraints: BigIntConstraints): Arbitrary<bigint>;
};
  • For bigint

    Remarks

    Since 1.9.0

    Modifiers

    • @public
  • For bigint between min (included) and max (included)

    Parameter min

    Lower bound for the generated bigints (eg.: -5n, 0n, BigInt(Number.MIN_SAFE_INTEGER))

    Parameter max

    Upper bound for the generated bigints (eg.: -2n, 2147483647n, BigInt(Number.MAX_SAFE_INTEGER))

    Remarks

    Since 1.9.0

    Modifiers

    • @public
  • For bigint between min (included) and max (included)

    Parameter constraints

    Constraints to apply when building instances

    Remarks

    Since 2.6.0

    Modifiers

    • @public

function bigInt64Array

bigInt64Array: (
constraints?: BigIntArrayConstraints
) => Arbitrary<BigInt64Array>;
  • For BigInt64Array

    Remarks

    Since 3.0.0

    Modifiers

    • @public

function bigIntN

bigIntN: (n: number) => Arbitrary<bigint>;
  • For signed bigint of n bits

    Generated values will be between -2^(n-1) (included) and 2^(n-1) (excluded)

    Parameter n

    Maximal number of bits of the generated bigint

    Remarks

    Since 1.9.0

    Modifiers

    • @public

function bigUint

bigUint: {
(): Arbitrary<bigint>;
(max: bigint): Arbitrary<bigint>;
(constraints: BigUintConstraints): Arbitrary<bigint>;
};
  • For positive bigint

    Remarks

    Since 1.9.0

    Modifiers

    • @public
  • For positive bigint between 0 (included) and max (included)

    Parameter max

    Upper bound for the generated bigint

    Remarks

    Since 1.9.0

    Modifiers

    • @public
  • For positive bigint between 0 (included) and max (included)

    Parameter constraints

    Constraints to apply when building instances

    Remarks

    Since 2.6.0

    Modifiers

    • @public

function bigUint64Array

bigUint64Array: (
constraints?: BigIntArrayConstraints
) => Arbitrary<BigUint64Array>;
  • For BigUint64Array

    Remarks

    Since 3.0.0

    Modifiers

    • @public

function bigUintN

bigUintN: (n: number) => Arbitrary<bigint>;
  • For unsigned bigint of n bits

    Generated values will be between 0 (included) and 2^n (excluded)

    Parameter n

    Maximal number of bits of the generated bigint

    Remarks

    Since 1.9.0

    Modifiers

    • @public

function boolean

boolean: () => Arbitrary<boolean>;
  • For boolean values - true or false

    Remarks

    Since 0.0.6

    Modifiers

    • @public

function char

char: () => Arbitrary<string>;
  • For single printable ascii characters - char code between 0x20 (included) and 0x7e (included)

    https://www.ascii-code.com/

    Remarks

    Since 0.0.1

    Modifiers

    • @public

function char16bits

char16bits: () => Arbitrary<string>;
  • For single characters - all values in 0x0000-0xffff can be generated

    WARNING:

    Some generated characters might appear invalid regarding UCS-2 and UTF-16 encoding. Indeed values within 0xd800 and 0xdfff constitute surrogate pair characters and are illegal without their paired character.

    Remarks

    Since 0.0.11

    Modifiers

    • @public

function check

check: {
<Ts>(property: IAsyncProperty<Ts>, params?: Parameters<Ts>): Promise<
RunDetails<Ts>
>;
<Ts>(property: IProperty<Ts>, params?: Parameters<Ts>): RunDetails<Ts>;
<Ts>(property: IRawProperty<Ts, boolean>, params?: Parameters<Ts>):
| RunDetails<Ts>
| Promise<RunDetails<Ts>>;
};
  • Run the property, do not throw contrary to assert

    WARNING: Has to be awaited

    Parameter property

    Asynchronous property to be checked

    Parameter params

    Optional parameters to customize the execution

    Returns

    Test status and other useful details

    Remarks

    Since 0.0.7

    Modifiers

    • @public
  • Run the property, do not throw contrary to assert

    Parameter property

    Synchronous property to be checked

    Parameter params

    Optional parameters to customize the execution

    Returns

    Test status and other useful details

    Remarks

    Since 0.0.1

    Modifiers

    • @public
  • Run the property, do not throw contrary to assert

    WARNING: Has to be awaited if the property is asynchronous

    Parameter property

    Property to be checked

    Parameter params

    Optional parameters to customize the execution

    Returns

    Test status and other useful details

    Remarks

    Since 0.0.7

    Modifiers

    • @public

function clone

clone: <T, N extends number>(
arb: Arbitrary<T>,
numValues: N
) => Arbitrary<CloneValue<T, N>>;
  • Clone the values generated by arb in order to produce fully equal values (might not be equal in terms of === or ==)

    Parameter arb

    Source arbitrary

    Parameter numValues

    Number of values to produce

    Remarks

    Since 2.5.0

    Modifiers

    • @public

function cloneIfNeeded

cloneIfNeeded: <T>(instance: T) => T;
  • Clone an instance if needed

    Remarks

    Since 2.15.0

    Modifiers

    • @public

function commands

commands: {
<Model extends object, Real, CheckAsync extends boolean>(
commandArbs: Arbitrary<AsyncCommand<Model, Real, CheckAsync>>[],
constraints?: CommandsContraints
): Arbitrary<Iterable<AsyncCommand<Model, Real, CheckAsync>>>;
<Model extends object, Real>(
commandArbs: Arbitrary<Command<Model, Real>>[],
constraints?: CommandsContraints
): Arbitrary<Iterable<Command<Model, Real>>>;
};
  • For arrays of AsyncCommand to be executed by asyncModelRun

    This implementation comes with a shrinker adapted for commands. It should shrink more efficiently than array for AsyncCommand arrays.

    Parameter commandArbs

    Arbitraries responsible to build commands

    Parameter constraints

    Constraints to be applied when generating the commands (since 1.11.0)

    Remarks

    Since 1.5.0

    Modifiers

    • @public
  • For arrays of Command to be executed by modelRun

    This implementation comes with a shrinker adapted for commands. It should shrink more efficiently than array for Command arrays.

    Parameter commandArbs

    Arbitraries responsible to build commands

    Parameter constraints

    Constraints to be applied when generating the commands (since 1.11.0)

    Remarks

    Since 1.5.0

    Modifiers

    • @public

function compareBooleanFunc

compareBooleanFunc: <T>() => Arbitrary<(a: T, b: T) => boolean>;
  • For comparison boolean functions

    A comparison boolean function returns: - true whenever a < b - false otherwise (ie. a = b or a > b)

    Remarks

    Since 1.6.0

    Modifiers

    • @public

function compareFunc

compareFunc: <T>() => Arbitrary<(a: T, b: T) => number>;
  • For comparison functions

    A comparison function returns: - negative value whenever a < b - positive value whenever a > b - zero whenever a and b are equivalent

    Comparison functions are transitive: a < b and b < c => a < c

    They also satisfy: a < b <=> b > a and a = b <=> b = a

    Remarks

    Since 1.6.0

    Modifiers

    • @public

function configureGlobal

configureGlobal: (parameters: GlobalParameters) => void;
  • Define global parameters that will be used by all the runners

    Parameter parameters

    Global parameters

    Remarks

    Since 1.18.0

    Example 1

    fc.configureGlobal({ numRuns: 10 });
    //...
    fc.assert(
    fc.property(
    fc.nat(), fc.nat(),
    (a, b) => a + b === b + a
    ), { seed: 42 }
    ) // equivalent to { numRuns: 10, seed: 42 }

    Modifiers

    • @public

function constant

constant: <T>(value: T) => Arbitrary<T>;
  • For value

    Parameter value

    The value to produce

    Remarks

    Since 0.0.1

    Modifiers

    • @public

function constantFrom

constantFrom: {
<T = never>(...values: T[]): Arbitrary<T>;
<TArgs extends any[] | [any]>(...values: TArgs): Arbitrary<TArgs[number]>;
};
  • For one ...values values - all equiprobable

    **WARNING**: It expects at least one value, otherwise it should throw

    Parameter values

    Constant values to be produced (all values shrink to the first one)

    Remarks

    Since 0.0.12

    Modifiers

    • @public

function context

context: () => Arbitrary<ContextValue>;
  • Produce a ContextValue instance

    Remarks

    Since 1.8.0

    Modifiers

    • @public

function createDepthIdentifier

createDepthIdentifier: () => DepthIdentifier;
  • Create a new and unique instance of DepthIdentifier that can be shared across multiple arbitraries if needed

    Modifiers

    • @public

function date

date: (constraints?: DateConstraints) => Arbitrary<Date>;
  • For date between constraints.min or new Date(-8640000000000000) (included) and constraints.max or new Date(8640000000000000) (included)

    Parameter constraints

    Constraints to apply when building instances

    Remarks

    Since 1.17.0

    Modifiers

    • @public

function defaultReportMessage

defaultReportMessage: {
<Ts>(out: RunDetails<Ts> & { failed: false }): undefined;
<Ts>(
out:
| (RunDetailsFailureProperty<Ts> & { failed: true })
| (RunDetailsFailureTooManySkips<Ts> & { failed: true })
| (RunDetailsFailureInterrupted<Ts> & { failed: true })
): string;
<Ts>(out: RunDetails<Ts>): string;
};
  • Format output of check using the default error reporting of assert

    Produce a string containing the formated error in case of failed run, undefined otherwise.

    Remarks

    Since 1.25.0

    Modifiers

    • @public

function dictionary

dictionary: <T>(
keyArb: Arbitrary<string>,
valueArb: Arbitrary<T>,
constraints?: DictionaryConstraints
) => Arbitrary<Record<string, T>>;
  • For dictionaries with keys produced by keyArb and values from valueArb

    Parameter keyArb

    Arbitrary used to generate the keys of the object

    Parameter valueArb

    Arbitrary used to generate the values of the object

    Remarks

    Since 1.0.0

    Modifiers

    • @public

function domain

domain: (constraints?: DomainConstraints) => Arbitrary<string>;
  • For domains having an extension with at least two lowercase characters

    According to RFC 1034, RFC 1035, RFC 1123 and WHATWG URL Standard

    Parameter constraints

    Constraints to apply when building instances (since 2.22.0)

    Remarks

    Since 1.14.0

    Modifiers

    • @public

function double

double: (constraints?: DoubleConstraints) => Arbitrary<number>;
  • For 64-bit floating point numbers: - sign: 1 bit - significand: 52 bits - exponent: 11 bits

    Parameter constraints

    Constraints to apply when building instances (since 2.8.0)

    Remarks

    Since 0.0.6

    Modifiers

    • @public

function emailAddress

emailAddress: (constraints?: EmailAddressConstraints) => Arbitrary<string>;
  • For email address

    According to RFC 2821, RFC 3696 and RFC 5322

    Parameter constraints

    Constraints to apply when building instances (since 2.22.0)

    Remarks

    Since 1.14.0

    Modifiers

    • @public

function falsy

falsy: <TConstraints extends FalsyContraints>(
constraints?: TConstraints
) => Arbitrary<FalsyValue<TConstraints>>;
  • For falsy values: - '' - 0 - NaN - false - null - undefined - 0n (whenever withBigInt: true)

    Parameter constraints

    Constraints to apply when building instances

    Remarks

    Since 1.26.0

    Modifiers

    • @public

function float

float: (constraints?: FloatConstraints) => Arbitrary<number>;
  • For 32-bit floating point numbers: - sign: 1 bit - significand: 23 bits - exponent: 8 bits

    The smallest non-zero value (in absolute value) that can be represented by such float is: 2 ** -126 * 2 ** -23. And the largest one is: 2 ** 127 * (1 + (2 ** 23 - 1) / 2 ** 23).

    Parameter constraints

    Constraints to apply when building instances (since 2.8.0)

    Remarks

    Since 0.0.6

    Modifiers

    • @public

function float32Array

float32Array: (constraints?: Float32ArrayConstraints) => Arbitrary<Float32Array>;
  • For Float32Array

    Remarks

    Since 2.9.0

    Modifiers

    • @public

function float64Array

float64Array: (constraints?: Float64ArrayConstraints) => Arbitrary<Float64Array>;
  • For Float64Array

    Remarks

    Since 2.9.0

    Modifiers

    • @public

function fullUnicode

fullUnicode: () => Arbitrary<string>;

function fullUnicodeString

fullUnicodeString: (constraints?: StringSharedConstraints) => Arbitrary<string>;
  • For strings of fullUnicode

    Parameter constraints

    Constraints to apply when building instances (since 2.4.0)

    Remarks

    Since 0.0.11

    Modifiers

    • @public

function func

func: <TArgs extends any[], TOut>(
arb: Arbitrary<TOut>
) => Arbitrary<(...args: TArgs) => TOut>;
  • For pure functions

    Parameter arb

    Arbitrary responsible to produce the values

    Remarks

    Since 1.6.0

    Modifiers

    • @public

function gen

gen: () => Arbitrary<GeneratorValue>;
  • Generate values within the test execution itself by leveraging the strength of gen

    Remarks

    Since 3.8.0

    Example 1

    fc.assert(
    fc.property(fc.gen(), gen => {
    const size = gen(fc.nat, {max: 10});
    const array = [];
    for (let index = 0 ; index !== size ; ++index) {
    array.push(gen(fc.integer));
    }
    // Here is an array!
    // Note: Prefer fc.array(fc.integer(), {maxLength: 10}) if you want to produce such array
    })
    )

    ⚠️ WARNING: While gen is easy to use, it may not shrink as well as tailored arbitraries based on filter or map.

    ⚠️ WARNING: Additionally it cannot run back the test properly when attempting to replay based on a seed and a path. You'll need to limit yourself to the seed and drop the path from the options if you attempt to replay something implying it. More precisely, you may keep the very first part of the path but have to drop anything after the first ":".

    ⚠️ WARNING: It also does not support custom examples.

    Modifiers

    • @public

function getDepthContextFor

getDepthContextFor: (
contextMeta: DepthContext | DepthIdentifier | string | undefined
) => DepthContext;
  • Get back the requested DepthContext

    Remarks

    Since 2.25.0

    Modifiers

    • @public

function hasAsyncToStringMethod

hasAsyncToStringMethod: <T>(
instance: T
) => instance is T & WithAsyncToStringMethod;

function hasCloneMethod

hasCloneMethod: <T>(
instance: T | WithCloneMethod<T>
) => instance is WithCloneMethod<T>;
  • Check if an instance has to be clone

    Remarks

    Since 2.15.0

    Modifiers

    • @public

function hash

hash: (repr: string) => number;
  • CRC-32 based hash function

    Used internally by fast-check in func, compareFunc or even compareBooleanFunc.

    Parameter repr

    String value to be hashed

    Remarks

    Since 2.1.0

    Modifiers

    • @public

function hasToStringMethod

hasToStringMethod: <T>(instance: T) => instance is T & WithToStringMethod;

function hexa

hexa: () => Arbitrary<string>;
  • For single hexadecimal characters - 0-9 or a-f

    Remarks

    Since 0.0.1

    Modifiers

    • @public

function hexaString

hexaString: (constraints?: StringSharedConstraints) => Arbitrary<string>;
  • For strings of hexa

    Parameter constraints

    Constraints to apply when building instances (since 2.4.0)

    Remarks

    Since 0.0.1

    Modifiers

    • @public

function infiniteStream

infiniteStream: <T>(arb: Arbitrary<T>) => Arbitrary<Stream<T>>;
  • Produce an infinite stream of values

    WARNING: Requires Object.assign

    Parameter arb

    Arbitrary used to generate the values

    Remarks

    Since 1.8.0

    Modifiers

    • @public

function int16Array

int16Array: (constraints?: IntArrayConstraints) => Arbitrary<Int16Array>;
  • For Int16Array

    Remarks

    Since 2.9.0

    Modifiers

    • @public

function int32Array

int32Array: (constraints?: IntArrayConstraints) => Arbitrary<Int32Array>;
  • For Int32Array

    Remarks

    Since 2.9.0

    Modifiers

    • @public

function int8Array

int8Array: (constraints?: IntArrayConstraints) => Arbitrary<Int8Array>;
  • For Int8Array

    Remarks

    Since 2.9.0

    Modifiers

    • @public

function integer

integer: (constraints?: IntegerConstraints) => Arbitrary<number>;
  • For integers between min (included) and max (included)

    Parameter constraints

    Constraints to apply when building instances (since 2.6.0)

    Remarks

    Since 0.0.1

    Modifiers

    • @public

function ipV4

ipV4: () => Arbitrary<string>;
  • For valid IP v4

    Following RFC 3986

    Remarks

    Since 1.14.0

    Modifiers

    • @public

function ipV4Extended

ipV4Extended: () => Arbitrary<string>;
  • For valid IP v4 according to WhatWG

    Following WhatWG, the specification for web-browsers

    There is no equivalent for IP v6 according to the IP v6 parser

    Remarks

    Since 1.17.0

    Modifiers

    • @public

function ipV6

ipV6: () => Arbitrary<string>;
  • For valid IP v6

    Following RFC 3986

    Remarks

    Since 1.14.0

    Modifiers

    • @public

function json

json: (constraints?: JsonSharedConstraints) => Arbitrary<string>;
  • For any JSON strings

    Keys and string values rely on string

    Parameter constraints

    Constraints to be applied onto the generated instance (since 2.5.0)

    Remarks

    Since 0.0.7

    Modifiers

    • @public

function jsonValue

jsonValue: (constraints?: JsonSharedConstraints) => Arbitrary<JsonValue>;
  • For any JSON compliant values

    Keys and string values rely on string

    As JSON.parse preserves -0, jsonValue can also have -0 as a value. jsonValue must be seen as: any value that could have been built by doing a JSON.parse on a given string.

    Parameter constraints

    Constraints to be applied onto the generated instance

    Remarks

    Since 2.20.0

    Modifiers

    • @public

function letrec

letrec: {
<T>(
builder: T extends Record<string, unknown> ? LetrecTypedBuilder<T> : never
): LetrecValue<T>;
<T>(builder: LetrecLooselyTypedBuilder<T>): LetrecValue<T>;
};
  • For mutually recursive types

    Parameter builder

    Arbitraries builder based on themselves (through tie)

    Remarks

    Since 1.16.0

    Example 1

    type Leaf = number;
    type Node = [Tree, Tree];
    type Tree = Node | Leaf;
    const { tree } = fc.letrec<{ tree: Tree, node: Node, leaf: Leaf }>(tie => ({
    tree: fc.oneof({depthSize: 'small'}, tie('leaf'), tie('node')),
    node: fc.tuple(tie('tree'), tie('tree')),
    leaf: fc.nat()
    }));
    // tree is 50% of node, 50% of leaf
    // the ratio goes in favor of leaves as we go deeper in the tree (thanks to depthSize)

    Modifiers

    • @public
  • For mutually recursive types

    Parameter builder

    Arbitraries builder based on themselves (through tie)

    Remarks

    Since 1.16.0

    Example 1

    const { tree } = fc.letrec(tie => ({
    tree: fc.oneof({depthSize: 'small'}, tie('leaf'), tie('node')),
    node: fc.tuple(tie('tree'), tie('tree')),
    leaf: fc.nat()
    }));
    // tree is 50% of node, 50% of leaf
    // the ratio goes in favor of leaves as we go deeper in the tree (thanks to depthSize)

    Modifiers

    • @public

function lorem

lorem: (constraints?: LoremConstraints) => Arbitrary<string>;
  • For lorem ipsum string of words or sentences with maximal number of words or sentences

    Parameter constraints

    Constraints to be applied onto the generated value (since 2.5.0)

    Remarks

    Since 0.0.1

    Modifiers

    • @public

function mapToConstant

mapToConstant: <T>(
...entries: { num: number; build: (idInGroup: number) => T }[]
) => Arbitrary<T>;
  • Generate non-contiguous ranges of values by mapping integer values to constant

    Parameter options

    Builders to be called to generate the values

    Remarks

    Since 1.14.0

    Example 1

    // generate alphanumeric values (a-z0-9)
    mapToConstant(
    { num: 26, build: v => String.fromCharCode(v + 0x61) },
    { num: 10, build: v => String.fromCharCode(v + 0x30) },
    )

    Modifiers

    • @public

function maxSafeInteger

maxSafeInteger: () => Arbitrary<number>;
  • For integers between Number.MIN_SAFE_INTEGER (included) and Number.MAX_SAFE_INTEGER (included)

    Remarks

    Since 1.11.0

    Modifiers

    • @public

function maxSafeNat

maxSafeNat: () => Arbitrary<number>;
  • For positive integers between 0 (included) and Number.MAX_SAFE_INTEGER (included)

    Remarks

    Since 1.11.0

    Modifiers

    • @public

function memo

memo: <T>(builder: (maxDepth: number) => Arbitrary<T>) => Memo<T>;
  • For mutually recursive types

    Parameter builder

    Arbitrary builder taken the maximal depth allowed as input (parameter n)

    Remarks

    Since 1.16.0

    Example 1

    // tree is 1 / 3 of node, 2 / 3 of leaf
    const tree: fc.Memo<Tree> = fc.memo(n => fc.oneof(node(n), leaf(), leaf()));
    const node: fc.Memo<Tree> = fc.memo(n => {
    if (n <= 1) return fc.record({ left: leaf(), right: leaf() });
    return fc.record({ left: tree(), right: tree() }); // tree() is equivalent to tree(n-1)
    });
    const leaf = fc.nat;

    Modifiers

    • @public

function mixedCase

mixedCase: (
stringArb: Arbitrary<string>,
constraints?: MixedCaseConstraints
) => Arbitrary<string>;
  • Randomly switch the case of characters generated by stringArb (upper/lower)

    WARNING: Require bigint support. Under-the-hood the arbitrary relies on bigint to compute the flags that should be toggled or not.

    Parameter stringArb

    Arbitrary able to build string values

    Parameter constraints

    Constraints to be applied when computing upper/lower case version

    Remarks

    Since 1.17.0

    Modifiers

    • @public

function modelRun

modelRun: <Model extends object, Real, InitialModel extends Model>(
s: ModelRunSetup<InitialModel, Real>,
cmds: Iterable<Command<Model, Real>>
) => void;
  • Run synchronous commands over a Model and the Real system

    Throw in case of inconsistency

    Parameter s

    Initial state provider

    Parameter cmds

    Synchronous commands to be executed

    Remarks

    Since 1.5.0

    Modifiers

    • @public

function nat

nat: {
(): Arbitrary<number>;
(max: number): Arbitrary<number>;
(constraints: NatConstraints): Arbitrary<number>;
};
  • For positive integers between 0 (included) and 2147483647 (included)

    Remarks

    Since 0.0.1

    Modifiers

    • @public
  • For positive integers between 0 (included) and max (included)

    Parameter max

    Upper bound for the generated integers

    Remarks

    Since 0.0.1

    Modifiers

    • @public
  • For positive integers between 0 (included) and max (included)

    Parameter constraints

    Constraints to apply when building instances

    Remarks

    Since 2.6.0

    Modifiers

    • @public

function object

object: {
(): Arbitrary<Record<string, unknown>>;
(constraints: ObjectConstraints): Arbitrary<Record<string, unknown>>;
};
  • For any objects

    You may use sample to preview the values that will be generated

    Remarks

    Since 0.0.7

    Example 1

    {}, {k: [{}, 1, 2]}

    Modifiers

    • @public
  • For any objects following the constraints defined by settings

    You may use sample to preview the values that will be generated

    Parameter constraints

    Constraints to apply when building instances

    Remarks

    Since 0.0.7

    Example 1

    {}, {k: [{}, 1, 2]}

    Modifiers

    • @public

function oneof

oneof: {
<Ts extends MaybeWeightedArbitrary<unknown>[]>(...arbs: Ts): Arbitrary<
OneOfValue<Ts>
>;
<Ts extends MaybeWeightedArbitrary<unknown>[]>(
constraints: OneOfConstraints,
...arbs: Ts
): Arbitrary<OneOfValue<Ts>>;
};
  • For one of the values generated by ...arbs - with all ...arbs equiprobable

    **WARNING**: It expects at least one arbitrary

    Parameter arbs

    Arbitraries that might be called to produce a value

    Remarks

    Since 0.0.1

    Modifiers

    • @public
  • For one of the values generated by ...arbs - with all ...arbs equiprobable

    **WARNING**: It expects at least one arbitrary

    Parameter constraints

    Constraints to be applied when generating the values

    Parameter arbs

    Arbitraries that might be called to produce a value

    Remarks

    Since 2.14.0

    Modifiers

    • @public

function option

option: <T, TNil = null>(
arb: Arbitrary<T>,
constraints?: OptionConstraints<TNil>
) => Arbitrary<T | TNil>;
  • For either nil or a value coming from arb with custom frequency

    Parameter arb

    Arbitrary that will be called to generate a non nil value

    Parameter constraints

    Constraints on the option(since 1.17.0)

    Remarks

    Since 0.0.6

    Modifiers

    • @public

function pre

pre: (expectTruthy: boolean) => asserts expectTruthy;
  • Add pre-condition checks inside a property execution

    Parameter expectTruthy

    cancel the run whenever this value is falsy

    Remarks

    Since 1.3.0

    Modifiers

    • @public

function property

property: <Ts extends [unknown, ...unknown[]]>(
...args: [
...arbitraries: { [K in keyof Ts]: Arbitrary<Ts[K]> },
predicate: (...args: Ts) => boolean | void
]
) => IPropertyWithHooks<Ts>;
  • Instantiate a new fast-check#IProperty

    Parameter predicate

    Assess the success of the property. Would be considered falsy if it throws or if its output evaluates to false

    Remarks

    Since 0.0.1

    Modifiers

    • @public

function readConfigureGlobal

readConfigureGlobal: () => GlobalParameters;
  • Read global parameters that will be used by runners

    Remarks

    Since 1.18.0

    Modifiers

    • @public

function record

record: {
<T>(recordModel: { [K in keyof T]: Arbitrary<T[K]> }): Arbitrary<{
[K in keyof T]: T[K];
}>;
<T, TConstraints extends RecordConstraints<keyof T>>(
recordModel: { [K in keyof T]: Arbitrary<T[K]> },
constraints: TConstraints
): Arbitrary<RecordValue<{ [K in keyof T]: T[K] }, TConstraints>>;
};
  • For records following the recordModel schema

    Parameter recordModel

    Schema of the record

    Remarks

    Since 0.0.12

    Example 1

    record({ x: someArbitraryInt, y: someArbitraryInt }): Arbitrary<{x:number,y:number}>
    // merge two integer arbitraries to produce a {x, y} record

    Modifiers

    • @public
  • For records following the recordModel schema

    Parameter recordModel

    Schema of the record

    Parameter constraints

    Contraints on the generated record

    Remarks

    Since 0.0.12

    Example 1

    record({ x: someArbitraryInt, y: someArbitraryInt }, {withDeletedKeys: true}): Arbitrary<{x?:number,y?:number}>
    // merge two integer arbitraries to produce a {x, y}, {x}, {y} or {} record

    Modifiers

    • @public

function resetConfigureGlobal

resetConfigureGlobal: () => void;
  • Reset global parameters

    Remarks

    Since 1.18.0

    Modifiers

    • @public

function sample

sample: <Ts>(
generator: IRawProperty<Ts> | Arbitrary<Ts>,
params?: Parameters<Ts> | number
) => Ts[];
  • Generate an array containing all the values that would have been generated during assert or check

    Parameter generator

    IProperty or Arbitrary to extract the values from

    Parameter params

    Integer representing the number of values to generate or Parameters as in assert

    Remarks

    Since 0.0.6

    Example 1

    fc.sample(fc.nat(), 10); // extract 10 values from fc.nat() Arbitrary
    fc.sample(fc.nat(), {seed: 42}); // extract values from fc.nat() as if we were running fc.assert with seed=42

    Modifiers

    • @public

function scheduledModelRun

scheduledModelRun: <
Model extends object,
Real,
CheckAsync extends boolean,
InitialModel extends Model
>(
scheduler: Scheduler,
s: ModelRunSetup<InitialModel, Real> | ModelRunAsyncSetup<InitialModel, Real>,
cmds: Iterable<AsyncCommand<Model, Real, CheckAsync>>
) => Promise<void>;
  • Run asynchronous and scheduled commands over a Model and the Real system

    Throw in case of inconsistency

    Parameter scheduler

    Scheduler

    Parameter s

    Initial state provider

    Parameter cmds

    Asynchronous commands to be executed

    Remarks

    Since 1.24.0

    Modifiers

    • @public

function scheduler

scheduler: <TMetaData = unknown>(
constraints?: SchedulerConstraints
) => Arbitrary<Scheduler<TMetaData>>;
  • For scheduler of promises

    Remarks

    Since 1.20.0

    Modifiers

    • @public

function schedulerFor

schedulerFor: {
<TMetaData = unknown>(constraints?: SchedulerConstraints): (
_strs: TemplateStringsArray,
...ordering: number[]
) => Scheduler<TMetaData>;
<TMetaData = unknown>(
customOrdering: number[],
constraints?: SchedulerConstraints
): Scheduler<TMetaData>;
};
  • For custom scheduler with predefined resolution order

    Ordering is defined by using a template string like the one generated in case of failure of a scheduler

    It may be something like:

    Remarks

    Since 1.25.0

    Example 1

    fc.schedulerFor()`
    -> [task\${2}] promise pending
    -> [task\${3}] promise pending
    -> [task\${1}] promise pending
    `

    Or more generally:

    fc.schedulerFor()`
    This scheduler will resolve task ${2} first
    followed by ${3} and only then task ${1}
    `

    WARNING: Custom scheduler will neither check that all the referred promises have been scheduled nor that they resolved with the same status and value.

    WARNING: If one the promises is wrongly defined it will fail - for instance asking to resolve 5 while 5 does not exist.

    Modifiers

    • @public
  • For custom scheduler with predefined resolution order

    WARNING: Custom scheduler will not check that all the referred promises have been scheduled.

    WARNING: If one the promises is wrongly defined it will fail - for instance asking to resolve 5 while 5 does not exist.

    Parameter customOrdering

    Array defining in which order the promises will be resolved. Id of the promises start at 1. 1 means first scheduled promise, 2 second scheduled promise and so on.

    Remarks

    Since 1.25.0

    Modifiers

    • @public

function shuffledSubarray

shuffledSubarray: <T>(
originalArray: T[],
constraints?: ShuffledSubarrayConstraints
) => Arbitrary<T[]>;
  • For subarrays of originalArray

    Parameter originalArray

    Original array

    Parameter constraints

    Constraints to apply when building instances (since 2.4.0)

    Remarks

    Since 1.5.0

    Modifiers

    • @public

function sparseArray

sparseArray: <T>(
arb: Arbitrary<T>,
constraints?: SparseArrayConstraints
) => Arbitrary<T[]>;
  • For sparse arrays of values coming from arb

    Parameter arb

    Arbitrary used to generate the values inside the sparse array

    Parameter constraints

    Constraints to apply when building instances

    Remarks

    Since 2.13.0

    Modifiers

    • @public

function statistics

statistics: <Ts>(
generator: IRawProperty<Ts> | Arbitrary<Ts>,
classify: (v: Ts) => string | string[],
params?: Parameters<Ts> | number
) => void;
  • Gather useful statistics concerning generated values

    Print the result in console.log or params.logger (if defined)

    Parameter generator

    IProperty or Arbitrary to extract the values from

    Parameter classify

    Classifier function that can classify the generated value in zero, one or more categories (with free labels)

    Parameter params

    Integer representing the number of values to generate or Parameters as in assert

    Remarks

    Since 0.0.6

    Example 1

    fc.statistics(
    fc.nat(999),
    v => v < 100 ? 'Less than 100' : 'More or equal to 100',
    {numRuns: 1000, logger: console.log});
    // Classify 1000 values generated by fc.nat(999) into two categories:
    // - Less than 100
    // - More or equal to 100
    // The output will be sent line by line to the logger

    Modifiers

    • @public

function stream

stream: <T>(g: IterableIterator<T>) => Stream<T>;
  • Create a Stream based on g

    Parameter g

    Underlying data of the Stream

    Remarks

    Since 0.0.7

    Modifiers

    • @public

function string

string: (constraints?: StringSharedConstraints) => Arbitrary<string>;
  • For strings of char

    Parameter constraints

    Constraints to apply when building instances (since 2.4.0)

    Remarks

    Since 0.0.1

    Modifiers

    • @public

function string16bits

string16bits: (constraints?: StringSharedConstraints) => Arbitrary<string>;
  • For strings of char16bits

    Parameter constraints

    Constraints to apply when building instances (since 2.4.0)

    Remarks

    Since 0.0.11

    Modifiers

    • @public

function stringify

stringify: <Ts>(value: Ts) => string;
  • Convert any value to its fast-check string representation

    Parameter value

    Value to be converted into a string

    Remarks

    Since 1.15.0

    Modifiers

    • @public

function stringMatching

stringMatching: (
regex: RegExp,
constraints?: StringMatchingConstraints
) => Arbitrary<string>;
  • For strings matching the provided regex

    Parameter regex

    Arbitrary able to generate random strings (possibly multiple characters)

    Parameter constraints

    Constraints to apply when building instances

    Remarks

    Since 3.10.0

    Modifiers

    • @public

function stringOf

stringOf: (
charArb: Arbitrary<string>,
constraints?: StringSharedConstraints
) => Arbitrary<string>;
  • For strings using the characters produced by charArb

    Parameter charArb

    Arbitrary able to generate random strings (possibly multiple characters)

    Parameter constraints

    Constraints to apply when building instances (since 2.4.0)

    Remarks

    Since 1.1.3

    Modifiers

    • @public

function subarray

subarray: <T>(
originalArray: T[],
constraints?: SubarrayConstraints
) => Arbitrary<T[]>;
  • For subarrays of originalArray (keeps ordering)

    Parameter originalArray

    Original array

    Parameter constraints

    Constraints to apply when building instances (since 2.4.0)

    Remarks

    Since 1.5.0

    Modifiers

    • @public

function tuple

tuple: <Ts extends unknown[]>(
...arbs: { [K in keyof Ts]: Arbitrary<Ts[K]> }
) => Arbitrary<Ts>;
  • For tuples produced using the provided arbs

    Parameter arbs

    Ordered list of arbitraries

    Remarks

    Since 0.0.1

    Modifiers

    • @public

function uint16Array

uint16Array: (constraints?: IntArrayConstraints) => Arbitrary<Uint16Array>;
  • For Uint16Array

    Remarks

    Since 2.9.0

    Modifiers

    • @public

function uint32Array

uint32Array: (constraints?: IntArrayConstraints) => Arbitrary<Uint32Array>;
  • For Uint32Array

    Remarks

    Since 2.9.0

    Modifiers

    • @public

function uint8Array

uint8Array: (constraints?: IntArrayConstraints) => Arbitrary<Uint8Array>;
  • For Uint8Array

    Remarks

    Since 2.9.0

    Modifiers

    • @public

function uint8ClampedArray

uint8ClampedArray: (
constraints?: IntArrayConstraints
) => Arbitrary<Uint8ClampedArray>;
  • For Uint8ClampedArray

    Remarks

    Since 2.9.0

    Modifiers

    • @public

function ulid

ulid: () => Arbitrary<string>;
  • For ulid

    According to ulid spec

    No mixed case, only upper case digits (0-9A-Z except for: I,L,O,U)

    Remarks

    Since 3.11.0

    Modifiers

    • @public

function unicode

unicode: () => Arbitrary<string>;
  • For single unicode characters defined in the BMP plan - char code between 0x0000 (included) and 0xffff (included) and without the range 0xd800 to 0xdfff (surrogate pair characters)

    Remarks

    Since 0.0.11

    Modifiers

    • @public

function unicodeJson

unicodeJson: (constraints?: UnicodeJsonSharedConstraints) => Arbitrary<string>;
  • For any JSON strings with unicode support

    Keys and string values rely on unicode

    Parameter constraints

    Constraints to be applied onto the generated instance (since 2.5.0)

    Remarks

    Since 0.0.7

    Modifiers

    • @public

    Deprecated

    Prefer using json with noUnicodeString: false, it will generate even more unicode strings: includings some having characters outside of BMP plan

function unicodeJsonValue

unicodeJsonValue: (
constraints?: UnicodeJsonSharedConstraints
) => Arbitrary<JsonValue>;
  • For any JSON compliant values with unicode support

    Keys and string values rely on unicode

    As JSON.parse preserves -0, unicodeJsonValue can also have -0 as a value. unicodeJsonValue must be seen as: any value that could have been built by doing a JSON.parse on a given string.

    Parameter constraints

    Constraints to be applied onto the generated instance

    Remarks

    Since 2.20.0

    Modifiers

    • @public

    Deprecated

    Prefer using jsonValue with noUnicodeString: false, it will generate even more unicode strings: includings some having characters outside of BMP plan

function unicodeString

unicodeString: (constraints?: StringSharedConstraints) => Arbitrary<string>;
  • For strings of unicode

    Parameter constraints

    Constraints to apply when building instances (since 2.4.0)

    Remarks

    Since 0.0.11

    Modifiers

    • @public

function uniqueArray

uniqueArray: {
<T, U>(
arb: Arbitrary<T>,
constraints?: UniqueArrayConstraintsRecommended<T, U>
): Arbitrary<T[]>;
<T>(
arb: Arbitrary<T>,
constraints: UniqueArrayConstraintsCustomCompare<T>
): Arbitrary<T[]>;
<T, U>(
arb: Arbitrary<T>,
constraints: UniqueArrayConstraintsCustomCompareSelect<T, U>
): Arbitrary<T[]>;
<T, U>(arb: Arbitrary<T>, constraints: UniqueArrayConstraints<T, U>): Arbitrary<
T[]
>;
};
  • For arrays of unique values coming from arb

    Parameter arb

    Arbitrary used to generate the values inside the array

    Parameter constraints

    Constraints to apply when building instances

    Remarks

    Since 2.23.0

    Modifiers

    • @public

function uuid

uuid: () => Arbitrary<string>;
  • For UUID from v1 to v5

    According to RFC 4122

    No mixed case, only lower case digits (0-9a-f)

    Remarks

    Since 1.17.0

    Modifiers

    • @public

function uuidV

uuidV: (versionNumber: 1 | 2 | 3 | 4 | 5) => Arbitrary<string>;
  • For UUID of a given version (in v1 to v5)

    According to RFC 4122

    No mixed case, only lower case digits (0-9a-f)

    Remarks

    Since 1.17.0

    Modifiers

    • @public

function webAuthority

webAuthority: (constraints?: WebAuthorityConstraints) => Arbitrary<string>;
  • For web authority

    According to RFC 3986 - authority = [ userinfo "@" ] host [ ":" port ]

    Parameter constraints

    Constraints to apply when building instances

    Remarks

    Since 1.14.0

    Modifiers

    • @public

function webFragments

webFragments: (constraints?: WebFragmentsConstraints) => Arbitrary<string>;
  • For fragments of an URI (web included)

    According to RFC 3986

    eg.: In the url https://domain/plop?page=1#hello=1&world=2, ?hello=1&world=2 are query parameters

    Parameter constraints

    Constraints to apply when building instances (since 2.22.0)

    Remarks

    Since 1.14.0

    Modifiers

    • @public

function webPath

webPath: (constraints?: WebPathConstraints) => Arbitrary<string>;
  • For web path

    According to RFC 3986 and WHATWG URL Standard

    Parameter constraints

    Constraints to apply when building instances

    Remarks

    Since 3.3.0

    Modifiers

    • @public

function webQueryParameters

webQueryParameters: (
constraints?: WebQueryParametersConstraints
) => Arbitrary<string>;
  • For query parameters of an URI (web included)

    According to RFC 3986

    eg.: In the url https://domain/plop/?hello=1&world=2, ?hello=1&world=2 are query parameters

    Parameter constraints

    Constraints to apply when building instances (since 2.22.0)

    Remarks

    Since 1.14.0

    Modifiers

    • @public

function webSegment

webSegment: (constraints?: WebSegmentConstraints) => Arbitrary<string>;
  • For internal segment of an URI (web included)

    According to RFC 3986

    eg.: In the url https://github.com/dubzzz/fast-check/, dubzzz and fast-check are segments

    Parameter constraints

    Constraints to apply when building instances (since 2.22.0)

    Remarks

    Since 1.14.0

    Modifiers

    • @public

function webUrl

webUrl: (constraints?: WebUrlConstraints) => Arbitrary<string>;
  • For web url

    According to RFC 3986 and WHATWG URL Standard

    Parameter constraints

    Constraints to apply when building instances

    Remarks

    Since 1.14.0

    Modifiers

    • @public

Classes

class Arbitrary

abstract class Arbitrary<T> {}
  • 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

    Modifiers

    • @public

method canShrinkWithoutContext

abstract canShrinkWithoutContext: (value: unknown) => value is T;
  • 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.

    Parameter value

    Value to be assessed

    Returns

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

    Remarks

    Since 3.0.0

method chain

chain: <U>(chainer: (t: T) => Arbitrary<U>) => Arbitrary<U>;
  • 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

    Parameter chainer

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

    Returns

    New arbitrary of new type

    Remarks

    Since 1.2.0

    Example 1

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

method filter

filter: {
<U extends T>(refinement: (t: T) => t is U): Arbitrary<U>;
(predicate: (t: T) => boolean): Arbitrary<T>;
};
  • 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

    Parameter refinement

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

    Returns

    New arbitrary filtered using predicate

    Remarks

    Since 1.23.0

    Example 1

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

  • 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

    Parameter predicate

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

    Returns

    New arbitrary filtered using predicate

    Remarks

    Since 0.0.1

    Example 1

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

method generate

abstract generate: (mrng: Random, biasFactor: number | undefined) => Value<T>;
  • Generate a value of type T along with its context (if any) based on the provided random number generator

    Parameter mrng

    Random number generator

    Parameter biasFactor

    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

    Random value of type T and its context

    Remarks

    Since 0.0.1 (return type changed in 3.0.0)

method map

map: <U>(
mapper: (t: T) => U,
unmapper?: (possiblyU: unknown) => T
) => Arbitrary<U>;
  • 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

    Parameter mapper

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

    Parameter unmapper

    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)

    Returns

    New arbitrary with mapped elements

    Remarks

    Since 0.0.1

    Example 1

    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'

method noBias

noBias: () => Arbitrary<T>;
  • Create another Arbitrary that cannot be biased

    Parameter freq

    The biased version will be used one time over freq - if it exists

    Remarks

    Since 1.1.0

method noShrink

noShrink: () => Arbitrary<T>;
  • Create another Arbitrary with no shrink values

    Returns

    Create another arbitrary with no shrink values

    Remarks

    Since 0.0.9

    Example 1

    const dataGenerator: Arbitrary<string> = ...;
    const unshrinkableDataGenerator: Arbitrary<string> = dataGenerator.noShrink();
    // same values no shrink

method shrink

abstract shrink: (value: T, context: unknown | undefined) => Stream<Value<T>>;
  • 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.

    Parameter value

    The value to shrink

    Parameter context

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

    Returns

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

    Remarks

    Since 3.0.0

class PreconditionFailure

class PreconditionFailure extends Error {}
  • Error type produced whenever a precondition fails

    Remarks

    Since 2.2.0

    Modifiers

    • @public

constructor

constructor(interruptExecution?: boolean);

    property interruptExecution

    readonly interruptExecution: boolean;

      method isFailure

      static isFailure: (err: unknown) => err is PreconditionFailure;

        class Random

        class Random {}
        • Wrapper around an instance of a pure-rand's random number generator offering a simpler interface to deal with random with impure patterns

          Modifiers

          • @public

        constructor

        constructor(sourceRng: RandomGenerator);
        • Create a mutable random number generator by cloning the passed one and mutate it

          Parameter sourceRng

          Immutable random generator from pure-rand library, will not be altered (a clone will be)

        method clone

        clone: () => Random;
        • Clone the random number generator

        method getState

        getState: () => readonly number[] | undefined;
        • Extract the internal state of the internal RandomGenerator backing the current instance of Random

        method next

        next: (bits: number) => number;
        • Generate an integer having bits random bits

          Parameter bits

          Number of bits to generate

        method nextArrayInt

        nextArrayInt: (
        min: { sign: 1 | -1; data: number[] },
        max: { sign: 1 | -1; data: number[] }
        ) => { sign: 1 | -1; data: number[] };
        • Generate a random ArrayInt between min (included) and max (included)

          Parameter min

          Minimal ArrayInt value

          Parameter max

          Maximal ArrayInt value

        method nextBigInt

        nextBigInt: (min: bigint, max: bigint) => bigint;
        • Generate a random bigint between min (included) and max (included)

          Parameter min

          Minimal bigint value

          Parameter max

          Maximal bigint value

        method nextBoolean

        nextBoolean: () => boolean;
        • Generate a random boolean

        method nextDouble

        nextDouble: () => number;
        • Generate a random floating point number between 0.0 (included) and 1.0 (excluded)

        method nextInt

        nextInt: { (): number; (min: number, max: number): number };
        • Generate a random integer (32 bits)

        • Generate a random integer between min (included) and max (included)

          Parameter min

          Minimal integer value

          Parameter max

          Maximal integer value

        class Stream

        class Stream<T> implements IterableIterator<T> {}
        • Wrapper around IterableIterator interface offering a set of helpers to deal with iterations in a simple way

          Remarks

          Since 0.0.7

          Modifiers

          • @public

        constructor

        constructor(g: IterableIterator<T>);
        • Create a Stream based on g

          Parameter g

          Underlying data of the Stream

        method [safeSymbolIterator]

        [safeSymbolIterator]: () => IterableIterator<T>;

          method drop

          drop: (n: number) => Stream<T>;
          • Drop n first elements of the Stream

            WARNING: It closes the current stream

            Parameter n

            Number of elements to drop

            Remarks

            Since 0.0.1

          method dropWhile

          dropWhile: (f: (v: T) => boolean) => Stream<T>;
          • Drop elements from the Stream while f(element) === true

            WARNING: It closes the current stream

            Parameter f

            Drop condition

            Remarks

            Since 0.0.1

          method every

          every: (f: (v: T) => boolean) => boolean;
          • Check whether all elements of the Stream are successful for f

            WARNING: It closes the current stream

            Parameter f

            Condition to check

            Remarks

            Since 0.0.1

          method filter

          filter: {
          <U extends T>(f: (v: T) => v is U): Stream<U>;
          (f: (v: T) => boolean): Stream<T>;
          };
          • Filter elements of the Stream

            WARNING: It closes the current stream

            Parameter f

            Elements to keep

            Remarks

            Since 1.23.0

          • Filter elements of the Stream

            WARNING: It closes the current stream

            Parameter f

            Elements to keep

            Remarks

            Since 0.0.1

          method flatMap

          flatMap: <U>(f: (v: T) => IterableIterator<U>) => Stream<U>;
          • Flat map all elements of the Stream using f

            WARNING: It closes the current stream

            Parameter f

            Mapper function

            Remarks

            Since 0.0.1

          method getNthOrLast

          getNthOrLast: (nth: number) => T | null;
          • Take the nth element of the Stream of the last (if it does not exist)

            WARNING: It closes the current stream

            Parameter nth

            Position of the element to extract

            Remarks

            Since 0.0.12

          method has

          has: (f: (v: T) => boolean) => [boolean, T | null];
          • Check whether one of the elements of the Stream is successful for f

            WARNING: It closes the current stream

            Parameter f

            Condition to check

            Remarks

            Since 0.0.1

          method join

          join: (...others: IterableIterator<T>[]) => Stream<T>;
          • Join others Stream to the current Stream

            WARNING: It closes the current stream and the other ones (as soon as it iterates over them)

            Parameter others

            Streams to join to the current Stream

            Remarks

            Since 0.0.1

          method map

          map: <U>(f: (v: T) => U) => Stream<U>;
          • Map all elements of the Stream using f

            WARNING: It closes the current stream

            Parameter f

            Mapper function

            Remarks

            Since 0.0.1

          method next

          next: () => IteratorResult<T>;

            method nil

            static nil: <T>() => Stream<T>;
            • Create an empty stream of T

              Remarks

              Since 0.0.1

            method of

            static of: <T>(...elements: T[]) => Stream<T>;
            • Create a stream of T from a variable number of elements

              Parameter elements

              Elements used to create the Stream

              Remarks

              Since 2.12.0

            method take

            take: (n: number) => Stream<T>;
            • Take n first elements of the Stream

              WARNING: It closes the current stream

              Parameter n

              Number of elements to take

              Remarks

              Since 0.0.1

            method takeWhile

            takeWhile: (f: (v: T) => boolean) => Stream<T>;
            • Take elements from the Stream while f(element) === true

              WARNING: It closes the current stream

              Parameter f

              Take condition

              Remarks

              Since 0.0.1

            class Value

            class Value<T> {}
            • A Value<T, TShrink = T> holds an internal value of type T and its associated context

              Remarks

              Since 3.0.0 (previously called NextValue in 2.15.0)

              Modifiers

              • @public

            constructor

            constructor(value_: {}, context: {}, customGetValue?: () => T);
            • Parameter value_

              Internal value of the shrinkable

              Parameter context

              Context associated to the generated value (useful for shrink)

              Parameter customGetValue

              Limited to internal usages (to ease migration to next), it will be removed on next major

            property context

            readonly context: {};
            • Context for the generated value TODO - Do we want to clone it too?

              Remarks

              2.15.0

            property hasToBeCloned

            readonly hasToBeCloned: boolean;
            • State storing the result of hasCloneMethod If true the value will be cloned each time it gets accessed

              Remarks

              Since 2.15.0

            property value

            readonly value: {};
            • Safe value of the shrinkable Depending on hasToBeCloned it will either be value_ or a clone of it

              Remarks

              Since 2.15.0

            property value_

            readonly value_: {};
            • Internal value of the shrinkable

              Remarks

              Since 2.15.0

            Interfaces

            interface ArrayConstraints

            interface ArrayConstraints {}
            • Constraints to be applied on array

              Remarks

              Since 2.4.0

              Modifiers

              • @public

            property depthIdentifier

            depthIdentifier?: DepthIdentifier | string;
            • When receiving a depth identifier, the arbitrary will impact the depth attached to it to avoid going too deep if it already generated lots of items.

              In other words, if the number of generated values within the collection is large then the generated items will tend to be less deep to avoid creating structures a lot larger than expected.

              For the moment, the depth is not taken into account to compute the number of items to define for a precise generate call of the array. Just applied onto eligible items.

              Remarks

              Since 2.25.0

            property maxLength

            maxLength?: number;
            • Upper bound of the generated array size

              Remarks

              Since 2.4.0

            property minLength

            minLength?: number;
            • Lower bound of the generated array size

              Remarks

              Since 2.4.0

            property size

            size?: SizeForArbitrary;
            • Define how large the generated values should be (at max)

              When used in conjonction with maxLength, size will be used to define the upper bound of the generated array size while maxLength will be used to define and document the general maximal length allowed for this case.

              Remarks

              Since 2.22.0

            interface AsyncCommand

            interface AsyncCommand<
            Model extends object,
            Real,
            CheckAsync extends boolean = false
            > extends ICommand<Model, Real, Promise<void>, CheckAsync> {}
            • Interface that should be implemented in order to define an asynchronous command

              Remarks

              Since 1.5.0

              Modifiers

              • @public

            interface BigIntConstraints

            interface BigIntConstraints {}
            • Constraints to be applied on bigInt

              Remarks

              Since 2.6.0

              Modifiers

              • @public

            property max

            max?: bigint;
            • Upper bound for the generated bigints (eg.: -2n, 2147483647n, BigInt(Number.MAX_SAFE_INTEGER))

              Remarks

              Since 2.6.0

            property min

            min?: bigint;
            • Lower bound for the generated bigints (eg.: -5n, 0n, BigInt(Number.MIN_SAFE_INTEGER))

              Remarks

              Since 2.6.0

            interface BigUintConstraints

            interface BigUintConstraints {}
            • Constraints to be applied on bigUint

              Remarks

              Since 2.6.0

              Modifiers

              • @public

            property max

            max?: bigint;
            • Upper bound for the generated bigints (eg.: 2147483647n, BigInt(Number.MAX_SAFE_INTEGER))

              Remarks

              Since 2.6.0

            interface Command

            interface Command<Model extends object, Real> extends ICommand<Model, Real, void> {}
            • Interface that should be implemented in order to define a synchronous command

              Remarks

              Since 1.5.0

              Modifiers

              • @public

            interface CommandsContraints

            interface CommandsContraints {}
            • Parameters for commands

              Remarks

              Since 2.2.0

              Modifiers

              • @public

            property disableReplayLog

            disableReplayLog?: boolean;
            • Do not show replayPath in the output

              Remarks

              Since 1.11.0

            property maxCommands

            maxCommands?: number;
            • Maximal number of commands to generate per run

              You probably want to use size instead.

              Remarks

              Since 1.11.0

            property replayPath

            replayPath?: string;
            • Hint for replay purposes only

              Should be used in conjonction with { seed, path } of assert

              Remarks

              Since 1.11.0

            property size

            size?: SizeForArbitrary;
            • Define how large the generated values (number of commands) should be (at max)

              Remarks

              Since 2.22.0

            interface ContextValue

            interface ContextValue {}
            • Execution context attached to one predicate run

              Remarks

              Since 2.2.0

              Modifiers

              • @public

            method log

            log: (data: string) => void;
            • Log execution details during a test. Very helpful when troubleshooting failures

              Parameter data

              Data to be logged into the current context

              Remarks

              Since 1.8.0

            method size

            size: () => number;
            • Number of logs already logged into current context

              Remarks

              Since 1.8.0

            interface DateConstraints

            interface DateConstraints {}
            • Constraints to be applied on date

              Remarks

              Since 3.3.0

              Modifiers

              • @public

            property max

            max?: Date;
            • Upper bound of the range (included)

              Remarks

              Since 1.17.0

            property min

            min?: Date;
            • Lower bound of the range (included)

              Remarks

              Since 1.17.0

            property noInvalidDate

            noInvalidDate?: boolean;
            • When set to true, no more "Invalid Date" can be generated.

              Remarks

              Since 3.13.0

            interface DictionaryConstraints

            interface DictionaryConstraints {}
            • Constraints to be applied on dictionary

              Remarks

              Since 2.22.0

              Modifiers

              • @public

            property depthIdentifier

            depthIdentifier?: DepthIdentifier | string;
            • Depth identifier can be used to share the current depth between several instances.

              By default, if not specified, each instance of dictionary will have its own depth. In other words: you can have depth=1 in one while you have depth=100 in another one.

              Remarks

              Since 3.15.0

            property maxKeys

            maxKeys?: number;
            • Lower bound for the number of keys defined into the generated instance

              Remarks

              Since 2.22.0

            property minKeys

            minKeys?: number;
            • Lower bound for the number of keys defined into the generated instance

              Remarks

              Since 2.22.0

            property noNullPrototype

            noNullPrototype?: boolean;
            • Do not generate objects with null prototype

              Remarks

              Since 3.13.0

            property size

            size?: SizeForArbitrary;
            • Define how large the generated values should be (at max)

              Remarks

              Since 2.22.0

            interface DomainConstraints

            interface DomainConstraints {}
            • Constraints to be applied on domain

              Remarks

              Since 2.22.0

              Modifiers

              • @public

            property size

            size?: Exclude<SizeForArbitrary, 'max'>;
            • Define how large the generated values should be (at max)

              Remarks

              Since 2.22.0

            interface DoubleConstraints

            interface DoubleConstraints {}
            • Constraints to be applied on double

              Remarks

              Since 2.6.0

              Modifiers

              • @public

            property max

            max?: number;
            • Upper bound for the generated 64-bit floats (included, see maxExcluded to exclude it)

              Remarks

              Since 2.8.0

            property maxExcluded

            maxExcluded?: boolean;
            • Should the upper bound (aka max) be excluded? Note: Excluding max=Number.POSITIVE_INFINITY would result into having max set to Number.MAX_VALUE.

              Remarks

              Since 3.12.0

            property min

            min?: number;
            • Lower bound for the generated 64-bit floats (included, see minExcluded to exclude it)

              Remarks

              Since 2.8.0

            property minExcluded

            minExcluded?: boolean;
            • Should the lower bound (aka min) be excluded? Note: Excluding min=Number.NEGATIVE_INFINITY would result into having min set to -Number.MAX_VALUE.

              Remarks

              Since 3.12.0

            property noDefaultInfinity

            noDefaultInfinity?: boolean;
            • By default, lower and upper bounds are -infinity and +infinity. By setting noDefaultInfinity to true, you move those defaults to minimal and maximal finite values.

              Remarks

              Since 2.8.0

            property noInteger

            noInteger?: boolean;
            • When set to true, Number.isInteger(value) will be false for any generated value. Note: -infinity and +infinity, or NaN can stil be generated except if you rejected them via another constraint.

              Remarks

              Since 3.18.0

            property noNaN

            noNaN?: boolean;
            • When set to true, no more Number.NaN can be generated.

              Remarks

              Since 2.8.0

            interface EmailAddressConstraints

            interface EmailAddressConstraints {}
            • Constraints to be applied on emailAddress

              Remarks

              Since 2.22.0

              Modifiers

              • @public

            property size

            size?: Exclude<SizeForArbitrary, 'max'>;
            • Define how large the generated values should be (at max)

              Remarks

              Since 2.22.0

            interface ExecutionTree

            interface ExecutionTree<Ts> {}
            • Summary of the execution process

              Remarks

              Since 1.9.0

              Modifiers

              • @public

            property children

            children: ExecutionTree<Ts>[];
            • Values derived from this value

              Remarks

              Since 1.9.0

            property status

            status: ExecutionStatus;
            • Status of the property

              Remarks

              Since 1.9.0

            property value

            value: Ts;
            • Generated value

              Remarks

              Since 1.9.0

            interface FalsyContraints

            interface FalsyContraints {}
            • Constraints to be applied on falsy

              Remarks

              Since 1.26.0

              Modifiers

              • @public

            property withBigInt

            withBigInt?: boolean;
            • Enable falsy bigint value

              Remarks

              Since 1.26.0

            interface FloatConstraints

            interface FloatConstraints {}
            • Constraints to be applied on float

              Remarks

              Since 2.6.0

              Modifiers

              • @public

            property max

            max?: number;
            • Upper bound for the generated 32-bit floats (included)

              Remarks

              Since 2.8.0

            property maxExcluded

            maxExcluded?: boolean;
            • Should the upper bound (aka max) be excluded? Note: Excluding max=Number.POSITIVE_INFINITY would result into having max set to 3.4028234663852886e+38.

              Remarks

              Since 3.12.0

            property min

            min?: number;
            • Lower bound for the generated 32-bit floats (included)

              Remarks

              Since 2.8.0

            property minExcluded

            minExcluded?: boolean;
            • Should the lower bound (aka min) be excluded? Note: Excluding min=Number.NEGATIVE_INFINITY would result into having min set to -3.4028234663852886e+38.

              Remarks

              Since 3.12.0

            property noDefaultInfinity

            noDefaultInfinity?: boolean;
            • By default, lower and upper bounds are -infinity and +infinity. By setting noDefaultInfinity to true, you move those defaults to minimal and maximal finite values.

              Remarks

              Since 2.8.0

            property noInteger

            noInteger?: boolean;
            • When set to true, Number.isInteger(value) will be false for any generated value. Note: -infinity and +infinity, or NaN can stil be generated except if you rejected them via another constraint.

              Remarks

              Since 3.18.0

            property noNaN

            noNaN?: boolean;
            • When set to true, no more Number.NaN can be generated.

              Remarks

              Since 2.8.0

            interface IAsyncProperty

            interface IAsyncProperty<Ts> extends IRawProperty<Ts, true> {}
            • Interface for asynchronous property, see IRawProperty

              Remarks

              Since 1.19.0

              Modifiers

              • @public

            interface IAsyncPropertyWithHooks

            interface IAsyncPropertyWithHooks<Ts> extends IAsyncProperty<Ts> {}
            • Interface for asynchronous property defining hooks, see IAsyncProperty

              Remarks

              Since 2.2.0

              Modifiers

              • @public

            method afterEach

            afterEach: (
            hookFunction: AsyncPropertyHookFunction
            ) => IAsyncPropertyWithHooks<Ts>;
            • Define a function that should be called after all calls to the predicate

              Parameter hookFunction

              Function to be called

              Remarks

              Since 1.6.0

            method beforeEach

            beforeEach: (
            hookFunction: AsyncPropertyHookFunction
            ) => IAsyncPropertyWithHooks<Ts>;
            • Define a function that should be called before all calls to the predicate

              Parameter hookFunction

              Function to be called

              Remarks

              Since 1.6.0

            interface ICommand

            interface ICommand<
            Model extends object,
            Real,
            RunResult,
            CheckAsync extends boolean = false
            > {}
            • Interface that should be implemented in order to define a command

              Remarks

              Since 1.5.0

              Modifiers

              • @public

            method check

            check: (
            m: Readonly<Model>
            ) => CheckAsync extends false ? boolean : Promise<boolean>;
            • Check if the model is in the right state to apply the command

              WARNING: does not change the model

              Parameter m

              Model, simplified or schematic representation of real system

              Remarks

              Since 1.5.0

            method run

            run: (m: Model, r: Real) => RunResult;
            • Receive the non-updated model and the real or system under test. Perform the checks post-execution - Throw in case of invalid state. Update the model accordingly

              Parameter m

              Model, simplified or schematic representation of real system

              Parameter r

              Sytem under test

              Remarks

              Since 1.5.0

            method toString

            toString: () => string;
            • Name of the command

              Remarks

              Since 1.5.0

            interface IntegerConstraints

            interface IntegerConstraints {}
            • Constraints to be applied on integer

              Remarks

              Since 2.6.0

              Modifiers

              • @public

            property max

            max?: number;
            • Upper bound for the generated integers (included)

              Remarks

              Since 2.6.0

            property min

            min?: number;
            • Lower bound for the generated integers (included)

              Remarks

              Since 2.6.0

            interface IProperty

            interface IProperty<Ts> extends IRawProperty<Ts, false> {}
            • Interface for synchronous property, see IRawProperty

              Remarks

              Since 1.19.0

              Modifiers

              • @public

            interface IPropertyWithHooks

            interface IPropertyWithHooks<Ts> extends IProperty<Ts> {}
            • Interface for synchronous property defining hooks, see IProperty

              Remarks

              Since 2.2.0

              Modifiers

              • @public

            method afterEach

            afterEach: {
            (
            invalidHookFunction: (
            hookFunction: GlobalPropertyHookFunction
            ) => Promise<unknown>
            ): 'afterEach expects a synchronous function but was given a function returning a Promise';
            (hookFunction: PropertyHookFunction): IPropertyWithHooks<Ts>;
            };
            • Define a function that should be called after all calls to the predicate

              Parameter invalidHookFunction

              Function to be called, please provide a valid hook function

              Remarks

              Since 1.6.0

            • Define a function that should be called after all calls to the predicate

              Parameter hookFunction

              Function to be called

              Remarks

              Since 1.6.0

            method beforeEach

            beforeEach: {
            (
            invalidHookFunction: (
            hookFunction: GlobalPropertyHookFunction
            ) => Promise<unknown>
            ): 'beforeEach expects a synchronous function but was given a function returning a Promise';
            (hookFunction: PropertyHookFunction): IPropertyWithHooks<Ts>;
            };
            • Define a function that should be called before all calls to the predicate

              Parameter invalidHookFunction

              Function to be called, please provide a valid hook function

              Remarks

              Since 1.6.0

            • Define a function that should be called before all calls to the predicate

              Parameter hookFunction

              Function to be called

              Remarks

              Since 1.6.0

            interface IRawProperty

            interface IRawProperty<Ts, IsAsync extends boolean = boolean> {}
            • Property

              A property is the combination of: - Arbitraries: how to generate the inputs for the algorithm - Predicate: how to confirm the algorithm succeeded?

              Remarks

              Since 1.19.0

              Modifiers

              • @public

            property runAfterEach

            runAfterEach?: () =>
            | (IsAsync extends true ? Promise<void> : never)
            | (IsAsync extends false ? void : never);
            • Run after each hook

              Remarks

              Since 3.4.0

            property runBeforeEach

            runBeforeEach?: () =>
            | (IsAsync extends true ? Promise<void> : never)
            | (IsAsync extends false ? void : never);
            • Run before each hook

              Remarks

              Since 3.4.0

            method generate

            generate: (mrng: Random, runId?: number) => Value<Ts>;
            • Generate values of type Ts

              Parameter mrng

              Random number generator

              Parameter runId

              Id of the generation, starting at 0 - if set the generation might be biased

              Remarks

              Since 0.0.7 (return type changed in 3.0.0)

            method isAsync

            isAsync: () => IsAsync;
            • Is the property asynchronous?

              true in case of asynchronous property, false otherwise

              Remarks

              Since 0.0.7

            method run

            run: (
            v: Ts,
            dontRunHook?: boolean
            ) =>
            | (IsAsync extends true
            ? Promise<PreconditionFailure | PropertyFailure | null>
            : never)
            | (IsAsync extends false
            ? PreconditionFailure | PropertyFailure | null
            : never);
            • Check the predicate for v

              Parameter v

              Value of which we want to check the predicate

              Parameter dontRunHook

              Do not run beforeEach and afterEach hooks within run

              Remarks

              Since 0.0.7

            method shrink

            shrink: (value: Value<Ts>) => Stream<Value<Ts>>;
            • Shrink value of type Ts

              Parameter value

              The value to be shrunk, it can be context-less

              Remarks

              Since 3.0.0

            interface JsonSharedConstraints

            interface JsonSharedConstraints {}
            • Shared constraints for: - json, - jsonValue,

              Remarks

              Since 2.5.0

              Modifiers

              • @public

            property depthSize

            depthSize?: DepthSize;
            • Limit the depth of the object by increasing the probability to generate simple values (defined via values) as we go deeper in the object.

              Remarks

              Since 2.20.0

            property maxDepth

            maxDepth?: number;
            • Maximal depth allowed

              Remarks

              Since 2.5.0

            property noUnicodeString

            noUnicodeString?: boolean;
            • Only generate instances having keys and values made of ascii strings (when true)

              Remarks

              Since 3.19.0

            interface LetrecTypedTie

            interface LetrecTypedTie<T> {}
            • Strongly typed type for the tie function passed by letrec to the builder function we pass to it. You may want also want to use its loosely typed version LetrecLooselyTypedTie.

              Remarks

              Since 3.0.0

              Modifiers

              • @public

            call signature

            <K extends keyof T>(key: K): Arbitrary<T[K]>;

              call signature

              (key: string): Arbitrary<unknown>;

                interface LoremConstraints

                interface LoremConstraints {}
                • Constraints to be applied on lorem

                  Remarks

                  Since 2.5.0

                  Modifiers

                  • @public

                property maxCount

                maxCount?: number;
                • Maximal number of entities: - maximal number of words in case mode is 'words' - maximal number of sentences in case mode is 'sentences'

                  Remarks

                  Since 2.5.0

                property mode

                mode?: 'words' | 'sentences';
                • Type of strings that should be produced by lorem: - words: multiple words - sentences: multiple sentences

                  Remarks

                  Since 2.5.0

                property size

                size?: SizeForArbitrary;
                • Define how large the generated values should be (at max)

                  Remarks

                  Since 2.22.0

                interface MixedCaseConstraints

                interface MixedCaseConstraints {}
                • Constraints to be applied on mixedCase

                  Remarks

                  Since 1.17.0

                  Modifiers

                  • @public

                property toggleCase

                toggleCase?: (rawChar: string) => string;
                • Transform a character to its upper and/or lower case version

                  Remarks

                  Since 1.17.0

                property untoggleAll

                untoggleAll?: (toggledString: string) => string;
                • In order to be fully reversable (only in case you want to shrink user definable values) you should provide a function taking a string containing possibly toggled items and returning its untoggled version.

                interface NatConstraints

                interface NatConstraints {}
                • Constraints to be applied on nat

                  Remarks

                  Since 2.6.0

                  Modifiers

                  • @public

                property max

                max?: number;
                • Upper bound for the generated postive integers (included)

                  Remarks

                  Since 2.6.0

                interface ObjectConstraints

                interface ObjectConstraints {}

                property depthSize

                depthSize?: DepthSize;
                • Limit the depth of the object by increasing the probability to generate simple values (defined via values) as we go deeper in the object.

                  Remarks

                  Since 2.20.0

                property key

                key?: Arbitrary<string>;
                • Arbitrary for keys

                  Remarks

                  Since 0.0.7

                property maxDepth

                maxDepth?: number;
                • Maximal depth allowed

                  Remarks

                  Since 0.0.7

                property maxKeys

                maxKeys?: number;
                • Maximal number of keys

                  Remarks

                  Since 1.13.0

                property size

                size?: SizeForArbitrary;
                • Define how large the generated values should be (at max)

                  Remarks

                  Since 2.22.0

                property values

                values?: Arbitrary<unknown>[];
                • Arbitrary for values

                  Remarks

                  Since 0.0.7

                property withBigInt

                withBigInt?: boolean;
                • Also generate BigInt

                  Remarks

                  Since 1.26.0

                property withBoxedValues

                withBoxedValues?: boolean;
                • Also generate boxed versions of values

                  Remarks

                  Since 1.11.0

                property withDate

                withDate?: boolean;
                • Also generate Date

                  Remarks

                  Since 2.5.0

                property withMap

                withMap?: boolean;
                • Also generate Map

                  Remarks

                  Since 1.11.0

                property withNullPrototype

                withNullPrototype?: boolean;
                • Also generate object with null prototype

                  Remarks

                  Since 1.23.0

                property withObjectString

                withObjectString?: boolean;
                • Also generate string representations of object instances

                  Remarks

                  Since 1.17.0

                property withSet

                withSet?: boolean;
                • Also generate Set

                  Remarks

                  Since 1.11.0

                property withSparseArray

                withSparseArray?: boolean;
                • Also generate sparse arrays (arrays with holes)

                  Remarks

                  Since 2.13.0

                property withTypedArray

                withTypedArray?: boolean;
                • Also generate typed arrays in: (Uint|Int)(8|16|32)Array and Float(32|64)Array Remark: no typed arrays made of bigint

                  Remarks

                  Since 2.9.0

                property withUnicodeString

                withUnicodeString?: boolean;
                • Replace the arbitrary of strings defaulted for key and values by one able to generate unicode strings with non-ascii characters. If you override key and/or values constraint, this flag will not apply to your override.

                  Remarks

                  Since 3.19.0

                interface OptionConstraints

                interface OptionConstraints<TNil = null> {}
                • Constraints to be applied on option

                  Remarks

                  Since 2.2.0

                  Modifiers

                  • @public

                property depthIdentifier

                depthIdentifier?: DepthIdentifier | string;
                • Depth identifier can be used to share the current depth between several instances.

                  By default, if not specified, each instance of option will have its own depth. In other words: you can have depth=1 in one while you have depth=100 in another one.

                  Remarks

                  Since 2.14.0

                property depthSize

                depthSize?: DepthSize;
                • While going deeper and deeper within a recursive structure (see letrec), this factor will be used to increase the probability to generate nil.

                  Remarks

                  Since 2.14.0

                property freq

                freq?: number;
                • The probability to build a nil value is of 1 / freq

                  Remarks

                  Since 1.17.0

                property maxDepth

                maxDepth?: number;
                • Maximal authorized depth. Once this depth has been reached only nil will be used.

                  Remarks

                  Since 2.14.0

                property nil

                nil?: TNil;
                • The nil value

                  Remarks

                  Since 1.17.0

                interface Parameters

                interface Parameters<T = void> {}
                • Customization of the parameters used to run the properties

                  Remarks

                  Since 0.0.6

                  Modifiers

                  • @public

                property asyncReporter

                asyncReporter?: (runDetails: RunDetails<T>) => Promise<void>;
                • Replace the default reporter handling errors by a custom one

                  Reporter is responsible to throw in case of failure: default one throws whenever runDetails.failed is true. But you may want to change this behaviour in yours.

                  Only used when calling assert Cannot be defined in conjonction with reporter Not compatible with synchronous properties: runner will throw

                  Remarks

                  Since 1.25.0

                property endOnFailure

                endOnFailure?: boolean;
                • Stop run on failure

                  It makes the run stop at the first encountered failure without shrinking.

                  When used in complement to seed and path, it replays only the minimal counterexample.

                  Remarks

                  Since 1.11.0

                property errorWithCause

                errorWithCause?: boolean;
                • Should the thrown Error include a cause leading to the original Error?

                  In such case the original Error will disappear from the message of the Error thrown by fast-check and only appear within the cause part of it.

                  Remark: At the moment, only node (≥16.14.0) and vitest seem to properly display such errors. Others will just discard the cause at display time.

                property examples

                examples?: T[];
                • Custom values added at the beginning of generated ones

                  It enables users to come with examples they want to test at every run

                  Remarks

                  Since 1.4.0

                property ignoreEqualValues

                ignoreEqualValues?: boolean;
                • Discard runs corresponding to already tried values.

                  WARNING: Discarded runs will not be replaced. In other words, if you ask for 100 runs and have 2 discarded runs you will only have 98 effective runs.

                  NOTE: Relies on fc.stringify to check the equality.

                  Remarks

                  Since 2.14.0

                property interruptAfterTimeLimit

                interruptAfterTimeLimit?: number;
                • Interrupt test execution after a given time limit: disabled by default

                  NOTE: Relies on Date.now().

                  NOTE: Useful to avoid having too long running processes in your CI. Replay capability (see seed, path) can still be used if needed.

                  WARNING: If the test got interrupted before any failure occured and before it reached the requested number of runs specified by numRuns it will be marked as success. Except if markInterruptAsFailure has been set to true

                  Remarks

                  Since 1.19.0

                property markInterruptAsFailure

                markInterruptAsFailure?: boolean;
                • Mark interrupted runs as failed runs if preceded by one success or more: disabled by default Interrupted with no success at all always defaults to failure whatever the value of this flag.

                  Remarks

                  Since 1.19.0

                property maxSkipsPerRun

                maxSkipsPerRun?: number;
                • Maximal number of skipped values per run

                  Skipped is considered globally, so this value is used to compute maxSkips = maxSkipsPerRun * numRuns. Runner will consider a run to have failed if it skipped maxSkips+1 times before having generated numRuns valid entries.

                  See pre for more details on pre-conditions

                  Remarks

                  Since 1.3.0

                property numRuns

                numRuns?: number;
                • Number of runs before success: 100 by default

                  Remarks

                  Since 1.0.0

                property path

                path?: string;
                • Way to replay a failing property directly with the counterexample. It can be fed with the counterexamplePath returned by the failing test (requires seed too).

                  Remarks

                  Since 1.0.0

                property randomType

                randomType?: RandomType | ((seed: number) => RandomGenerator);
                • Random number generator: xorshift128plus by default

                  Random generator is the core element behind the generation of random values - changing it might directly impact the quality and performances of the generation of random values. It can be one of: 'mersenne', 'congruential', 'congruential32', 'xorshift128plus', 'xoroshiro128plus' Or any function able to build a RandomGenerator based on a seed

                  As required since pure-rand v6.0.0, when passing a builder for RandomGenerator, the random number generator must generate values between -0x80000000 and 0x7fffffff.

                  Remarks

                  Since 1.6.0

                property reporter

                reporter?: (runDetails: RunDetails<T>) => void;
                • Replace the default reporter handling errors by a custom one

                  Reporter is responsible to throw in case of failure: default one throws whenever runDetails.failed is true. But you may want to change this behaviour in yours.

                  Only used when calling assert Cannot be defined in conjonction with asyncReporter

                  Remarks

                  Since 1.25.0

                property seed

                seed?: number;
                • Initial seed of the generator: Date.now() by default

                  It can be forced to replay a failed run.

                  In theory, seeds are supposed to be 32-bit integers. In case of double value, the seed will be rescaled into a valid 32-bit integer (eg.: values between 0 and 1 will be evenly spread into the range of possible seeds).

                  Remarks

                  Since 0.0.6

                property skipAllAfterTimeLimit

                skipAllAfterTimeLimit?: number;
                • Skip all runs after a given time limit: disabled by default

                  NOTE: Relies on Date.now().

                  NOTE: Useful to stop too long shrinking processes. Replay capability (see seed, path) can resume the shrinking.

                  WARNING: It skips runs. Thus test might be marked as failed. Indeed, it might not reached the requested number of successful runs.

                  Remarks

                  Since 1.15.0

                property skipEqualValues

                skipEqualValues?: boolean;
                • Skip runs corresponding to already tried values.

                  WARNING: Discarded runs will be retried. Under the hood they are simple calls to fc.pre. In other words, if you ask for 100 runs but your generator can only generate 10 values then the property will fail as 100 runs will never be reached. Contrary to ignoreEqualValues you always have the number of runs you requested.

                  NOTE: Relies on fc.stringify to check the equality.

                  Remarks

                  Since 2.14.0

                property timeout

                timeout?: number;
                • Maximum time in milliseconds for the predicate to answer: disabled by default

                  WARNING: Only works for async code (see asyncProperty), will not interrupt a synchronous code.

                  Remarks

                  Since 0.0.11

                property unbiased

                unbiased?: boolean;
                • Force the use of unbiased arbitraries: biased by default

                  Remarks

                  Since 1.1.0

                property verbose

                verbose?: boolean | VerbosityLevel;
                • Enable verbose mode: VerbosityLevel.None by default

                  Using verbose: true is equivalent to verbose: VerbosityLevel.Verbose

                  It can prove very useful to troubleshoot issues. See VerbosityLevel for more details on each level.

                  Remarks

                  Since 1.1.0

                method logger

                logger: (v: string) => void;
                • Logger (see statistics): console.log by default

                  Remarks

                  Since 0.0.6

                interface RunDetailsCommon

                interface RunDetailsCommon<Ts> {}
                • Shared part between variants of RunDetails

                  Remarks

                  Since 2.2.0

                  Modifiers

                  • @public

                property counterexample

                counterexample: Ts | null;
                • In case of failure: the counterexample contains the minimal failing case (first failure after shrinking)

                  Remarks

                  Since 0.0.7

                property counterexamplePath

                counterexamplePath: string | null;
                • In case of failure: path to the counterexample

                  For replay purposes, it can be forced in assert, check, sample and statistics using Parameters

                  Remarks

                  Since 1.0.0

                property error

                error: string | null;
                • In case of failure: it contains the reason of the failure

                  Remarks

                  Since 0.0.7

                property errorInstance

                errorInstance: unknown | null;
                • In case of failure: it contains the error that has been thrown if any

                  Remarks

                  Since 3.0.0

                property executionSummary

                executionSummary: ExecutionTree<Ts>[];
                • Execution summary of the run

                  Traces the origin of each value encountered during the test and its execution status. Can help to diagnose shrinking issues.

                  You must enable verbose with at least Verbosity.Verbose in Parameters in order to have values in it: - Verbose: Only failures - VeryVerbose: Failures, Successes and Skipped

                  Remarks

                  Since 1.9.0

                property failed

                failed: boolean;
                • Does the property failed during the execution of check?

                  Remarks

                  Since 0.0.7

                property failures

                failures: Ts[];
                • List all failures that have occurred during the run

                  You must enable verbose with at least Verbosity.Verbose in Parameters in order to have values in it

                  Remarks

                  Since 1.1.0

                property interrupted

                interrupted: boolean;
                • Was the execution interrupted?

                  Remarks

                  Since 1.19.0

                property numRuns

                numRuns: number;
                • Number of runs

                  - In case of failed property: Number of runs up to the first failure (including the failure run) - Otherwise: Number of successful executions

                  Remarks

                  Since 1.0.0

                property numShrinks

                numShrinks: number;
                • Number of shrinks required to get to the minimal failing case (aka counterexample)

                  Remarks

                  Since 1.0.0

                property numSkips

                numSkips: number;
                • Number of skipped entries due to failed pre-condition

                  As numRuns it only takes into account the skipped values that occured before the first failure. Refer to pre to add such pre-conditions.

                  Remarks

                  Since 1.3.0

                property runConfiguration

                runConfiguration: Parameters<Ts>;
                • Configuration of the run

                  It includes both local parameters set on check or assert and global ones specified using configureGlobal

                  Remarks

                  Since 1.25.0

                property seed

                seed: number;

                property verbose

                verbose: VerbosityLevel;
                • Verbosity level required by the user

                  Remarks

                  Since 1.9.0

                interface RunDetailsFailureInterrupted

                interface RunDetailsFailureInterrupted<Ts> extends RunDetailsCommon<Ts> {}
                • Run reported as failed because it took too long and thus has been interrupted

                  Refer to RunDetailsCommon for more details

                  Remarks

                  Since 1.25.0

                  Modifiers

                  • @public

                property counterexample

                counterexample: null;

                  property counterexamplePath

                  counterexamplePath: null;

                    property error

                    error: null;

                      property errorInstance

                      errorInstance: null;

                        property failed

                        failed: true;

                          property interrupted

                          interrupted: true;

                            interface RunDetailsFailureProperty

                            interface RunDetailsFailureProperty<Ts> extends RunDetailsCommon<Ts> {}
                            • Run reported as failed because the property failed

                              Refer to RunDetailsCommon for more details

                              Remarks

                              Since 1.25.0

                              Modifiers

                              • @public

                            property counterexample

                            counterexample: Ts;

                              property counterexamplePath

                              counterexamplePath: string;

                                property error

                                error: string;

                                  property errorInstance

                                  errorInstance: unknown;

                                    property failed

                                    failed: true;

                                      property interrupted

                                      interrupted: boolean;

                                        interface RunDetailsFailureTooManySkips

                                        interface RunDetailsFailureTooManySkips<Ts> extends RunDetailsCommon<Ts> {}
                                        • Run reported as failed because too many retries have been attempted to generate valid values

                                          Refer to RunDetailsCommon for more details

                                          Remarks

                                          Since 1.25.0

                                          Modifiers

                                          • @public

                                        property counterexample

                                        counterexample: null;

                                          property counterexamplePath

                                          counterexamplePath: null;

                                            property error

                                            error: null;

                                              property errorInstance

                                              errorInstance: null;

                                                property failed

                                                failed: true;

                                                  property interrupted

                                                  interrupted: false;

                                                    interface RunDetailsSuccess

                                                    interface RunDetailsSuccess<Ts> extends RunDetailsCommon<Ts> {}
                                                    • Run reported as success

                                                      Refer to RunDetailsCommon for more details

                                                      Remarks

                                                      Since 1.25.0

                                                      Modifiers

                                                      • @public

                                                    property counterexample

                                                    counterexample: null;

                                                      property counterexamplePath

                                                      counterexamplePath: null;

                                                        property error

                                                        error: null;

                                                          property errorInstance

                                                          errorInstance: null;

                                                            property failed

                                                            failed: false;

                                                              property interrupted

                                                              interrupted: boolean;

                                                                interface Scheduler

                                                                interface Scheduler<TMetaData = unknown> {}
                                                                • Instance able to reschedule the ordering of promises for a given app

                                                                  Remarks

                                                                  Since 1.20.0

                                                                  Modifiers

                                                                  • @public

                                                                property report

                                                                report: () => SchedulerReportItem<TMetaData>[];
                                                                • Produce an array containing all the scheduled tasks so far with their execution status. If the task has been executed, it includes a string representation of the associated output or error produced by the task if any.

                                                                  Tasks will be returned in the order they get executed by the scheduler.

                                                                  Remarks

                                                                  Since 1.25.0

                                                                property schedule

                                                                schedule: <T>(
                                                                task: Promise<T>,
                                                                label?: string,
                                                                metadata?: TMetaData,
                                                                customAct?: SchedulerAct
                                                                ) => Promise<T>;
                                                                • Wrap a new task using the Scheduler

                                                                  Remarks

                                                                  Since 1.20.0

                                                                property scheduleFunction

                                                                scheduleFunction: <TArgs extends any[], T>(
                                                                asyncFunction: (...args: TArgs) => Promise<T>,
                                                                customAct?: SchedulerAct
                                                                ) => (...args: TArgs) => Promise<T>;
                                                                • Automatically wrap function output using the Scheduler

                                                                  Remarks

                                                                  Since 1.20.0

                                                                property waitAll

                                                                waitAll: (customAct?: SchedulerAct) => Promise<void>;
                                                                • Wait all scheduled tasks, including the ones that might be created by one of the resolved task

                                                                  Remarks

                                                                  Since 1.20.0

                                                                property waitFor

                                                                waitFor: <T>(
                                                                unscheduledTask: Promise<T>,
                                                                customAct?: SchedulerAct
                                                                ) => Promise<T>;
                                                                • Wait as many scheduled tasks as need to resolve the received Promise

                                                                  Some tests frameworks like supertest are not triggering calls to subsequent queries in a synchronous way, some are waiting an explicit call to then to trigger them (either synchronously or asynchronously)... As a consequence, none of waitOne or waitAll cannot wait for them out-of-the-box.

                                                                  This helper is responsible to wait as many scheduled tasks as needed (but the bare minimal) to get unscheduledTask resolved. Once resolved it returns its output either success or failure.

                                                                  Be aware that while this helper will wait eveything to be ready for unscheduledTask to resolve, having uncontrolled tasks triggering stuff required for unscheduledTask might be a source a uncontrollable and not reproducible randomness as those triggers cannot be handled and scheduled by fast-check.

                                                                  Remarks

                                                                  Since 2.24.0

                                                                property waitOne

                                                                waitOne: (customAct?: SchedulerAct) => Promise<void>;
                                                                • Wait one scheduled task to be executed

                                                                  Throws

                                                                  Whenever there is no task scheduled

                                                                  Remarks

                                                                  Since 1.20.0

                                                                method count

                                                                count: () => number;
                                                                • Count of pending scheduled tasks

                                                                  Remarks

                                                                  Since 1.20.0

                                                                method scheduleSequence

                                                                scheduleSequence: (
                                                                sequenceBuilders: SchedulerSequenceItem<TMetaData>[],
                                                                customAct?: SchedulerAct
                                                                ) => {
                                                                done: boolean;
                                                                faulty: boolean;
                                                                task: Promise<{ done: boolean; faulty: boolean }>;
                                                                };
                                                                • Schedule a sequence of Promise to be executed sequencially. Items within the sequence might be interleaved by other scheduled operations.

                                                                  Please note that whenever an item from the sequence has started, the scheduler will wait until its end before moving to another scheduled task.

                                                                  A handle is returned by the function in order to monitor the state of the sequence. Sequence will be marked: - done if all the promises have been executed properly - faulty if one of the promises within the sequence throws

                                                                  Remarks

                                                                  Since 1.20.0

                                                                interface SchedulerConstraints

                                                                interface SchedulerConstraints {}
                                                                • Constraints to be applied on scheduler

                                                                  Remarks

                                                                  Since 2.2.0

                                                                  Modifiers

                                                                  • @public

                                                                property act

                                                                act: (f: () => Promise<void>) => Promise<unknown>;
                                                                • Ensure that all scheduled tasks will be executed in the right context (for instance it can be the act of React)

                                                                  Remarks

                                                                  Since 1.21.0

                                                                interface SchedulerReportItem

                                                                interface SchedulerReportItem<TMetaData = unknown> {}
                                                                • Describe a task for the report produced by the scheduler

                                                                  Remarks

                                                                  Since 1.25.0

                                                                  Modifiers

                                                                  • @public

                                                                property label

                                                                label: string;
                                                                • Label of the task

                                                                  Remarks

                                                                  Since 1.25.0

                                                                property metadata

                                                                metadata?: TMetaData;
                                                                • Metadata linked when scheduling the task

                                                                  Remarks

                                                                  Since 1.25.0

                                                                property outputValue

                                                                outputValue?: string;
                                                                • Stringified version of the output or error computed using fc.stringify

                                                                  Remarks

                                                                  Since 1.25.0

                                                                property schedulingType

                                                                schedulingType: 'promise' | 'function' | 'sequence';
                                                                • How was this task scheduled? - promise: schedule - function: scheduleFunction - sequence: scheduleSequence

                                                                  Remarks

                                                                  Since 1.25.0

                                                                property status

                                                                status: 'resolved' | 'rejected' | 'pending';
                                                                • Execution status for this task - resolved: task released by the scheduler and successful - rejected: task released by the scheduler but with errors - pending: task still pending in the scheduler, not released yet

                                                                  Remarks

                                                                  Since 1.25.0

                                                                property taskId

                                                                taskId: number;
                                                                • Incremental id for the task, first received task has taskId = 1

                                                                  Remarks

                                                                  Since 1.25.0

                                                                interface ShuffledSubarrayConstraints

                                                                interface ShuffledSubarrayConstraints {}
                                                                • Constraints to be applied on shuffledSubarray

                                                                  Remarks

                                                                  Since 2.18.0

                                                                  Modifiers

                                                                  • @public

                                                                property maxLength

                                                                maxLength?: number;
                                                                • Upper bound of the generated subarray size (included)

                                                                  Remarks

                                                                  Since 2.4.0

                                                                property minLength

                                                                minLength?: number;
                                                                • Lower bound of the generated subarray size (included)

                                                                  Remarks

                                                                  Since 2.4.0

                                                                interface SparseArrayConstraints

                                                                interface SparseArrayConstraints {}
                                                                • Constraints to be applied on sparseArray

                                                                  Remarks

                                                                  Since 2.13.0

                                                                  Modifiers

                                                                  • @public

                                                                property depthIdentifier

                                                                depthIdentifier?: DepthIdentifier | string;
                                                                • When receiving a depth identifier, the arbitrary will impact the depth attached to it to avoid going too deep if it already generated lots of items.

                                                                  In other words, if the number of generated values within the collection is large then the generated items will tend to be less deep to avoid creating structures a lot larger than expected.

                                                                  For the moment, the depth is not taken into account to compute the number of items to define for a precise generate call of the array. Just applied onto eligible items.

                                                                  Remarks

                                                                  Since 2.25.0

                                                                property maxLength

                                                                maxLength?: number;
                                                                • Upper bound of the generated array size (maximal size: 4294967295)

                                                                  Remarks

                                                                  Since 2.13.0

                                                                property maxNumElements

                                                                maxNumElements?: number;
                                                                • Upper bound of the number of non-hole elements

                                                                  Remarks

                                                                  Since 2.13.0

                                                                property minNumElements

                                                                minNumElements?: number;
                                                                • Lower bound of the number of non-hole elements

                                                                  Remarks

                                                                  Since 2.13.0

                                                                property noTrailingHole

                                                                noTrailingHole?: boolean;
                                                                • When enabled, all generated arrays will either be the empty array or end by a non-hole

                                                                  Remarks

                                                                  Since 2.13.0

                                                                property size

                                                                size?: SizeForArbitrary;
                                                                • Define how large the generated values should be (at max)

                                                                  Remarks

                                                                  Since 2.22.0

                                                                interface StringSharedConstraints

                                                                interface StringSharedConstraints {}
                                                                • Constraints to be applied on arbitraries for strings

                                                                  Remarks

                                                                  Since 2.4.0

                                                                  Modifiers

                                                                  • @public

                                                                property maxLength

                                                                maxLength?: number;
                                                                • Upper bound of the generated string length (included)

                                                                  Remarks

                                                                  Since 2.4.0

                                                                property minLength

                                                                minLength?: number;
                                                                • Lower bound of the generated string length (included)

                                                                  Remarks

                                                                  Since 2.4.0

                                                                property size

                                                                size?: SizeForArbitrary;
                                                                • Define how large the generated values should be (at max)

                                                                  Remarks

                                                                  Since 2.22.0

                                                                interface SubarrayConstraints

                                                                interface SubarrayConstraints {}
                                                                • Constraints to be applied on subarray

                                                                  Remarks

                                                                  Since 2.4.0

                                                                  Modifiers

                                                                  • @public

                                                                property maxLength

                                                                maxLength?: number;
                                                                • Upper bound of the generated subarray size (included)

                                                                  Remarks

                                                                  Since 2.4.0

                                                                property minLength

                                                                minLength?: number;
                                                                • Lower bound of the generated subarray size (included)

                                                                  Remarks

                                                                  Since 2.4.0

                                                                interface UnicodeJsonSharedConstraints

                                                                interface UnicodeJsonSharedConstraints {}

                                                                property depthSize

                                                                depthSize?: DepthSize;
                                                                • Limit the depth of the object by increasing the probability to generate simple values (defined via values) as we go deeper in the object.

                                                                  Remarks

                                                                  Since 2.20.0

                                                                property maxDepth

                                                                maxDepth?: number;
                                                                • Maximal depth allowed

                                                                  Remarks

                                                                  Since 2.5.0

                                                                interface WebAuthorityConstraints

                                                                interface WebAuthorityConstraints {}
                                                                • Constraints to be applied on webAuthority

                                                                  Remarks

                                                                  Since 1.14.0

                                                                  Modifiers

                                                                  • @public

                                                                property size

                                                                size?: Exclude<SizeForArbitrary, 'max'>;
                                                                • Define how large the generated values should be (at max)

                                                                  Remarks

                                                                  Since 2.22.0

                                                                property withIPv4

                                                                withIPv4?: boolean;
                                                                • Enable IPv4 in host

                                                                  Remarks

                                                                  Since 1.14.0

                                                                property withIPv4Extended

                                                                withIPv4Extended?: boolean;
                                                                • Enable extended IPv4 format

                                                                  Remarks

                                                                  Since 1.17.0

                                                                property withIPv6

                                                                withIPv6?: boolean;
                                                                • Enable IPv6 in host

                                                                  Remarks

                                                                  Since 1.14.0

                                                                property withPort

                                                                withPort?: boolean;
                                                                • Enable port suffix

                                                                  Remarks

                                                                  Since 1.14.0

                                                                property withUserInfo

                                                                withUserInfo?: boolean;
                                                                • Enable user information prefix

                                                                  Remarks

                                                                  Since 1.14.0

                                                                interface WebFragmentsConstraints

                                                                interface WebFragmentsConstraints {}
                                                                • Constraints to be applied on webFragments

                                                                  Remarks

                                                                  Since 2.22.0

                                                                  Modifiers

                                                                  • @public

                                                                property size

                                                                size?: Exclude<SizeForArbitrary, 'max'>;
                                                                • Define how large the generated values should be (at max)

                                                                  Remarks

                                                                  Since 2.22.0

                                                                interface WebPathConstraints

                                                                interface WebPathConstraints {}
                                                                • Constraints to be applied on webPath

                                                                  Remarks

                                                                  Since 3.3.0

                                                                  Modifiers

                                                                  • @public

                                                                property size

                                                                size?: Exclude<SizeForArbitrary, 'max'>;
                                                                • Define how large the generated values should be (at max)

                                                                  Remarks

                                                                  Since 3.3.0

                                                                interface WebQueryParametersConstraints

                                                                interface WebQueryParametersConstraints {}

                                                                property size

                                                                size?: Exclude