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[Random with 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. All

Type Members

  1. type Annotated[+A] = (A, TestAnnotationMap)
  2. type AssertResult = BoolAlgebra[AssertionValue]
  3. type AssertResultM = BoolAlgebraM[Any, Nothing, AssertionValue]
  4. type TestEnvironment = Has[Annotations] with Has[Live] with Has[Sized] with Has[TestClock] with Has[TestConfig] with Has[TestConsole] with Has[TestRandom] with Has[TestSystem] with ZEnv
  5. type TestReporter[-E] = (zio.Duration, ExecutedSpec[E]) ⇒ URIO[Has[TestLogger], Unit]
  6. type TestResult = BoolAlgebra[AssertionResult]
  7. type ZSpec[-R, +E] = Spec[R, TestFailure[E], TestSuccess]
  8. type ZTest[-R, +E] = ZIO[R, TestFailure[E], TestSuccess]
  9. type ZTestEnv = Has[TestClock] with Has[TestConsole] with Has[TestRandom] with Has[TestSystem]

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. macro def assertTrue(expr: Boolean): Assert
    Definition Classes
    CompileVariants
  6. macro def assertTrue(expr: Boolean, exprs: Boolean*): Assert
    Definition Classes
    CompileVariants
  7. def check[R <: Has[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) ⇒ TestResult)(implicit checkConstructor: CheckConstructor[R, In], trace: ZTraceElement): ZIO[OutEnvironment, OutError, TestResult]
  8. def check[R <: Has[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) ⇒ TestResult)(implicit checkConstructor: CheckConstructor[R, In], trace: ZTraceElement): ZIO[OutEnvironment, OutError, TestResult]
  9. def check[R <: Has[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]
  10. def check[R <: Has[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]
  11. def check[R <: Has[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]
  12. def check[R <: Has[TestConfig], A, In](rv: Gen[R, A])(test: (A) ⇒ In)(implicit checkConstructor: CheckConstructor[R, In], trace: ZTraceElement): ZIO[OutEnvironment, OutError, TestResult]
  13. def checkAll[R <: Has[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]
  14. def checkAll[R <: Has[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]
  15. def checkAll[R <: Has[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]
  16. def checkAll[R <: Has[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]
  17. def checkAll[R <: Has[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]
  18. def checkAll[R <: Has[TestConfig], A, In](rv: Gen[R, A])(test: (A) ⇒ In)(implicit checkConstructor: CheckConstructor[R, In], trace: ZTraceElement): ZIO[OutEnvironment, OutError, TestResult]
  19. def checkAllPar[R <: Has[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]
  20. def checkAllPar[R <: Has[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]
  21. def checkAllPar[R <: Has[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]
  22. def checkAllPar[R <: Has[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]
  23. def checkAllPar[R <: Has[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]
  24. def checkAllPar[R <: Has[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]
  25. def checkN(n: Int): CheckN
  26. val defaultTestRunner: TestRunner[TestEnvironment, Any]
  27. def failed[E](cause: Cause[E])(implicit trace: ZTraceElement): ZIO[Any, TestFailure[E], Nothing]
  28. val ignored: UIO[TestSuccess]
  29. def live[E, A](zio: ZIO[ZEnv, E, A])(implicit trace: ZTraceElement): ZIO[Has[Live], E, A]
  30. val liveEnvironment: ServiceBuilder[Nothing, ZEnv]
  31. def platformSpecific[R, E, A](js: ⇒ A, jvm: ⇒ A)(f: (A) ⇒ ZTest[R, E]): ZTest[R, E]
  32. def suite[In](label: String)(specs: In*)(implicit suiteConstructor: SuiteConstructor[In], trace: ZTraceElement): Spec[OutEnvironment, OutError, OutSuccess]
  33. def test[In](label: String)(assertion: ⇒ In)(implicit testConstructor: TestConstructor[Nothing, In], trace: ZTraceElement): Out
  34. val testEnvironment: ServiceBuilder[Nothing, TestEnvironment]
  35. final macro def typeCheck(code: String): UIO[Either[String, Unit]]
    Definition Classes
    CompileVariants
  36. def versionSpecific[R, E, A](dotty: ⇒ A, scala2: ⇒ A)(f: (A) ⇒ ZTest[R, E]): ZTest[R, E]
  37. def withLive[R, E, E1, A, B](zio: ZIO[R, E, A])(f: (IO[E, A]) ⇒ ZIO[ZEnv, E1, B])(implicit trace: ZTraceElement): ZIO[R with Has[Live], E1, B]

Deprecated Value Members

  1. def checkAllM[R <: Has[TestConfig], R1 <: R, E, A, B, C, D, F, G](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) ⇒ ZIO[R1, E, TestResult])(implicit trace: ZTraceElement): ZIO[R1, E, TestResult]
    Annotations
    @deprecated
    Deprecated

    (Since version 2.0.0) use checkAll

  2. def checkAllM[R <: Has[TestConfig], R1 <: R, E, A, B, C, D, F](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) ⇒ ZIO[R1, E, TestResult])(implicit trace: ZTraceElement): ZIO[R1, E, TestResult]
    Annotations
    @deprecated
    Deprecated

    (Since version 2.0.0) use checkAll

  3. def checkAllM[R <: Has[TestConfig], R1 <: R, E, A, B, C, D](rv1: Gen[R, A], rv2: Gen[R, B], rv3: Gen[R, C], rv4: Gen[R, D])(test: (A, B, C, D) ⇒ ZIO[R1, E, TestResult])(implicit trace: ZTraceElement): ZIO[R1, E, TestResult]
    Annotations
    @deprecated
    Deprecated

    (Since version 2.0.0) use checkAll

  4. def checkAllM[R <: Has[TestConfig], R1 <: R, E, A, B, C](rv1: Gen[R, A], rv2: Gen[R, B], rv3: Gen[R, C])(test: (A, B, C) ⇒ ZIO[R1, E, TestResult])(implicit trace: ZTraceElement): ZIO[R1, E, TestResult]
    Annotations
    @deprecated
    Deprecated

    (Since version 2.0.0) use checkAll

  5. def checkAllM[R <: Has[TestConfig], R1 <: R, E, A, B](rv1: Gen[R, A], rv2: Gen[R, B])(test: (A, B) ⇒ ZIO[R1, E, TestResult])(implicit trace: ZTraceElement): ZIO[R1, E, TestResult]
    Annotations
    @deprecated
    Deprecated

    (Since version 2.0.0) use checkAll

  6. def checkAllM[R <: Has[TestConfig], R1 <: R, E, A](rv: Gen[R, A])(test: (A) ⇒ ZIO[R1, E, TestResult])(implicit trace: ZTraceElement): ZIO[R1, E, TestResult]
    Annotations
    @deprecated
    Deprecated

    (Since version 2.0.0) use checkAll

  7. def checkAllMPar[R <: Has[TestConfig], R1 <: R, E, A, B, C, D, F, G](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) ⇒ ZIO[R1, E, TestResult])(implicit trace: ZTraceElement): ZIO[R1, E, TestResult]
    Annotations
    @deprecated
    Deprecated

    (Since version 2.0.0) use checkPar

  8. def checkAllMPar[R <: Has[TestConfig], R1 <: R, E, A, B, C, D, F](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) ⇒ ZIO[R1, E, TestResult])(implicit trace: ZTraceElement): ZIO[R1, E, TestResult]
    Annotations
    @deprecated
    Deprecated

    (Since version 2.0.0) use checkPar

  9. def checkAllMPar[R <: Has[TestConfig], R1 <: R, E, A, B, C, D](rv1: Gen[R, A], rv2: Gen[R, B], rv3: Gen[R, C], rv4: Gen[R, D], parallelism: Int)(test: (A, B, C, D) ⇒ ZIO[R1, E, TestResult])(implicit trace: ZTraceElement): ZIO[R1, E, TestResult]
    Annotations
    @deprecated
    Deprecated

    (Since version 2.0.0) use checkPar

  10. def checkAllMPar[R <: Has[TestConfig], R1 <: R, E, A, B, C](rv1: Gen[R, A], rv2: Gen[R, B], rv3: Gen[R, C], parallelism: Int)(test: (A, B, C) ⇒ ZIO[R1, E, TestResult])(implicit trace: ZTraceElement): ZIO[R1, E, TestResult]
    Annotations
    @deprecated
    Deprecated

    (Since version 2.0.0) use checkPar

  11. def checkAllMPar[R <: Has[TestConfig], R1 <: R, E, A, B](rv1: Gen[R, A], rv2: Gen[R, B], parallelism: Int)(test: (A, B) ⇒ ZIO[R1, E, TestResult])(implicit trace: ZTraceElement): ZIO[R1, E, TestResult]
    Annotations
    @deprecated
    Deprecated

    (Since version 2.0.0) use checkPar

  12. def checkAllMPar[R <: Has[TestConfig], R1 <: R, E, A](rv: Gen[R, A], parallelism: Int)(test: (A) ⇒ ZIO[R1, E, TestResult])(implicit trace: ZTraceElement): ZIO[R1, E, TestResult]
    Annotations
    @deprecated
    Deprecated

    (Since version 2.0.0) use checkPar

  13. def checkM[R <: Has[TestConfig], R1 <: R, E, A, B, C, D, F, G](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) ⇒ ZIO[R1, E, TestResult])(implicit trace: ZTraceElement): ZIO[R1, E, TestResult]
    Annotations
    @deprecated
    Deprecated

    (Since version 2.0.0) use check

  14. def checkM[R <: Has[TestConfig], R1 <: R, E, A, B, C, D, F](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) ⇒ ZIO[R1, E, TestResult])(implicit trace: ZTraceElement): ZIO[R1, E, TestResult]
    Annotations
    @deprecated
    Deprecated

    (Since version 2.0.0) use check

  15. def checkM[R <: Has[TestConfig], R1 <: R, E, A, B, C, D](rv1: Gen[R, A], rv2: Gen[R, B], rv3: Gen[R, C], rv4: Gen[R, D])(test: (A, B, C, D) ⇒ ZIO[R1, E, TestResult])(implicit trace: ZTraceElement): ZIO[R1, E, TestResult]
    Annotations
    @deprecated
    Deprecated

    (Since version 2.0.0) use check

  16. def checkM[R <: Has[TestConfig], R1 <: R, E, A, B, C](rv1: Gen[R, A], rv2: Gen[R, B], rv3: Gen[R, C])(test: (A, B, C) ⇒ ZIO[R1, E, TestResult])(implicit trace: ZTraceElement): ZIO[R1, E, TestResult]
    Annotations
    @deprecated
    Deprecated

    (Since version 2.0.0) use check

  17. def checkM[R <: Has[TestConfig], R1 <: R, E, A, B](rv1: Gen[R, A], rv2: Gen[R, B])(test: (A, B) ⇒ ZIO[R1, E, TestResult])(implicit trace: ZTraceElement): ZIO[R1, E, TestResult]
    Annotations
    @deprecated
    Deprecated

    (Since version 2.0.0) use check

  18. def checkM[R <: Has[TestConfig], R1 <: R, E, A](rv: Gen[R, A])(test: (A) ⇒ ZIO[R1, E, TestResult])(implicit trace: ZTraceElement): ZIO[R1, E, TestResult]
    Annotations
    @deprecated
    Deprecated

    (Since version 2.0.0) use check

  19. def checkNM(n: Int): CheckNM
    Annotations
    @deprecated
    Deprecated

    (Since version 2.0.0) use checkN

  20. def suiteM[R, E, T](label: String)(specs: ZIO[R, E, Iterable[Spec[R, E, T]]])(implicit trace: ZTraceElement): Spec[R, E, T]
    Annotations
    @deprecated
    Deprecated

    (Since version 2.0.0) use suite

  21. def testM[R, E](label: String)(assertion: ⇒ ZIO[R, E, TestResult])(implicit trace: ZTraceElement): ZSpec[R, E]
    Annotations
    @deprecated
    Deprecated

    (Since version 2.0.0) use test

Inherited from CompileVariants

Inherited from AnyRef

Inherited from Any

Ungrouped