Packages

  • package root
    Definition Classes
    root
  • package zio
    Definition Classes
    root
  • package test
    Definition Classes
    zio
  • 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
p

zio

test

package test

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 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. type Annotated[+A] = (A, TestAnnotationMap)
  2. type AssertResult = BoolAlgebra[AssertionValue]
  3. type AssertResultM = BoolAlgebraM[Any, Nothing, AssertionValue]
  4. type TestAspectAtLeastR[-R] = TestAspect[Nothing, R, Nothing, Any]
  5. type TestAspectPoly = TestAspect[Nothing, Any, Nothing, Any]
  6. type TestEnvironment = Annotations with Live with Sized with TestConfig
  7. type TestReporter[-E] = (zio.Duration, ExecutionEvent) => URIO[TestLogger, Unit]
  8. type TestResult = BoolAlgebra[AssertionResult]
  9. type ZSpec[-R, +E] = Spec[R, TestFailure[E], TestSuccess]
  10. type ZTest[-R, +E] = ZIO[R, TestFailure[E], TestSuccess]

Value Members

  1. macro def assert[A](expr: => A)(assertion: Assertion[A]): TestResult
    Definition Classes
    CompileVariants
  2. def assertCompletes(implicit trace: ZTraceElement): TestResult
  3. def assertCompletesM(implicit trace: ZTraceElement): UIO[TestResult]
  4. macro def assertM[R, E, A](effect: ZIO[R, E, A])(assertion: AssertionM[A]): ZIO[R, E, TestResult]
    Definition Classes
    CompileVariants
  5. def assertNever(message: String)(implicit trace: ZTraceElement): TestResult
  6. macro def assertTrue(expr: Boolean): Assert
    Definition Classes
    CompileVariants
  7. macro def assertTrue(expr: Boolean, exprs: Boolean*): Assert
    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]
  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]
  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]
  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]
  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]
  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]
  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]
  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]
  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]
  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]
  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]
  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]
  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]
  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]
  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]
  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]
  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]
  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]
  26. def checkN(n: Int): CheckN
  27. val defaultTestRunner: TestRunner[TestEnvironment, Any]
  28. def failed[E](cause: Cause[E])(implicit trace: ZTraceElement): ZIO[Any, TestFailure[E], Nothing]
  29. val ignored: UIO[TestSuccess]
  30. def live[R <: Live, E, A](zio: ZIO[R, E, A])(implicit trace: ZTraceElement): ZIO[R, E, A]
  31. val liveEnvironment: Layer[Nothing, ZEnv]
  32. def platformSpecific[R, E, A](js: => A, jvm: => A)(f: (A) => ZTest[R, E]): ZTest[R, E]
  33. def suite[In](label: String)(specs: In*)(implicit suiteConstructor: SuiteConstructor[In], trace: ZTraceElement): Spec[OutEnvironment, OutError, OutSuccess]
  34. def test[In](label: String)(assertion: => In)(implicit testConstructor: TestConstructor[Nothing, In], trace: ZTraceElement): Out
  35. def testClock(implicit trace: ZTraceElement): UIO[TestClock]
  36. def testClockWith[R, E, A](f: (TestClock) => ZIO[R, E, A])(implicit trace: ZTraceElement): ZIO[R, E, A]
  37. def testConsole(implicit trace: ZTraceElement): UIO[TestConsole]
  38. def testConsoleWith[R, E, A](f: (TestConsole) => ZIO[R, E, A])(implicit trace: ZTraceElement): ZIO[R, E, A]
  39. val testEnvironment: ZLayer[Scope, Nothing, TestEnvironment]
  40. def testRandom(implicit trace: ZTraceElement): UIO[TestRandom]
  41. def testRandomWith[R, E, A](f: (TestRandom) => ZIO[R, E, A])(implicit trace: ZTraceElement): ZIO[R, E, A]
  42. def testSystem(implicit trace: ZTraceElement): UIO[TestSystem]
  43. def testSystemWith[R, E, A](f: (TestSystem) => ZIO[R, E, A])(implicit trace: ZTraceElement): ZIO[R, E, A]
  44. final macro def typeCheck(code: String): UIO[Either[String, Unit]]
    Definition Classes
    CompileVariants
  45. def versionSpecific[R, E, A](scala3: => A, scala2: => A)(f: (A) => ZTest[R, E]): ZTest[R, E]
  46. 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]

Inherited from CompileVariants

Inherited from AnyRef

Inherited from Any

Ungrouped