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 TestAspectAtLeastR[-R] = TestAspect[Nothing, R, Nothing, Any]
  2. type TestAspectPoly = TestAspect[Nothing, Any, Nothing, Any]
  3. type TestEnvironment = Annotations with Live with Sized with TestConfig
  4. type TestReporter[-E] = (zio.Duration, ExecutionEvent) ⇒ URIO[TestLogger, Unit]
  5. type ZTest[-R, +E] = ZIO[R, TestFailure[E], TestSuccess]

Value Members

  1. macro def assert[A](expr: ⇒ A)(assertion: Assertion[A]): TestResult
    Definition Classes
    CompileVariants
  2. def assertCompletes(implicit trace: Trace): TestResult
  3. def assertCompletesZIO(implicit trace: Trace): UIO[TestResult]
  4. def assertNever(message: String)(implicit trace: Trace): TestResult
  5. macro def assertTrue(expr: Boolean): TestResult
    Definition Classes
    CompileVariants
  6. macro def assertTrue(expr: Boolean, exprs: Boolean*): TestResult
    Definition Classes
    CompileVariants
  7. def assertZIO[R, E, A](effect: ZIO[R, E, A])(assertion: Assertion[A])(implicit trace: Trace): ZIO[R, E, TestResult]
    Definition Classes
    CompileVariants
  8. def check[R <: TestConfig, A, B, C, D, F, G, In](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) ⇒ In)(implicit checkConstructor: CheckConstructor[R, In], trace: Trace): ZIO[OutEnvironment, OutError, TestResult]
  9. def check[R <: TestConfig, A, B, C, D, F, In](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) ⇒ In)(implicit checkConstructor: CheckConstructor[R, In], trace: Trace): ZIO[OutEnvironment, OutError, TestResult]
  10. def check[R <: TestConfig, A, B, C, D, In](rv1: Gen[R, A], rv2: Gen[R, B], rv3: Gen[R, C], rv4: Gen[R, D])(test: (A, B, C, D) ⇒ In)(implicit checkConstructor: CheckConstructor[R, In], trace: Trace): ZIO[OutEnvironment, OutError, TestResult]
  11. def check[R <: TestConfig, A, B, C, In](rv1: Gen[R, A], rv2: Gen[R, B], rv3: Gen[R, C])(test: (A, B, C) ⇒ In)(implicit checkConstructor: CheckConstructor[R, In], trace: Trace): ZIO[OutEnvironment, OutError, TestResult]
  12. def check[R <: TestConfig, A, B, In](rv1: Gen[R, A], rv2: Gen[R, B])(test: (A, B) ⇒ In)(implicit checkConstructor: CheckConstructor[R, In], trace: Trace): ZIO[OutEnvironment, OutError, TestResult]
  13. def check[R <: TestConfig, A, In](rv: Gen[R, A])(test: (A) ⇒ In)(implicit checkConstructor: CheckConstructor[R, In], trace: Trace): ZIO[OutEnvironment, OutError, TestResult]
  14. def checkAll[R <: TestConfig, A, B, C, D, F, G, In](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) ⇒ In)(implicit checkConstructor: CheckConstructor[R, In], trace: Trace): ZIO[OutEnvironment, OutError, TestResult]
  15. def checkAll[R <: TestConfig, A, B, C, D, F, In](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) ⇒ In)(implicit checkConstructor: CheckConstructor[R, In], trace: Trace): ZIO[OutEnvironment, OutError, TestResult]
  16. def checkAll[R <: TestConfig, A, B, C, D, In](rv1: Gen[R, A], rv2: Gen[R, B], rv3: Gen[R, C], rv4: Gen[R, D])(test: (A, B, C, D) ⇒ In)(implicit checkConstructor: CheckConstructor[R, In], trace: Trace): ZIO[OutEnvironment, OutError, TestResult]
  17. def checkAll[R <: TestConfig, A, B, C, In](rv1: Gen[R, A], rv2: Gen[R, B], rv3: Gen[R, C])(test: (A, B, C) ⇒ In)(implicit checkConstructor: CheckConstructor[R, In], trace: Trace): ZIO[OutEnvironment, OutError, TestResult]
  18. def checkAll[R <: TestConfig, A, B, In](rv1: Gen[R, A], rv2: Gen[R, B])(test: (A, B) ⇒ In)(implicit checkConstructor: CheckConstructor[R, In], trace: Trace): ZIO[OutEnvironment, OutError, TestResult]
  19. def checkAll[R <: TestConfig, A, In](rv: Gen[R, A])(test: (A) ⇒ In)(implicit checkConstructor: CheckConstructor[R, In], trace: Trace): ZIO[OutEnvironment, OutError, TestResult]
  20. def checkAllPar[R <: TestConfig, R1 <: R, E, A, B, C, D, F, G, In](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) ⇒ In)(implicit checkConstructor: CheckConstructor[R, In], trace: Trace): ZIO[OutEnvironment, OutError, TestResult]
  21. def checkAllPar[R <: TestConfig, R1 <: R, E, A, B, C, D, F, In](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) ⇒ In)(implicit checkConstructor: CheckConstructor[R, In], trace: Trace): ZIO[OutEnvironment, OutError, TestResult]
  22. def checkAllPar[R <: TestConfig, R1 <: R, E, A, B, C, D, In](rv1: Gen[R, A], rv2: Gen[R, B], rv3: Gen[R, C], rv4: Gen[R, D], parallelism: Int)(test: (A, B, C, D) ⇒ In)(implicit checkConstructor: CheckConstructor[R, In], trace: Trace): ZIO[OutEnvironment, OutError, TestResult]
  23. def checkAllPar[R <: TestConfig, R1 <: R, E, A, B, C, In](rv1: Gen[R, A], rv2: Gen[R, B], rv3: Gen[R, C], parallelism: Int)(test: (A, B, C) ⇒ In)(implicit checkConstructor: CheckConstructor[R, In], trace: Trace): ZIO[OutEnvironment, OutError, TestResult]
  24. def checkAllPar[R <: TestConfig, R1 <: R, E, A, B, In](rv1: Gen[R, A], rv2: Gen[R, B], parallelism: Int)(test: (A, B) ⇒ In)(implicit checkConstructor: CheckConstructor[R, In], trace: Trace): ZIO[OutEnvironment, OutError, TestResult]
  25. def checkAllPar[R <: TestConfig, R1 <: R, E, A, In](rv: Gen[R, A], parallelism: Int)(test: (A) ⇒ In)(implicit checkConstructor: CheckConstructor[R, In], trace: Trace): ZIO[OutEnvironment, OutError, TestResult]
  26. def checkN(n: Int): CheckN
  27. val defaultTestRunner: TestRunner[TestEnvironment, Any]
  28. def failed[E](cause: Cause[E])(implicit trace: Trace): ZIO[Any, TestFailure[E], Nothing]
  29. val ignored: UIO[TestSuccess]
  30. def live[R <: Live, E, A](zio: ZIO[R, E, A])(implicit trace: Trace): ZIO[R, E, A]
  31. val liveEnvironment: Layer[Nothing, ZEnv]
  32. def platformSpecific[R, E, A](js: ⇒ A, jvm: ⇒ A)(f: (A) ⇒ ZTest[R, E]): ZTest[R, E]
  33. val sinkLayer: ZLayer[Any, Nothing, ExecutionEventSink]
  34. def sinkLayerWithConsole(console: Console)(implicit trace: Trace): ZLayer[Any, Nothing, ExecutionEventSink]
  35. def suite[In](label: String)(specs: In*)(implicit suiteConstructor: SuiteConstructor[In], trace: Trace): Spec[OutEnvironment, OutError]
  36. def test[In](label: String)(assertion: ⇒ In)(implicit testConstructor: TestConstructor[Nothing, In], trace: Trace): Out
  37. def testClock(implicit trace: Trace): UIO[TestClock]
  38. def testClockWith[R, E, A](f: (TestClock) ⇒ ZIO[R, E, A])(implicit trace: Trace): ZIO[R, E, A]
  39. def testConsole(implicit trace: Trace): UIO[TestConsole]
  40. def testConsoleWith[R, E, A](f: (TestConsole) ⇒ ZIO[R, E, A])(implicit trace: Trace): ZIO[R, E, A]
  41. val testEnvironment: ZLayer[Any, Nothing, TestEnvironment]
  42. def testRandom(implicit trace: Trace): UIO[TestRandom]
  43. def testRandomWith[R, E, A](f: (TestRandom) ⇒ ZIO[R, E, A])(implicit trace: Trace): ZIO[R, E, A]
  44. def testSystem(implicit trace: Trace): UIO[TestSystem]
  45. def testSystemWith[R, E, A](f: (TestSystem) ⇒ ZIO[R, E, A])(implicit trace: Trace): ZIO[R, E, A]
  46. final macro def typeCheck(code: String): UIO[Either[String, Unit]]
    Definition Classes
    CompileVariants
  47. def versionSpecific[R, E, A](scala3: ⇒ A, scala2: ⇒ A)(f: (A) ⇒ ZTest[R, E]): ZTest[R, E]
  48. def withLive[R <: Live, E, E1, A, B](zio: ZIO[R, E, A])(f: (ZIO[R, E, A]) ⇒ ZIO[R, E1, B])(implicit trace: Trace): ZIO[R with Live, E1, B]

Inherited from CompileVariants

Inherited from AnyRef

Inherited from Any

Ungrouped