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
import Assertion.isGreaterThan

object MyTest extends DefaultRunnableSpec {
  def spec = suite("clock")(
    test("time is non-zero") {
      for {
        time <- Live.live(nanoTime)
      } yield assertTrue(time >= 0)
    }
  )
}
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[Sized, 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. case class Assert(arrow: TestArrow[Any, Boolean]) extends Product with Serializable
  3. type AssertResult = BoolAlgebra[AssertionValue]
  4. type AssertResultM = BoolAlgebraM[Any, Nothing, AssertionValue]
  5. final class Assertion[-A] extends AssertionM[A] with (=> A) => AssertResult

    An Assertion[A] is capable of producing assertion results on an A.

    An Assertion[A] is capable of producing assertion results on an A. As a proposition, assertions compose using logical conjunction and disjunction, and can be negated.

  6. sealed abstract class AssertionData extends AnyRef
  7. abstract class AssertionM[-A] extends AnyRef

    An AssertionM[A] is capable of producing assertion results on an A.

    An AssertionM[A] is capable of producing assertion results on an A. As a proposition, assertions compose using logical conjunction and disjunction, and can be negated.

  8. sealed abstract class AssertionMData extends AnyRef
  9. sealed trait AssertionResult extends AnyRef
  10. sealed abstract class AssertionValue extends AnyRef

    An AssertionValue keeps track of a assertion and a value, existentially hiding the type.

    An AssertionValue keeps track of a assertion and a value, existentially hiding the type. This is used internally by the library to provide useful error messages in the event of test failures.

  11. trait AssertionVariants extends AnyRef
  12. sealed abstract class BoolAlgebra[+A] extends Product with Serializable

    A BoolAlgebra[A] is a description of logical operations on values of type A.

  13. final case class BoolAlgebraM[-R, +E, +A](run: ZIO[R, E, BoolAlgebra[A]]) extends Product with Serializable
  14. trait CheckConstructor[Environment, In] extends AnyRef
  15. trait CheckConstructorLowPriority1 extends CheckConstructorLowPriority2
  16. trait CheckConstructorLowPriority2 extends CheckConstructorLowPriority3
  17. trait CheckConstructorLowPriority3 extends CheckConstructorLowPriority4
  18. trait CheckConstructorLowPriority4 extends CheckConstructorLowPriority5
  19. trait CheckConstructorLowPriority5 extends AnyRef
  20. trait CompileVariants extends AnyRef
  21. 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)
      }
    )
  22. 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()
  23. sealed trait ErrorMessage extends AnyRef
  24. sealed trait ExecutionEvent extends AnyRef
  25. trait ExecutionEventPrinter extends AnyRef
  26. trait ExecutionEventSink extends AnyRef
  27. case class FailureCase(errorMessage: Message, codeString: String, location: String, path: Chunk[(String, Any)], span: Span, nestedFailures: Chunk[FailureCase], result: Any) extends Product with Serializable
  28. final case class FailureDetails(assertion: ::[AssertionValue]) extends Product with Serializable

    FailureDetails keeps track of details relevant to failures.

  29. trait FunctionVariants extends AnyRef
  30. 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.

  31. sealed abstract class GenFailureDetails extends AnyRef

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

  32. trait GenZIO extends AnyRef
  33. 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.

  34. trait PrettyPrintVersionSpecific extends AnyRef
  35. trait Restorable extends Serializable
  36. sealed trait Result[+A] extends AnyRef
  37. 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.

  38. trait Sized extends Serializable
  39. class SmartAssertMacros extends AnyRef
  40. implicit final class SmartAssertionOps[A] extends AnyVal
  41. 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.

  42. class SpecLayerMacros extends LayerMacroUtils
  43. trait SuiteConstructor[In] extends AnyRef
  44. trait SuiteConstructorLowPriority1 extends SuiteConstructorLowPriority2
  45. trait SuiteConstructorLowPriority2 extends SuiteConstructorLowPriority3
  46. trait SuiteConstructorLowPriority3 extends SuiteConstructorLowPriority4
  47. trait SuiteConstructorLowPriority4 extends AnyRef
  48. 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

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

    A type of annotation.

  51. final class TestAnnotationMap extends AnyRef

    An annotation map keeps track of annotations of different types.

  52. sealed abstract class TestAnnotationRenderer extends AnyRef

    A TestAnnotationRenderer knows how to render test annotations.

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

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

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

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

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

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

  59. trait TestClockPlatformSpecific extends AnyRef
  60. 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.

  61. 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")
  62. trait TestConstructor[-Environment, In] extends AnyRef
  63. trait TestConstructorLowPriority1 extends TestConstructorLowPriority2
  64. trait TestConstructorLowPriority2 extends TestConstructorLowPriority3
  65. trait TestConstructorLowPriority3 extends TestConstructorLowPriority4
  66. trait TestConstructorLowPriority4 extends TestConstructorLowPriority5
  67. trait TestConstructorLowPriority5 extends AnyRef
  68. sealed trait TestDuration extends AnyRef
  69. type TestEnvironment = Annotations with Live with Sized with TestConfig
  70. 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.

  71. sealed abstract class TestFailure[+E] extends AnyRef
  72. final case class TestLens[+A]() extends Product with Serializable
  73. implicit final class TestLensAnyOps[A] extends AnyVal
  74. implicit final class TestLensCauseOps[E] extends AnyVal
  75. implicit final class TestLensEitherOps[E, A] extends AnyVal
  76. implicit final class TestLensExitOps[E, A] extends AnyVal
  77. implicit final class TestLensOptionOps[A] extends AnyVal
  78. trait TestLogger extends Serializable
  79. trait TestOutput extends AnyRef
  80. 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.

  81. type TestReporter[-E] = (zio.Duration, ExecutionEvent) => URIO[TestLogger, Unit]

    A TestReporter[E] is capable of reporting test results with error type E.

  82. case class TestReporters(reportersStack: Ref[List[SuiteId]]) extends Product with Serializable
  83. type TestResult = BoolAlgebra[AssertionResult]
  84. final case class TestRunner[R, E](executor: TestExecutor[R, E], runtimeConfig: RuntimeConfig = RuntimeConfig.makeDefault(), reporter: TestReporter[E] = DefaultTestReporter(TestRenderer.default, TestAnnotationRenderer.default)(ZTraceElement.empty), bootstrap: Layer[Nothing, TestLogger with ExecutionEventSink] = { implicit val emptyTracer = ZTraceElement.empty val printerLayer = TestLogger.fromConsole(Console.ConsoleLive) Clock.live ++ (printerLayer >+> sinkLayer) ++ Random.live }) 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.

  85. sealed abstract class TestSuccess extends AnyRef
  86. 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")
  87. final case class TestTimeoutException(message: String) extends Throwable with Product with Serializable
  88. trait TimeVariants extends AnyRef
  89. trait TimeoutVariants extends AnyRef
  90. sealed trait Trace[+A] extends AnyRef
  91. abstract class ZIOSpec[R] extends ZIOSpecAbstract
  92. abstract class ZIOSpecAbstract extends ZIOApp
    Annotations
    @EnableReflectiveInstantiation()
  93. abstract class ZIOSpecDefault extends ZIOSpec[TestEnvironment]
  94. 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.

  95. 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. 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
  2. def assertCompletes(implicit trace: ZTraceElement): TestResult

    Asserts that the given test was completed.

  3. def assertCompletesM(implicit trace: ZTraceElement): UIO[TestResult]

    Asserts that the given test was completed.

  4. macro def assertM[R, E, A](effect: ZIO[R, E, A])(assertion: AssertionM[A]): 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
  5. def assertNever(message: String)(implicit trace: ZTraceElement): TestResult

    Asserts that the given test was never completed.

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

    Checks the assertion holds for the given value.

    Checks the assertion holds for the given value.

    Definition Classes
    CompileVariants
  8. def check[R <: TestConfig, 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], trace: ZTraceElement): ZIO[OutEnvironment, OutError, TestResult]

    A version of check that accepts six random variables.

  9. def check[R <: TestConfig, 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], trace: ZTraceElement): ZIO[OutEnvironment, OutError, TestResult]

    A version of check that accepts five random variables.

  10. def check[R <: TestConfig, 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], trace: ZTraceElement): ZIO[OutEnvironment, OutError, TestResult]

    A version of check that accepts four random variables.

  11. def check[R <: TestConfig, 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], trace: ZTraceElement): ZIO[OutEnvironment, OutError, TestResult]

    A version of check that accepts three random variables.

  12. def check[R <: TestConfig, A, B, In](rv1: Gen[R, A], rv2: Gen[R, B])(test: (A, B) => In)(implicit checkConstructor: CheckConstructor[R, In], trace: ZTraceElement): ZIO[OutEnvironment, OutError, TestResult]

    A version of check that accepts two random variables.

  13. def check[R <: TestConfig, A, In](rv: Gen[R, A])(test: (A) => In)(implicit checkConstructor: CheckConstructor[R, In], trace: ZTraceElement): ZIO[OutEnvironment, OutError, TestResult]

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

  14. def checkAll[R <: TestConfig, 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], trace: ZTraceElement): ZIO[OutEnvironment, OutError, TestResult]

    A version of checkAll that accepts six random variables.

  15. def checkAll[R <: TestConfig, 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], trace: ZTraceElement): ZIO[OutEnvironment, OutError, TestResult]

    A version of checkAll that accepts five random variables.

  16. def checkAll[R <: TestConfig, 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], trace: ZTraceElement): ZIO[OutEnvironment, OutError, TestResult]

    A version of checkAll that accepts four random variables.

  17. def checkAll[R <: TestConfig, 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], trace: ZTraceElement): ZIO[OutEnvironment, OutError, TestResult]

    A version of checkAll that accepts three random variables.

  18. def checkAll[R <: TestConfig, A, B, In](rv1: Gen[R, A], rv2: Gen[R, B])(test: (A, B) => In)(implicit checkConstructor: CheckConstructor[R, In], trace: ZTraceElement): ZIO[OutEnvironment, OutError, TestResult]

    A version of checkAll that accepts two random variables.

  19. def checkAll[R <: TestConfig, A, In](rv: Gen[R, A])(test: (A) => In)(implicit checkConstructor: CheckConstructor[R, In], trace: ZTraceElement): ZIO[OutEnvironment, OutError, TestResult]

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

    Checks the 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.

  20. def checkAllPar[R <: TestConfig, R1 <: R, 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], trace: ZTraceElement): ZIO[OutEnvironment, OutError, TestResult]

    A version of checkAllMPar that accepts six random variables.

  21. def checkAllPar[R <: TestConfig, R1 <: R, 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], trace: ZTraceElement): ZIO[OutEnvironment, OutError, TestResult]

    A version of checkAllMPar that accepts five random variables.

  22. def checkAllPar[R <: TestConfig, R1 <: R, 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], trace: ZTraceElement): ZIO[OutEnvironment, OutError, TestResult]

    A version of checkAllMPar that accepts four random variables.

  23. def checkAllPar[R <: TestConfig, R1 <: R, 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], trace: ZTraceElement): ZIO[OutEnvironment, OutError, TestResult]

    A version of checkAllMPar that accepts three random variables.

  24. def checkAllPar[R <: TestConfig, R1 <: R, E, A, B, In](rv1: Gen[R, A], rv2: Gen[R, B], parallelism: Int)(test: (A, B) => In)(implicit checkConstructor: CheckConstructor[R, In], trace: ZTraceElement): ZIO[OutEnvironment, OutError, TestResult]

    A version of checkAllMPar that accepts two random variables.

  25. def checkAllPar[R <: TestConfig, R1 <: R, E, A, In](rv: Gen[R, A], parallelism: Int)(test: (A) => In)(implicit checkConstructor: CheckConstructor[R, In], trace: ZTraceElement): 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.

  26. def checkN(n: Int): CheckN

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

  27. val defaultTestRunner: TestRunner[TestEnvironment, Any]

    A Runner that provides a default testable environment.

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

    Creates a failed test result with the specified runtime cause.

  29. val ignored: UIO[TestSuccess]

    Creates an ignored test result.

  30. def live[R <: Live, E, A](zio: ZIO[R, E, A])(implicit trace: ZTraceElement): 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.

  31. val liveEnvironment: Layer[Nothing, ZEnv]
  32. 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.

  33. val sinkLayer: ZLayer[Any, Nothing, ExecutionEventSink]
  34. def sinkLayerWithConsole(console: Console)(implicit trace: ZTraceElement): ZLayer[Any, Nothing, ExecutionEventSink]
  35. def suite[In](label: String)(specs: In*)(implicit suiteConstructor: SuiteConstructor[In], trace: ZTraceElement): Spec[OutEnvironment, OutError]

    Builds a suite containing a number of other specs.

  36. def test[In](label: String)(assertion: => In)(implicit testConstructor: TestConstructor[Nothing, In], trace: ZTraceElement): Out

    Builds a spec with a single test.

  37. def testClock(implicit trace: ZTraceElement): UIO[TestClock]

    Retrieves the TestClock service for this test.

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

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

  39. def testConsole(implicit trace: ZTraceElement): UIO[TestConsole]

    Retrieves the TestConsole service for this test.

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

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

  41. val testEnvironment: ZLayer[Scope, Nothing, TestEnvironment]
  42. def testRandom(implicit trace: ZTraceElement): UIO[TestRandom]

    Retrieves the TestRandom service for this test.

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

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

  44. def testSystem(implicit trace: ZTraceElement): UIO[TestSystem]

    Retrieves the TestSystem service for this test.

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

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

  46. 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
  47. 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.

  48. def withLive[R <: Live, E, E1, A, B](zio: ZIO[R, E, A])(f: (ZIO[R, E, A]) => ZIO[R, E1, B])(implicit trace: ZTraceElement): ZIO[R with Live, 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))
  49. object Annotations extends Serializable
  50. object Assert extends Serializable
  51. object Assertion extends AssertionVariants
  52. object AssertionData
  53. object AssertionM
  54. object AssertionMData
  55. object AssertionResult
  56. object AssertionValue
  57. object BoolAlgebra extends Serializable
  58. object BoolAlgebraM extends Serializable
  59. object CheckConstructor extends CheckConstructorLowPriority1
  60. object CheckVariants
  61. object CompileVariants

    Proxy methods to call package private methods from the macro

  62. object CustomAssertion
  63. object DefaultTestReporter
  64. object Eql extends EqlLowPriority
  65. object ErrorMessage
  66. object ExecutionEvent
  67. object ExecutionEventPrinter
  68. object ExecutionEventSink
  69. object FailureCase extends Serializable
  70. object Gen extends GenZIO with FunctionVariants with TimeVariants with Serializable
  71. object GenFailureDetails
  72. object Live
  73. object ReporterEventRenderer
  74. object Result
  75. object Sample extends Serializable
  76. object Sized extends Serializable
  77. object Spec extends Serializable
  78. object SuiteConstructor extends SuiteConstructorLowPriority1
  79. object SuiteId extends Serializable
  80. object Summary extends Serializable
  81. object SummaryBuilder
  82. object TestAnnotation extends Serializable
  83. object TestAnnotationMap
  84. object TestAnnotationRenderer
  85. object TestArgs extends Serializable
  86. object TestArrow
  87. object TestAspect extends TimeoutVariants
  88. object TestClock extends Serializable
  89. object TestConfig extends Serializable
  90. object TestConsole extends Serializable
  91. object TestConstructor extends TestConstructorLowPriority1
  92. object TestDuration
  93. object TestEnvironment
  94. object TestExecutor
  95. object TestFailure
  96. object TestLogger extends Serializable
  97. object TestOutput
  98. object TestPlatform

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

  99. object TestRandom extends Serializable
  100. object TestReporter
  101. object TestReporters extends Serializable
  102. object TestResult
  103. object TestSuccess
  104. object TestSystem extends Serializable
  105. object TestVersion

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

  106. object Trace
  107. object ZTest
  108. object ZTestLogger

Inherited from CompileVariants

Inherited from AnyRef

Inherited from Any

Ungrouped