TestAspect

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

def after[R0, E0](effect: ZIO[R0, E0, Any]): WithOut[Nothing, R0, E0, Any, [Env]Env, [Err]Err]

Constructs an aspect that runs the specified effect after every test.

def afterAll[R0](effect: ZIO[R0, Nothing, Any]): WithOut[Nothing, R0, Nothing, Any, [Env]Env, [Err]Err]

Constructs an aspect that runs the specified effect after all tests.

def annotate[V](key: TestAnnotation[V], value: V): WithOut[Nothing, Any, Nothing, Any, [Env]Env, [Err]Err]

Annotates tests with the specified test annotation.

def around[R0, E0](before: ZIO[R0, E0, Any], after: ZIO[R0, Nothing, Any]): WithOut[Nothing, R0, E0, Any, [Env]Env, [Err]Err]

A less powerful variant of around where the result of before is not required by after.

def aroundAll[R0, E0](before: ZIO[R0, E0, Any], after: ZIO[R0, Nothing, Any]): WithOut[Nothing, R0, E0, Any, [Env]Env, [Err]Err]

A less powerful variant of aroundAll where the result of before is not required by after.

def aroundAllWith[R0, E0, A0](before: ZIO[R0, E0, A0])(after: (A0) ⇒ ZIO[R0, Nothing, Any]): WithOut[Nothing, R0, E0, Any, [Env]Env, [Err]Err]

Constructs an aspect that evaluates all tests between two effects, before and after, where the result of before can be used in after.

def aroundTest[R0, E0](managed: ZManaged[R0, TestFailure[E0], (TestSuccess) ⇒ ZIO[R0, TestFailure[E0], TestSuccess]]): WithOut[Nothing, R0, E0, Any, [Env]Env, [Err]Err]

Constructs an aspect that evaluates every test inside the context of the managed function.

def aroundWith[R0, E0, A0](before: ZIO[R0, E0, A0])(after: (A0) ⇒ ZIO[R0, Nothing, Any]): WithOut[Nothing, R0, E0, Any, [Env]Env, [Err]Err]

Constructs an aspect that evaluates every test between two effects, before and after, where the result of before can be used in after.

final def asInstanceOf[T0]: T0

def aspect[R0, E0](f: (ZIO[R0, TestFailure[E0], TestSuccess]) ⇒ ZIO[R0, TestFailure[E0], TestSuccess]): WithOut[R0, R0, E0, E0, [Env]Env, [Err]Err]

Constructs a simple monomorphic aspect that only works with the specified environment and error type.

def before[R0, E0](effect: ZIO[R0, E0, Any]): WithOut[Nothing, R0, E0, Any, [Env]Env, [Err]Err]

Constructs an aspect that runs the specified effect before every test.

def beforeAll[R0, E0](effect: ZIO[R0, E0, Any]): WithOut[Nothing, R0, E0, Any, [Env]Env, [Err]Err]

Constructs an aspect that runs the specified effect a single time before all tests.

def clone(): AnyRef

val debug: WithOut[Nothing, TestConsole, Nothing, Any, [Env]Env, [Err]Err]

An aspect that runs each test with the TestConsole instance in the environment set to debug mode so that console output is rendered to standard output in addition to being written to the output buffer.

def diagnose(duration: zio.Duration): WithOut[Nothing, Live with Annotations, Nothing, Any, [Env]Env, [Err]Err]

An aspect that runs each test on a separate fiber and prints a fiber dump if the test fails or has not terminated within the specified duration.

def dotty[LowerR, UpperR, LowerE, UpperE](that: WithOut[LowerR, UpperR, LowerE, UpperE, [Env]Env, [Err]Err]): WithOut[LowerR, UpperR, LowerE, UpperE, [Env]Env, [Err]Err]

An aspect that applies the specified aspect on Dotty.

val dottyOnly: WithOut[Nothing, Annotations, Nothing, Any, [Env]Env, [Err]Err]

An aspect that only runs tests on Dotty.

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

val eventually: WithOut[Nothing, ZTestEnv, Nothing, Any, [Env]Env, [Err]Err]

An aspect that retries a test until success, without limit.

val exceptDotty: WithOut[Nothing, Annotations, Nothing, Any, [Env]Env, [Err]Err]

An aspect that runs tests on all versions except Dotty.

val exceptJS: WithOut[Nothing, Annotations, Nothing, Any, [Env]Env, [Err]Err]

An aspect that runs tests on all platforms except ScalaJS.

val exceptJVM: WithOut[Nothing, Annotations, Nothing, Any, [Env]Env, [Err]Err]

An aspect that runs tests on all platforms except the JVM.

val exceptNative: WithOut[Nothing, Annotations, Nothing, Any, [Env]Env, [Err]Err]

An aspect that runs tests on all platforms except ScalaNative.

val exceptScala2: WithOut[Nothing, Annotations, Nothing, Any, [Env]Env, [Err]Err]

An aspect that runs tests on all versions except Scala 2.

val exceptScala211: WithOut[Nothing, Annotations, Nothing, Any, [Env]Env, [Err]Err]

An aspect that runs tests on all versions except Scala 2.11.

val exceptScala212: WithOut[Nothing, Annotations, Nothing, Any, [Env]Env, [Err]Err]

An aspect that runs tests on all versions except Scala 2.12.

val exceptScala213: WithOut[Nothing, Annotations, Nothing, Any, [Env]Env, [Err]Err]

An aspect that runs tests on all versions except Scala 2.13.

def executionStrategy(exec: ExecutionStrategy): WithOut[Nothing, Any, Nothing, Any, [Env]Env, [Err]Err]

An aspect that sets suites to the specified execution strategy, but only if their current strategy is inherited (undefined).

def failing[E0](assertion: (TestFailure[E0]) ⇒ Boolean): WithOut[Nothing, Any, Nothing, E0, [Env]Env, [Err]Err]

An aspect that makes a test that failed for the specified failure pass.

val failing: WithOut[Nothing, Any, Nothing, Any, [Env]Env, [Err]Err]

An aspect that makes a test that failed for any reason pass.

lazy val fibers: WithOut[Nothing, Annotations, Nothing, Any, [Env]Env, [Err]Err]

An aspect that records the state of fibers spawned by the current test in TestAnnotation.fibers.

def finalize(): Unit

def flaky(n: Int): WithOut[Nothing, ZTestEnv with Annotations, Nothing, Any, [Env]Env, [Err]Err]

An aspect that retries a test until success, with the specified limit, for use with flaky tests.

val flaky: WithOut[Nothing, Annotations with TestConfig with ZTestEnv, Nothing, Any, [Env]Env, [Err]Err]

An aspect that retries a test until success, with a default limit, for use with flaky tests.

val forked: WithOut[Nothing, Any, Nothing, Any, [Env]Env, [Err]Err]

An aspect that runs each test on its own separate fiber.

final def getClass(): Class[_]

def hashCode(): Int

val identity: WithOut[Nothing, Any, Nothing, Any, [Env]Env, [Err]Err]

An aspect that returns the tests unchanged

def ifEnv(env: String)(assertion: (String) ⇒ Boolean): WithOut[Nothing, Live with Annotations, Nothing, Any, [Env]Env, [Err]Err]

An aspect that only runs a test if the specified environment variable satisfies the specified assertion.

def ifEnvSet(env: String): WithOut[Nothing, Live with Annotations, Nothing, Any, [Env]Env, [Err]Err]

As aspect that only runs a test if the specified environment variable is set.

def ifProp(prop: String)(assertion: (String) ⇒ Boolean): WithOut[Nothing, Live with Annotations, Nothing, Any, [Env]Env, [Err]Err]

An aspect that only runs a test if the specified Java property satisfies the specified assertion.

def ifPropSet(prop: String): WithOut[Nothing, Live with Annotations, Nothing, Any, [Env]Env, [Err]Err]

As aspect that only runs a test if the specified Java property is set.

val ignore: WithOut[Nothing, Annotations, Nothing, Any, [Env]Env, [Err]Err]

An aspect that marks tests as ignored.

final def isInstanceOf[T0]: Boolean

def js[LowerR, UpperR, LowerE, UpperE](that: WithOut[LowerR, UpperR, LowerE, UpperE, [Env]Env, [Err]Err]): WithOut[LowerR, UpperR, LowerE, UpperE, [Env]Env, [Err]Err]

An aspect that applies the specified aspect on ScalaJS.

val jsOnly: WithOut[Nothing, Annotations, Nothing, Any, [Env]Env, [Err]Err]

An aspect that only runs tests on ScalaJS.

def jvm[LowerR, UpperR, LowerE, UpperE](that: WithOut[LowerR, UpperR, LowerE, UpperE, [Env]Env, [Err]Err]): WithOut[LowerR, UpperR, LowerE, UpperE, [Env]Env, [Err]Err]

An aspect that applies the specified aspect on the JVM.

val jvmOnly: WithOut[Nothing, Annotations, Nothing, Any, [Env]Env, [Err]Err]

An aspect that only runs tests on the JVM.

val mac: WithOut[Nothing, Annotations, Nothing, Any, [Env]Env, [Err]Err]

Runs only on Mac operating systems.

def native[LowerR, UpperR, LowerE, UpperE](that: WithOut[LowerR, UpperR, LowerE, UpperE, [Env]Env, [Err]Err]): WithOut[LowerR, UpperR, LowerE, UpperE, [Env]Env, [Err]Err]

An aspect that applies the specified aspect on ScalaNative.

val nativeOnly: WithOut[Nothing, Annotations, Nothing, Any, [Env]Env, [Err]Err]

An aspect that only runs tests on ScalaNative.

final def ne(arg0: AnyRef): Boolean

def nonFlaky(n: Int): WithOut[Nothing, ZTestEnv with Annotations, Nothing, Any, [Env]Env, [Err]Err]

An aspect that repeats the test a specified number of times, ensuring it is stable ("non-flaky").

val nonFlaky: WithOut[Nothing, ZTestEnv with Annotations with TestConfig, Nothing, Any, [Env]Env, [Err]Err]

An aspect that repeats the test a default number of times, ensuring it is stable ("non-flaky").

def nonTermination(duration: zio.Duration): WithOut[Nothing, Live, Nothing, Any, [Env]Env, [Err]Err]

Constructs an aspect that requires a test to not terminate within the specified time.

val nondeterministic: WithOut[Nothing, Live with TestRandom, Nothing, Any, [Env]Env, [Err]Err]

Sets the seed of the TestRandom instance in the environment to a random value before each test.

final def notify(): Unit

final def notifyAll(): Unit

def os(f: (OS) ⇒ Boolean): WithOut[Nothing, Annotations, Nothing, Any, [Env]Env, [Err]Err]

An aspect that runs only on operating systems accepted by the specified predicate.

val parallel: WithOut[Nothing, Any, Nothing, Any, [Env]Env, [Err]Err]

An aspect that executes the members of a suite in parallel.

def parallelN(n: Int): WithOut[Nothing, Any, Nothing, Any, [Env]Env, [Err]Err]

An aspect that executes the members of a suite in parallel, up to the specified number of concurrent fibers.

final def provide[R0, E1, R1](layer: ZLayer[R0, TestFailure[E1], R1]): WithOut[R1, Any, E1, Any, [Env]R0, [Err]Err]

An aspect that provides a layer to the spec, translating it up a level.

def provideCustom[E, R](layer: ZLayer[TestEnvironment, TestFailure[E], R])(implicit tagged: zio.Tag[R], trace: ZTraceElement): WithOut[TestEnvironment with R, Any, E, Any, [Env]Annotations with Live with Sized with TestClock with TestConfig with TestConsole with TestRandom with TestSystem with Clock with Console with System with Random, [Err]Err]

Provides each test with the part of the environment that is not part of the TestEnvironment, leaving a spec that only depends on the TestEnvironment.

val loggingLayer: ZLayer[Any, Nothing, Logging] = ???

val spec: ZSpec[TestEnvironment with Logging, Nothing] = ???

val spec2 = spec.provideCustom(loggingLayer)

def provideCustomShared[E, R](layer: ZLayer[TestEnvironment, TestFailure[E], R])(implicit tagged: zio.Tag[R], trace: ZTraceElement): WithOut[TestEnvironment with R, Any, E, Any, [Env]Annotations with Live with Sized with TestClock with TestConfig with TestConsole with TestRandom with TestSystem with Clock with Console with System with Random, [Err]Err]

Provides each test with the part of the environment that is not part of the TestEnvironment, leaving a spec that only depends on the TestEnvironment.

val loggingLayer: ZLayer[Any, Nothing, Logging] = ???

val spec: ZSpec[TestEnvironment with Logging, Nothing] = ???

val spec2 = spec.provideCustom(loggingLayer)

final def provideEnvironment[R0](r: ZEnvironment[R0]): WithOut[R0, Any, Nothing, Any, [Env]Any, [Err]Err]

An aspect that provides each test in the spec with its required environment.

final def provideShared[R0, E1, R1](layer: ZLayer[R0, TestFailure[E1], R1]): WithOut[R1, Any, E1, Any, [Env]R0, [Err]Err]

An aspect that provides a layer to the spec, translating it up a level.

final def provideSome[R0]: ProvideSomeLayer[R0]

Splits the environment into two parts, providing each test with one part using the specified service builder and leaving the remainder R0.

val clockServiceBuilder: ZServiceBuilder[Any, Nothing, Clock] = ???

val spec: ZSpec[Clock with Random, Nothing] = ???

val spec2 = spec @@ provideSome[Random](clockServiceBuilder)

final def provideSomeEnvironment[R0, R1](f: (ZEnvironment[R0]) ⇒ ZEnvironment[R1]): WithOut[R1, Any, Nothing, Any, [Env]R0, [Err]Err]

Transforms the environment being provided to this spec with the specified function.

final def provideSomeShared[R0]: ProvideSomeLayerShared[R0]

Splits the environment into two parts, providing all tests with a shared version of one part using the specified layer and leaving the remainder R0.

val clockLayer: ZLayer[Any, Nothing, Clock] = ???

val spec: ZSpec[Clock with Random, Nothing] = ???

val spec2 = spec.provideSomeShared[Random](clockLayer)

def repeat[R0 <: ZTestEnv with Annotations with Live](schedule: Schedule[R0, TestSuccess, Any]): WithOut[Nothing, R0, Nothing, Any, [Env]Env, [Err]Err]

An aspect that repeats successful tests according to a schedule.

def repeats(n: Int): WithOut[Nothing, TestConfig, Nothing, Any, [Env]Env, [Err]Err]

An aspect that runs each test with the number of times to repeat tests to ensure they are stable set to the specified value.

def restore[R0](service: (ZEnvironment[R0]) ⇒ Restorable): WithOut[Nothing, R0, Nothing, Any, [Env]Env, [Err]Err]

An aspect that restores a given Restorable's state to its starting state after the test is run.

def restoreTestClock: WithOut[Nothing, TestClock, Nothing, Any, [Env]Env, [Err]Err]

An aspect that restores the TestClock's state to its starting state after the test is run.

def restoreTestConsole: WithOut[Nothing, TestConsole, Nothing, Any, [Env]Env, [Err]Err]

An aspect that restores the TestConsole's state to its starting state after the test is run.

def restoreTestEnvironment: WithOut[Nothing, ZTestEnv, Nothing, Any, [Env]Env, [Err]Err]

An aspect that restores all state in the standard provided test environments (TestClock, TestConsole, TestRandom, and TestSystem) to their starting state after the test is run.

def restoreTestRandom: WithOut[Nothing, TestRandom, Nothing, Any, [Env]Env, [Err]Err]

An aspect that restores the TestRandom's state to its starting state after the test is run.

def restoreTestSystem: WithOut[Nothing, TestSystem, Nothing, Any, [Env]Env, [Err]Err]

An aspect that restores the TestSystem's state to its starting state after the test is run.

def retries(n: Int): WithOut[Nothing, TestConfig, Nothing, Any, [Env]Env, [Err]Err]

An aspect that runs each test with the number of times to retry flaky tests set to the specified value.

def retry[R0 <: ZTestEnv with Annotations with Live, E0](schedule: Schedule[R0, TestFailure[E0], Any]): WithOut[Nothing, R0, Nothing, E0, [Env]Env, [Err]Err]

An aspect that retries failed tests according to a schedule.

def runtimeConfig(runtimeConfigAspect: RuntimeConfigAspect): WithOut[Nothing, Any, Nothing, Any, [Env]Env, [Err]Err]

As aspect that runs each test with the specified RuntimeConfigAspect.

def samples(n: Int): WithOut[Nothing, TestConfig, Nothing, Any, [Env]Env, [Err]Err]

An aspect that runs each test with the number of sufficient samples to check for a random variable set to the specified value.

def scala2[LowerR, UpperR, LowerE, UpperE](that: WithOut[LowerR, UpperR, LowerE, UpperE, [Env]Env, [Err]Err]): WithOut[LowerR, UpperR, LowerE, UpperE, [Env]Env, [Err]Err]

An aspect that applies the specified aspect on Scala 2.

def scala211[LowerR, UpperR, LowerE, UpperE](that: WithOut[LowerR, UpperR, LowerE, UpperE, [Env]Env, [Err]Err]): WithOut[LowerR, UpperR, LowerE, UpperE, [Env]Env, [Err]Err]

An aspect that applies the specified aspect on Scala 2.11.

val scala211Only: WithOut[Nothing, Annotations, Nothing, Any, [Env]Env, [Err]Err]

An aspect that only runs tests on Scala 2.11.

def scala212[LowerR, UpperR, LowerE, UpperE](that: WithOut[LowerR, UpperR, LowerE, UpperE, [Env]Env, [Err]Err]): WithOut[LowerR, UpperR, LowerE, UpperE, [Env]Env, [Err]Err]

An aspect that applies the specified aspect on Scala 2.12.

val scala212Only: WithOut[Nothing, Annotations, Nothing, Any, [Env]Env, [Err]Err]

An aspect that only runs tests on Scala 2.12.

def scala213[LowerR, UpperR, LowerE, UpperE](that: WithOut[LowerR, UpperR, LowerE, UpperE, [Env]Env, [Err]Err]): WithOut[LowerR, UpperR, LowerE, UpperE, [Env]Env, [Err]Err]

An aspect that applies the specified aspect on Scala 2.13.

val scala213Only: WithOut[Nothing, Annotations, Nothing, Any, [Env]Env, [Err]Err]

An aspect that only runs tests on Scala 2.13.

val scala2Only: WithOut[Nothing, Annotations, Nothing, Any, [Env]Env, [Err]Err]

An aspect that only runs tests on Scala 2.

val sequential: WithOut[Nothing, Any, Nothing, Any, [Env]Env, [Err]Err]

An aspect that executes the members of a suite sequentially.

def setSeed(seed: ⇒ Long): WithOut[Nothing, TestRandom, Nothing, Any, [Env]Env, [Err]Err]

Sets the seed of the TestRandom instance in the environment to the specified value before each test.

def shrinks(n: Int): WithOut[Nothing, TestConfig, Nothing, Any, [Env]Env, [Err]Err]

An aspect that runs each test with the maximum number of shrinkings to minimize large failures set to the specified value.

val silent: WithOut[Nothing, TestConsole, Nothing, Any, [Env]Env, [Err]Err]

An aspect that runs each test with the TestConsole instance in the environment set to silent mode so that console output is only written to the output buffer and not rendered to standard output.

def sized(n: Int): WithOut[Nothing, Sized, Nothing, Any, [Env]Env, [Err]Err]

An aspect that runs each test with the size set to the specified value.

val success: WithOut[Nothing, Any, Nothing, Any, [Env]Env, [Err]Err]

An aspect that converts ignored tests into test failures.

final def synchronized[T0](arg0: ⇒ T0): T0

def tag(tag: String, tags: String*): WithOut[Nothing, Any, Nothing, Any, [Env]Env, [Err]Err]

Annotates tests with string tags.

val timed: WithOut[Nothing, Live with Annotations, Nothing, Any, [Env]Env, [Err]Err]

Annotates tests with their execution times.

def timeout(duration: zio.Duration): WithOut[Nothing, Live, Nothing, Any, [Env]Env, [Err]Err]

An aspect that times out tests using the specified duration.

def timeoutWarning(duration: zio.Duration): WithOut[Nothing, Live, Nothing, Any, [Env]Env, [Err]Err]

A test aspect that prints a warning to the console when a test takes longer than the specified duration.

def toString(): String

val unix: WithOut[Nothing, Annotations, Nothing, Any, [Env]Env, [Err]Err]

Runs only on Unix / Linux operating systems.

def verify[R0, E0](condition: ⇒ ZIO[R0, E0, TestResult]): WithOut[Nothing, R0, E0, Any, [Env]Env, [Err]Err]

Verifies the specified post-condition after each test is run.

final def wait(): Unit

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit

val windows: WithOut[Nothing, Annotations, Nothing, Any, [Env]Env, [Err]Err]

Runs only on Windows operating systems.

final def provideSomeLayer[R0]: ProvideSomeLayer[R0]

Splits the environment into two parts, providing each test with one part using the specified layer and leaving the remainder R0.

val clockLayer: ZLayer[Any, Nothing, Clock] = ???

val spec: ZSpec[Clock with Random, Nothing] = ???

val spec2 = spec @@ provideSomeLayer[Random](clockLayer)

final def provideSomeLayerShared[R0]: ProvideSomeLayerShared[R0]

Splits the environment into two parts, providing all tests with a shared version of one part using the specified layer and leaving the remainder R0.

val clockLayer: ZLayer[Any, Nothing, Clock] = ???

val spec: ZSpec[Clock with Random, Nothing] = ???

val spec2 = spec.provideSomeLayerShared[Random](clockLayer)