fast-check

https://fast-check.dev/
Admin
fast-check is a property-based testing library for JavaScript and TypeScript that helps find bugs,...
Tokens:34,225
Snippets:419
Trust Score:8.1
Update:3 months ago
Show doc for...
Tokens:
Raw
### Setup Project with Bun

Source: https://fast-check.dev/docs/tutorials/quick-start/basic-setup

Use Bun to download the project template and install dependencies.

```bash
bun x degit dubzzz/fast-check/website/templates/fast-check-tutorial fast-check-tutorial  

cd fast-check-tutorial  

npm i  

```

--------------------------------

### Setup Project with npm

Source: https://fast-check.dev/docs/tutorials/quick-start/basic-setup

Use npm to download the project template and install dependencies.

```bash
npx degit dubzzz/fast-check/website/templates/fast-check-tutorial fast-check-tutorial  

cd fast-check-tutorial  

npm i  

```

--------------------------------

### Setup Project with pnpm

Source: https://fast-check.dev/docs/tutorials/quick-start/basic-setup

Use pnpm to download the project template and install dependencies.

```bash
pnpm dlx degit dubzzz/fast-check/website/templates/fast-check-tutorial fast-check-tutorial  

cd fast-check-tutorial  

npm i  

```

--------------------------------

### Setup Project with Yarn

Source: https://fast-check.dev/docs/tutorials/quick-start/basic-setup

Use Yarn to download the project template and install dependencies.

```bash
yarn dlx degit dubzzz/fast-check/website/templates/fast-check-tutorial fast-check-tutorial  

cd fast-check-tutorial  

npm i  

```

--------------------------------

### Install fast-check JavaScript Testing Expert Skill

Source: https://fast-check.dev/docs/ai-powered-testing

Install the fast-check skill to your AI assistant using npx. This enables the AI to apply best practices for writing high-quality JavaScript tests.

```bash
npx skills add dubzzz/fast-check --skill javascript-testing-expert  
```

--------------------------------

### Generate Map with specific constraints

Source: https://fast-check.dev/blog/2025/12/15/whats-new-in-fast-check-4-4-0

Customize Map generation using options like minKeys and maxKeys. This example creates a Map with string keys and number values, ensuring it has between 1 and 10 entries.

```javascript
fc.map(fc.string(), fc.nat(), { minKeys: 1, maxKeys: 10 });
```

--------------------------------

### Generate Set with size constraints

Source: https://fast-check.dev/blog/2025/12/15/whats-new-in-fast-check-4-4-0

Control the size of the generated Set using minLength and maxLength options. This example creates a Set of non-negative integers with a size between 2 and 20 elements.

```javascript
fc.set(fc.nat(), { minLength: 2, maxLength: 20 });
```

--------------------------------

### Generate Connected Graph with fast-check

Source: https://fast-check.dev/blog/2026/01/15/whats-new-in-fast-check-4-5-0

Generates a graph where all nodes are reachable from a single entry point. This is achieved by setting `initialPoolConstraints` to ensure a single starting node.

```typescript
fc.entityGraph(
  { node: { id: fc.uuid() } },
  { node: { linkTo: { arity: 'many', type: 'node' } } },
  {
    initialPoolConstraints: { node: { maxLength: 1 } }, // <-- line added
    unicityConstraints: { node: (value) => value.id },
  },
);
```

--------------------------------

### Capture Stack Trace Example

Source: https://fast-check.dev/docs/api/classes/PreconditionFailure

Demonstrates how to use Error.captureStackTrace to create a stack trace property on an object. The optional constructorOpt argument can be used to omit frames from the stack trace.

```typescript
const myObject = {};

Error.captureStackTrace(myObject);

myObject.stack;  // Similar to `new Error().stack`
```

```typescript
function a() {
  b();
}

function b() {
  c();
}

function c() {
  const { stackTraceLimit } = Error;
  Error.stackTraceLimit = 0;
  const error = new Error();
  Error.stackTraceLimit = stackTraceLimit;
  
  Error.captureStackTrace(error, b);
  throw error;
}

a();
```

--------------------------------

### Generate Map with string keys and number values

Source: https://fast-check.dev/blog/2025/12/15/whats-new-in-fast-check-4-4-0

Use fc.map to generate a Map with specified key and value arbitraries. This example generates a Map where keys are strings and values are non-negative integers.

```javascript
fc.map(fc.string(), fc.nat());
```

--------------------------------

### Integrating Faker with Controlled Randomness

Source: https://fast-check.dev/blog/2025/03/28/beyond-flaky-tests-bringing-controlled-randomness-to-vitest

This example demonstrates how to integrate the `g` generator with Faker to produce realistic random values while maintaining test reproducibility. The `randomizer.next` function is configured to use `g` for generating random numbers.

```typescript
import { Faker, base } from '@faker-js/faker';

test('the name of your test', ({ g }) => {
  const faker = new Faker({
    locale: base,
    randomizer: {
      next: () => g(fc.nat, { max: 0xffffffff }) / 0x100000000,
      seed: () => {},
    },
  });
  // Your test...
});
```

--------------------------------

### Testing asynchronous code with fast-check scheduler

Source: https://fast-check.dev/blog/2025/04/06/whats-new-in-fast-check-4-1-0

This test setup utilizes fast-check's scheduler to reorder asynchronous operations, particularly focusing on how `waitFor` handles already resolved promises and micro-tasks.

```javascript
// s is the scheduler provided by fast-check
const caches = {
  // our test focuses on caches being already resolved
  d: Promise.resolve('d'),
  e: Promise.resolve('e'),
  f: Promise.resolve('f'),
};
const myapi = fc.scheduleFunction(async (value) => value);
await s.waitFor(Promise.all([abc(myapi), def(caches, myapi)]));
// more code with expectations...
```

--------------------------------

### chainUntil

Source: https://fast-check.dev/docs/api/functions/chainUntil

Build an arbitrary by iteratively chaining arbitraries until the chainer returns undefined. Starting from a value produced by `startArb`, the `chainer` function is called with the current value to produce the next arbitrary. This process repeats until `chainer` returns `undefined`. The final value in the chain is the one produced by this arbitrary. The implementation is fully iterative (non-recursive) and supports shrinking.

```APIDOC
## Function: chainUntil()

> **chainUntil** <`T`>(`startArb`, `chainer`): `Arbitrary`<`T`>

Defined in: packages/fast-check/src/arbitrary/chainUntil.ts:155

Build an arbitrary by iteratively chaining arbitraries until the chainer returns undefined.

Starting from a value produced by `startArb`, the `chainer` function is called with the current value to produce the next arbitrary. This process repeats until `chainer` returns `undefined`. The final value in the chain is the one produced by this arbitrary.

The implementation is fully iterative (non-recursive) and supports shrinking.

## Type Parameters

Type Parameter  
---
`T`

## Parameters

Parameter| Type| Description  
---|---|---
`startArb`| `Arbitrary`<`T`>| The starting arbitrary producing the initial value  
`chainer`| (`prev`) => `Arbitrary`<`T`> | `undefined`| A function called with the current value that returns either the next arbitrary to generate from or undefined to stop the chain

## Returns

`Arbitrary`<`T`>
An arbitrary producing the last value in the chain

## Remarks

Since 4.8.0
```

--------------------------------

### Test race condition with scheduler and waitAll

Source: https://fast-check.dev/blog/2025/07/18/whats-new-in-fast-check-4-2-0

This example demonstrates how to test race conditions using fc.scheduler() and the deprecated waitAll primitive. It schedules a function and asserts that a side effect occurs after waiting for all tasks.

```typescript
import { test, expect } from 'vitest';

test('our test', async () => {
  await fc.assert(
    fc.asyncProperty(fc.scheduler(), async (s) => {
      const fetchIdFor = s.scheduleFunction(async (name) => `id:${name}`);
      const { doStuff, warmup } = buildDoStuff(fetchIdFor);
      await warmup();
      let done = false;
      doStuff('name').then(() => (done = true));
      await s.waitAll();
      expect(done).toBe(true);
    }),
  );
});

// In a real world example, the function below would probably have been defined
// into a dedicated file not being the file holding the test.
function buildDoStuff(fetchIdFor) {
  return {
    doStuff: async function doStuff(name) {
      const { default: executeTaskOnId } = await import('./executor');
      await executeTaskOnId(await fetchIdFor(name));
    },
    warmup: async function warmup(name) {
      await import('./executor');
    },
  };
}
```

--------------------------------

### Constructor

Source: https://fast-check.dev/docs/api/classes/Arbitrary

Initializes a new instance of the Arbitrary class.

```APIDOC
## Constructor

### Description
Initializes a new instance of the Arbitrary class.

### Signature
```typescript
new Arbitrary<T>(): Arbitrary<T>
```

### Returns
An instance of Arbitrary<T>.
```

--------------------------------

### Constructor

Source: https://fast-check.dev/docs/api/classes/Value

Initializes a new instance of the Value class.

```APIDOC
## new Value<T>(value_, context, customGetValue?)

### Description
Initializes a new instance of the Value class.

### Parameters
#### Parameters
- **value_** (T) - Internal value of the shrinkable
- **context** (unknown) - Context associated to the generated value (useful for shrink)
- **customGetValue?** (() => T) - Limited to internal usages (to ease migration to next), it will be removed on next major

### Returns
Value<T>
```

--------------------------------

### getDepthContextFor

Source: https://fast-check.dev/docs/api

Gets back the requested DepthContext.

```APIDOC
## getDepthContextFor

### Description
Get back the requested DepthContext.

### Function
getDepthContextFor(identifier: DepthIdentifier): DepthContext
```

--------------------------------

### Run Tests with Bun

Source: https://fast-check.dev/docs/tutorials/quick-start/basic-setup

Execute the project's tests using the Bun run test command.

```bash
bun run test  

```

--------------------------------

### Run Tests with npm

Source: https://fast-check.dev/docs/tutorials/quick-start/basic-setup

Execute the project's tests using the npm test script.

```bash
npm test  

```

--------------------------------

### asyncProperty()

Source: https://fast-check.dev/docs/api/functions/asyncProperty

Instantiate a new fast-check#IAsyncProperty.

```APIDOC
## Function: asyncProperty()

> **asyncProperty** <`Ts`>(...`args`): `IAsyncPropertyWithHooks`<`Ts`>

Defined in: packages/fast-check/src/check/property/AsyncProperty.ts:15

Instantiate a new fast-check#IAsyncProperty.

## Type Parameters

Type Parameter  
---
`Ts` _extends_ [`unknown`, `...unknown[]`]

## Parameters

Parameter| Type  
--|--
...`args`| [...arbitraries: { [K in string | number | symbol]: Arbitrary<Ts[K]> }[], (...`args`) => `Promise`<`boolean` | `void`>]

## Returns

`IAsyncPropertyWithHooks`<`Ts`>

## Remarks

Since 0.0.7
```

--------------------------------

### Iterative Chaining with chainUntil

Source: https://fast-check.dev/blog/2026/06/25/whats-new-in-fast-check-4-8-0

Use `chainUntil` to generate values iteratively. It starts with an initial arbitrary and repeatedly calls a chainer function until it returns `undefined`. This is useful for variable-length dependent generation.

```javascript
fc.chainUntil(
  // Start from a tuple containing one value in 0..20,
  fc.nat(20).map((n) => [n]),
  // Then, if value is greater than 10, append another value in 0..20
  (tuple) => (tuple.at(-1) > 10 ? fc.nat(20).map((n) => [...tuple, n]) : undefined)
);
```

--------------------------------

### anything(constraints)

Source: https://fast-check.dev/docs/api/functions/anything

Generates arbitrary values of any type following the specified constraints. You can use sample() to preview the generated values.

```APIDOC
## anything(constraints)

### Description
Generates arbitrary values of any type following the constraints defined by `settings`.

### Parameters
#### Parameters
- **constraints** (`ObjectConstraints`) - Constraints to apply when building instances

### Returns
`Arbitrary<unknown>`

### Examples
```
// Using custom settings

fc.anything({

    key: fc.string(),

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

### Remarks
Since 0.0.7
```

--------------------------------

### anything()

Source: https://fast-check.dev/docs/api/functions/anything

Generates arbitrary values of any type. You can use sample() to preview the generated values.

```APIDOC
## anything()

### Description
Generates arbitrary values of any type.

### Returns
`Arbitrary<unknown>`

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

### Remarks
Since 0.0.7
```

--------------------------------

### Run Tests with Yarn

Source: https://fast-check.dev/docs/tutorials/quick-start/basic-setup

Execute the project's tests using the Yarn test command.

```bash
yarn test  

```

--------------------------------

### asyncProperty

Source: https://fast-check.dev/docs/api

Instantiates a new fast-check#IAsyncProperty.

```APIDOC
## asyncProperty

### Description
Instantiate a new fast-check#IAsyncProperty.

### Function
asyncProperty(property: Property<any>)
```

--------------------------------

### asyncModelRun

Source: https://fast-check.dev/docs/api/functions/asyncModelRun

Runs asynchronous commands over a Model and the Real system. Throws an error in case of inconsistency.

```APIDOC
## Function: asyncModelRun()

> **asyncModelRun** <`Model`, `Real`, `CheckAsync`, `InitialModel`>(`s`, `cmds`): `Promise`<`void`>

Defined in: packages/fast-check/src/check/model/ModelRunner.ts:131

Run asynchronous commands over a `Model` and the `Real` system
Throw in case of inconsistency

## Type Parameters

| Type Parameter | Description |
|---|---|
| `Model` _extends_ `object` | |
| `Real` | |
| `CheckAsync` _extends_ `boolean` | |
| `InitialModel` _extends_ `object` | |

## Parameters

| Parameter | Type | Description |
|---|---|---|
| `s` | `ModelRunSetup`<`InitialModel`, `Real`> <br> `ModelRunAsyncSetup`<`InitialModel`, `Real`> | Initial state provider |
| `cmds` | `Iterable`<`AsyncCommand`<`Model`, `Real`, `CheckAsync`>> | Asynchronous commands to be executed |

## Returns

`Promise`<`void`>

## Remarks

Since 1.5.0
```

--------------------------------

### Run Tests with pnpm

Source: https://fast-check.dev/docs/tutorials/quick-start/basic-setup

Execute the project's tests using the pnpm test script.

```bash
pnpm test  

```

--------------------------------

### Configure and Run Model-Based Tests

Source: https://fast-check.dev/docs/advanced/model-based-testing

This code configures the possible commands and their inputs, then uses `fc.assert` with `fc.commands` and `fc.modelRun` to execute the model-based tests.

```typescript
// define the possible commands and their inputs
const allCommands = [
  fc.integer().map((v) => new PushCommand(v)),
  fc.constant(new PopCommand()),
  fc.constant(new SizeCommand()),
];
// run everything
fc.assert(
  fc.property(fc.commands(allCommands, { size: '+1' }), (cmds) => {
    const s = () => ({ model: { num: 0 }, real: new List() });
    fc.modelRun(s, cmds);
  }),
);
```

--------------------------------

### asyncModelRun

Source: https://fast-check.dev/docs/api

Runs asynchronous commands over a Model and the Real system.

```APIDOC
## asyncModelRun

### Description
Run asynchronous commands over a `Model` and the `Real` system.

### Function
asyncModelRun(model: Model<T>, commands: AsyncCommand<T, U>[])
```

--------------------------------

### commands

Source: https://fast-check.dev/docs/api

Generates arrays of AsyncCommand to be executed by asyncModelRun.

```APIDOC
## commands

### Description
For arrays of AsyncCommand to be executed by asyncModelRun.

### Function
commands<T, U>(commandArb: Arbitrary<AsyncCommand<T, U>>): Arbitrary<AsyncCommand<T, U>[]>
```

--------------------------------

### configureGlobal

Source: https://fast-check.dev/docs/api/functions/configureGlobal

Sets global configuration parameters for all subsequent assertions.

```APIDOC
## Function: configureGlobal()

> **configureGlobal**(`parameters`): `void`

Define global parameters that will be used by all the runners.

### Parameters

- **parameters** (`GlobalParameters`) - Required - Global parameters

### Returns

`void`

### Example

```javascript
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 }
```

### Remarks

Since 1.18.0
```

--------------------------------

### Define a Model-Based Command

Source: https://fast-check.dev/docs/advanced/model-based-testing

Implement the `ICommand` interface with `check`, `run`, and `toString` methods. The `run` method can capture state for reporting, and `toString` should provide a human-readable representation.

```typescript
class GoToTrackCommand {
  constructor(trackPosition) {
    this.trackPosition = trackPosition;
  }
  check(m) {
    return m.allTracks.length !== 0;
  }
  run(m, r) {
    this.trackName = m.allTracks[this.trackPosition % m.allTracks.length];
    // execute 'go to track' on the system (r) and impact the model (m) if needed
  }
  toString() {
    return `go to track '${this.trackName}'`;
  }
}
```

--------------------------------

### context

Source: https://fast-check.dev/docs/api

Produces a ContextValue instance.

```APIDOC
## context

### Description
Produce a ContextValue instance.

### Function
context(): Arbitrary<ContextValue>
```

--------------------------------

### nextBigInt(min, max)

Source: https://fast-check.dev/docs/api/classes/Random

Generate a random bigint between min (included) and max (included).

```APIDOC
## nextBigInt(min, max)

### Description
Generate a random bigint between min (included) and max (included).

### Parameters
#### Path Parameters
- **min** (bigint) - Required - Minimal bigint value
- **max** (bigint) - Required - Maximal bigint value

### Returns
- **bigint**
```

--------------------------------

### assert

Source: https://fast-check.dev/docs/api

Runs a property test and throws an error if it fails.

```APIDOC
## assert

### Description
Runs the property, throw in case of failure.

### Function
assert(property: Property<any>, configuration?: Configuration)
```

--------------------------------

### Replay Model-Based Test Failures

Source: https://fast-check.dev/docs/advanced/model-based-testing

Demonstrates how to replay a specific failing test case by providing the `replayPath` option to `fc.commands` and the `seed` and `path` to `fc.assert`.

```typescript
// Original code
fc.assert(
  fc.property(
    fc.commands(/* array of commands */),
    checkEverythingIsOk
  )
);

// Replay code: straight to the minimal counterexample.
// It only replays the minimal counterexample.
fc.assert(
  fc.property(
    fc.commands(
      /* array of commands */,
      { replayPath: 'AAAAABAAE:VF' }
    ),
    checkEverythingIsOk
  ),
  { seed: 670108017, path: '96:5', endOnFailure: true }
);
```

--------------------------------

### modelRun

Source: https://fast-check.dev/docs/api

Runs synchronous commands over a Model and the Real system.

```APIDOC
## modelRun

### Description
Run synchronous commands over a `Model` and the `Real` system.

### Function
modelRun<T, U>(model: Model<T>, commands: Command<T, U>[]): U
```

--------------------------------

### Sync Command Generation

Source: https://fast-check.dev/docs/api/functions/commands

Generates an Arbitrary for an iterable of Command. This is suitable for model-based testing with synchronous operations. It also features an optimized shrinker.

```APIDOC
## Function: commands() - Sync

### Description
Generates an Arbitrary for an iterable of `Command`. This implementation is optimized for synchronous command execution and comes with an efficient shrinker.

### Call Signature
`commands<Model, Real>(commandArbs, constraints?): Arbitrary<Iterable<Command<Model, Real>, any, any>>`

### Type Parameters
- `Model` extends `object`: The type of the model.
- `Real`: The type of the real execution context.

### Parameters
- `commandArbs` (Arbitrary<Command<Model, Real>>[]): An array of arbitraries used to build the commands.
- `constraints?` (CommandsContraints): Optional constraints to apply during command generation (since version 1.11.0).

### Returns
`Arbitrary<Iterable<Command<Model, Real>, any, any>>`: An arbitrary that produces iterables of synchronous commands.

### Remarks
Available since version 1.5.0.
```

--------------------------------

### PreconditionFailure Constructor

Source: https://fast-check.dev/docs/api/classes/PreconditionFailure

Initializes a new instance of the PreconditionFailure class. This error is produced whenever a precondition fails.

```APIDOC
## Constructor

> **new PreconditionFailure**(`interruptExecution?`): `PreconditionFailure`

Defined in: packages/fast-check/src/check/precondition/PreconditionFailure.ts:12

#### Parameters

Parameter| Type| Default value  
---|---|---
`interruptExecution`| `boolean`| `false`

#### Returns

`PreconditionFailure`

#### Overrides

`Error.constructor`
```

--------------------------------

### Create a Hardcoded Scheduler

Source: https://fast-check.dev/docs/advanced/race-conditions

Generates a scheduler instance with a predefined execution order for promises. Use `fc.constant` to pass it as an arbitrary.

```typescript
fc.schedulerFor([1,3,2])
```

--------------------------------

### context()

Source: https://fast-check.dev/docs/api/functions/context

Produces a ContextValue instance. This is an Arbitrary that can be used to generate context values during property-based testing.

```APIDOC
## Function: context()

> **context**(): `Arbitrary<ContextValue>`

Defined in: packages/fast-check/src/arbitrary/context.ts:50

Produce a ContextValue instance.

## Returns

`Arbitrary<ContextValue>`

## Remarks

Since 1.8.0
```

--------------------------------

### check

Source: https://fast-check.dev/docs/api

Runs a property test without throwing an error on failure.

```APIDOC
## check

### Description
Run the property, do not throw contrary to assert.

### Function
check(property: Property<any>, configuration?: Configuration)
```

--------------------------------

### anything

Source: https://fast-check.dev/docs/api

Generates arbitrary values of any type.

```APIDOC
## anything

### Description
Generates arbitrary values of any type.

### Function
anything()
```

--------------------------------

### Constructor

Source: https://fast-check.dev/docs/api/classes/Random

Create a mutable random number generator by cloning the passed one and mutate it.

```APIDOC
## new Random(sourceRng)

### Description
Create a mutable random number generator by cloning the passed one and mutate it.

### Parameters
#### Path Parameters
- **sourceRng** (any) - Required - Immutable random generator from pure-rand library, will not be altered (a clone will be)

### Returns
- **Random**
```

--------------------------------

### lorem

Source: https://fast-check.dev/docs/api

Generates lorem ipsum strings of words or sentences.

```APIDOC
## lorem

### Description
For lorem ipsum string of words or sentences with maximal number of words or sentences.

### Function
lorem(constraints?: constraints.LoremConstraints)
```

--------------------------------

### Implement Commands for List Operations

Source: https://fast-check.dev/docs/advanced/model-based-testing

TypeScript classes implementing the `fc.Command` interface for push, pop, and size operations. Each command defines `check` and `run` methods to interact with the model and the real system.

```typescript
class PushCommand implements fc.Command<Model, List> {
  constructor(readonly value: number) {}
  check = (m: Readonly<Model>) => true;
  run(m: Model, r: List): void {
    r.push(this.value); // impact the system
    ++m.num; // impact the model
  }
  toString = () => `push(${this.value})`;
}
```

```typescript
class PopCommand implements fc.Command<Model, List> {
  check(m: Readonly<Model>): boolean {
    // should not call pop on empty list
    return m.num > 0;
  }
  run(m: Model, r: List): void {
    assert.equal(typeof r.pop(), 'number');
    --m.num;
  }
  toString = () => 'pop';
}
```

```typescript
class SizeCommand implements fc.Command<Model, List> {
  check = (m: Readonly<Model>) => true;
  run(m: Model, r: List): void {
    assert.equal(r.size(), m.num);
  }
  toString = () => 'size';
}
```

--------------------------------

### domain

Source: https://fast-check.dev/docs/api

Generates valid domain names.

```APIDOC
## domain

### Description
For domains having an extension with at least two lowercase characters.

### Function
domain(): Arbitrary<string>
```

--------------------------------

### chainUntil

Source: https://fast-check.dev/docs/api

Builds an arbitrary by iteratively chaining arbitraries until the chainer returns undefined.

```APIDOC
## chainUntil

### Description
Build an arbitrary by iteratively chaining arbitraries until the chainer returns undefined.

### Function
chainUntil<T, U>(initial: Arbitrary<T>, chainer: (value: T) => Arbitrary<U> | undefined)
```

--------------------------------

### Assert with Global and Local Parameters

Source: https://fast-check.dev/docs/api/functions/configureGlobal

Demonstrates how global parameters (numRuns: 10) are combined with local parameters (seed: 42) for an assertion. The resulting configuration for this assertion is { numRuns: 10, seed: 42 }.

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

--------------------------------

### Generic Property Check (Sync or Async)

Source: https://fast-check.dev/docs/api/functions/check

Runs a property, which can be either synchronous or asynchronous, and returns either RunDetails or a Promise of RunDetails. This is the most versatile overload.

```APIDOC
## check<Ts>(property: IRawProperty<Ts>, params?: Parameters<Ts>): RunDetails<Ts> | Promise<RunDetails<Ts>>

### Description
Runs the property, does not throw contrary to assert.
WARNING: Has to be awaited if the property is asynchronous.

### Type Parameters
* `Ts` - The type of the values generated by the property.

### Parameters
* `property` (IRawProperty<Ts>) - Property to be checked.
* `params` (Parameters<Ts>) - Optional parameters to customize the execution.

### Returns
RunDetails<Ts> | Promise<RunDetails<Ts>> - Test status and other useful details.

### Remarks
Since 0.0.7
```

--------------------------------

### bigInt(...args) - Generate bigint with flexible arguments

Source: https://fast-check.dev/docs/api/functions/bigInt

Generates an arbitrary bigint value using a flexible set of arguments. This can include min/max bounds or constraints, provided as an object or directly.

```APIDOC
## Function: bigInt(...args)

### Call Signature
> **bigInt**(...`args`): `Arbitrary<bigint>`

For bigint between min (included) and max (included)

### Parameters
Parameter| Type| Description  
---|---|---  
...`args`| [] | [`bigint`, `bigint`] | [`BigIntConstraints`]| Either min/max bounds as an object or constraints to apply when building instances

### Returns
`Arbitrary<bigint>`

### Remarks
Since 2.6.0
```

--------------------------------

### base64String()

Source: https://fast-check.dev/docs/api/functions/base64String

Generates an arbitrary base64 string. Optionally accepts constraints to customize the generated strings.

```APIDOC
## Function: base64String()

> **base64String**(`constraints?`): `Arbitrary`<`string`>

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

### Parameters

Parameter| Type| Description  
---|---|---  
`constraints`| `StringSharedConstraints`| Constraints to apply when building instances (since 2.4.0)  

### Returns

`Arbitrary`<`string`>

### Remarks

Since 0.0.1
```

--------------------------------

### func

Source: https://fast-check.dev/docs/api

Generates pure functions.

```APIDOC
## func

### Description
For pure functions.

### Function
func(): Arbitrary<Function>
```

--------------------------------

### take(n)

Source: https://fast-check.dev/docs/api/classes/Stream

Takes the first 'n' elements from the stream. This operation closes the current stream.

```APIDOC
## take(n)

### Description
Take `n` first elements of the Stream.
WARNING: It closes the current stream.

### Parameters
#### Path Parameters
- **n** (number) - Required - Number of elements to take

### Returns
`Stream<T>`

### Remarks
Since 0.0.1
```

--------------------------------

### array()

Source: https://fast-check.dev/docs/api/functions/array

Generates an arbitrary array of values. You can specify the arbitrary used for the elements and optional constraints for the array.

```APIDOC
## Function: array()

> **array** <`T`>(`arb`, `constraints?`): `Arbitrary`<`T`[]>

Defined in: packages/fast-check/src/arbitrary/array.ts:78

For arrays of values coming from `arb`

## Type Parameters

Type Parameter  
---
`T`

## Parameters

Parameter| Type| Description  
---|---|---
`arb`| `Arbitrary`<`T`>| Arbitrary used to generate the values inside the array  
`constraints`| `ArrayConstraints`| Constraints to apply when building instances (since 2.4.0)  

## Returns

`Arbitrary`<`T`[]>

## Remarks

Since 0.0.1
```

--------------------------------

### map()

Source: https://fast-check.dev/docs/api/classes/Arbitrary

Creates a new arbitrary by applying a mapping function to the values produced by the current arbitrary. An optional unmapping function can be provided for shrinking.

```APIDOC
## map()

> **map** <`U`>(`mapper`, `unmapper?`): `Arbitrary`<`U`>

### Description
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.

### Type Parameters
* `U`: The type of the values produced by the new arbitrary.

### Parameters
* `mapper` (`t`) => `U`: Map function, to produce a new element based on an old one.
* `unmapper?` (`possiblyU`) => `T`: Optional unmap function, it will never be used except when shrinking user defined values. Must throw if value is not compatible (since 3.0.0).

### Returns
`Arbitrary`<`U`>: New arbitrary with mapped elements.

### Example
```javascript
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'
```

### Remarks
Since 0.0.1
```

--------------------------------

### clone()

Source: https://fast-check.dev/docs/api/classes/Random

Clone the random number generator.

```APIDOC
## clone()

### Description
Clone the random number generator.

### Returns
- **Random**
```

--------------------------------

### dictionary<T>(keyArb, valueArb, constraints?)

Source: https://fast-check.dev/docs/api/functions/dictionary

Generates dictionaries with string keys produced by keyArb and values from valueArb. This overload is available since version 1.0.0.

```APIDOC
## Function: dictionary<T>(keyArb, valueArb, constraints?)

### Description
Generates dictionaries with keys produced by `keyArb` and values from `valueArb`.

### Type Parameters
* `T`: The type of the values in the dictionary.

### Parameters
* `keyArb` (Arbitrary<string>): Arbitrary used to generate the keys of the object.
* `valueArb` (Arbitrary<T>): Arbitrary used to generate the values of the object.
* `constraints?` (DictionaryConstraints): Optional constraints for the dictionary.

### Returns
Arbitrary<Record<string, T>>: An arbitrary that generates dictionaries.

### Remarks
Since 1.0.0
```

--------------------------------

### compareFunc

Source: https://fast-check.dev/docs/api

Generates comparison functions.

```APIDOC
## compareFunc

### Description
For comparison functions.

### Function
compareFunc(): Arbitrary<(a: any, b: any) => number>
```

--------------------------------

### dictionary<K, V>(keyArb, valueArb, constraints?)

Source: https://fast-check.dev/docs/api/functions/dictionary

Generates dictionaries with keys of type K produced by keyArb and values of type V from valueArb. This overload is available since version 4.4.0.

```APIDOC
## Function: dictionary<K, V>(keyArb, valueArb, constraints?)

### Description
Generates dictionaries with keys produced by `keyArb` and values from `valueArb`.

### Type Parameters
* `K` extends PropertyKey: The type of the keys in the dictionary.
* `V`: The type of the values in the dictionary.

### Parameters
* `keyArb` (Arbitrary<K>): Arbitrary used to generate the keys of the object.
* `valueArb` (Arbitrary<V>): Arbitrary used to generate the values of the object.
* `constraints?` (DictionaryConstraints): Optional constraints for the dictionary.

### Returns
Arbitrary<Record<K, V>>: An arbitrary that generates dictionaries.

### Remarks
Since 4.4.0
```

--------------------------------

### Generate anything with custom constraints

Source: https://fast-check.dev/docs/api/functions/anything

Use this to generate values with specific constraints on keys, values, and depth. This allows for more controlled generation of complex data structures.

```typescript
// Using custom settings  

fc.anything({

    key: fc.string(),  

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

--------------------------------

### Schedule Mocked Server Function Call

Source: https://fast-check.dev/docs/advanced/race-conditions

Wraps a function to schedule its execution via a scheduler, simulating delayed server responses. This allows for testing scenarios where server calls might not be received in the order they were made.

```typescript
const scheduleMockedServerFunction = <TArgs extends unknown[], TOut>(
  s: Scheduler,
  f: (...args: TArgs) => Promise<TOut>,
) => {
  return (...args: TArgs) => {
    return s.schedule(Promise.resolve('Server received the call')).then(() => f(...args));
  };
};

const newAddTodo = scheduleMockedServerFunction(s, (label) => mockedApi.addTodo(label));
// With newAddTodo = s.scheduleFunction((label) => mockedApi.addTodo(label))
// The mockedApi would have received todo-1 first, followed by todo-2
// When each of those calls resolve would have been the responsibility of s
// In the contrary, with scheduleMockedServerFunction, the mockedApi might receive todo-2 first.
newAddTodo('todo-1'); // .then
newAddTodo('todo-2'); // .then
```

```typescript
const scheduleMockedServerFunction = <TArgs extends unknown[], TOut>(
  s: Scheduler,
  f: (...args: TArgs) => Promise<TOut>,
) => {
  const scheduledF = s.scheduleFunction(f);
  return (...args: TArgs) => {
    return s.schedule(Promise.resolve('Server received the call')).then(() => scheduledF(...args));
  };
};
```

--------------------------------

### shrink()

Source: https://fast-check.dev/docs/api/classes/Arbitrary

Abstract method to shrink a given value. It may rely on context for efficient shrinking.

```APIDOC
## shrink()

> `abstract` **shrink**(`value`, `context`): `Stream`<`Value`<`T`>>

### Description
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.

### Parameters
* `value` (`T`): The value to shrink.
* `context` (`unknown`): Its associated context (the one returned by generate) or `undefined` if no context but `canShrinkWithoutContext(value) === true`.

### Returns
`Stream`<`Value`<`T`>>: Stream of shrinks for value based on context (if provided).

### Remarks
Since 3.0.0
```

--------------------------------

### clone()

Source: https://fast-check.dev/docs/api/functions/clone

Clones the values generated by `arb` to produce fully equal values. Note that these values might not be equal using strict equality (`===`) or loose equality (`==`).

```APIDOC
## Function: clone()

> **clone** <`T`, `N`>(`arb`, `numValues`): `Arbitrary`<`CloneValue`<`T`, `N`, []>>

Defined in: packages/fast-check/src/arbitrary/clone.ts:24

Clone the values generated by `arb` in order to produce fully equal values (might not be equal in terms of === or ==)

## Type Parameters

Type Parameter  
---
`T`
`N` _extends_ `number`

## Parameters

Parameter| Type| Description  
--|---
`arb`| `Arbitrary`<`T`>| Source arbitrary  
`numValues`| `N`| Number of values to produce

## Returns

`Arbitrary`<`CloneValue`<`T`, `N`, []>>

## Remarks

Since 2.5.0
```

--------------------------------

### hasCloneMethod

Source: https://fast-check.dev/docs/api

Checks if an instance has to be cloned.

```APIDOC
## hasCloneMethod

### Description
Check if an instance has to be clone.

### Function
hasCloneMethod(instance: any): boolean
```

--------------------------------

### nextDouble()

Source: https://fast-check.dev/docs/api/classes/Random

Generate a random floating point number between 0.0 (included) and 1.0 (excluded).

```APIDOC
## nextDouble()

### Description
Generate a random floating point number between 0.0 (included) and 1.0 (excluded).

### Returns
- **number**
```

--------------------------------

### domain()

Source: https://fast-check.dev/docs/api/functions/domain

Generates a domain name string. It can take an optional constraints object to customize the generated domains. This function is available since version 1.14.0.

```APIDOC
## Function: domain()

### Description
Generates arbitrary domain names adhering to RFC standards.

### Signature
`domain(constraints?: DomainConstraints): Arbitrary<string>`

### Parameters
#### Optional Parameters
- `constraints` (DomainConstraints) - Constraints to apply when building instances (since 2.22.0)

### Returns
`Arbitrary<string>` - An arbitrary string representing a domain name.

### Remarks
- Available since version 1.14.0.
- For domains having an extension with at least two lowercase characters.
- According to RFC 1034, RFC 1035, RFC 1123 and WHATWG URL Standard.
```

--------------------------------

### date

Source: https://fast-check.dev/docs/api

Generates dates within specified constraints.

```APIDOC
## date

### Description
For date between constraints.min or new Date(-8640000000000000) (included) and constraints.max or new Date(8640000000000000) (included).

### Function
date(constraints?: constraints.DateConstraints)
```

--------------------------------

### date()

Source: https://fast-check.dev/docs/api/functions/date

Generates an arbitrary Date. You can specify constraints to limit the range of generated dates.

```APIDOC
## date()

### Description
Generates an arbitrary Date. You can specify constraints to limit the range of generated dates.

### Signature
date(constraints?: DateConstraints): Arbitrary<Date>

### Parameters
#### Optional Parameters
- **constraints** (DateConstraints) - Constraints to apply when building instances.

### Returns
Arbitrary<Date>

### Remarks
Since 1.17.0

### Example
```javascript
import { date } from '@fast-check/date';

const arbitraryDate = date(); // Generates any date
const specificDate = date({ min: new Date(2023, 0, 1), max: new Date(2023, 11, 31) }); // Generates a date within 2023
```
```

--------------------------------

### cloneIfNeeded

Source: https://fast-check.dev/docs/api

Clones an instance if it has a clone method.

```APIDOC
## cloneIfNeeded

### Description
Clone an instance if needed.

### Function
cloneIfNeeded<T>(value: T): T
```

--------------------------------

### nextInt()

Source: https://fast-check.dev/docs/api/classes/Random

Generate a random integer (32 bits).

```APIDOC
## nextInt()

### Description
Generate a random integer (32 bits).

### Returns
- **number**

### Deprecated
Prefer nextInt with explicit bounds: `nextInt(-2147483648, 2147483647)`
```

--------------------------------

### ipV6

Source: https://fast-check.dev/docs/api

Generates valid IPv6 addresses.

```APIDOC
## ipV6

### Description
For valid IP v6.

### Function
ipV6(): Arbitrary<string>
```

--------------------------------

### nextInt(min, max)

Source: https://fast-check.dev/docs/api/classes/Random

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

```APIDOC
## nextInt(min, max)

### Description
Generate a random integer between min (included) and max (included).

### Parameters
#### Path Parameters
- **min** (number) - Required - Minimal integer value
- **max** (number) - Required - Maximal integer value

### Returns
- **number**
```

--------------------------------

### bigInt64Array()

Source: https://fast-check.dev/docs/api/functions/bigInt64Array

Generates an arbitrary BigInt64Array. You can provide constraints to control the properties of the generated array.

```APIDOC
## Function: bigInt64Array()

> **bigInt64Array**(`constraints?`): `Arbitrary`<`BigInt64Array`<`ArrayBuffer`>>

For BigInt64Array

### Parameters

- **constraints** (`BigIntArrayConstraints`): Optional. Constraints to apply to the generated BigInt64Array.

### Returns

- `Arbitrary`<`BigInt64Array`<`ArrayBuffer`>>: An arbitrary instance that generates BigInt64Array values.

### Remarks

Since version 3.0.0.
```

--------------------------------

### infiniteStream

Source: https://fast-check.dev/docs/api

Produces an infinite stream of values.

```APIDOC
## infiniteStream

### Description
Produce an infinite stream of values.

### Function
infiniteStream<T>(arb: Arbitrary<T>): Stream<T>
```

--------------------------------

### constantFrom() - Basic Usage

Source: https://fast-check.dev/docs/api/functions/constantFrom

Creates an arbitrary that will always produce one of the specified values. All values are equiprobable.

```APIDOC
## constantFrom(...values)

### Description
Generates an arbitrary that produces one of the provided values with equal probability. It expects at least one value, otherwise it should throw.

### Method Signature
`constantFrom<T>(...values: T[]): Arbitrary<T>`

### Parameters
#### `values`
- `...values` (T[]) - Required - Constant values to be produced. All values shrink to the first one.

### Returns
- `Arbitrary<T>` - An arbitrary that produces one of the constant values.

### Remarks
Since 0.0.12
```

--------------------------------

### constant

Source: https://fast-check.dev/docs/api

Generates a constant value.

```APIDOC
## constant

### Description
For `value`.

### Function
constant<T>(value: T): Arbitrary<T>
```

--------------------------------

### join()

Source: https://fast-check.dev/docs/api/classes/Stream

Joins other streams to the current stream, creating a new stream that yields elements from the current stream followed by elements from the other streams. This operation closes the current stream and the others as they are iterated.

```APIDOC
## join(...others: IterableIterator<T, any, any>[]): Stream<T>

### Description
Join `others` Stream to the current Stream.

### Parameters
#### Parameters
- **...others** (IterableIterator<T, any, any>[]) - Streams to join to the current Stream

### Returns
`Stream<T>`

### Remarks
Since 0.0.1
```

--------------------------------

### getState()

Source: https://fast-check.dev/docs/api/classes/Random

Extract the internal state of the internal RandomGenerator backing the current instance of Random.

```APIDOC
## getState()

### Description
Extract the internal state of the internal RandomGenerator backing the current instance of Random.

### Returns
- **readonly number[] | undefined**
```

--------------------------------

### ipV4Extended

Source: https://fast-check.dev/docs/api

Generates valid IPv4 addresses according to WhatWG.

```APIDOC
## ipV4Extended

### Description
For valid IP v4 according to WhatWG.

### Function
ipV4Extended(): Arbitrary<string>
```

--------------------------------

### json

Source: https://fast-check.dev/docs/api

Generates JSON strings.

```APIDOC
## json

### Description
For any JSON strings.

### Function
json(): Arbitrary<string>
```

--------------------------------

### dictionary

Source: https://fast-check.dev/docs/api

Generates dictionaries with keys from `keyArb` and values from `valueArb`.

```APIDOC
## dictionary

### Description
For dictionaries with keys produced by `keyArb` and values from `valueArb`.

### Function
dictionary<TKey, TValue>(keyArb: Arbitrary<TKey>, valueArb: Arbitrary<TValue>): Arbitrary<Map<TKey, TValue>>
```

--------------------------------

### constant()

Source: https://fast-check.dev/docs/api/functions/constant

Generates an arbitrary that always produces the provided value.

```APIDOC
## Function: constant()

> **constant** <`T`>(`value`): `Arbitrary`<`T`>

Defined in: packages/fast-check/src/arbitrary/constant.ts:10

For `value`

## Type Parameters

| Type Parameter |
| --- |
| `T` |

## Parameters

| Parameter | Type | Description |
|---|---|---|
| `value` | `T` | The value to produce |

## Returns

`Arbitrary`<`T`>

## Remarks

Since 0.0.1
```

--------------------------------

### asyncStringify

Source: https://fast-check.dev/docs/api

Converts any value to its fast-check string representation asynchronously.

```APIDOC
## asyncStringify

### Description
Convert any value to its fast-check string representation.

### Function
asyncStringify(value: any): Promise<string>
```

--------------------------------

### Define a List Class for Testing

Source: https://fast-check.dev/docs/advanced/model-based-testing

This TypeScript class represents a simple list with push, pop, and size methods, serving as the real system to be tested.

```typescript
class List {
  data: number[] = [];
  push = (v: number) => this.data.push(v);
  pop = () => this.data.pop()!;
  size = () => this.data.length;
}
```

--------------------------------

### Generate anything without constraints

Source: https://fast-check.dev/docs/api/functions/anything

Use this to generate a wide variety of values including null, undefined, numbers, strings, and objects. This is the most basic usage of the `anything()` function.

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

--------------------------------

### hasToStringMethod

Source: https://fast-check.dev/docs/api

Checks if an instance implements WithToStringMethod.

```APIDOC
## hasToStringMethod

### Description
Check if an instance implements WithToStringMethod.

### Function
hasToStringMethod(instance: any): boolean
```

--------------------------------

### base64String

Source: https://fast-check.dev/docs/api

Generates base64 encoded strings.

```APIDOC
## base64String

### Description
For base64 strings.

### Function
base64String()
```

--------------------------------

### integer

Source: https://fast-check.dev/docs/api

Generates integers within specified min and max constraints.

```APIDOC
## integer

### Description
For integers between min (included) and max (included).

### Function
integer(constraints?: constraints.IntegerConstraints)
```

--------------------------------

### map

Source: https://fast-check.dev/docs/api

Generates Maps with keys from `keyArb` and values from `valueArb`.

```APIDOC
## map

### Description
For Maps with keys produced by `keyArb` and values from `valueArb`.

### Function
map<TKey, TValue>(keyArb: Arbitrary<TKey>, valueArb: Arbitrary<TValue>): Arbitrary<Map<TKey, TValue>>
```

--------------------------------

### cloneIfNeeded

Source: https://fast-check.dev/docs/api/functions/cloneIfNeeded

Clones an instance if it is needed. This function is available since version 2.15.0.

```APIDOC
## Function: cloneIfNeeded()

> **cloneIfNeeded** <`T`>(`instance`): `T`

Defined in: packages/fast-check/src/check/symbols.ts:48

Clone an instance if needed

## Type Parameters

Type Parameter  
---
`T`

## Parameters

Parameter| Type  
---|---
`instance`| `T`  

## Returns

`T`

## Remarks

Since 2.15.0
```
Tokens:
Raw