package test
- Alphabetic
- By Inheritance
- test
- CompileVariants
- AnyRef
- Any
- Hide All
- Show All
- Public
- Protected
Package Members
- 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
Type Members
- type Annotated[+A] = (A, TestAnnotationMap)
- type Annotations = Has[Service]
- type AssertResult = BoolAlgebra[AssertionValue]
- type AssertResultM = BoolAlgebraM[Any, Nothing, AssertionValue]
- type Sized = Has[Service]
- type TestAspectAtLeastR[R] = TestAspect[Nothing, R, Nothing, Any]
- type TestAspectPoly = TestAspect[Nothing, Any, Nothing, Any]
- type TestConfig = Has[Service]
- type TestLogger = Has[Service]
- type TestReporter[-E] = (Duration, ExecutedSpec[E]) => URIO[TestLogger, Unit]
- type TestResult = BoolAlgebra[AssertionResult]
- type ZSpec[-R, +E] = Spec[R, TestFailure[E], TestSuccess]
- type ZTest[-R, +E] = ZIO[R, TestFailure[E], TestSuccess]
- type ZTestEnv = TestClock with TestConsole with TestRandom with TestSystem
Value Members
- macro def assert[A](expr: => A)(assertion: Assertion[A]): TestResult
- Definition Classes
- CompileVariants
- val assertCompletes: TestResult
- val assertCompletesM: UIO[TestResult]
- macro def assertM[R, E, A](effect: ZIO[R, E, A])(assertion: AssertionM[A]): ZIO[R, E, TestResult]
- Definition Classes
- CompileVariants
- macro def assertTrue(expr: Boolean): Assert
- Definition Classes
- CompileVariants
- macro def assertTrue(expr: Boolean, exprs: Boolean*): Assert
- Definition Classes
- CompileVariants
- def check[R <: TestConfig, 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) => TestResult): URIO[R, TestResult]
- def check[R <: TestConfig, 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) => TestResult): URIO[R, TestResult]
- def check[R <: TestConfig, 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) => TestResult): URIO[R, TestResult]
- def check[R <: TestConfig, A, B, C](rv1: Gen[R, A], rv2: Gen[R, B], rv3: Gen[R, C])(test: (A, B, C) => TestResult): URIO[R, TestResult]
- def check[R <: TestConfig, A, B](rv1: Gen[R, A], rv2: Gen[R, B])(test: (A, B) => TestResult): URIO[R, TestResult]
- def check[R <: TestConfig, A](rv: Gen[R, A])(test: (A) => TestResult): URIO[R, TestResult]
- def checkAll[R <: TestConfig, 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) => TestResult): URIO[R, TestResult]
- def checkAll[R <: TestConfig, 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) => TestResult): URIO[R, TestResult]
- def checkAll[R <: TestConfig, 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) => TestResult): URIO[R, TestResult]
- def checkAll[R <: TestConfig, A, B, C](rv1: Gen[R, A], rv2: Gen[R, B], rv3: Gen[R, C])(test: (A, B, C) => TestResult): URIO[R, TestResult]
- def checkAll[R <: TestConfig, A, B](rv1: Gen[R, A], rv2: Gen[R, B])(test: (A, B) => TestResult): URIO[R, TestResult]
- def checkAll[R <: TestConfig, A](rv: Gen[R, A])(test: (A) => TestResult): URIO[R, TestResult]
- def checkAllM[R <: 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]): ZIO[R1, E, TestResult]
- def checkAllM[R <: 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]): ZIO[R1, E, TestResult]
- def checkAllM[R <: 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]): ZIO[R1, E, TestResult]
- def checkAllM[R <: 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]): ZIO[R1, E, TestResult]
- def checkAllM[R <: TestConfig, R1 <: R, E, A, B](rv1: Gen[R, A], rv2: Gen[R, B])(test: (A, B) => ZIO[R1, E, TestResult]): ZIO[R1, E, TestResult]
- def checkAllM[R <: TestConfig, R1 <: R, E, A](rv: Gen[R, A])(test: (A) => ZIO[R1, E, TestResult]): ZIO[R1, E, TestResult]
- def checkAllMPar[R <: 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]): ZIO[R1, E, TestResult]
- def checkAllMPar[R <: 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]): ZIO[R1, E, TestResult]
- def checkAllMPar[R <: 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]): ZIO[R1, E, TestResult]
- def checkAllMPar[R <: 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]): ZIO[R1, E, TestResult]
- def checkAllMPar[R <: TestConfig, R1 <: R, E, A, B](rv1: Gen[R, A], rv2: Gen[R, B], parallelism: Int)(test: (A, B) => ZIO[R1, E, TestResult]): ZIO[R1, E, TestResult]
- def checkAllMPar[R <: TestConfig, R1 <: R, E, A](rv: Gen[R, A], parallelism: Int)(test: (A) => ZIO[R1, E, TestResult]): ZIO[R1, E, TestResult]
- def checkM[R <: 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]): ZIO[R1, E, TestResult]
- def checkM[R <: 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]): ZIO[R1, E, TestResult]
- def checkM[R <: 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]): ZIO[R1, E, TestResult]
- def checkM[R <: 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]): ZIO[R1, E, TestResult]
- def checkM[R <: TestConfig, R1 <: R, E, A, B](rv1: Gen[R, A], rv2: Gen[R, B])(test: (A, B) => ZIO[R1, E, TestResult]): ZIO[R1, E, TestResult]
- def checkM[R <: TestConfig, R1 <: R, E, A](rv: Gen[R, A])(test: (A) => ZIO[R1, E, TestResult]): ZIO[R1, E, TestResult]
- def checkN(n: Int): CheckN
- def checkNM(n: Int): CheckNM
- val defaultTestRunner: TestRunner[test.environment.TestEnvironment, Any]
- def failed[E](cause: Cause[E]): ZIO[Any, TestFailure[E], Nothing]
- val ignored: UIO[TestSuccess]
- def platformSpecific[R, E, A](js: => A, jvm: => A)(f: (A) => ZTest[R, E]): ZTest[R, E]
- def suite[R, E, T](label: String)(specs: Spec[R, E, T]*): Spec[R, E, T]
- def suiteM[R, E, T](label: String)(specs: ZIO[R, E, Iterable[Spec[R, E, T]]]): Spec[R, E, T]
- def test(label: String)(assertion: => TestResult)(implicit loc: SourceLocation): ZSpec[Any, Nothing]
- def testM[R, E](label: String)(assertion: => ZIO[R, E, TestResult])(implicit loc: SourceLocation): ZSpec[R, E]
- final macro def typeCheck(code: String): UIO[Either[String, Unit]]
- Definition Classes
- CompileVariants
- def versionSpecific[R, E, A](dotty: => A, scala2: => A)(f: (A) => ZTest[R, E]): ZTest[R, E]