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
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 scalacheck

    Provides functionality for converting legacy ScalaCheck generators to ZIO Test generators to support upgrading to ZIO Test without having to reimplement existing generators.

    Provides functionality for converting 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

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 AnyRef
  7. trait CompileVariants extends AnyRef
  8. 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)
      }
    )
  9. 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()
  10. sealed trait ErrorMessage extends AnyRef
  11. sealed trait ExecutionEvent extends AnyRef
  12. trait ExecutionEventPrinter 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, Option[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. trait PrettyPrintVersionSpecific extends AnyRef
  21. final class ProvideSomePartiallyApplied[R0, -R, +E] extends AnyVal
  22. final class ProvideSomeSharedPartiallyApplied[R0, -R, +E] extends AnyVal
  23. trait ReporterEventRenderer extends AnyRef
  24. trait Restorable extends Serializable
  25. sealed trait Result[+A] extends AnyRef
  26. final case class Sample[-R, +A](value: A, shrink: ZStream[R, Nothing, Option[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.

  27. trait Sized extends Serializable
  28. class SmartAssertMacros extends AnyRef
  29. implicit final class SmartAssertionOps[A] extends AnyVal
  30. class SmartSpecMacros extends AnyRef
  31. 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.

  32. class SpecLayerMacros extends LayerMacroUtils
  33. trait SuiteConstructor[In] extends AnyRef
  34. trait SuiteConstructorLowPriority1 extends SuiteConstructorLowPriority2
  35. trait SuiteConstructorLowPriority2 extends SuiteConstructorLowPriority3
  36. trait SuiteConstructorLowPriority3 extends SuiteConstructorLowPriority4
  37. trait SuiteConstructorLowPriority4 extends AnyRef
  38. 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

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

    A type of annotation.

  41. final class TestAnnotationMap extends AnyRef

    An annotation map keeps track of annotations of different types.

  42. sealed abstract class TestAnnotationRenderer extends AnyRef

    A TestAnnotationRenderer knows how to render test annotations.

  43. final case class TestArgs(testSearchTerms: List[String], tagSearchTerms: List[String], tagIgnoreTerms: List[String], testTaskPolicy: Option[String], testRenderer: Option[String], printSummary: Boolean) extends Product with Serializable
  44. sealed trait TestArrow[-A, +B] extends AnyRef
  45. 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.

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

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

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

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

  48. 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.

  49. trait TestClockPlatformSpecific extends AnyRef
  50. 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.

  51. 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")
  52. trait TestConstructor[-Environment, In] extends AnyRef
  53. trait TestConstructorLowPriority1 extends TestConstructorLowPriority2
  54. trait TestConstructorLowPriority2 extends AnyRef
  55. sealed trait TestDuration extends AnyRef
  56. type TestEnvironment = Annotations with Live with Sized with TestConfig
  57. 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.

  58. sealed abstract class TestFailure[+E] extends AnyRef
  59. final case class TestLens[+A]() extends Product with Serializable
  60. implicit final class TestLensAnyOps[A] extends AnyVal
  61. implicit final class TestLensCauseOps[E] extends AnyVal
  62. implicit final class TestLensEitherOps[E, A] extends AnyVal
  63. implicit final class TestLensExitOps[E, A] extends AnyVal
  64. implicit final class TestLensOptionOps[A] extends AnyVal
  65. trait TestLogger extends Serializable
  66. trait TestOutput extends AnyRef
  67. 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.

  68. case class TestReporters(reportersStack: Ref[List[SuiteId]]) extends Product with Serializable
  69. case class TestResult(arrow: TestArrow[Any, Boolean]) extends Product with Serializable
  70. implicit final class TestResultZIOOps[R, E] extends AnyVal
  71. final case class TestRunner[R, E](executor: TestExecutor[R, E], bootstrap: ULayer[TestOutput with ExecutionEventSink] = TestRunner.defaultBootstrap) 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.

  72. sealed abstract class TestSuccess extends AnyRef
  73. 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")
  74. final case class TestTimeoutException(message: String) extends Throwable with Product with Serializable
  75. sealed trait TestTrace[+A] extends AnyRef
  76. trait TimeVariants extends AnyRef
  77. trait TimeoutVariants extends AnyRef
  78. abstract class ZIOSpec[R] extends ZIOSpecAbstract with ZIOSpecVersionSpecific[R]
  79. abstract class ZIOSpecAbstract extends ZIOApp with ZIOSpecAbstractVersionSpecific
    Annotations
    @EnableReflectiveInstantiation()
  80. trait ZIOSpecAbstractVersionSpecific extends AnyRef
  81. abstract class ZIOSpecDefault extends ZIOSpec[TestEnvironment]
  82. trait ZIOSpecVersionSpecific[R] extends AnyRef
  83. 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.

  84. trait ZTestEventHandler extends AnyRef
  85. 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. lazy val defaultTestRunner: TestRunner[TestEnvironment, Any]

    A Runner that provides a default testable environment.

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

    Creates a failed test result with the specified runtime cause.

  37. val ignored: UIO[TestSuccess]

    Creates an ignored test result.

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

    Retrieves the Live service for this test.

  39. 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.

  40. val liveEnvironment: Layer[Nothing, Clock with Console with System with Random]
  41. 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.

  42. 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.

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

    Retrieves the Sized service for this test.

  44. 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.

  45. 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.

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

    Builds a spec with a single test.

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

    Retrieves the TestClock service for this test.

  48. 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.

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

    Retrieves the TestConfig service for this test.

  50. 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.

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

    Retrieves the TestConsole service for this test.

  52. 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.

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

    Retrieves the TestRandom service for this test.

  55. 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.

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

    Retrieves the TestSystem service for this test.

  57. 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.

  58. 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
  59. 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.

  60. 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.

  61. 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.

  62. 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))
  63. 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.

  64. 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.

  65. 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.

  66. 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.

  67. 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.

  68. 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.

  69. object Annotations extends Serializable
  70. object Assertion extends AssertionVariants with Serializable
  71. object CheckConstructor extends CheckConstructorLowPriority1
  72. object CheckVariants
  73. object CompileVariants

    Proxy methods to call package private methods from the macro

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

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

  110. object TestRandom extends Serializable
  111. object TestReporters extends Serializable
  112. object TestResult extends Serializable
  113. object TestRunner extends Serializable
  114. object TestServices
  115. object TestSuccess
  116. object TestSystem extends Serializable
  117. object TestTrace
  118. object TestVersion

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

  119. object ZTest
  120. object ZTestEventHandler
  121. object ZTestLogger

Inherited from CompileVariants

Inherited from AnyRef

Inherited from Any

Ungrouped