package test
Linear Supertypes
Ordering
- Alphabetic
- By Inheritance
Inherited
- test
- CompileVariants
- AnyRef
- Any
- Hide All
- Show All
Visibility
- Public
- Protected
Type Members
- type Annotated[+A] = (A, TestAnnotationMap)
- type Annotations = Has[Service]
- type AssertResult = BoolAlgebraM[Any, Nothing, AssertionValue]
- type ExecutedResult[+E] = Either[TestFailure[E], TestSuccess]
- type ExecutedSpec[+E] = Spec[Any, Nothing, ExecutedResult[E]]
- type Sized = Has[Service]
- type TestAspectAtLeastR[R] = TestAspect[Nothing, R, Nothing, Any]
- type TestAspectPoly = TestAspect[Nothing, Any, Nothing, Any]
- type TestLogger = Has[Service]
- type TestReporter[-E] = (Duration, ExecutedSpec[E]) => URIO[TestLogger, Unit]
- type TestResult = BoolAlgebraM[Any, Nothing, FailureDetails]
- 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
- def assert[A](value: => A)(assertion: Assertion[A]): TestResult
- val assertCompletes: TestResult
- def assertM[R, E, A](value: ZIO[R, E, A])(assertion: Assertion[A]): ZIO[R, E, TestResult]
- def check[R, 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): ZIO[R, Nothing, TestResult]
- def check[R, 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): ZIO[R, Nothing, TestResult]
- def check[R, 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): ZIO[R, Nothing, TestResult]
- def check[R, A, B, C](rv1: Gen[R, A], rv2: Gen[R, B], rv3: Gen[R, C])(test: (A, B, C) => TestResult): ZIO[R, Nothing, TestResult]
- def check[R, A, B](rv1: Gen[R, A], rv2: Gen[R, B])(test: (A, B) => TestResult): ZIO[R, Nothing, TestResult]
- def check[R, A](rv: Gen[R, A])(test: (A) => TestResult): ZIO[R, Nothing, TestResult]
- def checkAll[R, 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): ZIO[R, Nothing, TestResult]
- def checkAll[R, 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): ZIO[R, Nothing, TestResult]
- def checkAll[R, 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): ZIO[R, Nothing, TestResult]
- def checkAll[R, A, B, C](rv1: Gen[R, A], rv2: Gen[R, B], rv3: Gen[R, C])(test: (A, B, C) => TestResult): ZIO[R, Nothing, TestResult]
- def checkAll[R, A, B](rv1: Gen[R, A], rv2: Gen[R, B])(test: (A, B) => TestResult): ZIO[R, Nothing, TestResult]
- def checkAll[R, A](rv: Gen[R, A])(test: (A) => TestResult): ZIO[R, Nothing, TestResult]
- def checkAllM[R, 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, 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, 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, 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, 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, R1 <: R, E, A](rv: Gen[R, A])(test: (A) => ZIO[R1, E, TestResult]): ZIO[R1, E, TestResult]
- def checkM[R, 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, 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, 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, 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, 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, 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: ZIO[Any, Nothing, 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 test(label: String)(assertion: => TestResult): ZSpec[Any, Nothing]
- def testM[R, E](label: String)(assertion: => ZIO[R, E, TestResult]): 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]
Deprecated Value Members
- def assert[A](value: => A, assertion: Assertion[A], dummy: Boolean): TestResult
- Annotations
- @deprecated
- Deprecated
(Since version 1.0.0) To benefit from much better type inference and type safety, we recommend that you use the curried version of assert, which takes two parameter lists instead of one: assert(value)(assertion)
- def assertM[R, E, A](value: ZIO[R, E, A], assertion: Assertion[A], dummy: Boolean): ZIO[R, E, TestResult]
- Annotations
- @deprecated
- Deprecated
(Since version 1.0.0) To benefit from much better type inference and type safety, we recommend that you use the curried version of assertM, which takes two parameter lists instead of one: assertM(value)(assertion)