@fncts/test 0.0.1

package/_src/control/TestAnnotationRenderer/definition.ts

@@ -0,0 +1,49 @@
+import type { TestAnnotation } from "../../data/TestAnnotation.js";
+import type { TestAnnotationMap } from "../../data/TestAnnotationMap.js";
+
+export const enum TestAnnotationRendererTag {
+  LeafRenderer = "LeafRenderer",
+  CompositeRenderer = "CompositeRenderer",
+}
+
+export class LeafRenderer {
+  readonly _tag = TestAnnotationRendererTag.LeafRenderer;
+  constructor(
+    readonly use: <X>(f: <V>(annotation: TestAnnotation<V>, render: (_: List<V>) => Maybe<string>) => X) => X,
+  ) {}
+
+  run(ancestors: List<TestAnnotationMap>, child: TestAnnotationMap): List<string> {
+    return this.use((annotation, render) =>
+      render(
+        Cons(
+          child.get(annotation),
+          ancestors.map((map) => map.get(annotation)),
+        ),
+      ).match(
+        () => List.empty(),
+        (s) => Cons(s, Nil()),
+      ),
+    );
+  }
+}
+
+export class CompositeRenderer {
+  readonly _tag = TestAnnotationRendererTag.CompositeRenderer;
+  constructor(readonly renderers: Vector<TestAnnotationRenderer>) {}
+
+  run(ancestors: List<TestAnnotationMap>, child: TestAnnotationMap): List<string> {
+    return this.renderers.toList.flatMap((renderer) => renderer.run(ancestors, child));
+  }
+}
+
+/**
+ * @tsplus type fncts.test.TestAnnotationRenderer
+ */
+export type TestAnnotationRenderer = LeafRenderer | CompositeRenderer;
+
+/**
+ * @tsplus type fncts.test.TestAnnotationRendererOps
+ */
+export interface TestAnnotationRendererOps {}
+
+export const TestAnnotationRenderer: TestAnnotationRendererOps = {};

package/_src/control/TestAnnotationRenderer.ts

@@ -0,0 +1,4 @@
+// codegen:start { preset: barrel, include: ./TestAnnotationRenderer/*.ts }
+export * from "./TestAnnotationRenderer/api.js";
+export * from "./TestAnnotationRenderer/definition.js";
+// codegen:end

package/_src/control/TestAspect/api.ts

@@ -0,0 +1,122 @@
+import type { TestAspect } from "@fncts/test/control/TestAspect/definition";
+import type { TestSuccess } from "@fncts/test/data/TestSuccess";
+
+import { matchTag, matchTag_ } from "@fncts/base/util/pattern";
+import { Console } from "@fncts/io/Console";
+import { Annotations } from "@fncts/test/control/Annotations";
+import { Live } from "@fncts/test/control/Live";
+import { Spec, TestCase } from "@fncts/test/control/Spec";
+import { TestAnnotation } from "@fncts/test/data/TestAnnotation";
+import { RuntimeFailure, TestFailure } from "@fncts/test/data/TestFailure";
+
+export type TestAspectAtLeastR<R> = TestAspect<R, never>;
+
+export type TestAspectPoly = TestAspect<unknown, never>;
+
+export const id: TestAspectPoly = Function.identity;
+
+export const ignore: TestAspectAtLeastR<Has<Annotations>> = (spec) => spec.when(false);
+
+export function perTest<R, E>(
+  f: <R1, E1>(test: IO<R1, TestFailure<E1>, TestSuccess>) => IO<R & R1, TestFailure<E | E1>, TestSuccess>,
+): TestAspect<R, E> {
+  return (spec) =>
+    spec.transform(
+      matchTag(
+        {
+          Test: ({ test, annotations }) => new TestCase(f(test), annotations),
+        },
+        Function.identity,
+      ),
+    );
+}
+
+export function after<R, E, A>(effect: IO<R, E, A>): TestAspect<R, E> {
+  return perTest<R, E>((test) =>
+    test.result
+      .zipWith(effect.catchAllCause((cause) => IO.fail(new RuntimeFailure(cause))).result, (ex0, ex1) =>
+        ex0.apFirst(ex1),
+      )
+      .flatMap(IO.fromExitNow),
+  );
+}
+
+export function around<R, E, A, R1>(before: IO<R, E, A>, after: (a: A) => IO<R1, never, any>): TestAspect<R & R1, E> {
+  return perTest<R & R1, E>((test) =>
+    before.catchAllCause((c) => IO.fail(new RuntimeFailure(c))).bracket(() => test, after),
+  );
+}
+
+export function aroundAll<R, E, A, R1>(
+  before: IO<R, E, A>,
+  after: (a: A) => IO<R1, never, any>,
+): TestAspect<R & R1, E> {
+  return <R0, E0>(spec: Spec<R0, E0>) =>
+    Spec.scoped<R & R1 & R0, TestFailure<E | E0>, TestSuccess>(
+      IO.acquireRelease(before, after)
+        .mapError((e) => TestFailure.fail(e))
+        .as(spec),
+    );
+}
+
+export function before<R0>(effect: IO<R0, never, any>): TestAspect<R0, never> {
+  return perTest<R0, never>((test) => effect.apSecond(test));
+}
+
+export function beforeAll<R0, E0>(effect: IO<R0, E0, any>): TestAspect<R0, E0> {
+  return aroundAll(effect, () => IO.unit);
+}
+
+export const eventually = perTest((test) => test.eventually);
+
+export function repeat<R0>(schedule: Schedule<R0, TestSuccess, any>): TestAspect<R0 & Has<Annotations>, never> {
+  return perTest<R0 & Has<Annotations>, never>(
+    <R1, E1>(
+      test: IO<R1, TestFailure<E1>, TestSuccess>,
+    ): IO<R0 & R1 & Has<Annotations>, TestFailure<E1>, TestSuccess> =>
+      IO.environmentWithIO((r: Environment<R0 & R1 & Has<Annotations>>) =>
+        test
+          .provideEnvironment(r)
+          .repeat(
+            schedule.zipRight(
+              Schedule.identity<TestSuccess>().tapOutput((_) =>
+                Annotations.annotate(TestAnnotation.Repeated, 1).provideEnvironment(r),
+              ),
+            ),
+          ),
+      ),
+  );
+}
+
+export function timeoutWarning(duration: number): TestAspect<Has<Live>, any> {
+  return <R1, E1>(spec: Spec<R1, E1>) => {
+    const loop = (labels: Vector<string>, spec: Spec<R1, E1>): Spec<R1 & Has<Live>, E1> =>
+      matchTag_(spec.caseValue, {
+        Exec: ({ exec, spec }) => Spec.exec(loop(labels, spec), exec),
+        Labeled: ({ label, spec }) => Spec.labeled(loop(labels.append(label), spec), label),
+        Scoped: ({ scoped }) => Spec.scoped(scoped.map((spec) => loop(labels, spec))),
+        Multiple: ({ specs }) => Spec.multiple(specs.map((spec) => loop(labels, spec))),
+        Test: ({ test, annotations }) => Spec.test(warn(labels, test, duration), annotations),
+      });
+
+    return loop(Vector(), spec);
+  };
+}
+
+function warn<R, E>(labels: Vector<string>, test: IO<R, TestFailure<E>, TestSuccess>, duration: number) {
+  return test.raceWith(
+    Live.withLive(showWarning(labels, duration), (io) => Clock.sleep(duration) > io),
+    (result, fiber) => fiber.interrupt > IO.fromExitNow(result),
+    (_, fiber) => fiber.join,
+  );
+}
+
+function showWarning(labels: Vector<string>, duration: number) {
+  return Live.Live(Console.print(renderWarning(labels, duration)));
+}
+
+function renderWarning(labels: Vector<string>, duration: number) {
+  return `Test ${labels.join(
+    " - ",
+  )} has taken more than ${duration} milliseconds to execute. If this is not expected, consider using TestAspect.timeout to timeout runaway tests for faster diagnostics`;
+}

package/_src/control/TestAspect/definition.ts

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

package/_src/control/TestAspect.ts

@@ -0,0 +1,4 @@
+// codegen:start { preset: barrel, include: ./TestAspect/*.ts }
+export * from "./TestAspect/api.js";
+export * from "./TestAspect/definition.js";
+// codegen:end

package/_src/control/TestClock/api.ts

@@ -0,0 +1,36 @@
+import { IOEnv } from "@fncts/io/IOEnv";
+import { Annotations } from "@fncts/test/control/Annotations";
+import { Live } from "@fncts/test/control/Live";
+import { Data, Start, TestClock } from "@fncts/test/control/TestClock/definition";
+
+/**
+ * @tsplus static fncts.test.TestClockOps make
+ */
+export function make(data: Data): Layer<Has<Live> & Has<Annotations>, never, Has<TestClock>> {
+  return Layer.scoped(
+    IO.gen(function* (_) {
+      const live         = yield* _(IO.service(Live.Tag));
+      const annotations  = yield* _(IO.service(Annotations.Tag));
+      const ref          = yield* _(Ref.make(data));
+      const synchronized = yield* _(Ref.Synchronized.make(Start));
+      const test         = yield* _(
+        IO.acquireRelease(IO.succeed(new TestClock(ref, live, annotations, synchronized)), (tc) => tc.warningDone),
+      );
+      yield* _(IOEnv.services.locallyScopedWith((_) => _.add(test, TestClock.Tag)));
+      return test;
+    }),
+    TestClock.Tag,
+  );
+}
+
+/**
+ * @tsplus static fncts.test.TestClockOps Live
+ */
+export const live: Layer<Has<Live> & Has<Annotations>, never, Has<TestClock>> = TestClock.make(new Data(0, Nil()));
+
+/**
+ * @tsplus static fncts.test.TestClockOps adjust
+ */
+export function adjust(duration: number): IO<Has<TestClock>, never, void> {
+  return IO.serviceWithIO((service: TestClock) => service.adjust(duration), TestClock.Tag);
+}

package/_src/control/TestClock/definition.ts

@@ -0,0 +1,196 @@
+import type { FiberStatus } from "@fncts/io/FiberStatus";
+import type { Annotations } from "@fncts/test/control/Annotations";
+import type { Live } from "@fncts/test/control/Live";
+
+import { matchTag } from "@fncts/base/util/pattern";
+import { Console } from "@fncts/io/Console";
+import { TestAnnotation } from "@fncts/test/data/TestAnnotation";
+
+export class Data {
+  constructor(readonly duration: number, readonly sleeps: List<readonly [number, Future<never, void>]>) {}
+}
+
+export class Sleep {
+  constructor(readonly duration: number, readonly promise: Future<never, void>, readonly fiberId: FiberId) {}
+}
+
+interface Start {
+  readonly _tag: "Start";
+}
+
+interface Pending {
+  readonly _tag: "Pending";
+  readonly fiber: Fiber<never, void>;
+}
+
+interface Done {
+  readonly _tag: "Done";
+}
+
+type WarningData = Start | Pending | Done;
+
+export const Start: WarningData = { _tag: "Start" };
+
+export const Pending = (fiber: Fiber<never, void>): WarningData => ({ _tag: "Pending", fiber });
+
+export const Done: WarningData = { _tag: "Done" };
+
+const warning =
+  "Warning: A test is using time, but is not advancing the test clock, " +
+  "which may result in the test hanging. Use TestClock.adjust to " +
+  "manually advance the time.";
+
+/**
+ * @tsplus static fncts.test.TestClockOps Tag
+ */
+export const TestClockTag = Tag<TestClock>();
+
+/**
+ * @tsplus type fncts.test.TestClock
+ * @tsplus companion fncts.test.TestClockOps
+ */
+export class TestClock extends Clock {
+  constructor(
+    readonly clockState: Ref<Data>,
+    readonly live: Live,
+    readonly annotations: Annotations,
+    readonly warningState: Ref.Synchronized<WarningData>,
+  ) {
+    super();
+  }
+  sleep = (ms: number) => {
+    const self = this;
+    return IO.gen(function* (_) {
+      const promise = yield* _(Future.make<never, void>());
+      const wait    = yield* _(
+        self.clockState.modify((data) => {
+          const end = data.duration + ms;
+          if (end > data.duration) {
+            return [true, new Data(data.duration, data.sleeps.prepend([end, promise]))];
+          } else {
+            return [false, data];
+          }
+        }),
+      );
+      yield* _(
+        IO.defer(() => {
+          if (wait) {
+            return self.warningStart > promise.await;
+          } else {
+            return promise.succeed(undefined) > IO.unit;
+          }
+        }),
+      );
+    });
+  };
+
+  currentTime = this.clockState.get.map((data) => data.duration);
+
+  adjust(duration: number): UIO<void> {
+    return this.warningDone > this.run((d) => d + duration);
+  }
+
+  setDate(date: Date): UIO<void> {
+    return this.setTime(date.getTime());
+  }
+
+  setTime(time: number): UIO<void> {
+    return this.warningDone > this.run((_) => time);
+  }
+
+  sleeps = this.clockState.get.map((data) => data.sleeps.map(([_]) => _));
+
+  get supervizedFibers(): UIO<HashSet<Fiber.Runtime<any, any>>> {
+    return IO.descriptorWith((descriptor) =>
+      this.annotations.get(TestAnnotation.Fibers).flatMap((_) =>
+        _.match(
+          (_) => IO.succeed(HashSet.makeDefault()),
+          (fibers) =>
+            IO.foreach(fibers, (ref) => ref.get)
+              .map((_) => _.foldLeft(HashSet.makeDefault<Fiber.Runtime<any, any>>(), (s0, s1) => s0.union(s1)))
+              .map((set) => set.filter((f) => !Equatable.strictEquals(f.id, descriptor.id))),
+        ),
+      ),
+    );
+  }
+
+  private get freeze(): IO<unknown, void, HashMap<FiberId, FiberStatus>> {
+    return this.supervizedFibers.flatMap((fibers) =>
+      IO.foldLeft(fibers, HashMap.makeDefault<FiberId, FiberStatus>(), (map, fiber) =>
+        fiber.status.flatMap((status) => {
+          switch (status._tag) {
+            case "Done": {
+              return IO.succeed(map.set(fiber.id, status));
+            }
+            case "Suspended": {
+              return IO.succeed(map.set(fiber.id, status));
+            }
+            default: {
+              return IO.fail(undefined);
+            }
+          }
+        }),
+      ),
+    );
+  }
+
+  private get delay(): UIO<void> {
+    return this.live.provide(Clock.sleep(5));
+  }
+
+  private get awaitSuspended(): UIO<void> {
+    return this.suspended
+      .zipWith(this.live.provide(Clock.sleep(10)) > this.suspended, Equatable.strictEquals)
+      .filterOrFail(Function.identity, (): void => undefined).eventually.asUnit;
+  }
+
+  private run(f: (duration: number) => number): UIO<void> {
+    return (
+      this.awaitSuspended >
+      this.clockState.modify((data) => {
+        const end    = f(data.duration);
+        const sorted = data.sleeps.sortWith(([x], [y]) => Number.Ord.compare_(x, y));
+        return sorted.head
+          .flatMap(([duration, promise]) =>
+            duration <= end
+              ? Just([Just([end, promise] as const), new Data(duration, sorted.unsafeTail)] as const)
+              : Nothing(),
+          )
+          .getOrElse([Nothing(), new Data(end, data.sleeps)] as const);
+      })
+    ).flatMap((_) =>
+      _.match(
+        () => IO.unit,
+        ([end, promise]) => promise.succeed(undefined) > IO.yieldNow > this.run(() => end),
+      ),
+    );
+  }
+
+  private get suspended(): IO<unknown, void, HashMap<FiberId, FiberStatus>> {
+    return this.freeze.zip(this.delay > this.freeze).flatMap(([first, last]) => {
+      if (Equatable.strictEquals(first, last)) {
+        return IO.succeedNow(first);
+      } else {
+        return IO.failNow(undefined);
+      }
+    });
+  }
+
+  warningDone: UIO<void> = this.warningState.updateJustIO(
+    matchTag({
+      Start: () => Just(IO(Done)),
+      Pending: ({ fiber }) => Just(fiber.interrupt.as(Done)),
+      Done: () => Nothing(),
+    }),
+  );
+
+  private warningStart: UIO<void> = this.warningState.updateJustIO(
+    matchTag(
+      {
+        Start: () =>
+          Just(this.live.provide(Clock.sleep(5000) > Console.print(warning)).interruptible.fork.map(Pending)),
+      },
+      () => Nothing<IO<unknown, never, WarningData>>(),
+    ),
+  );
+}

package/_src/control/TestClock.ts

@@ -0,0 +1,4 @@
+// codegen:start { preset: barrel, include: ./TestClock/*.ts }
+export * from "./TestClock/api.js";
+export * from "./TestClock/definition.js";
+// codegen:end

package/_src/control/TestConsole/api.ts

@@ -0,0 +1,36 @@
+import { Console } from "@fncts/io/Console";
+import { IOEnv } from "@fncts/io/IOEnv";
+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
+ */
+export function make(data: ConsoleData, debug = true): Layer<Has<Live>, never, Has<TestConsole>> {
+  return Layer.scopedEnvironment(
+    IO.serviceWithIO(
+      (live) =>
+        IO.gen(function* (_) {
+          const ref      = yield* _(Ref.make(data));
+          const debugRef = yield* _(FiberRef.make(debug));
+          const test     = new TestConsole(ref, live, debugRef);
+          yield* _(IOEnv.services.locallyScopedWith((_) => _.add(test, Console.Tag)));
+          return Environment.empty.add(test, TestConsole.Tag);
+        }),
+      Live.Tag,
+    ),
+  );
+}
+
+/**
+ * @tsplus static fncts.test.TestConsoleOps Live
+ */
+export const live = TestConsole.make(
+  new ConsoleData({
+    input: Vector.empty(),
+    output: Vector.empty(),
+    errOutput: Vector.empty(),
+    debugOutput: Vector.empty(),
+  }),
+);

package/_src/control/TestConsole/definition.ts

@@ -0,0 +1,61 @@
+import type { Console } from "@fncts/io/Console";
+import type { Live } from "@fncts/test/control/Live";
+
+import { showWithOptions } from "@fncts/base/typeclass/Showable";
+
+export 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 class TestConsole implements Console {
+  constructor(readonly consoleState: Ref<ConsoleData>, readonly live: Live, readonly debugState: FiberRef<boolean>) {}
+  show(...input: ReadonlyArray<unknown>): UIO<void> {
+    return this.consoleState.update((data) =>
+      data.copy({
+        output: data.output.concat(
+          input.foldLeft(Vector.empty(), (b, a) => b.append(showWithOptions(a, { colors: false }))),
+        ),
+      }),
+    );
+  }
+  print(line: string): UIO<void> {
+    return this.consoleState.update((data) =>
+      data.copy({
+        output: data.output.append(`${line}\n`),
+      }),
+    );
+  }
+  error(line: string): UIO<void> {
+    return this.consoleState.update((data) =>
+      data.copy({
+        errOutput: data.errOutput.append(`${line}\n`),
+      }),
+    );
+  }
+  clearInput  = this.consoleState.update((data) => data.copy({ input: Vector.empty() }));
+  clearOutput = this.consoleState.update((data) => data.copy({ output: Vector.empty() }));
+  output      = this.consoleState.get.map((data) => data.output);
+  errOutput   = this.consoleState.get.map((data) => data.errOutput);
+  debugOutput = this.consoleState.get.map((data) => data.debugOutput);
+  feedLines(...lines: ReadonlyArray<string>): UIO<void> {
+    return this.consoleState.update((data) => data.copy({ input: data.input.concat(Vector.from(lines)) }));
+  }
+  silent<R, E, A>(io: IO<R, E, A>): IO<R, E, A> {
+    return this.debugState.locally(false)(io);
+  }
+  debug<R, E, A>(io: IO<R, E, A>): IO<R, E, A> {
+    return this.debugState.locally(true)(io);
+  }
+}
+
+/**
+ * @tsplus static fncts.test.TestConsoleOps Tag
+ */
+export const TestConsoleTag = Tag<TestConsole>();

package/_src/control/TestConsole.ts

@@ -0,0 +1,4 @@
+// codegen:start { preset: barrel, include: ./TestConsole/*.ts }
+export * from "./TestConsole/api.js";
+export * from "./TestConsole/definition.js";
+// codegen:end

package/_src/control/TestEnvironment.ts

@@ -0,0 +1,30 @@
+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 type TestEnvironment = Has<Annotations> &
+  Has<Live> &
+  Has<Sized> &
+  Has<TestClock> &
+  Has<TestConfig> &
+  Has<TestRandom> &
+  Has<Clock> &
+  Has<Random> &
+  Has<Console> &
+  Has<TestConsole>;
+
+export const LiveTestEnvironment: Layer<IOEnv, never, TestEnvironment> = Annotations.Live.and(Live.Default)
+  .and(Sized.Live(100))
+  .and(TestConfig.Live({ repeats: 100, retries: 100, samples: 200, shrinks: 1000 }))
+  .and(TestRandom.Deterministic)
+  .andTo(TestClock.Live)
+  .andTo(TestConsole.Live);
+
+export const TestEnvironment = IOEnv.Live.to(LiveTestEnvironment);

package/_src/control/TestExecutor.ts

@@ -0,0 +1,54 @@
+import type { TestFailure } from "../data/TestFailure.js";
+import type { TestSuccess } from "../data/TestSuccess.js";
+import type { Annotated, Annotations } from "./Annotations.js";
+import type { Spec, SpecCase } from "./Spec.js";
+import type { ExecutionStrategy } from "@fncts/base/data/ExecutionStrategy";
+
+import { matchTag_ } from "@fncts/base/util/pattern";
+
+import { ExecutedSpec } from "../data/ExecutedSpec.js";
+import { TestAnnotationMap } from "../data/TestAnnotationMap.js";
+import { RuntimeFailure } from "../data/TestFailure.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 function defaultTestExecutor<R>(
+  env: Layer<unknown, never, R & Has<Annotations>>,
+): TestExecutor<R & Has<Annotations>> {
+  return {
+    run: <E>(spec: Spec<R & Has<Annotations>, E>, defExec: ExecutionStrategy): UIO<ExecutedSpec<E>> =>
+      spec.annotated
+        .provideLayer(env)
+        .foreachExec(
+          (cause): UIO<Annotated<Either<TestFailure<E>, TestSuccess>>> =>
+            cause.failureOrCause.match(
+              ([failure, annotations]) => IO.succeedNow([Either.left(failure), annotations]),
+              (cause) => IO.succeedNow([Either.left(new RuntimeFailure(cause)), TestAnnotationMap.empty]),
+            ),
+          ([success, annotations]): UIO<Annotated<Either<TestFailure<E>, TestSuccess>>> =>
+            IO.succeedNow([Either.right(success), annotations]),
+          defExec,
+        )
+        .scoped.flatMap(
+          (s) =>
+            s.foldScoped(
+              (spec: SpecCase<unknown, never, Annotated<Either<TestFailure<E>, TestSuccess>>, ExecutedSpec<E>>) =>
+                matchTag_(spec, {
+                  Exec: ({ spec }) => IO.succeedNow(spec),
+                  Labeled: ({ label, spec }) => IO.succeedNow(ExecutedSpec.labeled(spec, label)),
+                  Scoped: ({ scoped }) => scoped,
+                  Multiple: ({ specs }) => IO.succeedNow(ExecutedSpec.multiple(specs)),
+                  Test: ({ test, annotations }) =>
+                    test.map(([result, dynamicAnnotations]) =>
+                      ExecutedSpec.test(result, annotations.combine(dynamicAnnotations)),
+                    ),
+                }),
+              defExec,
+            ).scoped,
+        ),
+    environment: env,
+  };
+}

package/_src/control/TestLogger.ts

@@ -0,0 +1,37 @@
+import { Console } from "@fncts/io/Console";
+
+/**
+ * @tsplus type fncts.test.TestLogger
+ * @tsplus companion fncts.test.TestLoggerOps
+ */
+export abstract class TestLogger {
+  abstract logLine(line: string): UIO<void>;
+}
+
+/**
+ * @tsplus static fncts.test.TestLoggerOps Tag
+ */
+export const TestLoggerTag = Tag<TestLogger>();
+
+/**
+ * @tsplus static fncts.test.TestLoggerOps fromConsole
+ */
+export const fromConsole: Layer<unknown, never, Has<TestLogger>> = Layer.fromIO(
+  IO.consoleWith((console) =>
+    IO.succeedNow(
+      new (class extends TestLogger {
+        logLine(line: string): UIO<void> {
+          return console.print(line);
+        }
+      })(),
+    ),
+  ),
+  TestLogger.Tag,
+);
+
+/**
+ * @tsplus static fncts.test.TestLoggerOps logLine
+ */
+export function logLine(line: string): URIO<Has<TestLogger>, void> {
+  return IO.serviceWithIO((testLogger) => testLogger.logLine(line), TestLogger.Tag);
+}