object TestAspect extends TimeoutVariants
- Alphabetic
- By Inheritance
- TestAspect
- TimeoutVariants
- AnyRef
- Any
- Hide All
- Show All
- Public
- Protected
Type Members
- trait PerTest[+LowerR, -UpperR, +LowerE, -UpperE] extends TestAspect[LowerR, UpperR, LowerE, UpperE]
Value Members
- final def !=(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
- final def ##(): Int
- Definition Classes
- AnyRef → Any
- final def ==(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
- def after[R0, E0](effect: ZIO[R0, E0, Any]): TestAspect[Nothing, R0, E0, Any]
Constructs an aspect that runs the specified effect after every test.
- def annotate[V](key: TestAnnotation[V], value: V): TestAspectPoly
Annotates tests with the specified test annotation.
- def around[R0, E0, A0](before: ZIO[R0, E0, A0])(after: (A0) => ZIO[R0, Nothing, Any]): TestAspect[Nothing, R0, E0, Any]
Constructs an aspect that evaluates every test between two effects,
before
andafter
, where the result ofbefore
can be used inafter
. - def aroundTest[R0, E0](managed: ZManaged[R0, TestFailure[E0], (TestSuccess) => ZIO[R0, TestFailure[E0], TestSuccess]]): TestAspect[Nothing, R0, E0, Any]
Constructs an aspect that evaluates every test inside the context of the managed function.
- def around_[R0, E0](before: ZIO[R0, E0, Any], after: ZIO[R0, Nothing, Any]): TestAspect[Nothing, R0, E0, Any]
A less powerful variant of
around
where the result ofbefore
is not required by after. - final def asInstanceOf[T0]: T0
- Definition Classes
- Any
- def aspect[R0, E0](f: (ZIO[R0, TestFailure[E0], TestSuccess]) => ZIO[R0, TestFailure[E0], TestSuccess]): TestAspect[R0, R0, E0, E0]
Constructs a simple monomorphic aspect that only works with the specified environment and error type.
- def before[R0, E0](effect: ZIO[R0, Nothing, Any]): TestAspect[Nothing, R0, E0, Any]
Constructs an aspect that runs the specified effect before every test.
- def clone(): AnyRef
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.CloneNotSupportedException]) @native()
- val debug: TestAspectAtLeastR[TestConsole]
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: Duration): TestAspectAtLeastR[Live]
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: TestAspect[LowerR, UpperR, LowerE, UpperE]): TestAspect[LowerR, UpperR, LowerE, UpperE]
An aspect that applies the specified aspect on Dotty.
- val dottyOnly: TestAspectAtLeastR[Annotations]
An aspect that only runs tests on Dotty.
- final def eq(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
- def equals(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef → Any
- val eventually: TestAspectAtLeastR[ZTestEnv]
An aspect that retries a test until success, without limit.
- val exceptDotty: TestAspectAtLeastR[Annotations]
An aspect that runs tests on all versions except Dotty.
- val exceptJS: TestAspectAtLeastR[Annotations]
An aspect that runs tests on all platforms except ScalaJS.
- val exceptJVM: TestAspectAtLeastR[Annotations]
An aspect that runs tests on all platforms except the JVM.
- val exceptScala2: TestAspectAtLeastR[Annotations]
An aspect that runs tests on all versions except Scala 2.
- val exceptScala211: TestAspectAtLeastR[Annotations]
An aspect that runs tests on all versions except Scala 2.11.
- val exceptScala212: TestAspectAtLeastR[Annotations]
An aspect that runs tests on all versions except Scala 2.12.
- val exceptScala213: TestAspectAtLeastR[Annotations]
An aspect that runs tests on all versions except Scala 2.13.
- def executionStrategy(exec: ExecutionStrategy): TestAspectPoly
An aspect that sets suites to the specified execution strategy, but only if their current strategy is inherited (undefined).
- def failure[E0](p: Assertion[TestFailure[E0]]): TestAspect[Nothing, Any, Nothing, E0]
An aspect that makes a test that failed for the specified failure pass.
An aspect that makes a test that failed for the specified failure pass. Note that the test will fail for other failures and also if it passes correctly.
- val failure: TestAspectPoly
An aspect that makes a test that failed for any reason pass.
An aspect that makes a test that failed for any reason pass. Note that if the test passes this aspect will make it fail.
- def finalize(): Unit
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.Throwable])
- def flaky(n: Int): TestAspectAtLeastR[ZTestEnv with Annotations]
An aspect that retries a test until success, with the specified limit, for use with flaky tests.
- val flaky: TestAspectAtLeastR[ZTestEnv with Annotations]
An aspect that retries a test until success, with a default limit, for use with flaky tests.
- val forked: TestAspectPoly
An aspect that runs each test on its own separate fiber.
- final def getClass(): Class[_ <: AnyRef]
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
- def hashCode(): Int
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
- val identity: TestAspectPoly
An aspect that returns the tests unchanged
- def ifEnv(env: String, assertion: Assertion[String]): TestAspectAtLeastR[Live with Annotations]
An aspect that only runs a test if the specified environment variable satisfies the specified assertion.
- def ifEnvSet(env: String): TestAspectAtLeastR[Live with Annotations]
As aspect that only runs a test if the specified environment variable is set.
- def ifProp(prop: String, assertion: Assertion[String]): TestAspectAtLeastR[Live with Annotations]
An aspect that only runs a test if the specified Java property satisfies the specified assertion.
- def ifPropSet(prop: String): TestAspectAtLeastR[Live with Annotations]
As aspect that only runs a test if the specified Java property is set.
- val ignore: TestAspectAtLeastR[Annotations]
An aspect that marks tests as ignored.
- final def isInstanceOf[T0]: Boolean
- Definition Classes
- Any
- def js[LowerR, UpperR, LowerE, UpperE](that: TestAspect[LowerR, UpperR, LowerE, UpperE]): TestAspect[LowerR, UpperR, LowerE, UpperE]
An aspect that applies the specified aspect on ScalaJS.
- val jsOnly: TestAspectAtLeastR[Annotations]
An aspect that only runs tests on ScalaJS.
- def jvm[LowerR, UpperR, LowerE, UpperE](that: TestAspect[LowerR, UpperR, LowerE, UpperE]): TestAspect[LowerR, UpperR, LowerE, UpperE]
An aspect that applies the specified aspect on the JVM.
- val jvmOnly: TestAspectAtLeastR[Annotations]
An aspect that only runs tests on the JVM.
- final def ne(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
- val noDelay: TestAspectAtLeastR[TestClock]
An aspect that causes calls to
sleep
and methods implemented in terms of it to be executed immediately instead of requiring theTestClock
to be adjusted. - def nonFlaky(n: Int): TestAspectAtLeastR[ZTestEnv with Annotations]
An aspect that repeats the test a specified number of times, ensuring it is stable ("non-flaky").
An aspect that repeats the test a specified number of times, ensuring it is stable ("non-flaky"). Stops at the first failure.
- val nonFlaky: TestAspectAtLeastR[ZTestEnv with Annotations]
An aspect that repeats the test a default number of times, ensuring it is stable ("non-flaky").
An aspect that repeats the test a default number of times, ensuring it is stable ("non-flaky"). Stops at the first failure.
- def nonTermination(duration: Duration): TestAspectAtLeastR[Live]
Constructs an aspect that requires a test to not terminate within the specified time.
- val nondeterministic: TestAspectAtLeastR[Live with TestRandom]
Sets the seed of the
TestRandom
instance in the environment to a random value before each test. - final def notify(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
- final def notifyAll(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
- val parallel: TestAspectPoly
An aspect that executes the members of a suite in parallel.
- def parallelN(n: Int): TestAspectPoly
An aspect that executes the members of a suite in parallel, up to the specified number of concurrent fibers.
- def repeat[R0 <: ZTestEnv with Annotations](schedule: Schedule[R0, TestSuccess, Any]): TestAspectAtLeastR[R0]
An aspect that repeats successful tests according to a schedule.
- def restore[R0](service: (R0) => Restorable): TestAspectAtLeastR[R0]
An aspect that restores a given Restorable's state to its starting state after the test is run.
An aspect that restores a given Restorable's state to its starting state after the test is run. Note that this is only useful when repeating tests.
- def restoreTestClock: TestAspectAtLeastR[TestClock]
An aspect that restores the TestClock's state to its starting state after the test is run.
An aspect that restores the TestClock's state to its starting state after the test is run. Note that this is only useful when repeating tests.
- def restoreTestConsole: TestAspectAtLeastR[TestConsole]
An aspect that restores the TestConsole's state to its starting state after the test is run.
An aspect that restores the TestConsole's state to its starting state after the test is run. Note that this is only useful when repeating tests.
- def restoreTestEnvironment: TestAspectAtLeastR[ZTestEnv]
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.
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. Note that this is only useful when repeating tests.
- def restoreTestRandom: TestAspectAtLeastR[TestRandom]
An aspect that restores the TestRandom's state to its starting state after the test is run.
An aspect that restores the TestRandom's state to its starting state after the test is run. Note that this is only useful when repeating tests.
- def restoreTestSystem: TestAspectAtLeastR[ZTestEnv]
An aspect that restores the TestSystem's state to its starting state after the test is run.
An aspect that restores the TestSystem's state to its starting state after the test is run. Note that this is only useful when repeating tests.
- def retry[R0 <: ZTestEnv with Annotations, E0](schedule: Schedule[R0, TestFailure[E0], Any]): TestAspect[Nothing, R0, Nothing, E0]
An aspect that retries failed tests according to a schedule.
- def scala2[LowerR, UpperR, LowerE, UpperE](that: TestAspect[LowerR, UpperR, LowerE, UpperE]): TestAspect[LowerR, UpperR, LowerE, UpperE]
An aspect that applies the specified aspect on Scala 2.
- def scala211[LowerR, UpperR, LowerE, UpperE](that: TestAspect[LowerR, UpperR, LowerE, UpperE]): TestAspect[LowerR, UpperR, LowerE, UpperE]
An aspect that applies the specified aspect on Scala 2.11.
- val scala211Only: TestAspectAtLeastR[Annotations]
An aspect that only runs tests on Scala 2.11.
- def scala212[LowerR, UpperR, LowerE, UpperE](that: TestAspect[LowerR, UpperR, LowerE, UpperE]): TestAspect[LowerR, UpperR, LowerE, UpperE]
An aspect that applies the specified aspect on Scala 2.12.
- val scala212Only: TestAspectAtLeastR[Annotations]
An aspect that only runs tests on Scala 2.12.
- def scala213[LowerR, UpperR, LowerE, UpperE](that: TestAspect[LowerR, UpperR, LowerE, UpperE]): TestAspect[LowerR, UpperR, LowerE, UpperE]
An aspect that applies the specified aspect on Scala 2.13.
- val scala213Only: TestAspectAtLeastR[Annotations]
An aspect that only runs tests on Scala 2.13.
- val scala2Only: TestAspectAtLeastR[Annotations]
An aspect that only runs tests on Scala 2.
- val sequential: TestAspectPoly
An aspect that executes the members of a suite sequentially.
- def setSeed(seed: => Long): TestAspectAtLeastR[TestRandom]
Sets the seed of the
TestRandom
instance in the environment to the specified value before each test. - val silent: TestAspectAtLeastR[TestConsole]
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. - val success: TestAspectPoly
An aspect that converts ignored tests into test failures.
- final def synchronized[T0](arg0: => T0): T0
- Definition Classes
- AnyRef
- def tag(tag: String, tags: String*): TestAspectPoly
Annotates tests with string tags.
- val timed: TestAspectAtLeastR[Live with Annotations]
Annotates tests with their execution times.
- def timeout(duration: Duration): TestAspectAtLeastR[Live]
An aspect that times out tests using the specified duration.
An aspect that times out tests using the specified duration.
- duration
maximum test duration
- def timeoutWarning(duration: Duration): TestAspect[Nothing, Live, Nothing, Any]
A test aspect that prints a warning to the console when a test takes longer than the specified duration.
A test aspect that prints a warning to the console when a test takes longer than the specified duration.
- Definition Classes
- TimeoutVariants
- def toString(): String
- Definition Classes
- AnyRef → Any
- def verify[R0, E0](condition: => ZIO[R0, E0, TestResult]): TestAspect[Nothing, R0, E0, Any]
Verifies the specified post-condition after each test is run.
- final def wait(): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.InterruptedException])
- final def wait(arg0: Long, arg1: Int): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.InterruptedException])
- final def wait(arg0: Long): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.InterruptedException]) @native()
- object PerTest