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. Protected

Package Members

  1. package magnolia

Type Members

  1. type Annotated[+A] = (A, TestAnnotationMap)
  2. type Annotations = Has[Service]
  3. type AssertResult = BoolAlgebra[AssertionValue]
  4. type AssertResultM = BoolAlgebraM[Any, Nothing, AssertionValue]
  5. type Sized = Has[Service]
  6. type TestAspectAtLeastR[R] = TestAspect[Nothing, R, Nothing, Any]
  7. type TestAspectPoly = TestAspect[Nothing, Any, Nothing, Any]
  8. type TestConfig = Has[Service]
  9. type TestLogger = Has[Service]
  10. type TestReporter[-E] = (Duration, ExecutedSpec[E]) => URIO[TestLogger, Unit]
  11. type TestResult = BoolAlgebra[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. macro def assert[A](expr: => A)(assertion: Assertion[A]): TestResult
    Definition Classes
    CompileVariants
  2. val assertCompletes: TestResult
  3. macro def assertM[R, E, A](effect: ZIO[R, E, A])(assertion: AssertionM[A]): ZIO[R, E, TestResult]
    Definition Classes
    CompileVariants
  4. 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]
  5. 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]
  6. 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]
  7. 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]
  8. def check[R <: TestConfig, A, B](rv1: Gen[R, A], rv2: Gen[R, B])(test: (A, B) => TestResult): URIO[R, TestResult]
  9. def check[R <: TestConfig, A](rv: Gen[R, A])(test: (A) => TestResult): URIO[R, TestResult]
  10. 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]
  11. 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]
  12. 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]
  13. 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]
  14. def checkAll[R <: TestConfig, A, B](rv1: Gen[R, A], rv2: Gen[R, B])(test: (A, B) => TestResult): URIO[R, TestResult]
  15. def checkAll[R <: TestConfig, A](rv: Gen[R, A])(test: (A) => TestResult): URIO[R, TestResult]
  16. 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]
  17. 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]
  18. 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]
  19. 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]
  20. 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]
  21. def checkAllM[R <: TestConfig, R1 <: R, E, A](rv: Gen[R, A])(test: (A) => ZIO[R1, E, TestResult]): ZIO[R1, E, TestResult]
  22. 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]
  23. 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]
  24. 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]
  25. 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]
  26. 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]
  27. def checkAllMPar[R <: TestConfig, R1 <: R, E, A](rv: Gen[R, A], parallelism: Int)(test: (A) => ZIO[R1, E, TestResult]): ZIO[R1, E, TestResult]
  28. 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]
  29. 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]
  30. 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]
  31. 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]
  32. 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]
  33. def checkM[R <: TestConfig, R1 <: R, E, A](rv: Gen[R, A])(test: (A) => ZIO[R1, E, TestResult]): ZIO[R1, E, TestResult]
  34. def checkN(n: Int): CheckN
  35. def checkNM(n: Int): CheckNM
  36. val defaultTestRunner: TestRunner[test.environment.TestEnvironment, Any]
  37. def failed[E](cause: Cause[E]): ZIO[Any, TestFailure[E], Nothing]
  38. val ignored: UIO[TestSuccess]
  39. def platformSpecific[R, E, A](js: => A, jvm: => A)(f: (A) => ZTest[R, E]): ZTest[R, E]
  40. def suite[R, E, T](label: String)(specs: Spec[R, E, T]*): Spec[R, E, T]
  41. def suiteM[R, E, T](label: String)(specs: ZIO[R, E, Iterable[Spec[R, E, T]]]): Spec[R, E, T]
  42. def test(label: String)(assertion: => TestResult)(implicit loc: SourceLocation): ZSpec[Any, Nothing]
  43. def testM[R, E](label: String)(assertion: => ZIO[R, E, TestResult])(implicit loc: SourceLocation): ZSpec[R, E]
  44. final macro def typeCheck(code: String): UIO[Either[String, Unit]]
    Definition Classes
    CompileVariants
  45. 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