@fncts/test 0.0.1

package/control/Spec/definition.d.ts

@@ -0,0 +1,96 @@
+import { ExecutionStrategy } from "@fncts/base/data/ExecutionStrategy";
+import { IO } from "@fncts/io/IO";
+import { Has } from "@fncts/base/typeclass";
+import { Scope } from "@fncts/io/Scope";
+import { Conc } from "@fncts/base/collection/immutable/Conc";
+import type { TestAnnotationMap } from "../../data/TestAnnotationMap.js";
+import type { TestFailure } from "../../data/TestFailure.js";
+import type { TestSuccess } from "../../data/TestSuccess.js";
+import type { _A, _E, _R } from "@fncts/base/types.js";
+/**
+ * @tsplus type fncts.test.PSpec
+ * @tsplus companion fncts.test.PSpecOps
+ */
+export declare class PSpec<R, E, T> {
+    readonly caseValue: SpecCase<R, E, T, PSpec<R, E, T>>;
+    readonly _R: (_: R) => void;
+    readonly _E: () => E;
+    readonly _A: () => T;
+    constructor(caseValue: SpecCase<R, E, T, PSpec<R, E, T>>);
+}
+/**
+ * @tsplus type fncts.test.PSpecOps
+ */
+export interface SpecOps {
+}
+export declare const Spec: SpecOps;
+/**
+ * @tsplus type fncts.test.PSpec
+ */
+export declare type Spec<R, E> = PSpec<R, TestFailure<E>, TestSuccess>;
+export declare const enum SpecCaseTag {
+    Exec = "Exec",
+    Labeled = "Labeled",
+    Scoped = "Scoped",
+    Multiple = "Multiple",
+    Test = "Test"
+}
+/**
+ * @tsplus companion fncts.test.PSpec.ExecCaseOps
+ */
+export declare class ExecCase<Spec> {
+    readonly exec: ExecutionStrategy;
+    readonly spec: Spec;
+    readonly _tag = SpecCaseTag.Exec;
+    constructor(exec: ExecutionStrategy, spec: Spec);
+}
+/**
+ * @tsplus companion fncts.test.PSpec.LabeledCaseOps
+ */
+export declare class LabeledCase<Spec> {
+    readonly label: string;
+    readonly spec: Spec;
+    readonly _tag = SpecCaseTag.Labeled;
+    constructor(label: string, spec: Spec);
+}
+/**
+ * @tsplus companion fncts.test.PSpec.ScopedCaseOps
+ */
+export declare class ScopedCase<R, E, Spec> {
+    readonly scoped: IO<R & Has<Scope>, E, Spec>;
+    readonly _tag = SpecCaseTag.Scoped;
+    constructor(scoped: IO<R & Has<Scope>, E, Spec>);
+}
+/**
+ * @tsplus companion fncts.test.PSpec.MultipleCaseOps
+ */
+export declare class MultipleCase<Spec> {
+    readonly specs: Conc<Spec>;
+    readonly _tag = SpecCaseTag.Multiple;
+    constructor(specs: Conc<Spec>);
+}
+/**
+ * @tsplus companion fncts.test.PSpec.TestCaseOps
+ */
+export declare class TestCase<R, E, T> {
+    readonly test: IO<R, E, T>;
+    readonly annotations: TestAnnotationMap;
+    readonly _R: (_: R) => void;
+    readonly _E: () => E;
+    readonly _A: () => T;
+    readonly _tag = SpecCaseTag.Test;
+    constructor(test: IO<R, E, T>, annotations: TestAnnotationMap);
+}
+/**
+ * @tsplus type fncts.test.SpecCase
+ */
+export declare type SpecCase<R, E, T, A> = ExecCase<A> | LabeledCase<A> | ScopedCase<R, E, A> | MultipleCase<A> | TestCase<R, E, T>;
+/**
+ * @tsplus fluent fncts.test.SpecCase isMultiple
+ * @tsplus location "@fncts/test/control/Spec/definition"
+ */
+export declare function isMultiple<R, E, T, A>(self: SpecCase<R, E, T, A>): self is MultipleCase<A>;
+/**
+ * @tsplus unify fncts.test.PSpec
+ */
+export declare function unifyPSpec<X extends PSpec<any, any, any>>(_: X): PSpec<_R<X>, _E<X>, _A<X>>;

package/control/Spec.d.ts

@@ -0,0 +1,2 @@
+export * from "./Spec/api.js";
+export * from "./Spec/definition.js";

package/control/SummaryBuilder.d.ts

@@ -0,0 +1,15 @@
+import { Either } from "@fncts/base/data/Either/definition";
+import { Vector } from "@fncts/base/collection/immutable/Vector";
+import { ExecutedSpec } from "@fncts/test/data/ExecutedSpec";
+import { Summary } from "@fncts/test/data/Summary";
+/**
+ * @tsplus type fncts.test.SummaryBuilder
+ */
+export interface SummaryBuilderOps {
+}
+export declare const SummaryBuilder: SummaryBuilderOps;
+/**
+ * @tsplus static fncts.test.SummaryBuilder buildSummary
+ * @tsplus location "@fncts/test/control/SummaryBuilder"
+ */
+export declare function buildSummary<E>(executedSpec: ExecutedSpec<E>): Summary;

package/control/Test.d.ts

@@ -0,0 +1,20 @@
+import { IO } from "@fncts/io/IO";
+import { Lazy } from "@fncts/base/data/function/definition";
+import type { TestResult } from "../data/FailureDetails.js";
+import { TestFailure } from "../data/TestFailure.js";
+import { TestSuccess } from "../data/TestSuccess.js";
+/**
+ * @tsplus type fncts.control.IO
+ */
+export declare type Test<R, E> = IO<R, TestFailure<E>, TestSuccess>;
+/**
+ * @tsplus type fncts.test.TestOps
+ */
+export interface TestOps {
+}
+export declare const Test: TestOps;
+/**
+ * @tsplus static fncts.test.TestOps fromAssertion
+ * @tsplus location "@fncts/test/control/Test"
+ */
+export declare function fromAssertion<R, E>(assertion: Lazy<IO<R, E, TestResult>>): Test<R, E>;

package/control/TestAnnotationRenderer/api.d.ts

@@ -0,0 +1,42 @@
+import type { TestAnnotationRenderer } from "./definition.js";
+/**
+ * @tsplus fluent fncts.test.TestAnnotationRenderer combine
+ * @tsplus operator fncts.test.TestAnnotationRenderer +
+ * @tsplus location "@fncts/test/control/TestAnnotationRenderer/api"
+ */
+export declare function combine_(self: TestAnnotationRenderer, that: TestAnnotationRenderer): TestAnnotationRenderer;
+/**
+ * @tsplus static fncts.test.TestAnnotationRendererOps Ignored
+ * @tsplus location "@fncts/test/control/TestAnnotationRenderer/api"
+ */
+export declare const ignored: TestAnnotationRenderer;
+/**
+ * @tsplus static fncts.test.TestAnnotationRendererOps Repeated
+ * @tsplus location "@fncts/test/control/TestAnnotationRenderer/api"
+ */
+export declare const repeated: TestAnnotationRenderer;
+/**
+ * @tsplus static fncts.test.TestAnnotationRendererOps Retried
+ * @tsplus location "@fncts/test/control/TestAnnotationRenderer/api"
+ */
+export declare const retried: TestAnnotationRenderer;
+/**
+ * @tsplus static fncts.test.TestAnnotationRendererOps Tagged
+ * @tsplus location "@fncts/test/control/TestAnnotationRenderer/api"
+ */
+export declare const tagged: TestAnnotationRenderer;
+/**
+ * @tsplus static fncts.test.TestAnnotationRendererOps Timed
+ * @tsplus location "@fncts/test/control/TestAnnotationRenderer/api"
+ */
+export declare const timed: TestAnnotationRenderer;
+/**
+ * @tsplus static fncts.test.TestAnnotationRendererOps Silent
+ * @tsplus location "@fncts/test/control/TestAnnotationRenderer/api"
+ */
+export declare const silent: TestAnnotationRenderer;
+/**
+ * @tsplus static fncts.test.TestAnnotationRendererOps Default
+ * @tsplus location "@fncts/test/control/TestAnnotationRenderer/api"
+ */
+export declare const Default: TestAnnotationRenderer;

package/control/TestAnnotationRenderer/definition.d.ts

@@ -0,0 +1,31 @@
+import { List } from "@fncts/base/collection/immutable/List";
+import { Maybe } from "@fncts/base/data/Maybe";
+import { Vector } from "@fncts/base/collection/immutable/Vector";
+import type { TestAnnotation } from "../../data/TestAnnotation.js";
+import type { TestAnnotationMap } from "../../data/TestAnnotationMap.js";
+export declare const enum TestAnnotationRendererTag {
+    LeafRenderer = "LeafRenderer",
+    CompositeRenderer = "CompositeRenderer"
+}
+export declare class LeafRenderer {
+    readonly use: <X>(f: <V>(annotation: TestAnnotation<V>, render: (_: List<V>) => Maybe<string>) => X) => X;
+    readonly _tag = TestAnnotationRendererTag.LeafRenderer;
+    constructor(use: <X>(f: <V>(annotation: TestAnnotation<V>, render: (_: List<V>) => Maybe<string>) => X) => X);
+    run(ancestors: List<TestAnnotationMap>, child: TestAnnotationMap): List<string>;
+}
+export declare class CompositeRenderer {
+    readonly renderers: Vector<TestAnnotationRenderer>;
+    readonly _tag = TestAnnotationRendererTag.CompositeRenderer;
+    constructor(renderers: Vector<TestAnnotationRenderer>);
+    run(ancestors: List<TestAnnotationMap>, child: TestAnnotationMap): List<string>;
+}
+/**
+ * @tsplus type fncts.test.TestAnnotationRenderer
+ */
+export declare type TestAnnotationRenderer = LeafRenderer | CompositeRenderer;
+/**
+ * @tsplus type fncts.test.TestAnnotationRendererOps
+ */
+export interface TestAnnotationRendererOps {
+}
+export declare const TestAnnotationRenderer: TestAnnotationRendererOps;

package/control/TestAnnotationRenderer.d.ts

@@ -0,0 +1,2 @@
+export * from "./TestAnnotationRenderer/api.js";
+export * from "./TestAnnotationRenderer/definition.js";

package/control/TestAspect/api.d.ts

@@ -0,0 +1,23 @@
+import { Has } from "@fncts/base/typeclass";
+import { IO } from "@fncts/io/IO";
+import { Schedule } from "@fncts/io/Schedule/definition";
+import { Environment } from "@fncts/base/data/Environment";
+import { Vector } from "@fncts/base/collection/immutable/Vector";
+import type { TestAspect } from "@fncts/test/control/TestAspect/definition";
+import type { TestSuccess } from "@fncts/test/data/TestSuccess";
+import { Annotations } from "@fncts/test/control/Annotations";
+import { Live } from "@fncts/test/control/Live";
+import { TestFailure } from "@fncts/test/data/TestFailure";
+export declare type TestAspectAtLeastR<R> = TestAspect<R, never>;
+export declare type TestAspectPoly = TestAspect<unknown, never>;
+export declare const id: TestAspectPoly;
+export declare const ignore: TestAspectAtLeastR<Has<Annotations>>;
+export declare function perTest<R, E>(f: <R1, E1>(test: IO<R1, TestFailure<E1>, TestSuccess>) => IO<R & R1, TestFailure<E | E1>, TestSuccess>): TestAspect<R, E>;
+export declare function after<R, E, A>(effect: IO<R, E, A>): TestAspect<R, E>;
+export declare function around<R, E, A, R1>(before: IO<R, E, A>, after: (a: A) => IO<R1, never, any>): TestAspect<R & R1, E>;
+export declare function aroundAll<R, E, A, R1>(before: IO<R, E, A>, after: (a: A) => IO<R1, never, any>): TestAspect<R & R1, E>;
+export declare function before<R0>(effect: IO<R0, never, any>): TestAspect<R0, never>;
+export declare function beforeAll<R0, E0>(effect: IO<R0, E0, any>): TestAspect<R0, E0>;
+export declare const eventually: TestAspect<unknown, unknown>;
+export declare function repeat<R0>(schedule: Schedule<R0, TestSuccess, any>): TestAspect<R0 & Has<Annotations>, never>;
+export declare function timeoutWarning(duration: number): TestAspect<Has<Live>, any>;

package/control/TestAspect/definition.d.ts

@@ -0,0 +1,2 @@
+import type { Spec } from "@fncts/test/control/Spec";
+export declare type TestAspect<R, E> = <R1, E1>(spec: Spec<R1, E1>) => Spec<R & R1, E | E1>;

package/control/TestAspect.d.ts

@@ -0,0 +1,2 @@
+export * from "./TestAspect/api.js";
+export * from "./TestAspect/definition.js";

package/control/TestClock/api.d.ts

@@ -0,0 +1,21 @@
+import { Layer } from "@fncts/io/Layer";
+import { Has } from "@fncts/base/typeclass";
+import { IO } from "@fncts/io/IO";
+import { Annotations } from "@fncts/test/control/Annotations";
+import { Live } from "@fncts/test/control/Live";
+import { Data, TestClock } from "@fncts/test/control/TestClock/definition";
+/**
+ * @tsplus static fncts.test.TestClockOps make
+ * @tsplus location "@fncts/test/control/TestClock/api"
+ */
+export declare function make(data: Data): Layer<Has<Live> & Has<Annotations>, never, Has<TestClock>>;
+/**
+ * @tsplus static fncts.test.TestClockOps Live
+ * @tsplus location "@fncts/test/control/TestClock/api"
+ */
+export declare const live: Layer<Has<Live> & Has<Annotations>, never, Has<TestClock>>;
+/**
+ * @tsplus static fncts.test.TestClockOps adjust
+ * @tsplus location "@fncts/test/control/TestClock/api"
+ */
+export declare function adjust(duration: number): IO<Has<TestClock>, never, void>;

package/control/TestClock/definition.d.ts

@@ -0,0 +1,66 @@
+import { List } from "@fncts/base/collection/immutable/List";
+import { Future } from "@fncts/io/Future";
+import { FiberId } from "@fncts/base/data/FiberId/definition";
+import { Fiber } from "@fncts/io/Fiber";
+import { Ref } from "@fncts/io/Ref";
+import { UIO, IO } from "@fncts/io/IO";
+import { HashSet } from "@fncts/base/collection/immutable/HashSet";
+import { HashMap } from "@fncts/base/collection/immutable/HashMap";
+import type { Annotations } from "@fncts/test/control/Annotations";
+import type { Live } from "@fncts/test/control/Live";
+export declare class Data {
+    readonly duration: number;
+    readonly sleeps: List<readonly [number, Future<never, void>]>;
+    constructor(duration: number, sleeps: List<readonly [number, Future<never, void>]>);
+}
+export declare class Sleep {
+    readonly duration: number;
+    readonly promise: Future<never, void>;
+    readonly fiberId: FiberId;
+    constructor(duration: number, promise: Future<never, void>, fiberId: FiberId);
+}
+interface Start {
+    readonly _tag: "Start";
+}
+interface Pending {
+    readonly _tag: "Pending";
+    readonly fiber: Fiber<never, void>;
+}
+interface Done {
+    readonly _tag: "Done";
+}
+declare type WarningData = Start | Pending | Done;
+export declare const Start: WarningData;
+export declare const Pending: (fiber: Fiber<never, void>) => WarningData;
+export declare const Done: WarningData;
+/**
+ * @tsplus static fncts.test.TestClockOps Tag
+ * @tsplus location "@fncts/test/control/TestClock/definition"
+ */
+export declare const TestClockTag: import("@fncts/base/data/Tag").Tag<TestClock>;
+/**
+ * @tsplus type fncts.test.TestClock
+ * @tsplus companion fncts.test.TestClockOps
+ */
+export declare class TestClock extends Clock {
+    readonly clockState: Ref<Data>;
+    readonly live: Live;
+    readonly annotations: Annotations;
+    readonly warningState: Ref.Synchronized<WarningData>;
+    constructor(clockState: Ref<Data>, live: Live, annotations: Annotations, warningState: Ref.Synchronized<WarningData>);
+    sleep: (ms: number) => import("@fncts/io/IO").IO<unknown, never, void>;
+    currentTime: import("@fncts/io/IO").IO<unknown, never, number>;
+    adjust(duration: number): UIO<void>;
+    setDate(date: Date): UIO<void>;
+    setTime(time: number): UIO<void>;
+    sleeps: import("@fncts/io/IO").IO<unknown, never, import("@fncts/base/collection/immutable/List").List<number>>;
+    get supervizedFibers(): UIO<HashSet<Fiber.Runtime<any, any>>>;
+    private get freeze();
+    private get delay();
+    private get awaitSuspended();
+    private run;
+    private get suspended();
+    warningDone: UIO<void>;
+    private warningStart;
+}
+export {};

package/control/TestClock.d.ts

@@ -0,0 +1,2 @@
+export * from "./TestClock/api.js";
+export * from "./TestClock/definition.js";

package/control/TestConsole/api.d.ts

@@ -0,0 +1,15 @@
+import { Layer } from "@fncts/io/Layer";
+import { Has } from "@fncts/base/typeclass";
+import { Live } from "@fncts/test/control/Live";
+import { ConsoleData } from "@fncts/test/control/TestConsole/definition";
+import { TestConsole } from "@fncts/test/control/TestConsole/definition";
+/**
+ * @tsplus static fncts.test.TestConsoleOps make
+ * @tsplus location "@fncts/test/control/TestConsole/api"
+ */
+export declare function make(data: ConsoleData, debug?: boolean): Layer<Has<Live>, never, Has<TestConsole>>;
+/**
+ * @tsplus static fncts.test.TestConsoleOps Live
+ * @tsplus location "@fncts/test/control/TestConsole/api"
+ */
+export declare const live: import("@fncts/io/Layer").Layer<import("@fncts/base/typeclass").Has<Live>, never, import("@fncts/base/typeclass").Has<TestConsole>>;

package/control/TestConsole/definition.d.ts

@@ -0,0 +1,39 @@
+import { Vector } from "@fncts/base/collection/immutable/Vector";
+import { Ref } from "@fncts/io/Ref";
+import { FiberRef } from "@fncts/io/FiberRef";
+import { UIO, IO } from "@fncts/io/IO";
+import type { Console } from "@fncts/io/Console";
+import type { Live } from "@fncts/test/control/Live";
+export declare class ConsoleData extends CaseClass<{
+    readonly input: Vector<string>;
+    readonly output: Vector<string>;
+    readonly errOutput: Vector<string>;
+    readonly debugOutput: Vector<string>;
+}> {
+}
+/**
+ * @tsplus type fncts.test.TestConsole
+ * @tsplus companion fncts.test.TestConsoleOps
+ */
+export declare class TestConsole implements Console {
+    readonly consoleState: Ref<ConsoleData>;
+    readonly live: Live;
+    readonly debugState: FiberRef<boolean>;
+    constructor(consoleState: Ref<ConsoleData>, live: Live, debugState: FiberRef<boolean>);
+    show(...input: ReadonlyArray<unknown>): UIO<void>;
+    print(line: string): UIO<void>;
+    error(line: string): UIO<void>;
+    clearInput: import("@fncts/io/IO").IO<unknown, never, void>;
+    clearOutput: import("@fncts/io/IO").IO<unknown, never, void>;
+    output: import("@fncts/io/IO").IO<unknown, never, import("@fncts/base/collection/immutable/Vector").Vector<string>>;
+    errOutput: import("@fncts/io/IO").IO<unknown, never, import("@fncts/base/collection/immutable/Vector").Vector<string>>;
+    debugOutput: import("@fncts/io/IO").IO<unknown, never, import("@fncts/base/collection/immutable/Vector").Vector<string>>;
+    feedLines(...lines: ReadonlyArray<string>): UIO<void>;
+    silent<R, E, A>(io: IO<R, E, A>): IO<R, E, A>;
+    debug<R, E, A>(io: IO<R, E, A>): IO<R, E, A>;
+}
+/**
+ * @tsplus static fncts.test.TestConsoleOps Tag
+ * @tsplus location "@fncts/test/control/TestConsole/definition"
+ */
+export declare const TestConsoleTag: import("@fncts/base/data/Tag").Tag<TestConsole>;

package/control/TestConsole.d.ts

@@ -0,0 +1,2 @@
+export * from "./TestConsole/api.js";
+export * from "./TestConsole/definition.js";

package/control/TestEnvironment.d.ts

@@ -0,0 +1,16 @@
+import { Has } from "@fncts/base/typeclass";
+import { Clock } from "@fncts/io/Clock";
+import { Random } from "@fncts/io/Random";
+import { Layer } from "@fncts/io/Layer";
+import type { Console } from "@fncts/io/Console";
+import { IOEnv } from "@fncts/io/IOEnv";
+import { Annotations } from "@fncts/test/control/Annotations";
+import { Live } from "@fncts/test/control/Live";
+import { Sized } from "@fncts/test/control/Sized";
+import { TestClock } from "@fncts/test/control/TestClock";
+import { TestConsole } from "@fncts/test/control/TestConsole";
+import { TestRandom } from "@fncts/test/control/TestRandom";
+import { TestConfig } from "@fncts/test/data/TestConfig";
+export declare type TestEnvironment = Has<Annotations> & Has<Live> & Has<Sized> & Has<TestClock> & Has<TestConfig> & Has<TestRandom> & Has<Clock> & Has<Random> & Has<Console> & Has<TestConsole>;
+export declare const LiveTestEnvironment: Layer<IOEnv, never, TestEnvironment>;
+export declare const TestEnvironment: import("@fncts/io/Layer").Layer<unknown, never, TestEnvironment>;

package/control/TestExecutor.d.ts

@@ -0,0 +1,13 @@
+import { Has } from "@fncts/base/typeclass";
+import { UIO } from "@fncts/io/IO";
+import { Layer } from "@fncts/io/Layer";
+import { Either } from "@fncts/base/data/Either/definition";
+import type { Annotations } from "./Annotations.js";
+import type { Spec } from "./Spec.js";
+import type { ExecutionStrategy } from "@fncts/base/data/ExecutionStrategy";
+import { ExecutedSpec } from "../data/ExecutedSpec.js";
+export interface TestExecutor<R> {
+    readonly run: <E>(spec: Spec<R & Has<Annotations>, E>, defExec: ExecutionStrategy) => UIO<ExecutedSpec<E>>;
+    readonly environment: Layer<unknown, never, R>;
+}
+export declare function defaultTestExecutor<R>(env: Layer<unknown, never, R & Has<Annotations>>): TestExecutor<R & Has<Annotations>>;

package/control/TestLogger.d.ts

@@ -0,0 +1,25 @@
+import { UIO, URIO } from "@fncts/io/IO";
+import { Layer } from "@fncts/io/Layer";
+import { Has } from "@fncts/base/typeclass";
+/**
+ * @tsplus type fncts.test.TestLogger
+ * @tsplus companion fncts.test.TestLoggerOps
+ */
+export declare abstract class TestLogger {
+    abstract logLine(line: string): UIO<void>;
+}
+/**
+ * @tsplus static fncts.test.TestLoggerOps Tag
+ * @tsplus location "@fncts/test/control/TestLogger"
+ */
+export declare const TestLoggerTag: import("@fncts/base/data/Tag").Tag<TestLogger>;
+/**
+ * @tsplus static fncts.test.TestLoggerOps fromConsole
+ * @tsplus location "@fncts/test/control/TestLogger"
+ */
+export declare const fromConsole: Layer<unknown, never, Has<TestLogger>>;
+/**
+ * @tsplus static fncts.test.TestLoggerOps logLine
+ * @tsplus location "@fncts/test/control/TestLogger"
+ */
+export declare function logLine(line: string): URIO<Has<TestLogger>, void>;

package/control/TestRandom/api.d.ts

@@ -0,0 +1,49 @@
+import { Byte } from "@fncts/base/data/Byte";
+import { Layer } from "@fncts/io/Layer";
+import { Has } from "@fncts/base/typeclass";
+import { Data, TestRandom } from "@fncts/test/control/TestRandom";
+/**
+ * @tsplus static fncts.test.TestRandom feedInts
+ * @tsplus location "@fncts/test/control/TestRandom/api"
+ */
+export declare function feedInts(...ints: ReadonlyArray<number>): import("@fncts/io/IO").IO<import("@fncts/base/typeclass").Has<TestRandom>, never, void>;
+/**
+ * @tsplus static fncts.test.TestRandom feedBytes
+ * @tsplus location "@fncts/test/control/TestRandom/api"
+ */
+export declare function feedBytes(...bytes: ReadonlyArray<ReadonlyArray<Byte>>): import("@fncts/io/IO").IO<import("@fncts/base/typeclass").Has<TestRandom>, never, void>;
+/**
+ * @tsplus static fncts.test.TestRandom feedChars
+ * @tsplus location "@fncts/test/control/TestRandom/api"
+ */
+export declare function feedChars(...chars: ReadonlyArray<string>): import("@fncts/io/IO").IO<import("@fncts/base/typeclass").Has<TestRandom>, never, void>;
+/**
+ * @tsplus static fncts.test.TestRandom feedDoubles
+ * @tsplus location "@fncts/test/control/TestRandom/api"
+ */
+export declare function feedDoubles(...doubles: ReadonlyArray<number>): import("@fncts/io/IO").IO<import("@fncts/base/typeclass").Has<TestRandom>, never, void>;
+/**
+ * @tsplus static fncts.test.TestRandom feedStrings
+ * @tsplus location "@fncts/test/control/TestRandom/api"
+ */
+export declare function feedStrings(...strings: ReadonlyArray<string>): import("@fncts/io/IO").IO<import("@fncts/base/typeclass").Has<TestRandom>, never, void>;
+/**
+ * @tsplus static fncts.test.TestRandom feedBooleans
+ * @tsplus location "@fncts/test/control/TestRandom/api"
+ */
+export declare function feedBooleans(...booleans: ReadonlyArray<boolean>): import("@fncts/io/IO").IO<import("@fncts/base/typeclass").Has<TestRandom>, never, void>;
+/**
+ * @tsplus static fncts.test.TestRandomOps make
+ * @tsplus location "@fncts/test/control/TestRandom/api"
+ */
+export declare function make(initialData: Data): Layer<unknown, never, unknown & Has<TestRandom>>;
+/**
+ * @tsplus static fncts.test.TestRandomOps Deterministic
+ * @tsplus location "@fncts/test/control/TestRandom/api"
+ */
+export declare const determinictic: import("@fncts/io/Layer").Layer<unknown, never, import("@fncts/base/typeclass").Has<TestRandom>>;
+/**
+ * @tsplus static fncts.test.TestRandomOps Random
+ * @tsplus location "@fncts/test/control/TestRandom/api"
+ */
+export declare const random: Layer<unknown, never, Has<TestRandom>>;

package/control/TestRandom/definition.d.ts

@@ -0,0 +1,91 @@
+import { Random } from "@fncts/io/Random";
+import { Ref } from "@fncts/io/Ref";
+import { UIO } from "@fncts/io/IO";
+import { Byte } from "@fncts/base/data/Byte";
+import { Maybe } from "@fncts/base/data/Maybe";
+import { List } from "@fncts/base/collection/immutable/List";
+import { ImmutableQueue } from "@fncts/base/collection/immutable/Queue";
+import { Vector } from "@fncts/base/collection/immutable/Vector";
+import type { ArrayInt } from "@fncts/base/util/rand";
+/**
+ * @tsplus static fncts.test.TestRandomOps Tag
+ * @tsplus location "@fncts/test/control/TestRandom/definition"
+ */
+export declare const TestRandomTag: import("@fncts/base/data/Tag").Tag<TestRandom>;
+/**
+ * @tsplus type fncts.test.TestRandom
+ * @tsplus companion fncts.test.TestRandomOps
+ */
+export declare class TestRandom implements Random {
+    readonly randomState: Ref<Data>;
+    readonly bufferState: Ref<Buffer>;
+    constructor(randomState: Ref<Data>, bufferState: Ref<Buffer>);
+    clearBooleans: UIO<void>;
+    clearBytes: UIO<void>;
+    clearChars: UIO<void>;
+    clearDoubles: UIO<void>;
+    clearInts: UIO<void>;
+    clearStrings: UIO<void>;
+    feedBooleans(...booleans: ReadonlyArray<boolean>): UIO<void>;
+    feedBytes(...bytes: ReadonlyArray<ReadonlyArray<Byte>>): UIO<void>;
+    feedChars(...chars: ReadonlyArray<string>): UIO<void>;
+    feedDoubles(...doubles: ReadonlyArray<number>): UIO<void>;
+    feedInts(...ints: ReadonlyArray<number>): UIO<void>;
+    feedStrings(...strings: ReadonlyArray<string>): UIO<void>;
+    getSeed: UIO<number>;
+    setSeed(seed: number): UIO<void>;
+    private bufferedBoolean;
+    private bufferedDouble;
+    private bufferedInt;
+    private getOrElse;
+    private leastSignificantBits;
+    private mostSignificantBits;
+    private randomBits;
+    private randomBoolean;
+    private randomBytes;
+    private randomIntBounded;
+    private randomLong;
+    private randomInt;
+    private randomDouble;
+    private random;
+    get nextInt(): UIO<number>;
+    get nextBoolean(): UIO<boolean>;
+    get nextDouble(): UIO<number>;
+    get next(): UIO<number>;
+    nextBigIntBetween(low: bigint, high: bigint): UIO<bigint>;
+    nextIntBetween(low: number, high: number): UIO<number>;
+    nextRange(low: number, high: number): UIO<number>;
+    nextArrayIntBetween(low: ArrayInt, high: ArrayInt): UIO<ArrayInt>;
+}
+export declare class Data {
+    readonly seed1: number;
+    readonly seed2: number;
+    readonly nextNextGaussians: ImmutableQueue<number>;
+    constructor(seed1: number, seed2: number, nextNextGaussians?: ImmutableQueue<number>);
+}
+export declare class Buffer {
+    readonly booleans: Vector<boolean>;
+    readonly bytes: Vector<ReadonlyArray<Byte>>;
+    readonly chars: Vector<string>;
+    readonly doubles: Vector<number>;
+    readonly integers: Vector<number>;
+    readonly strings: Vector<string>;
+    constructor(booleans?: Vector<boolean>, bytes?: Vector<ReadonlyArray<Byte>>, chars?: Vector<string>, doubles?: Vector<number>, integers?: Vector<number>, strings?: Vector<string>);
+    copy(_: Partial<Buffer>): Buffer;
+}
+export declare function substractArrayIntToNew(arrayIntA: ArrayInt, arrayIntB: ArrayInt): ArrayInt;
+/**
+ * Trim uneeded zeros in ArrayInt
+ * and uniform notation for zero: {sign: 1, data: [0]}
+ */
+export declare function trimArrayIntInplace(arrayInt: ArrayInt): ArrayInt;
+/**
+ * Add two ArrayInt
+ * @internal
+ */
+export declare function addArrayIntToNew(arrayIntA: ArrayInt, arrayIntB: ArrayInt): ArrayInt;
+/**
+ * Add one to a given positive ArrayInt
+ * @internal
+ */
+export declare function addOneToPositiveArrayInt(arrayInt: ArrayInt): ArrayInt;

package/control/TestRandom.d.ts

@@ -0,0 +1,2 @@
+export * from "./TestRandom/api.js";
+export * from "./TestRandom/definition.js";

package/control/TestRenderer/ConsoleRenderer.d.ts

@@ -0,0 +1,15 @@
+import { Vector } from "@fncts/base/collection/immutable/Vector";
+import { List } from "@fncts/base/collection/immutable/List";
+import type { ExecutionResult } from "../../data/ExecutionResult.js";
+import type { TestAnnotationRenderer } from "../TestAnnotationRenderer.js";
+/**
+ * @tsplus type fncts.test.ConsoleRenderer
+ */
+export interface ConsoleRenderer {
+}
+export declare const ConsoleRenderer: ConsoleRenderer;
+/**
+ * @tsplus static fncts.test.ConsoleRenderer render
+ * @tsplus location "@fncts/test/control/TestRenderer/ConsoleRenderer"
+ */
+export declare function render(results: Vector<ExecutionResult>, testAnnotationRenderer: TestAnnotationRenderer): Vector<string>;

package/control/TestRenderer/definition.d.ts

@@ -0,0 +1,4 @@
+import { Vector } from "@fncts/base/collection/immutable/Vector";
+import type { ExecutionResult } from "../../data/ExecutionResult.js";
+import type { TestAnnotationRenderer } from "../TestAnnotationRenderer.js";
+export declare type TestRenderer = (results: Vector<ExecutionResult>, testAnnotationRenderer: TestAnnotationRenderer) => Vector<string>;