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 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 TestReporter[-E] = (zio.Duration, ExecutedSpec[E]) ⇒ URIO[Has[TestLogger], Unit]
  7. type TestResult = BoolAlgebra[AssertionResult]
  8. type ZSpec[-R, +E] = Spec[R, TestFailure[E], TestSuccess]
  9. type ZTest[-R, +E] = ZIO[R, TestFailure[E], TestSuccess]
  10. 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. val assertCompletes: TestResult
  3. val assertCompletesM: 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](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]
  8. def check[R <: Has[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]
  9. def check[R <: Has[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]
  10. def check[R <: Has[TestConfig], A, B, C](rv1: Gen[R, A], rv2: Gen[R, B], rv3: Gen[R, C])(test: (A, B, C) ⇒ TestResult): URIO[R, TestResult]
  11. def check[R <: Has[TestConfig], A, B](rv1: Gen[R, A], rv2: Gen[R, B])(test: (A, B) ⇒ TestResult): URIO[R, TestResult]
  12. def check[R <: Has[TestConfig], A](rv: Gen[R, A])(test: (A) ⇒ TestResult): URIO[R, TestResult]
  13. def checkAll[R <: Has[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]
  14. def checkAll[R <: Has[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]
  15. def checkAll[R <: Has[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]
  16. def checkAll[R <: Has[TestConfig], A, B, C](rv1: Gen[R, A], rv2: Gen[R, B], rv3: Gen[R, C])(test: (A, B, C) ⇒ TestResult): URIO[R, TestResult]
  17. def checkAll[R <: Has[TestConfig], A, B](rv1: Gen[R, A], rv2: Gen[R, B])(test: (A, B) ⇒ TestResult): URIO[R, TestResult]
  18. def checkAll[R <: Has[TestConfig], A](rv: Gen[R, A])(test: (A) ⇒ TestResult): URIO[R, TestResult]
  19. 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]): ZIO[R1, E, TestResult]
  20. 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]): ZIO[R1, E, TestResult]
  21. 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]): ZIO[R1, E, TestResult]
  22. 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]): ZIO[R1, E, TestResult]
  23. 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]): ZIO[R1, E, TestResult]
  24. def checkAllM[R <: Has[TestConfig], R1 <: R, E, A](rv: Gen[R, A])(test: (A) ⇒ ZIO[R1, E, TestResult]): ZIO[R1, E, TestResult]
  25. 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]): ZIO[R1, E, TestResult]
  26. 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]): ZIO[R1, E, TestResult]
  27. 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]): ZIO[R1, E, TestResult]
  28. 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]): ZIO[R1, E, TestResult]
  29. 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]): ZIO[R1, E, TestResult]
  30. def checkAllMPar[R <: Has[TestConfig], R1 <: R, E, A](rv: Gen[R, A], parallelism: Int)(test: (A) ⇒ ZIO[R1, E, TestResult]): ZIO[R1, E, TestResult]
  31. 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]): ZIO[R1, E, TestResult]
  32. 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]): ZIO[R1, E, TestResult]
  33. 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]): ZIO[R1, E, TestResult]
  34. 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]): ZIO[R1, E, TestResult]
  35. 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]): ZIO[R1, E, TestResult]
  36. def checkM[R <: Has[TestConfig], R1 <: R, E, A](rv: Gen[R, A])(test: (A) ⇒ ZIO[R1, E, TestResult]): ZIO[R1, E, TestResult]
  37. def checkN(n: Int): CheckN
  38. def checkNM(n: Int): CheckNM
  39. val defaultTestRunner: TestRunner[test.environment.TestEnvironment, Any]
  40. def failed[E](cause: Cause[E]): ZIO[Any, TestFailure[E], Nothing]
  41. val ignored: UIO[TestSuccess]
  42. def platformSpecific[R, E, A](js: ⇒ A, jvm: ⇒ A)(f: (A) ⇒ ZTest[R, E]): ZTest[R, E]
  43. def suite[R, E, T](label: String)(specs: Spec[R, E, T]*): Spec[R, E, T]
  44. def suiteM[R, E, T](label: String)(specs: ZIO[R, E, Iterable[Spec[R, E, T]]]): Spec[R, E, T]
  45. def test[In](label: String)(assertion: ⇒ In)(implicit testConstructor: TestConstructor[Nothing, In], sourceLocation: SourceLocation): Out
  46. final macro def typeCheck(code: String): UIO[Either[String, Unit]]
    Definition Classes
    CompileVariants
  47. def versionSpecific[R, E, A](dotty: ⇒ A, scala2: ⇒ A)(f: (A) ⇒ ZTest[R, E]): ZTest[R, E]

Inherited from CompileVariants

Inherited from AnyRef

Inherited from Any

Ungrouped