Packages

p

zio

test

package test

_ZIO Test_ is a featherweight testing library for effectful programs.

The library imagines every spec as an ordinary immutable value, providing tremendous potential for composition. Thanks to tight integration with ZIO, specs can use resources (including those requiring disposal), have well- defined linear and parallel semantics, and can benefit from a host of ZIO combinators.

import zio.test._
import zio.Clock.nanoTime

object MyTest extends ZIOSpecDefault {
  def spec = suite("clock")(
    test("time is non-zero") {
      for {
        time <- Live.live(nanoTime)
      } yield assertTrue(time >= 0L)
    }
  )
}
Linear Supertypes
CompileVariants, AnyRef, Any
Ordering
  1. Alphabetic
  2. By Inheritance
Inherited
  1. test
  2. CompileVariants
  3. AnyRef
  4. Any
  1. Hide All
  2. Show All
Visibility
  1. Public
  2. Protected

Package Members

  1. package diff
  2. package internal
  3. package laws

    The laws package provides functionality for describing laws as values.

    The laws package provides functionality for describing laws as values. The fundamental abstraction is a set of ZLaws[Caps, R]. These laws model the laws that instances having a capability of type Caps are expected to satisfy. A capability Caps[_] is an abstraction describing some functionality that is common across different data types and obeys certain laws. For example, we can model the capability of two values of a type being compared for equality as follows:

    trait Equal[-A] {
  def equal(a1: A, a2: A): Boolean
}

    Definitions of equality are expected to obey certain laws:

    1. Reflexivity - a1 === a1
    2. Symmetry - a1 === a2 ==> a2 === a1
    3. Transitivity - (a1 === a2) && (a2 === a3) ==> (a1 === a3)

    These laws define what the capabilities mean and ensure that it is safe to abstract across different instances with the same capability.

    Using ZIO Test, we can represent these laws as values. To do so, we define each law using one of the ZLaws constructors. For example:

    val transitivityLaw = ZLaws.Laws3[Equal]("transitivityLaw") {
  def apply[A: Equal](a1: A, a2: A, a3: A): TestResult =
    ???
}

    We can then combine laws using the + operator:

    val reflexivityLaw: = ???
val symmetryLaw:    = ???

val equalLaws = reflexivityLaw + symmetryLaw + transitivityLaw

    Laws have a run method that takes a generator of values of type A and checks that those values satisfy the laws. In addition, objects can extend ZLawful to provide an even more convenient syntax for users to check that instances satisfy certain laws.

    object Equal extends Lawful[Equal]

object Hash extends Lawful[Hash]

object Ord extends Lawful[Ord]

checkAllLaws(Equal + Hash + Ord)(Gen.int)

    Note that capabilities compose seamlessly because of contravariance. We can combine laws describing different capabilities to construct a set of laws requiring that instances having all of the capabilities satisfy each of the laws.

  4. package magnolia
  5. package poly
  6. package refined
  7. package render
  8. package results
  9. package scalacheck

    This package provides helpers to integrate *some* ScalaCheck primitives to their ZIO equivalents.

    This package provides helpers to integrate *some* ScalaCheck primitives to their ZIO equivalents. Currently available helpers:

    • Converting ScalaCheck Generators to ZIO Generators
    • Asserting a ScalaCheck Prop with ZIO
    • Asserting a ScalaCheck Properties with ZIO

    **Generators**

    This functionality converts legacy ScalaCheck generators to ZIO Test generators to support upgrading to ZIO Test without having to reimplement existing generators. To use it import this module and then call toGenZIO on any existing ScalaCheck generator. For example:

    import org.scalacheck.Arbitrary

import zio._
import zio.test._
import zio.test.scalacheck._

val anyInt: Gen[Any, Int] =
  Arbitrary.arbitrary[Int].toGenZIO

    **Asserting ScalaCheck Prop and Properties**

    This functionality generates ZIO Assertions from either ScalaCheck Prop or Properties. This helps with integrating other libraries that provide ScalaCheck properties as helpers, i.e. cats-laws.

    Prop example:

    import org.scalacheck.Prop
import org.scalacheck.Test.{ Parameters => ScalaCheckParameters }

import zio._
import zio.test._
import zio.test.scalacheck._

val prop: Prop = Prop.forAll { (n: Int, m: Int) =>
  n + m == m + n
}
val resultDefault: TestResult = prop.assertZIO()

val resultWithCustomizations: TestResult =
  prop.assertZIO("My Prop Name", ScalaCheckParameters.default.withMaxSize(10))

    Properties example:

    import org.scalacheck.{ Prop, Properties }
import org.scalacheck.Test.{ Parameters => ScalaCheckParameters }

import zio._
import zio.test._
import zio.test.scalacheck._

object MyProperties extends Properties("MyProperties") {
  property("myProp") = Prop.forAll { (n: Int, m: Int) =>
    n + m == m + n
  }
}

* val resultDefault: TestResult = MyProperties.assertZIO()

// Beware that we can't provide a custom name here, it will be
// taken from the `Properties` name parameter
val resultWithCustomizations: TestResult =
  MyProperties.assertZIO(ScalaCheckParameters.default.withMaxSize(10))

Type Members

  1. trait Annotations extends Serializable

    The Annotations trait provides access to an annotation map that tests can add arbitrary annotations to.

    The Annotations trait provides access to an annotation map that tests can add arbitrary annotations to. Each annotation consists of a string identifier, an initial value, and a function for combining two values. Annotations form monoids and you can think of Annotations as a more structured logging service or as a super polymorphic version of the writer monad effect.

  2. final case class Assertion[-A](arrow: TestArrow[A, Boolean]) extends Product with Serializable
  3. trait AssertionVariants extends AnyRef
  4. trait CheckConstructor[Environment, In] extends AnyRef
  5. trait CheckConstructorLowPriority1 extends CheckConstructorLowPriority2
  6. trait CheckConstructorLowPriority2 extends CheckConstructorLowPriority3
  7. trait CheckConstructorLowPriority3 extends AnyRef
  8. trait CompileVariants extends AnyRef
  9. final class CustomAssertion[A, B] extends AnyRef

    CustomAssertion allows users to create their own custom assertions for use in assertTrue.

    CustomAssertion allows users to create their own custom assertions for use in assertTrue. They are constructed with CustomAssertion.make.

    // Definition
sealed trait Pet
case class Dog(hasBone: Boolean) extends Pet
case class Fish(bubbles: Double) extends Pet
case class Cat(livesRemaining: Int) extends Color

val lives =
  CustomAssertion.make[Pet] {
    case Cat(livesRemaining) => Right(livesRemaining)
    case other => Left(s"Expected $$other to be Cat")
  }

// Usage
suite("custom assertions")(
  test("as even") {
    val pet: Option[Pet] = Some(Cat(8))
    assertTrue(pet.is(_.some.custom(lives)) == 8)
  }
)
  10. sealed abstract class Eql[A, B] extends AnyRef

    A value of type Eql[A, B] provides implicit evidence that two values with types A and B could potentially be equal, that is, that A is a subtype of B or B is a subtype of A.

    A value of type Eql[A, B] provides implicit evidence that two values with types A and B could potentially be equal, that is, that A is a subtype of B or B is a subtype of A.

    Annotations
    @implicitNotFound()
  11. sealed trait ErrorMessage extends AnyRef
  12. sealed trait ExecutionEvent extends AnyRef
  13. trait ExecutionEventSink extends AnyRef
  14. case class FailureCase(errorMessage: Message, codeString: String, location: String, path: Chunk[(String, String)], span: Span, nestedFailures: Chunk[FailureCase], result: Any, customLabel: Option[String]) extends Product with Serializable
  15. trait FunctionVariants extends AnyRef
  16. final case class Gen[-R, +A](sample: ZStream[R, Nothing, Sample[R, A]]) extends Product with Serializable

    A Gen[R, A] represents a generator of values of type A, which requires an environment R.

    A Gen[R, A] represents a generator of values of type A, which requires an environment R. Generators may be random or deterministic.

  17. sealed abstract class GenFailureDetails extends AnyRef

    GenFailureDetails keeps track of relevant information related to a failure in a generative test.

  18. trait GenZIO extends AnyRef
  19. trait Live extends AnyRef

    The Live trait provides access to the "live" default ZIO services from within ZIO Test for workflows such as printing test results to the console or timing out tests where it is necessary to access the real implementations of these services.

    The Live trait provides access to the "live" default ZIO services from within ZIO Test for workflows such as printing test results to the console or timing out tests where it is necessary to access the real implementations of these services.

    The easiest way to access the "live" services is to use the live method with a workflow that would otherwise use the test version of the default ZIO services.

    import zio.Clock
import zio.test._

val realTime = live(Clock.nanoTime)

    The withLive method can be used to apply a transformation to a workflow with the live services while ensuring that the workflow itself still runs with the test services, for example to time out a test. Both of these methods are re-exported in the ZIO Test package object for easy availability.

  20. final class ProvideSomePartiallyApplied[R0, -R, +E] extends AnyVal
  21. final class ProvideSomeSharedPartiallyApplied[R0, -R, +E] extends AnyVal
  22. trait ReporterEventRenderer extends AnyRef
  23. trait Restorable extends Serializable
  24. sealed trait Result[+A] extends AnyRef
  25. final case class Sample[-R, +A](value: A, shrink: ZStream[R, Nothing, Sample[R, A]]) extends Product with Serializable

    A sample is a single observation from a random variable, together with a tree of "shrinkings" used for minimization of "large" failures.

  26. trait Sized extends Serializable
  27. class SmartAssertMacros extends AnyRef
  28. implicit final class SmartAssertionOps[A] extends AnyVal
  29. class SmartSpecMacros extends AnyRef
  30. final case class Spec[-R, +E](caseValue: SpecCase[R, E, Spec[R, E]]) extends SpecVersionSpecific[R, E] with Product with Serializable

    A Spec[R, E] is the backbone of _ZIO Test_.

    A Spec[R, E] is the backbone of _ZIO Test_. Every spec is either a suite, which contains other specs, or a test. All specs require an environment of type R and may potentially fail with an error of type E.

  31. class SpecLayerMacros extends LayerMacroUtils
  32. trait SuiteConstructor[In] extends AnyRef
  33. trait SuiteConstructorLowPriority1 extends SuiteConstructorLowPriority2
  34. trait SuiteConstructorLowPriority2 extends SuiteConstructorLowPriority3
  35. trait SuiteConstructorLowPriority3 extends SuiteConstructorLowPriority4
  36. trait SuiteConstructorLowPriority4 extends AnyRef
  37. case class SuiteId(id: Int) extends Product with Serializable

    id

    Level of the spec nesting that you are at. Suites get new values, test cases inherit their suite's

  38. sealed case class Summary(success: Int, fail: Int, ignore: Int, failureDetails: String, duration: zio.Duration = Duration.Zero) extends Product with Serializable
  39. final class TestAnnotation[V] extends Serializable

    A type of annotation.

  40. final class TestAnnotationMap extends AnyRef

    An annotation map keeps track of annotations of different types.

  41. sealed abstract class TestAnnotationRenderer extends AnyRef

    A TestAnnotationRenderer knows how to render test annotations.

  42. sealed trait TestArrow[-A, +B] extends AnyRef
  43. abstract class TestAspect[+LowerR, -UpperR, +LowerE, -UpperE] extends AnyRef

    A TestAspect is an aspect that can be weaved into specs.

    A TestAspect is an aspect that can be weaved into specs. You can think of an aspect as a polymorphic function, capable of transforming one test into another, possibly enlarging the environment or error type.

  44. type TestAspectAtLeastR[-R] = TestAspect[Nothing, R, Nothing, Any]

    A TestAspectAtLeast[R] is a TestAspect that requires at least an R in its environment.

  45. type TestAspectPoly = TestAspect[Nothing, Any, Nothing, Any]

    A TestAspectPoly is a TestAspect that is completely polymorphic, having no requirements on error or environment.

  46. trait TestClock extends Clock with Restorable

    TestClock makes it easy to deterministically and efficiently test effects involving the passage of time.

    TestClock makes it easy to deterministically and efficiently test effects involving the passage of time.

    Instead of waiting for actual time to pass, sleep and methods implemented in terms of it schedule effects to take place at a given clock time. Users can adjust the clock time using the adjust and setTime methods, and all effects scheduled to take place on or before that time will automatically be run in order.

    For example, here is how we can test ZIO#timeout using TestClock:

    import zio.ZIO
import zio.test.TestClock

for {
  fiber  <- ZIO.sleep(5.minutes).timeout(1.minute).fork
  _      <- TestClock.adjust(1.minute)
  result <- fiber.join
} yield result == None

    Note how we forked the fiber that sleep was invoked on. Calls to sleep and methods derived from it will semantically block until the time is set to on or after the time they are scheduled to run. If we didn't fork the fiber on which we called sleep we would never get to set the time on the line below. Thus, a useful pattern when using TestClock is to fork the effect being tested, then adjust the clock time, and finally verify that the expected effects have been performed.

    For example, here is how we can test an effect that recurs with a fixed delay:

    import zio.Queue
import zio.test.TestClock

for {
  q <- Queue.unbounded[Unit]
  _ <- q.offer(()).delay(60.minutes).forever.fork
  a <- q.poll.map(_.isEmpty)
  _ <- TestClock.adjust(60.minutes)
  b <- q.take.as(true)
  c <- q.poll.map(_.isEmpty)
  _ <- TestClock.adjust(60.minutes)
  d <- q.take.as(true)
  e <- q.poll.map(_.isEmpty)
} yield a && b && c && d && e

    Here we verify that no effect is performed before the recurrence period, that an effect is performed after the recurrence period, and that the effect is performed exactly once. The key thing to note here is that after each recurrence the next recurrence is scheduled to occur at the appropriate time in the future, so when we adjust the clock by 60 minutes exactly one value is placed in the queue, and when we adjust the clock by another 60 minutes exactly one more value is placed in the queue.

  47. trait TestClockPlatformSpecific extends AnyRef
  48. trait TestConfig extends Serializable

    The TestConfig service provides access to default configuration settings used by ZIO Test, including the number of times to repeat tests to ensure they are stable, the number of times to retry flaky tests, the sufficient number of samples to check from a random variable, and the maximum number of shrinkings to minimize large failures.

  49. trait TestConsole extends Console with Restorable

    TestConsole provides a testable interface for programs interacting with the console by modeling input and output as reading from and writing to input and output buffers maintained by TestConsole and backed by a Ref.

    TestConsole provides a testable interface for programs interacting with the console by modeling input and output as reading from and writing to input and output buffers maintained by TestConsole and backed by a Ref.

    All calls to print and printLine using the TestConsole will write the string to the output buffer and all calls to readLine will take a string from the input buffer. To facilitate debugging, by default output will also be rendered to standard output. You can enable or disable this for a scope using debug, silent, or the corresponding test aspects.

    TestConsole has several methods to access and manipulate the content of these buffers including feedLines to feed strings to the input buffer that will then be returned by calls to readLine, output to get the content of the output buffer from calls to print and printLine, and clearInput and clearOutput to clear the respective buffers.

    Together, these functions make it easy to test programs interacting with the console.

    import zio.Console._
import zio.test.TestConsole
import zio.ZIO

val sayHello = for {
  name <- readLine
  _    <- printLine("Hello, " + name + "!")
} yield ()

for {
  _ <- TestConsole.feedLines("John", "Jane", "Sally")
  _ <- ZIO.collectAll(List.fill(3)(sayHello))
  result <- TestConsole.output
} yield result == Vector("Hello, John!\n", "Hello, Jane!\n", "Hello, Sally!\n")
  50. trait TestConstructor[-Environment, In] extends AnyRef
  51. trait TestConstructorLowPriority1 extends TestConstructorLowPriority2
  52. trait TestConstructorLowPriority2 extends TestConstructorLowPriority3
  53. trait TestConstructorLowPriority3 extends AnyRef
  54. sealed trait TestDuration extends AnyRef
  55. type TestEnvironment = Annotations with Live with Sized with TestConfig
  56. abstract class TestExecutor[+R, E] extends AnyRef

    A TestExecutor[R, E] is capable of executing specs that require an environment R and may fail with an E.

  57. sealed abstract class TestFailure[+E] extends AnyRef
  58. final case class TestLens[+A]() extends Product with Serializable
  59. implicit final class TestLensAnyOps[A] extends AnyVal
  60. implicit final class TestLensCauseOps[E] extends AnyVal
  61. implicit final class TestLensEitherOps[E, A] extends AnyVal
  62. implicit final class TestLensExitOps[E, A] extends AnyVal
  63. implicit final class TestLensOptionOps[A] extends AnyVal
  64. implicit final class TestLensTryOps[A] extends AnyVal
  65. trait TestLogger extends Serializable
  66. trait TestRandom extends Random with Restorable

    TestRandom allows for deterministically testing effects involving randomness.

    TestRandom allows for deterministically testing effects involving randomness.

    TestRandom operates in two modes. In the first mode, TestRandom is a purely functional pseudo-random number generator. It will generate pseudo-random values just like scala.util.Random except that no internal state is mutated. Instead, methods like nextInt describe state transitions from one random state to another that are automatically composed together through methods like flatMap. The random seed can be set using setSeed and TestRandom is guaranteed to return the same sequence of values for any given seed. This is useful for deterministically generating a sequence of pseudo-random values and powers the property based testing functionality in ZIO Test.

    In the second mode, TestRandom maintains an internal buffer of values that can be "fed" with methods such as feedInts and then when random values of that type are generated they will first be taken from the buffer. This is useful for verifying that functions produce the expected output for a given sequence of "random" inputs.

    import zio.Random
import zio.test.TestRandom

for {
  _ <- TestRandom.feedInts(4, 5, 2)
  x <- Random.nextIntBounded(6)
  y <- Random.nextIntBounded(6)
  z <- Random.nextIntBounded(6)
} yield x + y + z == 11

    TestRandom will automatically take values from the buffer if a value of the appropriate type is available and otherwise generate a pseudo-random value, so there is nothing you need to do to switch between the two modes. Just generate random values as you normally would to get pseudo-random values, or feed in values of your own to get those values back. You can also use methods like clearInts to clear the buffer of values of a given type so you can fill the buffer with new values or go back to pseudo-random number generation.

  67. case class TestReporters(reportersStack: Ref[List[SuiteId]]) extends Product with Serializable
  68. case class TestResult(arrow: TestArrow[Any, Boolean]) extends Product with Serializable
  69. implicit final class TestResultZIOOps[R, E] extends AnyVal
  70. final case class TestRunner[R, E](executor: TestExecutor[R, E]) extends Product with Serializable

    A TestRunner[R, E] encapsulates all the logic necessary to run specs that require an environment R and may fail with an error E.

    A TestRunner[R, E] encapsulates all the logic necessary to run specs that require an environment R and may fail with an error E. Test runners require a test executor, a runtime configuration, and a reporter.

  71. sealed abstract class TestSuccess extends AnyRef
  72. trait TestSystem extends System with Restorable

    TestSystem supports deterministic testing of effects involving system properties.

    TestSystem supports deterministic testing of effects involving system properties. Internally, TestSystem maintains mappings of environment variables and system properties that can be set and accessed. No actual environment variables or system properties will be accessed or set as a result of these actions.

    import zio.system
import zio.test.TestSystem

for {
  _      <- TestSystem.putProperty("java.vm.name", "VM")
  result <- system.property("java.vm.name")
} yield result == Some("VM")
  73. final case class TestTimeoutException(message: String) extends Throwable with Product with Serializable
  74. sealed trait TestTrace[+A] extends AnyRef
  75. trait TimeVariants extends AnyRef
  76. trait TimeoutVariants extends AnyRef
  77. abstract class ZIOSpec[R] extends ZIOSpecAbstract with ZIOSpecVersionSpecific[R]
  78. abstract class ZIOSpecAbstract extends ZIOApp with ZIOSpecAbstractVersionSpecific
    Annotations
    @EnableReflectiveInstantiation()
  79. abstract class ZIOSpecDefault extends ZIOSpec[TestEnvironment]
  80. type ZTest[-R, +E] = ZIO[R, TestFailure[E], TestSuccess]

    A ZTest[R, E] is an effectfully produced test that requires an R and may fail with an E.

  81. trait ZTestEventHandler extends AnyRef
  82. sealed trait ZTestLogger[-Message, +Output] extends ZLogger[Message, Output]

    A ZTestLogger is an implementation of a ZLogger that writes all log messages to an internal data structure.

    A ZTestLogger is an implementation of a ZLogger that writes all log messages to an internal data structure. The contents of this data structure can be accessed using the logOutput operator. This makes it easy to write tests to verify that expected messages are being logged.

    test("logging works") {
  for {
    _      <- ZIO.logDebug("It's alive!")
    output <- ZTestLogger.logOutput
  } yield assertTrue(output.length == 1) &&
    assertTrue(output(0).message() == "It's alive!") &&
    assertTrue(output(0).logLevel == LogLevel.Debug)
}

Value Members

  1. def annotations(implicit trace: Trace): UIO[Annotations]

    Retrieves the Annotations service for this test.

  2. def annotationsWith[R, E, A](f: (Annotations) => ZIO[R, E, A])(implicit trace: Trace): ZIO[R, E, A]

    Retrieves the Annotations service for this test and uses it to run the specified workflow.

  3. macro def assert[A](expr: => A)(assertion: Assertion[A]): TestResult

    Checks the assertion holds for the given value.

    Checks the assertion holds for the given value.

    Definition Classes
    CompileVariants
  4. def assertCompletes(implicit trace: Trace, sourceLocation: SourceLocation): TestResult

    Asserts that the given test was completed.

  5. def assertCompletesZIO(implicit trace: Trace, sourceLocation: SourceLocation): UIO[TestResult]

    Asserts that the given test was completed.

  6. def assertNever(message: String)(implicit trace: Trace, sourceLocation: SourceLocation): TestResult

    Asserts that the given test was never completed.

  7. macro def assertTrue(expr: Boolean): TestResult
    Definition Classes
    CompileVariants
  8. macro def assertTrue(expr: Boolean, exprs: Boolean*): TestResult

    Checks the assertion holds for the given value.

    Checks the assertion holds for the given value.

    Definition Classes
    CompileVariants
  9. def assertZIO[R, E, A](effect: ZIO[R, E, A])(assertion: Assertion[A])(implicit trace: Trace, sourceLocation: SourceLocation): ZIO[R, E, TestResult]

    Checks the assertion holds for the given effectfully-computed value.

    Checks the assertion holds for the given effectfully-computed value.

    Definition Classes
    CompileVariants
  10. def check[R <: ZAny, A, B, C, D, F, G, H, I, In](rv1: Gen[R, A], rv2: Gen[R, B], rv3: Gen[R, C], rv4: Gen[R, D], rv5: Gen[R, F], rv6: Gen[R, G], rv7: Gen[R, H], rv8: Gen[R, I])(test: (A, B, C, D, F, G, H, I) => In)(implicit checkConstructor: CheckConstructor[R, In], sourceLocation: SourceLocation, trace: Trace): ZIO[OutEnvironment, OutError, TestResult]

    A version of check that accepts eight random variables.

  11. def check[R <: ZAny, A, B, C, D, F, G, H, In](rv1: Gen[R, A], rv2: Gen[R, B], rv3: Gen[R, C], rv4: Gen[R, D], rv5: Gen[R, F], rv6: Gen[R, G], rv7: Gen[R, H])(test: (A, B, C, D, F, G, H) => In)(implicit checkConstructor: CheckConstructor[R, In], sourceLocation: SourceLocation, trace: Trace): ZIO[OutEnvironment, OutError, TestResult]

    A version of check that accepts seven random variables.

  12. def check[R <: ZAny, A, B, C, D, F, G, In](rv1: Gen[R, A], rv2: Gen[R, B], rv3: Gen[R, C], rv4: Gen[R, D], rv5: Gen[R, F], rv6: Gen[R, G])(test: (A, B, C, D, F, G) => In)(implicit checkConstructor: CheckConstructor[R, In], sourceLocation: SourceLocation, trace: Trace): ZIO[OutEnvironment, OutError, TestResult]

    A version of check that accepts six random variables.

  13. def check[R <: ZAny, A, B, C, D, F, In](rv1: Gen[R, A], rv2: Gen[R, B], rv3: Gen[R, C], rv4: Gen[R, D], rv5: Gen[R, F])(test: (A, B, C, D, F) => In)(implicit checkConstructor: CheckConstructor[R, In], sourceLocation: SourceLocation, trace: Trace): ZIO[OutEnvironment, OutError, TestResult]

    A version of check that accepts five random variables.

  14. def check[R <: ZAny, A, B, C, D, In](rv1: Gen[R, A], rv2: Gen[R, B], rv3: Gen[R, C], rv4: Gen[R, D])(test: (A, B, C, D) => In)(implicit checkConstructor: CheckConstructor[R, In], sourceLocation: SourceLocation, trace: Trace): ZIO[OutEnvironment, OutError, TestResult]

    A version of check that accepts four random variables.

  15. def check[R <: ZAny, A, B, C, In](rv1: Gen[R, A], rv2: Gen[R, B], rv3: Gen[R, C])(test: (A, B, C) => In)(implicit checkConstructor: CheckConstructor[R, In], sourceLocation: SourceLocation, trace: Trace): ZIO[OutEnvironment, OutError, TestResult]

    A version of check that accepts three random variables.

  16. def check[R <: ZAny, A, B, In](rv1: Gen[R, A], rv2: Gen[R, B])(test: (A, B) => In)(implicit checkConstructor: CheckConstructor[R, In], sourceLocation: SourceLocation, trace: Trace): ZIO[OutEnvironment, OutError, TestResult]

    A version of check that accepts two random variables.

  17. def check[R <: ZAny, A, In](rv: Gen[R, A])(test: (A) => In)(implicit checkConstructor: CheckConstructor[R, In], sourceLocation: SourceLocation, trace: Trace): ZIO[OutEnvironment, OutError, TestResult]

    Checks the test passes for "sufficient" numbers of samples from the given random variable.

  18. def checkAll[R <: ZAny, E, A, B, C, D, F, G, H, I, In](rv1: Gen[R, A], rv2: Gen[R, B], rv3: Gen[R, C], rv4: Gen[R, D], rv5: Gen[R, F], rv6: Gen[R, G], rv7: Gen[R, H], rv8: Gen[R, I])(test: (A, B, C, D, F, G, H, I) => In)(implicit checkConstructor: CheckConstructor[R, In], sourceLocation: SourceLocation, trace: Trace): ZIO[OutEnvironment, OutError, TestResult]

    A version of checkAll that accepts eight random variables.

  19. def checkAll[R <: ZAny, A, B, C, D, F, G, H, In](rv1: Gen[R, A], rv2: Gen[R, B], rv3: Gen[R, C], rv4: Gen[R, D], rv5: Gen[R, F], rv6: Gen[R, G], rv7: Gen[R, H])(test: (A, B, C, D, F, G, H) => In)(implicit checkConstructor: CheckConstructor[R, In], sourceLocation: SourceLocation, trace: Trace): ZIO[OutEnvironment, OutError, TestResult]

    A version of checkAll that accepts seven random variables.

  20. def checkAll[R <: ZAny, A, B, C, D, F, G, In](rv1: Gen[R, A], rv2: Gen[R, B], rv3: Gen[R, C], rv4: Gen[R, D], rv5: Gen[R, F], rv6: Gen[R, G])(test: (A, B, C, D, F, G) => In)(implicit checkConstructor: CheckConstructor[R, In], sourceLocation: SourceLocation, trace: Trace): ZIO[OutEnvironment, OutError, TestResult]

    A version of checkAll that accepts six random variables.

  21. def checkAll[R <: ZAny, A, B, C, D, F, In](rv1: Gen[R, A], rv2: Gen[R, B], rv3: Gen[R, C], rv4: Gen[R, D], rv5: Gen[R, F])(test: (A, B, C, D, F) => In)(implicit checkConstructor: CheckConstructor[R, In], sourceLocation: SourceLocation, trace: Trace): ZIO[OutEnvironment, OutError, TestResult]

    A version of checkAll that accepts five random variables.

  22. def checkAll[R <: ZAny, A, B, C, D, In](rv1: Gen[R, A], rv2: Gen[R, B], rv3: Gen[R, C], rv4: Gen[R, D])(test: (A, B, C, D) => In)(implicit checkConstructor: CheckConstructor[R, In], sourceLocation: SourceLocation, trace: Trace): ZIO[OutEnvironment, OutError, TestResult]

    A version of checkAll that accepts four random variables.

  23. def checkAll[R <: ZAny, A, B, C, In](rv1: Gen[R, A], rv2: Gen[R, B], rv3: Gen[R, C])(test: (A, B, C) => In)(implicit checkConstructor: CheckConstructor[R, In], sourceLocation: SourceLocation, trace: Trace): ZIO[OutEnvironment, OutError, TestResult]

    A version of checkAll that accepts three random variables.

  24. def checkAll[R <: ZAny, A, B, In](rv1: Gen[R, A], rv2: Gen[R, B])(test: (A, B) => In)(implicit checkConstructor: CheckConstructor[R, In], sourceLocation: SourceLocation, trace: Trace): ZIO[OutEnvironment, OutError, TestResult]

    A version of checkAll that accepts two random variables.

  25. def checkAll[R <: ZAny, A, In](rv: Gen[R, A])(test: (A) => In)(implicit checkConstructor: CheckConstructor[R, In], sourceLocation: SourceLocation, trace: Trace): ZIO[OutEnvironment, OutError, TestResult]

    Checks the test passes for all values from the given finite, deterministic generator.

    Checks the test passes for all values from the given finite, deterministic generator. For non-deterministic or infinite generators use check or checkN.

  26. def checkAllPar[R <: ZAny, E, A, B, C, D, F, G, H, I, In](rv1: Gen[R, A], rv2: Gen[R, B], rv3: Gen[R, C], rv4: Gen[R, D], rv5: Gen[R, F], rv6: Gen[R, G], rv7: Gen[R, H], rv8: Gen[R, I], parallelism: Int)(test: (A, B, C, D, F, G, H, I) => In)(implicit checkConstructor: CheckConstructor[R, In], sourceLocation: SourceLocation, trace: Trace): ZIO[OutEnvironment, OutError, TestResult]

    A version of checkAllPar that accepts six random variables.

  27. def checkAllPar[R <: ZAny, E, A, B, C, D, F, G, H, In](rv1: Gen[R, A], rv2: Gen[R, B], rv3: Gen[R, C], rv4: Gen[R, D], rv5: Gen[R, F], rv6: Gen[R, G], rv7: Gen[R, H], parallelism: Int)(test: (A, B, C, D, F, G, H) => In)(implicit checkConstructor: CheckConstructor[R, In], sourceLocation: SourceLocation, trace: Trace): ZIO[OutEnvironment, OutError, TestResult]

    A version of checkAllPar that accepts six random variables.

  28. def checkAllPar[R <: ZAny, E, A, B, C, D, F, G, In](rv1: Gen[R, A], rv2: Gen[R, B], rv3: Gen[R, C], rv4: Gen[R, D], rv5: Gen[R, F], rv6: Gen[R, G], parallelism: Int)(test: (A, B, C, D, F, G) => In)(implicit checkConstructor: CheckConstructor[R, In], sourceLocation: SourceLocation, trace: Trace): ZIO[OutEnvironment, OutError, TestResult]

    A version of checkAllPar that accepts six random variables.

  29. def checkAllPar[R <: ZAny, E, A, B, C, D, F, In](rv1: Gen[R, A], rv2: Gen[R, B], rv3: Gen[R, C], rv4: Gen[R, D], rv5: Gen[R, F], parallelism: Int)(test: (A, B, C, D, F) => In)(implicit checkConstructor: CheckConstructor[R, In], sourceLocation: SourceLocation, trace: Trace): ZIO[OutEnvironment, OutError, TestResult]

    A version of checkAllPar that accepts five random variables.

  30. def checkAllPar[R <: ZAny, E, A, B, C, D, In](rv1: Gen[R, A], rv2: Gen[R, B], rv3: Gen[R, C], rv4: Gen[R, D], parallelism: Int)(test: (A, B, C, D) => In)(implicit checkConstructor: CheckConstructor[R, In], sourceLocation: SourceLocation, trace: Trace): ZIO[OutEnvironment, OutError, TestResult]

    A version of checkAllPar that accepts four random variables.

  31. def checkAllPar[R <: ZAny, E, A, B, C, In](rv1: Gen[R, A], rv2: Gen[R, B], rv3: Gen[R, C], parallelism: Int)(test: (A, B, C) => In)(implicit checkConstructor: CheckConstructor[R, In], sourceLocation: SourceLocation, trace: Trace): ZIO[OutEnvironment, OutError, TestResult]

    A version of checkAllPar that accepts three random variables.

  32. def checkAllPar[R <: ZAny, E, A, B, In](rv1: Gen[R, A], rv2: Gen[R, B], parallelism: Int)(test: (A, B) => In)(implicit checkConstructor: CheckConstructor[R, In], sourceLocation: SourceLocation, trace: Trace): ZIO[OutEnvironment, OutError, TestResult]

    A version of checkAllPar that accepts two random variables.

  33. def checkAllPar[R <: ZAny, E, A, In](rv: Gen[R, A], parallelism: Int)(test: (A) => In)(implicit checkConstructor: CheckConstructor[R, In], sourceLocation: SourceLocation, trace: Trace): ZIO[OutEnvironment, OutError, TestResult]

    Checks in parallel the effectual test passes for all values from the given random variable.

    Checks in parallel the effectual test passes for all values from the given random variable. This is useful for deterministic Gen that comprehensively explore all possibilities in a given domain.

  34. def checkN(n: Int): CheckN

    Checks the test passes for the specified number of samples from the given random variable.

  35. def checkPar[R <: ZAny, A, B, C, D, F, G, H, I, In](rv1: Gen[R, A], rv2: Gen[R, B], rv3: Gen[R, C], rv4: Gen[R, D], rv5: Gen[R, F], rv6: Gen[R, G], rv7: Gen[R, H], rv8: Gen[R, I], parallelism: Int)(test: (A, B, C, D, F, G, H, I) => In)(implicit checkConstructor: CheckConstructor[R, In], sourceLocation: SourceLocation, trace: Trace): ZIO[OutEnvironment, OutError, TestResult]

    A version of checkPar that accepts eight random variables.

  36. def checkPar[R <: ZAny, A, B, C, D, F, G, H, In](rv1: Gen[R, A], rv2: Gen[R, B], rv3: Gen[R, C], rv4: Gen[R, D], rv5: Gen[R, F], rv6: Gen[R, G], rv7: Gen[R, H], parallelism: Int)(test: (A, B, C, D, F, G, H) => In)(implicit checkConstructor: CheckConstructor[R, In], sourceLocation: SourceLocation, trace: Trace): ZIO[OutEnvironment, OutError, TestResult]

    A version of checkPar that accepts seven random variables.

  37. def checkPar[R <: ZAny, A, B, C, D, F, G, In](rv1: Gen[R, A], rv2: Gen[R, B], rv3: Gen[R, C], rv4: Gen[R, D], rv5: Gen[R, F], rv6: Gen[R, G], parallelism: Int)(test: (A, B, C, D, F, G) => In)(implicit checkConstructor: CheckConstructor[R, In], sourceLocation: SourceLocation, trace: Trace): ZIO[OutEnvironment, OutError, TestResult]

    A version of checkPar that accepts six random variables.

  38. def checkPar[R <: ZAny, A, B, C, D, F, In](rv1: Gen[R, A], rv2: Gen[R, B], rv3: Gen[R, C], rv4: Gen[R, D], rv5: Gen[R, F], parallelism: Int)(test: (A, B, C, D, F) => In)(implicit checkConstructor: CheckConstructor[R, In], sourceLocation: SourceLocation, trace: Trace): ZIO[OutEnvironment, OutError, TestResult]

    A version of checkPar that accepts five random variables.

  39. def checkPar[R <: ZAny, A, B, C, D, In](rv1: Gen[R, A], rv2: Gen[R, B], rv3: Gen[R, C], rv4: Gen[R, D], parallelism: Int)(test: (A, B, C, D) => In)(implicit checkConstructor: CheckConstructor[R, In], sourceLocation: SourceLocation, trace: Trace): ZIO[OutEnvironment, OutError, TestResult]

    A version of checkPar that accepts four random variables.

  40. def checkPar[R <: ZAny, A, B, C, In](rv1: Gen[R, A], rv2: Gen[R, B], rv3: Gen[R, C], parallelism: Int)(test: (A, B, C) => In)(implicit checkConstructor: CheckConstructor[R, In], sourceLocation: SourceLocation, trace: Trace): ZIO[OutEnvironment, OutError, TestResult]

    A version of checkPar that accepts three random variables.

  41. def checkPar[R <: ZAny, A, B, In](rv1: Gen[R, A], rv2: Gen[R, B], parallelism: Int)(test: (A, B) => In)(implicit checkConstructor: CheckConstructor[R, In], sourceLocation: SourceLocation, trace: Trace): ZIO[OutEnvironment, OutError, TestResult]

    A version of checkPar that accepts two random variables.

  42. def checkPar[R <: ZAny, A, In](rv: Gen[R, A], parallelism: Int)(test: (A) => In)(implicit checkConstructor: CheckConstructor[R, In], sourceLocation: SourceLocation, trace: Trace): ZIO[OutEnvironment, OutError, TestResult]

    Checks in parallel the test passes for "sufficient" numbers of samples from the given random variable.

  43. lazy val defaultTestRunner: TestRunner[TestEnvironment, Any]

    A Runner that provides a default testable environment.

  44. def failed[E](cause: Cause[E])(implicit trace: Trace): ZIO[Any, TestFailure[E], Nothing]

    Creates a failed test result with the specified runtime cause.

  45. val ignored: UIO[TestSuccess]

    Creates an ignored test result.

  46. def live(implicit trace: Trace): UIO[Live]

    Retrieves the Live service for this test.

  47. def live[R, E, A](zio: ZIO[R, E, A])(implicit trace: Trace): ZIO[R, E, A]

    Provides an effect with the "real" environment as opposed to the test environment.

    Provides an effect with the "real" environment as opposed to the test environment. This is useful for performing effects such as timing out tests, accessing the real time, or printing to the real console.

  48. val liveEnvironment: Layer[Nothing, Clock with Console with System with Random]
  49. def liveWith[R, E, A](f: (Live) => ZIO[R, E, A])(implicit trace: Trace): ZIO[R, E, A]

    Retrieves the Live service for this test and uses it to run the specified workflow.

  50. def platformSpecific[R, E, A](js: => A, jvm: => A)(f: (A) => ZTest[R, E]): ZTest[R, E]

    Passes platform specific information to the specified function, which will use that information to create a test.

    Passes platform specific information to the specified function, which will use that information to create a test. If the platform is neither ScalaJS nor the JVM, an ignored test result will be returned.

  51. def sized(implicit trace: Trace): UIO[Sized]

    Retrieves the Sized service for this test.

  52. def sizedWith[R, E, A](f: (Sized) => ZIO[R, E, A])(implicit trace: Trace): ZIO[R, E, A]

    Retrieves the Sized service for this test and uses it to run the specified workflow.

  53. def suite[In](label: String)(specs: In*)(implicit suiteConstructor: SuiteConstructor[In], sourceLocation: SourceLocation, trace: Trace): Spec[OutEnvironment, OutError]

    Builds a suite containing a number of other specs.

  54. def test[In](label: String)(assertion: => In)(implicit testConstructor: TestConstructor[Nothing, In], sourceLocation: SourceLocation, trace: Trace): Out

    Builds a spec with a single test.

  55. def testClock(implicit trace: Trace): UIO[TestClock]

    Retrieves the TestClock service for this test.

  56. def testClockWith[R, E, A](f: (TestClock) => ZIO[R, E, A])(implicit trace: Trace): ZIO[R, E, A]

    Retrieves the TestClock service for this test and uses it to run the specified workflow.

  57. def testConfig(implicit trace: Trace): UIO[TestConfig]

    Retrieves the TestConfig service for this test.

  58. def testConfigWith[R, E, A](f: (TestConfig) => ZIO[R, E, A])(implicit trace: Trace): ZIO[R, E, A]

    Retrieves the TestConfig service for this test and uses it to run the specified workflow.

  59. def testConsole(implicit trace: Trace): UIO[TestConsole]

    Retrieves the TestConsole service for this test.

  60. def testConsoleWith[R, E, A](f: (TestConsole) => ZIO[R, E, A])(implicit trace: Trace): ZIO[R, E, A]

    Retrieves the TestConsole service for this test and uses it to run the specified workflow.

  61. val testEnvironment: ZLayer[Any, Nothing, TestEnvironment]
  62. def testRandom(implicit trace: Trace): UIO[TestRandom]

    Retrieves the TestRandom service for this test.

  63. def testRandomWith[R, E, A](f: (TestRandom) => ZIO[R, E, A])(implicit trace: Trace): ZIO[R, E, A]

    Retrieves the TestRandom service for this test and uses it to run the specified workflow.

  64. def testSystem(implicit trace: Trace): UIO[TestSystem]

    Retrieves the TestSystem service for this test.

  65. def testSystemWith[R, E, A](f: (TestSystem) => ZIO[R, E, A])(implicit trace: Trace): ZIO[R, E, A]

    Retrieves the TestSystem service for this test and uses it to run the specified workflow.

  66. final macro def typeCheck(code: String): UIO[Either[String, Unit]]

    Returns either Right if the specified string type checks as valid Scala code or Left with an error message otherwise.

    Returns either Right if the specified string type checks as valid Scala code or Left with an error message otherwise. Dies with a runtime exception if specified string cannot be parsed or is not a known value at compile time.

    Definition Classes
    CompileVariants
  67. def versionSpecific[R, E, A](scala3: => A, scala2: => A)(f: (A) => ZTest[R, E]): ZTest[R, E]

    Passes version specific information to the specified function, which will use that information to create a test.

    Passes version specific information to the specified function, which will use that information to create a test. If the version is neither Scala 3 nor Scala 2, an ignored test result will be returned.

  68. def withAnnotations[R, E, A <: Annotations, B](annotations: => A)(zio: => ZIO[R, E, B])(implicit tag: Tag[A], trace: Trace): ZIO[R, E, B]

    Executes the specified workflow with the specified implementation of the annotations service.

  69. def withAnnotationsScoped[A <: Annotations](annotations: => A)(implicit tag: Tag[A], trace: Trace): ZIO[Scope, Nothing, Unit]

    Sets the implementation of the annotations service to the specified value and restores it to its original value when the scope is closed.

  70. def withLive[R, E, E1, A, B](zio: ZIO[R, E, A])(f: (ZIO[R, E, A]) => ZIO[R, E1, B])(implicit trace: Trace): ZIO[R, E1, B]

    Transforms this effect with the specified function.

    Transforms this effect with the specified function. The test environment will be provided to this effect, but the live environment will be provided to the transformation function. This can be useful for applying transformations to an effect that require access to the "real" environment while ensuring that the effect itself uses the test environment.

    withLive(test)(_.timeout(duration))
  71. def withLive[R, E, A <: Live, B](live: => A)(zio: => ZIO[R, E, B])(implicit tag: Tag[A], trace: Trace): ZIO[R, E, B]

    Executes the specified workflow with the specified implementation of the live service.

  72. def withLiveScoped[A <: Live](live: => A)(implicit tag: Tag[A], trace: Trace): ZIO[Scope, Nothing, Unit]

    Sets the implementation of the live service to the specified value and restores it to its original value when the scope is closed.

  73. def withSized[R, E, A <: Sized, B](sized: => A)(zio: => ZIO[R, E, B])(implicit tag: Tag[A], trace: Trace): ZIO[R, E, B]

    Executes the specified workflow with the specified implementation of the sized service.

  74. def withSizedScoped[A <: Sized](sized: => A)(implicit tag: Tag[A], trace: Trace): ZIO[Scope, Nothing, Unit]

    Sets the implementation of the sized service to the specified value and restores it to its original value when the scope is closed.

  75. def withTestConfig[R, E, A <: TestConfig, B](testConfig: => A)(zio: => ZIO[R, E, B])(implicit tag: Tag[A], trace: Trace): ZIO[R, E, B]

    Executes the specified workflow with the specified implementation of the config service.

  76. def withTestConfigScoped[A <: TestConfig](testConfig: => A)(implicit tag: Tag[A], trace: Trace): ZIO[Scope, Nothing, Unit]

    Sets the implementation of the config service to the specified value and restores it to its original value when the scope is closed.

  77. object Annotations extends Serializable
  78. object Assertion extends AssertionVariants with Serializable
  79. object CheckConstructor extends CheckConstructorLowPriority1
  80. object CheckVariants
  81. object CompileVariants

    Proxy methods to call package private methods from the macro

  82. object CustomAssertion
  83. object Eql extends EqlLowPriority
  84. object ErrorMessage
  85. object ExecutionEvent
  86. object ExecutionEventSink
  87. object FailureCase extends Serializable
  88. object Gen extends GenZIO with FunctionVariants with TimeVariants with Serializable
  89. object GenFailureDetails
  90. object Live
  91. object ReporterEventRenderer
  92. object Result
  93. object Sample extends Serializable
  94. object Sized extends Serializable
  95. object Spec extends Serializable
  96. object SuiteConstructor extends SuiteConstructorLowPriority1
  97. object SuiteId extends Serializable
  98. object Summary extends Serializable
  99. object SummaryBuilder
  100. object TestAnnotation extends Serializable
  101. object TestAnnotationMap
  102. object TestAnnotationRenderer
  103. object TestArgs extends Serializable
  104. object TestArrow
  105. object TestAspect extends TimeoutVariants
  106. object TestClock extends Serializable
  107. object TestConfig extends Serializable
  108. object TestConsole extends Serializable
  109. object TestConstructor extends TestConstructorLowPriority1
  110. object TestDuration
  111. object TestEnvironment
  112. object TestExecutor
  113. object TestFailure
  114. object TestLogger extends Serializable
  115. object TestPlatform

    TestPlatform provides information about the platform tests are being run on to enable platform specific test configuration.

  116. object TestRandom extends Serializable
  117. object TestReporters extends Serializable
  118. object TestResult extends Serializable
  119. object TestServices
  120. object TestSuccess
  121. object TestSystem extends Serializable
  122. object TestTrace
  123. object TestVersion

    TestVersion provides information about the Scala version tests are being run on to enable platform specific test configuration.

  124. object ZTest
  125. object ZTestEventHandler
  126. object ZTestLogger

Inherited from CompileVariants

Inherited from AnyRef

Inherited from Any

Ungrouped