tape-check/tape-check.js.flow

Generative property tests for Mocha

/* @flow */

export { gen } from 'testcheck'
import type { Generator, CheckOptions } from 'testcheck'

type Test<T> = (t: T) => void;

declare export var check: {
  <T,A>(
    genA: Generator<A>,
    f: (t: T, a: A) => void
  ): Test<T>;
  <T,A,B>(
    genA: Generator<A>,
    genB: Generator<B>,
    f: (t: T, a: A, b: B) => void
  ): Test<T>;
  <T,A,B,C>(
    genA: Generator<A>,
    genB: Generator<B>,
    genC: Generator<C>,
    f: (t: T, a: A, b: B, c: C) => void
  ): Test<T>;
  <T,A,B,C,D>(
    genA: Generator<A>,
    genB: Generator<B>,
    genC: Generator<C>,
    genD: Generator<D>,
    f: (t: T, a: A, b: B, c: C, d: D) => void
  ): Test<T>;
  <T,A,B,C,D,E>(
    genA: Generator<A>,
    genB: Generator<B>,
    genC: Generator<C>,
    genD: Generator<D>,
    genE: Generator<E>,
    f: (t: T, a: A, b: B, c: C, d: D, e: E) => void
  ): Test<T>;

  <T,A>(
    options: CheckOptions,
    genA: Generator<A>,
    f: (t: T, a: A) => void
  ): Test<T>;
  <T,A,B>(
    options: CheckOptions,
    genA: Generator<A>,
    genB: Generator<B>,
    f: (t: T, a: A, b: B) => void
  ): Test<T>;
  <T,A,B,C>(
    options: CheckOptions,
    genA: Generator<A>,
    genB: Generator<B>,
    genC: Generator<C>,
    f: (t: T, a: A, b: B, c: C) => void
  ): Test<T>;
  <T,A,B,C,D>(
    options: CheckOptions,
    genA: Generator<A>,
    genB: Generator<B>,
    genC: Generator<C>,
    genD: Generator<D>,
    f: (t: T, a: A, b: B, c: C, d: D) => void
  ): Test<T>;
  <T,A,B,C,D,E>(
    options: CheckOptions,
    genA: Generator<A>,
    genB: Generator<B>,
    genC: Generator<C>,
    genD: Generator<D>,
    genE: Generator<E>,
    f: (t: T, a: A, b: B, c: C, d: D, e: E) => void
  ): Test<T>;
};