cats-effect-testkit/cats.effect.testkit/TestInstances

TestInstances

trait TestInstances extends ParallelFGenerators with OutcomeGenerators with SyncTypeGenerators
trait SyncTypeGenerators
trait OutcomeGenerators
trait ParallelFGenerators
class Object
trait Matchable
class Any

Type members

Classlikes

@implicitNotFound("could not find an instance of Ticker; try using `in ticked { implicit ticker =>`")
case class Ticker(ctx: TestContext)

Value members

Concrete methods

def genResource[F[_], A](implicit F: Applicative[F], AFA: Arbitrary[F[A]], AFU: Arbitrary[F[Unit]], AA: Arbitrary[A]): Gen[Resource[F, A]]
def scheduler(implicit ticker: Ticker): Scheduler
def unsafeRun[A](ioa: IO[A])(implicit ticker: Ticker): Outcome[[A] =>> Option[A], Throwable, A]
def unsafeRunSync[A](ioa: SyncIO[A]): Outcome[Id, Throwable, A]

Inherited methods

def outcomeGenerators[F[_], E](implicit evidence$61: Applicative[F], evidence$62: Arbitrary[E], evidence$63: Cogen[E]): ApplicativeErrorGenerators[[_] =>> Outcome[F, E, _$29], E]
Inherited from
OutcomeGenerators

Concrete fields

lazy val arbitraryThrowable: Arbitrary[Throwable]

Implicits

Implicits

implicit def arbitraryExecutionContext(implicit ticker: Ticker): Arbitrary[ExecutionContext]
implicit lazy val arbitraryFiniteDuration: Arbitrary[FiniteDuration]
implicit def arbitraryIO[A](implicit evidence$2: Arbitrary[A], evidence$3: Cogen[A], ticker: Ticker): Arbitrary[IO[A]]
implicit def arbitraryResource[F[_], A](implicit F: Applicative[F], AFA: Arbitrary[F[A]], AFU: Arbitrary[F[Unit]], AA: Arbitrary[A]): Arbitrary[Resource[F, A]]
implicit def arbitrarySyncIO[A](implicit evidence$4: Arbitrary[A], evidence$5: Cogen[A]): Arbitrary[SyncIO[A]]
implicit def cogenIO[A](implicit evidence$1: Cogen[A], ticker: Ticker): Cogen[IO[A]]
implicit lazy val eqExecutionContext: Eq[ExecutionContext]
implicit def eqIOA[A](implicit evidence$6: Eq[A], ticker: Ticker): Eq[IO[A]]
implicit def eqResource[F[_], A](implicit E: Eq[F[A]], F: MonadCancel[F, Throwable]): Eq[Resource[F, A]]

Defines equality for a Resource. Two resources are deemed equivalent if they allocate an equivalent resource. Cleanup, which is run purely for effect, is not considered.

Defines equality for a Resource. Two resources are deemed equivalent if they allocate an equivalent resource. Cleanup, which is run purely for effect, is not considered.

implicit def eqSyncIOA[A](implicit evidence$7: Eq[A]): Eq[SyncIO[A]]
implicit lazy val eqThrowable: Eq[Throwable]
implicit def ioBooleanToProp(iob: IO[Boolean])(implicit ticker: Ticker): Prop
implicit def materializeRuntime(implicit ticker: Ticker): IORuntime
implicit def ordResourceFFD[F[_]](implicit ordF: Order[F[FiniteDuration]], F: MonadCancel[F, Throwable]): Order[Resource[F, FiniteDuration]]
implicit def orderIoFiniteDuration(implicit ticker: Ticker): Order[IO[FiniteDuration]]
implicit def resourceFBooleanToProp[F[_]](r: Resource[F, Boolean])(implicit view: F[Boolean] => Prop, F: MonadCancel[F, Throwable]): Prop
implicit lazy val showThrowable: Show[Throwable]
implicit def syncIoBooleanToProp(iob: SyncIO[Boolean]): Prop

Inherited implicits

implicit def arbitraryOutcome[F[_], E, A](implicit evidence$64: Applicative[F], evidence$65: Arbitrary[E], evidence$66: Cogen[E], evidence$67: Arbitrary[A], evidence$68: Cogen[A]): Arbitrary[Outcome[F, E, A]]
Inherited from
OutcomeGenerators
implicit def arbitraryParallelF[F[_], A](implicit ArbF: Arbitrary[F[A]]): Arbitrary[T[F, A]]
Inherited from
ParallelFGenerators
implicit val arbitrarySyncType: Arbitrary[Type]
Inherited from
SyncTypeGenerators
implicit def cogenOutcome[F[_], E, A](implicit evidence$69: Cogen[E], A: Cogen[F[A]]): Cogen[Outcome[F, E, A]]
Inherited from
OutcomeGenerators
implicit val cogenSyncType: Cogen[Type]
Inherited from
SyncTypeGenerators
implicit def eqParallelF[F[_], A](implicit EqF: Eq[F[A]]): Eq[T[F, A]]
Inherited from
ParallelFGenerators