@fncts/test 0.0.1

package/_src/data/AssertionValue/api.ts

@@ -0,0 +1,48 @@
+import { showWithOptions } from "@fncts/base/typeclass/Showable";
+
+import { AssertionValue } from "./definition.js";
+
+/**
+ * @tsplus fluent fncts.test.data.AssertionValue label
+ */
+export function label<A>(self: AssertionValue<A>, string: string): AssertionValue<A> {
+  return new AssertionValue(
+    LazyValue(() => self.assertion.value.label(string)),
+    self.value,
+    self.result,
+    self.expression,
+    self.sourceLocation,
+  );
+}
+
+/**
+ * @tsplus fluent fncts.test.data.AssertionValue isSameAssertionAs
+ */
+export function isSameAssertionAs<A>(self: AssertionValue<A>, that: AssertionValue<A>): boolean {
+  return self.assertion.value.rendered === that.assertion.value.rendered;
+}
+
+/**
+ * @tsplus fluent fncts.test.data.AssertionValue showValue
+ */
+export function showValue<A>(self: AssertionValue<A>, offset = 0): string {
+  return showWithOptions(self.value, { indentationLevel: offset });
+}
+
+/**
+ * @tsplus getter fncts.test.data.AssertionValue printAssertion
+ */
+export function printAssertion<A>(self: AssertionValue<A>): string {
+  return self.assertion.value.rendered;
+}
+
+/**
+ * @tsplus fluent fncts.test.data.AssertionValue withContext
+ */
+export function withContext<A>(
+  self: AssertionValue<A>,
+  expr: Maybe<string>,
+  sourceLocation: Maybe<string>,
+): AssertionValue<A> {
+  return new AssertionValue(self.assertion, self.value, self.result, expr, sourceLocation);
+}

package/_src/data/AssertionValue/definition.ts

@@ -0,0 +1,20 @@
+import type { AssertionIO } from "../../control/AssertionIO/definition.js";
+import type { FreeBooleanAlgebra } from "../FreeBooleanAlgebra.js";
+
+export const AssertionValueTypeId = Symbol.for("fncts.test.data.AssertionValue");
+export type AssertionValueTypeId = typeof AssertionValueTypeId;
+
+/**
+ * @tsplus type fncts.test.data.AssertionValue
+ * @tsplus companion fncts.test.data.AssertionValueOps
+ */
+export class AssertionValue<A> {
+  readonly _typeId: AssertionValueTypeId = AssertionValueTypeId;
+  constructor(
+    readonly assertion: LazyValue<AssertionIO<A>>,
+    readonly value: A,
+    readonly result: LazyValue<FreeBooleanAlgebra<AssertionValue<A>>>,
+    readonly expression: Maybe<string> = Nothing(),
+    readonly sourceLocation: Maybe<string> = Nothing(),
+  ) {}
+}

package/_src/data/AssertionValue.ts

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

package/_src/data/ExecutedSpec/api.ts

@@ -0,0 +1,96 @@
+import type { TestAnnotationMap } from "../TestAnnotationMap.js";
+import type { TestFailure } from "../TestFailure.js";
+import type { TestSuccess } from "../TestSuccess.js";
+import type { SpecCase } from "./definition.js";
+
+import { identity } from "@fncts/base/data/function";
+import { matchTag, matchTag_ } from "@fncts/base/util/pattern";
+
+import { ExecutedSpec, TestCase } from "./definition.js";
+import { LabeledCase, MultipleCase } from "./definition.js";
+
+/**
+ * @tsplus fluent fncts.test.data.ExecutedSpec fold
+ */
+export function fold_<E, Z>(self: ExecutedSpec<E>, f: (_: SpecCase<E, Z>) => Z): Z {
+  return matchTag_(self.caseValue, {
+    Labeled: ({ label, spec }) => f(new LabeledCase(label, spec.fold(f))),
+    Multiple: ({ specs }) => f(new MultipleCase(specs.map((spec) => spec.fold(f)))),
+    Test: f,
+  });
+}
+
+/**
+ * @tsplus static fncts.test.data.ExecutedSpecOps labeled
+ */
+export function labeled<E>(spec: ExecutedSpec<E>, label: string): ExecutedSpec<E> {
+  return new ExecutedSpec(new LabeledCase(label, spec));
+}
+
+/**
+ * @tsplus fluent fncts.test.data.ExecutedSpecCase map
+ */
+export function mapSpecCase_<E, A, B>(self: SpecCase<E, A>, f: (a: A) => B): SpecCase<E, B> {
+  return matchTag_(
+    self,
+    {
+      Labeled: ({ label, spec }) => new LabeledCase(label, f(spec)),
+      Multiple: ({ specs }) => new MultipleCase(specs.map(f)),
+    },
+    identity,
+  );
+}
+
+/**
+ * @tsplus static fncts.test.data.ExecutedSpecOps multiple
+ */
+export function multiple<E>(specs: Conc<ExecutedSpec<E>>): ExecutedSpec<E> {
+  return new ExecutedSpec(new MultipleCase(specs));
+}
+
+/**
+ * @tsplus static fncts.test.data.ExecutedSpecOps test
+ */
+export function test<E>(test: Either<TestFailure<E>, TestSuccess>, annotations: TestAnnotationMap): ExecutedSpec<E> {
+  return new ExecutedSpec(new TestCase(test, annotations));
+}
+
+/**
+ * @tsplus fluent fncts.test.data.ExecutedSpec transform
+ */
+export function transform_<E, E1>(
+  self: ExecutedSpec<E>,
+  f: (_: SpecCase<E, ExecutedSpec<E1>>) => SpecCase<E1, ExecutedSpec<E1>>,
+): ExecutedSpec<E1> {
+  return matchTag_(self.caseValue, {
+    Labeled: ({ label, spec }) => new ExecutedSpec(f(new LabeledCase(label, spec.transform(f)))),
+    Multiple: ({ specs }) => new ExecutedSpec(f(new MultipleCase(specs.map((spec) => spec.transform(f))))),
+    Test: (t) => new ExecutedSpec(f(t)),
+  });
+}
+
+/**
+ * @tsplus fluent fncts.test.data.ExecutedSpec exists
+ */
+export function exists_<E>(self: ExecutedSpec<E>, f: (_: SpecCase<E, boolean>) => boolean): boolean {
+  return self.fold(
+    matchTag({
+      Labeled: (c) => c.spec || f(c),
+      Multiple: (c) => c.specs.exists(identity) || f(c),
+      Test: f,
+    }),
+  );
+}
+
+/**
+ * @tsplus getter fncts.test.data.ExecutedSpec size
+ */
+export function size<E>(self: ExecutedSpec<E>): number {
+  return self.fold(
+    matchTag({
+      Labeled: ({ spec }) => spec,
+      Multiple: ({ specs }) => specs.foldLeft(0, (b, a) => b + a),
+      Test: () => 1,
+    }),
+  );
+}

package/_src/data/ExecutedSpec/definition.ts

@@ -0,0 +1,37 @@
+import type { TestAnnotationMap } from "../TestAnnotationMap.js";
+import type { TestFailure } from "../TestFailure.js";
+import type { TestSuccess } from "../TestSuccess.js";
+
+export const enum ExecutedSpecCaseTag {
+  Test = "Test",
+  Labeled = "Labeled",
+  Multiple = "Multiple",
+}
+
+/**
+ * @tsplus type fncts.test.data.ExecutedSpec
+ * @tsplus companion fncts.test.data.ExecutedSpecOps
+ */
+export class ExecutedSpec<E> {
+  constructor(readonly caseValue: SpecCase<E, ExecutedSpec<E>>) {}
+}
+
+export class TestCase<E> {
+  readonly _tag = ExecutedSpecCaseTag.Test;
+  constructor(readonly test: Either<TestFailure<E>, TestSuccess>, readonly annotations: TestAnnotationMap) {}
+}
+
+export class LabeledCase<A> {
+  readonly _tag = ExecutedSpecCaseTag.Labeled;
+  constructor(readonly label: string, readonly spec: A) {}
+}
+
+export class MultipleCase<A> {
+  readonly _tag = ExecutedSpecCaseTag.Multiple;
+  constructor(readonly specs: Conc<A>) {}
+}
+
+/**
+ * @tsplus type fncts.test.data.ExecutedSpecCase
+ */
+export type SpecCase<E, A> = TestCase<E> | LabeledCase<A> | MultipleCase<A>;

package/_src/data/ExecutedSpec.ts

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

package/_src/data/ExecutionResult.ts

@@ -0,0 +1,153 @@
+import type { Line } from "./LogLine/Line.js";
+import type { TestAnnotationMap } from "./TestAnnotationMap.js";
+
+import { matchTag_ } from "@fncts/base/util/pattern";
+
+export interface Failed {
+  readonly _tag: "Failed";
+}
+
+export const Failed: Failed = {
+  _tag: "Failed",
+};
+
+export interface Passed {
+  readonly _tag: "Passed";
+}
+
+export const Passed: Passed = {
+  _tag: "Passed",
+};
+
+export interface Ignored {
+  readonly _tag: "Ignored";
+}
+
+export const Ignored: Ignored = {
+  _tag: "Ignored",
+};
+
+export type Status = Failed | Passed | Ignored;
+
+interface Test {
+  readonly _tag: "Test";
+}
+
+export const Test: ResultType = {
+  _tag: "Test",
+};
+
+export interface Suite {
+  readonly _tag: "Suite";
+}
+
+export const Suite: ResultType = {
+  _tag: "Suite",
+};
+
+export interface Other {
+  readonly _tag: "Other";
+}
+
+export const Other: ResultType = {
+  _tag: "Other",
+};
+
+export type ResultType = Test | Suite | Other;
+
+/**
+ * @tsplus type fncts.test.ExecutionResult
+ */
+export class ExecutionResult {
+  constructor(
+    readonly resultType: ResultType,
+    readonly label: string,
+    readonly status: Status,
+    readonly offset: number,
+    readonly annotations: List<TestAnnotationMap>,
+    readonly lines: List<Line>,
+  ) {}
+
+  withAnnotations(annotations: List<TestAnnotationMap>): ExecutionResult {
+    return new ExecutionResult(this.resultType, this.label, this.status, this.offset, annotations, this.lines);
+  }
+}
+
+export function rendered(
+  caseType: ResultType,
+  label: string,
+  status: Status,
+  offset: number,
+  lines: List<Line>,
+): ExecutionResult {
+  return new ExecutionResult(caseType, label, status, offset, Nil(), lines);
+}
+
+/**
+ * @tsplus operator fncts.test.ExecutionResult &&
+ */
+export function and_(self: ExecutionResult, that: ExecutionResult): ExecutionResult {
+  if (self.status._tag === "Ignored") {
+    return that;
+  }
+  if (that.status._tag === "Ignored") {
+    return self;
+  }
+  if (self.status._tag === "Failed" && that.status._tag === "Failed") {
+    return new ExecutionResult(
+      self.resultType,
+      self.label,
+      self.status,
+      self.offset,
+      self.annotations,
+      self.lines.concat(that.lines.tail.getOrElse(Nil())),
+    );
+  }
+  if (self.status._tag === "Passed") {
+    return that;
+  }
+  if (that.status._tag === "Passed") {
+    return self;
+  }
+  throw new Error("BUG");
+}
+
+/**
+ * @tsplus operator fncts.test.ExecutionResult ||
+ */
+export function or_(self: ExecutionResult, that: ExecutionResult): ExecutionResult {
+  if (self.status._tag === "Ignored") {
+    return that;
+  }
+  if (that.status._tag === "Ignored") {
+    return self;
+  }
+  if (self.status._tag === "Failed" && that.status._tag === "Failed") {
+    return new ExecutionResult(
+      self.resultType,
+      self.label,
+      self.status,
+      self.offset,
+      self.annotations,
+      self.lines.concat(that.lines.tail.getOrElse(Nil())),
+    );
+  }
+  if (self.status._tag === "Passed") {
+    return self;
+  }
+  if (that.status._tag === "Passed") {
+    return that;
+  }
+  throw new Error("BUG");
+}
+
+/**
+ * @tsplus getter fncts.test.ExecutionResult invert
+ */
+export function invert(self: ExecutionResult): ExecutionResult {
+  return matchTag_(self.status, {
+    Ignored: () => self,
+    Failed: () => new ExecutionResult(self.resultType, self.label, Passed, self.offset, self.annotations, self.lines),
+    Passed: () => new ExecutionResult(self.resultType, self.label, Failed, self.offset, self.annotations, self.lines),
+  });
+}

package/_src/data/FailureDetails.ts

@@ -0,0 +1,13 @@
+import type { FailureDetailsResult } from "./AssertionResult.js";
+import type { AssertionValue } from "./AssertionValue.js";
+import type { FreeBooleanAlgebra } from "./FreeBooleanAlgebra.js";
+import type { GenFailureDetails } from "./GenFailureDetails.js";
+
+/**
+ * @tsplus type fncts.test.FreeBooleanAlgebra
+ */
+export type TestResult = FreeBooleanAlgebra<FailureDetailsResult>;
+
+export class FailureDetails {
+  constructor(readonly assertion: Cons<AssertionValue<any>>, readonly gen: Maybe<GenFailureDetails<any>>) {}
+}

package/_src/data/FreeBooleanAlgebra/api.ts

@@ -0,0 +1,152 @@
+import { And, FreeBooleanAlgebra, FreeBooleanAlgebraTag, Not, Or, Value } from "./definition.js";
+
+/**
+ * @tsplus fluent fncts.test.FreeBooleanAlgebra and
+ * @tsplus operator fncts.test.FreeBooleanAlgebra &&
+ */
+export function and_<A>(left: FreeBooleanAlgebra<A>, right: FreeBooleanAlgebra<A>): FreeBooleanAlgebra<A> {
+  return new And(left, right);
+}
+
+/**
+ * @tsplus fluent fncts.test.FreeBooleanAlgebra flatMap
+ */
+export function flatMap_<A, B>(self: FreeBooleanAlgebra<A>, f: (a: A) => FreeBooleanAlgebra<B>): FreeBooleanAlgebra<B> {
+  return self.fold({
+    Value: f,
+    And: (l, r) => l && r,
+    Or: (l, r) => l || r,
+    Not: (v) => v.invert,
+  });
+}
+
+/**
+ * @tsplus static fncts.test.FreeBooleanAlgebraOps failure
+ */
+export function failure<A>(a: A): FreeBooleanAlgebra<A> {
+  return FreeBooleanAlgebra.success(a).invert;
+}
+
+/**
+ * @tsplus getter fncts.test.FreeBooleanAlgebra failures
+ */
+export function failures<A>(self: FreeBooleanAlgebra<A>): Maybe<FreeBooleanAlgebra<A>> {
+  return self
+    .fold<A, Either<FreeBooleanAlgebra<A>, FreeBooleanAlgebra<A>>>({
+      Value: (a) => Either.right(FreeBooleanAlgebra.success(a)),
+      And: (l, r) =>
+        l.isRight()
+          ? r.isRight()
+            ? Either.right(l.right && r.right)
+            : r
+          : r.isRight()
+          ? l
+          : Either.left(l.left && r.left),
+      Or: (l, r) =>
+        l.isRight()
+          ? r.isRight()
+            ? Either.right(l.right || r.right)
+            : l
+          : r.isRight()
+          ? r
+          : Either.left(l.left || r.left),
+      Not: (v) => v.swap,
+    })
+    .match(Maybe.just, () => Nothing());
+}
+
+/**
+ * @tsplus fluent fncts.test.FreeBooleanAlgebra foldEval
+ */
+export function foldEval_<A, B>(
+  self: FreeBooleanAlgebra<A>,
+  cases: {
+    Value: (value: A) => B;
+    And: (left: B, right: B) => B;
+    Or: (left: B, right: B) => B;
+    Not: (value: B) => B;
+  },
+): Eval<B> {
+  return Eval.defer(() => {
+    switch (self._tag) {
+      case FreeBooleanAlgebraTag.Value:
+        return Eval.now(cases.Value(self.value));
+      case FreeBooleanAlgebraTag.And:
+        return self.left.foldEval(cases).zipWith(self.right.foldEval(cases), cases.And);
+      case FreeBooleanAlgebraTag.Or:
+        return self.left.foldEval(cases).zipWith(self.right.foldEval(cases), cases.Or);
+      case FreeBooleanAlgebraTag.Not:
+        return self.result.foldEval(cases).map(cases.Not);
+    }
+  });
+}
+
+/**
+ * @tsplus fluent fncts.test.FreeBooleanAlgebra fold
+ */
+export function fold_<A, B>(
+  self: FreeBooleanAlgebra<A>,
+  cases: {
+    Value: (value: A) => B;
+    And: (left: B, right: B) => B;
+    Or: (left: B, right: B) => B;
+    Not: (value: B) => B;
+  },
+): B {
+  return self.foldEval(cases).run;
+}
+
+/**
+ * @tsplus fluent fncts.test.FreeBooleanAlgebra iff
+ */
+export function iff_<A>(left: FreeBooleanAlgebra<A>, right: FreeBooleanAlgebra<A>): FreeBooleanAlgebra<A> {
+  return left.implies(right) && right.implies(left);
+}
+
+/**
+ * @tsplus fluent fncts.test.FreeBooleanAlgebra implies
+ */
+export function implies_<A>(left: FreeBooleanAlgebra<A>, right: FreeBooleanAlgebra<A>): FreeBooleanAlgebra<A> {
+  return left.invert || right;
+}
+
+/**
+ * @tsplus getter fncts.test.FreeBooleanAlgebra isFailure
+ */
+export function isFailure<A>(self: FreeBooleanAlgebra<A>): boolean {
+  return !self.isSuccess;
+}
+
+/**
+ * @tsplus getter fncts.test.FreeBooleanAlgebra isSuccess
+ */
+export function isSuccess<A>(self: FreeBooleanAlgebra<A>): boolean {
+  return self.fold({
+    Value: (): boolean => true,
+    And: (l, r) => l && r,
+    Or: (l, r) => l || r,
+    Not: (v) => !v,
+  });
+}
+
+/**
+ * @tsplus getter fncts.test.FreeBooleanAlgebra invert
+ */
+export function not<A>(self: FreeBooleanAlgebra<A>): FreeBooleanAlgebra<A> {
+  return new Not(self);
+}
+
+/**
+ * @tsplus fluent fncts.test.FreeBooleanAlgebra or
+ * @tsplus operator fncts.test.FreeBooleanAlgebra ||
+ */
+export function or_<A>(left: FreeBooleanAlgebra<A>, right: FreeBooleanAlgebra<A>): FreeBooleanAlgebra<A> {
+  return new Or(left, right);
+}
+
+/**
+ * @tsplus static fncts.test.FreeBooleanAlgebraOps success
+ */
+export function success<A>(a: A): FreeBooleanAlgebra<A> {
+  return new Value(a);
+}

package/_src/data/FreeBooleanAlgebra/definition.ts

@@ -0,0 +1,38 @@
+export const enum FreeBooleanAlgebraTag {
+  Value = "Value",
+  And = "And",
+  Or = "Or",
+  Not = "Not",
+}
+
+export class Value<A> {
+  readonly _tag = FreeBooleanAlgebraTag.Value;
+  constructor(readonly value: A) {}
+}
+
+export class And<A> {
+  readonly _tag = FreeBooleanAlgebraTag.And;
+  constructor(readonly left: FreeBooleanAlgebra<A>, readonly right: FreeBooleanAlgebra<A>) {}
+}
+
+export class Or<A> {
+  readonly _tag = FreeBooleanAlgebraTag.Or;
+  constructor(readonly left: FreeBooleanAlgebra<A>, readonly right: FreeBooleanAlgebra<A>) {}
+}
+
+export class Not<A> {
+  readonly _tag = FreeBooleanAlgebraTag.Not;
+  constructor(readonly result: FreeBooleanAlgebra<A>) {}
+}
+
+/**
+ * @tsplus type fncts.test.FreeBooleanAlgebra
+ */
+export type FreeBooleanAlgebra<A> = Value<A> | And<A> | Or<A> | Not<A>;
+
+/**
+ * @tsplus type fncts.test.FreeBooleanAlgebraOps
+ */
+export interface FreeBooleanAlgebraOps {}
+
+export const FreeBooleanAlgebra: FreeBooleanAlgebraOps = {};

package/_src/data/FreeBooleanAlgebra.ts

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

package/_src/data/GenFailureDetails.ts

@@ -0,0 +1,3 @@
+export class GenFailureDetails<A = any> {
+  constructor(readonly initialInput: A, readonly shrunkenInput: A, readonly iterations: number) {}
+}

package/_src/data/LogLine/Fragment.ts

@@ -0,0 +1,59 @@
+import { Line } from "./Line.js";
+import { Style } from "./Style.js";
+
+/**
+ * @tsplus type fncts.test.data.Fragment
+ * @tsplus companion fncts.test.data.FragmentOps
+ */
+export class Fragment {
+  constructor(readonly text: string, readonly style: Style = Style.Default) {}
+}
+
+/**
+ * @tsplus static fncts.test.data.FragmentOps __call
+ */
+export function makeFragment(text: string, style = Style.Default): Fragment {
+  return new Fragment(text, style);
+}
+
+/**
+ * @tsplus operator fncts.test.data.Fragment +
+ */
+export function appendTo(line: Line, self: Fragment): Line {
+  return new Line(line.fragments.append(self), line.offset);
+}
+
+/**
+ * @tsplus operator fncts.test.data.Fragment +
+ */
+export function prependTo(self: Fragment, line: Line): Line {
+  return new Line(line.fragments.prepend(self), line.offset);
+}
+
+/**
+ * @tsplus operator fncts.test.data.Fragment +
+ */
+export function append(self: Fragment, that: Fragment): Line {
+  return new Line(Vector(self, that));
+}
+
+/**
+ * @tsplus getter fncts.test.data.Fragment toLine
+ */
+export function toLine(self: Fragment): Line {
+  return new Line(Vector(self));
+}
+
+/**
+ * @tsplus getter fncts.test.data.Fragment bold
+ */
+export function bold(self: Fragment): Fragment {
+  return new Fragment(self.text, Style.Bold(self));
+}
+
+/**
+ * @tsplus getter fncts.test.data.Fragment underlined
+ */
+export function underlined(self: Fragment): Fragment {
+  return new Fragment(self.text, Style.Underlined(self));
+}