Packages

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 Annotations = Has[Service]
  3. type AssertResult = BoolAlgebraM[Any, Nothing, AssertionValue]
  4. type ExecutedResult[+E] = Either[TestFailure[E], TestSuccess]
  5. type ExecutedSpec[+E] = Spec[Any, Nothing, ExecutedResult[E]]
  6. type Sized = Has[Service]
  7. type TestAspectAtLeastR[R] = TestAspect[Nothing, R, Nothing, Any]
  8. type TestAspectPoly = TestAspect[Nothing, Any, Nothing, Any]
  9. type TestLogger = Has[Service]
  10. type TestReporter[-E] = (Duration, ExecutedSpec[E]) ⇒ URIO[TestLogger, Unit]
  11. type TestResult = BoolAlgebraM[Any, Nothing, FailureDetails]
  12. type ZSpec[-R, +E] = Spec[R, TestFailure[E], TestSuccess]
  13. type ZTest[-R, +E] = ZIO[R, TestFailure[E], TestSuccess]
  14. type ZTestEnv = TestClock with TestConsole with TestRandom with TestSystem

Value Members

  1. def assert[A](value: ⇒ A)(assertion: Assertion[A]): TestResult
  2. val assertCompletes: TestResult
  3. def assertM[R, E, A](value: ZIO[R, E, A])(assertion: Assertion[A]): ZIO[R, E, TestResult]
  4. 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]
  5. 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]
  6. 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]
  7. 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]
  8. def check[R, A, B](rv1: Gen[R, A], rv2: Gen[R, B])(test: (A, B) ⇒ TestResult): ZIO[R, Nothing, TestResult]
  9. def check[R, A](rv: Gen[R, A])(test: (A) ⇒ TestResult): ZIO[R, Nothing, TestResult]
  10. 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]
  11. 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]
  12. 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]
  13. 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]
  14. def checkAll[R, A, B](rv1: Gen[R, A], rv2: Gen[R, B])(test: (A, B) ⇒ TestResult): ZIO[R, Nothing, TestResult]
  15. def checkAll[R, A](rv: Gen[R, A])(test: (A) ⇒ TestResult): ZIO[R, Nothing, TestResult]
  16. 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]
  17. 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]
  18. 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]
  19. 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]
  20. 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]
  21. def checkAllM[R, R1 <: R, E, A](rv: Gen[R, A])(test: (A) ⇒ ZIO[R1, E, TestResult]): ZIO[R1, E, TestResult]
  22. 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]
  23. 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]
  24. 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]
  25. 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]
  26. 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]
  27. def checkM[R, R1 <: R, E, A](rv: Gen[R, A])(test: (A) ⇒ ZIO[R1, E, TestResult]): ZIO[R1, E, TestResult]
  28. def checkN(n: Int): CheckN
  29. def checkNM(n: Int): CheckNM
  30. val defaultTestRunner: TestRunner[test.environment.TestEnvironment, Any]
  31. def failed[E](cause: Cause[E]): ZIO[Any, TestFailure[E], Nothing]
  32. val ignored: ZIO[Any, Nothing, TestSuccess]
  33. def platformSpecific[R, E, A](js: ⇒ A, jvm: ⇒ A)(f: (A) ⇒ ZTest[R, E]): ZTest[R, E]
  34. def suite[R, E, T](label: String)(specs: Spec[R, E, T]*): Spec[R, E, T]
  35. def test(label: String)(assertion: ⇒ TestResult): ZSpec[Any, Nothing]
  36. def testM[R, E](label: String)(assertion: ⇒ ZIO[R, E, TestResult]): ZSpec[R, E]
  37. final macro def typeCheck(code: String): UIO[Either[String, Unit]]
    Definition Classes
    CompileVariants
  38. def versionSpecific[R, E, A](dotty: ⇒ A, scala2: ⇒ A)(f: (A) ⇒ ZTest[R, E]): ZTest[R, E]

Deprecated Value Members

  1. 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)

  2. 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)

Inherited from CompileVariants

Inherited from AnyRef

Inherited from Any

Ungrouped