Build Logs

1##################################

2Clonning https://github.com/monix/monix-bio.git into /build/repo using revision v1.2.0

3##################################

4Note: switching to '471cbe3ecf13687c2c57b1e64b02818684ac2165'.

6You are in 'detached HEAD' state. You can look around, make experimental

7changes and commit them, and you can discard any commits you make in this

8state without impacting any branches by switching back to a branch.

10If you want to create a new branch to retain commits you create, you may

11do so (now or later) by using -c with the switch command. Example:

13 git switch -c <new-branch-name>

15Or undo this operation with:

17 git switch -

19Turn off this advice by setting config variable advice.detachedHead to false

21----

22Preparing build for 3.8.0-RC4

23Scala binary version found: 3.8

24Implicitly using source version 3.8

25Scala binary version found: 3.8

26Implicitly using source version 3.8

27Would try to apply common scalacOption (best-effort, sbt/mill only):

28Append: ,REQUIRE:-source:3.8

29Remove: ,-deprecation,-feature,-Xfatal-warnings,-Werror,MATCH:.*-Wconf.*any:e

30----

31Starting build for 3.8.0-RC4

32Execute tests: true

33sbt project found:

34Sbt version 1.5.2 is not supported, minimal supported version is 1.11.5

35Enforcing usage of sbt in version 1.11.5

36No prepare script found for project monix/monix-bio

37##################################

38Scala version: 3.8.0-RC4

39Targets: io.monix%monix-bio

40Project projectConfig: {"projects":{"exclude":[],"overrides":{}},"java":{"version":"17"},"sbt":{"commands":[],"options":[]},"mill":{"options":[]},"tests":"full","migrationVersions":[],"sourcePatches":[]}

41##################################

42Using extra scalacOptions: ,REQUIRE:-source:3.8

43Filtering out scalacOptions: ,-deprecation,-feature,-Xfatal-warnings,-Werror,MATCH:.*-Wconf.*any:e

44[sbt_options] declare -a sbt_options=()

45[process_args] java_version = '17'

46[copyRt] java9_rt = '/root/.sbt/1.0/java9-rt-ext-eclipse_adoptium_17_0_8/rt.jar'

47# Executing command line:

48java

49-Dfile.encoding=UTF-8

50-Dcommunitybuild.scala=3.8.0-RC4

51-Dcommunitybuild.project.dependencies.add=

52-Xmx7G

53-Xms4G

54-Xss8M

55-Dsbt.script=/root/.sdkman/candidates/sbt/current/bin/sbt

56-Dscala.ext.dirs=/root/.sbt/1.0/java9-rt-ext-eclipse_adoptium_17_0_8

57-jar

58/root/.sdkman/candidates/sbt/1.11.5/bin/sbt-launch.jar

59"setCrossScalaVersions 3.8.0-RC4"

60"++3.8.0-RC4 -v"

61"mapScalacOptions ",REQUIRE:-source:3.8,-Wconf:msg=can be rewritten automatically under:s" ",-deprecation,-feature,-Xfatal-warnings,-Werror,MATCH:.*-Wconf.*any:e""

62"set every credentials := Nil"

63"excludeLibraryDependency com.github.ghik:zerowaste_{scalaVersion} com.olegpy:better-monadic-for_3 org.polyvariant:better-tostring_{scalaVersion} org.wartremover:wartremover_{scalaVersion}"

64"removeScalacOptionsStartingWith -P:wartremover"

66moduleMappings

67"runBuild 3.8.0-RC4 """{"projects":{"exclude":[],"overrides":{}},"java":{"version":"17"},"sbt":{"commands":[],"options":[]},"mill":{"options":[]},"tests":"full","migrationVersions":[],"sourcePatches":[]}""" io.monix%monix-bio"

69[info] welcome to sbt 1.11.5 (Eclipse Adoptium Java 17.0.8)

70[info] loading settings for project repo-build from akka.sbt, plugins.sbt...

71[info] loading project definition from /build/repo/project

72[info] compiling 3 Scala sources to /build/repo/project/target/scala-2.12/sbt-1.0/classes ...

73[info] Non-compiled module 'compiler-bridge_2.12' for Scala 2.12.20. Compiling...

74[info] Compilation completed in 8.436s.

75[info] done compiling

77 unmanagedSourceDirectories in FullTracingTest += {

78 ^

80 test in Test := (test in Test).dependsOn(test in FullTracingTest).value,

81 ^

83 test in Test := (test in Test).dependsOn(test in FullTracingTest).value,

84 ^

86 test in Test := (test in Test).dependsOn(test in FullTracingTest).value,

87 ^

89 fork in Test := true,

90 ^

92 fork in FullTracingTest := true,

93 ^

95 javaOptions in Test ++= Seq(

96 ^

98 javaOptions in FullTracingTest ++= Seq(

99 ^

101 unidocProjectFilter in (ScalaUnidoc, unidoc) := inProjects(coreJVM),

102 ^

104 target in (ScalaUnidoc, unidoc) := (baseDirectory in LocalRootProject).value / "website" / "static" / "api",

105 ^

107 target in (ScalaUnidoc, unidoc) := (baseDirectory in LocalRootProject).value / "website" / "static" / "api",

108 ^

110 cleanFiles += (target in (ScalaUnidoc, unidoc)).value,

111 ^

113 .dependsOn(unidoc in Compile)

114 ^

116 .dependsOn(updateSiteVariables in ThisBuild)

117 ^

119 .dependsOn(unidoc in Compile)

120 ^

122 .dependsOn(updateSiteVariables in ThisBuild)

123 ^

125 scalacOptions in (ScalaUnidoc, unidoc) ++= Seq(

126 ^

128 "-sourcepath", baseDirectory.in(LocalRootProject).value.getAbsolutePath,

129 ^

131 sources in (Compile, doc) ~= (_ filterNot { file =>

132 ^

134 publishArtifact in (Compile, packageDoc) := false,

135 ^

137 publishArtifact in (Compile, packageSrc) := false,

138 ^

140 publishArtifact in (Compile, packageBin) := false

141 ^

143 scalacOptions in (Compile, doc) ~= (_ filterNot (_ == "-Xfatal-warnings")),

144 ^

146 val cp: Seq[Attributed[File]] = (fullClasspath in Compile).value

147 ^

149 scalacOptions in ThisBuild ++= Seq(

150 ^

152 resolvers += Resolver.sonatypeCentralSnapshots

154 Resolver.sonatypeRepo("releases")

155 ^

157 publishArtifact in Test := false,

158 ^

160 unmanagedSourceDirectories in Compile += {

161 ^

163 unmanagedSourceDirectories in Test += {

164 ^

166 val l = (baseDirectory in LocalRootProject).value.toURI.toString

167 ^

169 skip in publish := true,

170 ^

172updateSiteVariables in ThisBuild := {

173 ^

175 val minorVersions = (crossScalaVersions in coreJVM).value.map(minorVersion)

176 ^

178 "coreModuleName" -> (moduleName in coreJVM).value,

179 ^

181 "organization" -> (organization in LocalRootProject).value,

182 ^

184 (baseDirectory in LocalRootProject).value / "website" / "variables.js"

185 ^

187mimaFailOnNoPrevious in ThisBuild := false

188 ^

190git.baseVersion := (version in ThisBuild).value

191 ^

192[info] loading settings for project monix-bio from build.sbt...

193[info] set current project to monix-bio (in build file:/build/repo/)

194Execute setCrossScalaVersions: 3.8.0-RC4

195OpenCB::Changing crossVersion 3.0.0 -> 3.8.0-RC4 in coreJVM/crossScalaVersions

196OpenCB::Changing crossVersion 3.0.0 -> 3.8.0-RC4 in tracingTests/crossScalaVersions

197OpenCB::Changing crossVersion 3.0.0 -> 3.8.0-RC4 in benchmarks/crossScalaVersions

198OpenCB::Changing crossVersion 3.0.0 -> 3.8.0-RC4 in coreJS/crossScalaVersions

199OpenCB::Changing crossVersion 3.0.0 -> 3.8.0-RC4 in monix-bio/crossScalaVersions

200[info] set current project to monix-bio (in build file:/build/repo/)

201[info] Setting Scala version to 3.8.0-RC4 on 5 projects.

202[info] Switching Scala version on:

203[info] benchmarks (2.12.13, 2.13.5, 3.8.0-RC4)

204[info] tracingTests (2.12.13, 2.13.5, 3.8.0-RC4)

205[info] coreJS (2.12.13, 2.13.5, 3.8.0-RC4)

206[info] coreJVM (2.12.13, 2.13.5, 3.8.0-RC4)

207[info] * monix-bio (2.12.13, 2.13.5, 3.8.0-RC4)

208[info] Excluding projects:

209[info] docs (2.13.5)

210[info] Reapplying settings...

211[info] set current project to monix-bio (in build file:/build/repo/)

212Execute mapScalacOptions: ,REQUIRE:-source:3.8,-Wconf:msg=can be rewritten automatically under:s ,-deprecation,-feature,-Xfatal-warnings,-Werror,MATCH:.*-Wconf.*any:e

213[info] Reapplying settings...

214[info] set current project to monix-bio (in build file:/build/repo/)

215[info] Defining Global / credentials, benchmarks / credentials and 4 others.

216[info] The new values will be used by Global / pgpSelectPassphrase, Global / pgpSigningKey and 29 others.

217[info] Run `last` for details.

218[info] Reapplying settings...

219[info] set current project to monix-bio (in build file:/build/repo/)

220Execute excludeLibraryDependency: com.github.ghik:zerowaste_{scalaVersion} com.olegpy:better-monadic-for_3 org.polyvariant:better-tostring_{scalaVersion} org.wartremover:wartremover_{scalaVersion}

221[info] Reapplying settings...

222OpenCB::Failed to reapply settings in excludeLibraryDependency: Reference to undefined setting:

224 Global / allExcludeDependencies from Global / allExcludeDependencies (CommunityBuildPlugin.scala:331)

225 Did you mean tracingTests / allExcludeDependencies ?

226 , retry without global scopes

227[info] Reapplying settings...

228[info] set current project to monix-bio (in build file:/build/repo/)

229Execute removeScalacOptionsStartingWith: -P:wartremover

230[info] Reapplying settings...

231[info] set current project to monix-bio (in build file:/build/repo/)

232[success] Total time: 0 s, completed Dec 22, 2025, 6:01:18 PM

233Build config: {"projects":{"exclude":[],"overrides":{}},"java":{"version":"17"},"sbt":{"commands":[],"options":[]},"mill":{"options":[]},"tests":"full","migrationVersions":[],"sourcePatches":[]}

234Parsed config: Success(ProjectBuildConfig(ProjectsConfig(List(),Map()),Full,List()))

235Starting build...

236Projects: Set(coreJVM)

237Starting build for ProjectRef(file:/build/repo/,coreJVM) (monix-bio)... [0/1]

238OpenCB::Exclude Scala3 specific scalacOption `REQUIRE:-source:3.8` in Scala 2.12.20 module Global

239OpenCB::Exclude Scala3 specific scalacOption `REQUIRE:-source:3.8` in Scala 2.12.20 module Scope(Select(BuildRef(file:/build/repo/)), Zero, Zero, Zero)

240OpenCB::Filter out '-deprecation', matches setting pattern '^-?-deprecation'

241OpenCB::Filter out '-feature', matches setting pattern '^-?-feature'

242Compile scalacOptions: -sourcepath, /build/repo/, -sourcepath, /build/repo/, -sourcepath, /build/repo/, -sourcepath, /build/repo/, -sourcepath, /build/repo/, -sourcepath, /build/repo/, -unchecked, -language:higherKinds, -language:implicitConversions, -language:experimental.macros, -Ykind-projector, -Wconf:msg=can be rewritten automatically under:s, -source:3.8

243[info] compiling 69 Scala sources and 1 Java source to /build/repo/core/jvm/target/scala-3.8.0-RC4/classes ...

246[info] done compiling

247[info] compiling 80 Scala sources to /build/repo/core/jvm/target/scala-3.8.0-RC4/test-classes ...

250[info] done compiling

251[info] monix.bio.IOLikeDoctest

252[info] - IOLike.scala:29: IOLike

253[info] monix.bio.TaskEffectInstanceSuite

254[info] - Effect instance should make use of implicit TaskOptions

255[info] - Effect instance should use Task.defaultOptions with default TestScheduler

256[info] - Effect instance should use Task.defaultOptions.withSchedulerFeatures

257[info] monix.bio.TaskConnectionCompositeSuite

258[info] - cancels Cancelable references

259[info] - cancels Cancelable references after cancel on assignment

260[info] - cancels Task references

261[info] - cancels Task references after cancel on assignment

262[info] - cancels CancelableF references

263[info] - cancels CancelableF references after cancel on assignment

264[info] - addAll

265[info] - remove Task

266[info] - remove Cancelable

267[info] - remove CancelableF

268[info] monix.bio.TaskClockTimerAndContextShiftSuite

269[info] - IO.clock is implicit

270[info] - IO.clock.monotonic

271[info] - IO.clock.realTime

272[info] - IO.clock(s2).monotonic

273[info] - IO.clock(s).realTime

274[info] - IO.timer is implicit

275[info] - IO.timer

276[info] - IO.timer(s)

277[info] - IO.timer(s).clock

278[info] - IO.contextShift is implicit

279[info] - IO.contextShift.shift

280[info] - IO.contextShift.evalOn(s2)

281[info] - IO.contextShift.evalOn(s2) failure

282[info] - IO.contextShift.evalOn(s2) fatal failure

283[info] - IO.contextShift.evalOn(s2) uses s2 for async boundaries

284[info] - IO.contextShift.evalOn(s2) injects s2 to IO.deferAction

285[info] - IO.contextShift(s).shift

286[info] - IO.contextShift(s).evalOn(s2)

287[info] - IO.contextShift(s).evalOn(s2) failure

288[info] - IO.contextShift(s).evalOn(s2) fatal failure

289[info] - IO.contextShift(s).evalOn(s2) uses s2 for async boundaries

290[info] - IO.contextShift(s).evalOn(s2) injects s2 to IO.deferAction

291[info] monix.bio.TaskSuspendSuite

292[info] - IO.suspend should suspend evaluation

293[info] - IO.suspend should protect against user code errors

294[info] - IO.suspendTotal should protect against unexpected errors

295[info] monix.bio.TaskExecuteWithOptionsSuite

296[info] - executeWithOptions works

297[info] - local.write.executeWithOptions

298[info] - executeWithOptions is stack safe in flatMap loops

299[info] monix.bio.TaskEvalAlwaysSuite

300[info] - IO.eval should work synchronously

301[info] - IO.eval should protect against user code errors

302[info] - IO.eval is equivalent with IO.evalOnce on first run

303[info] - IO.eval.flatMap should be equivalent with IO.eval

304[info] - IO.eval.flatMap should protect against user code

305[info] - IO.eval.flatMap should be tail recursive

306[info] - IO.eval should not be cancelable

307[info] - IO.eval.coeval

308[info] - IO.eval.flatMap should protect against user code errors

309[info] - IO.delay is an alias for IO.eval

310[info] - IO.evalTotal should protect against unexpected errors

311[info] monix.bio.TaskToStringSuite

312[info] - IO.Now

313[info] - IO.Error

314[info] - IO.Termination

315[info] - IO.Eval

316[info] - IO.EvalTotal

317[info] - IO.Async

318[info] - IO.FlatMap

319[info] - IO.Suspend

320[info] - IO.SuspendTotal

321[info] - IO.Map

322[info] monix.bio.IOMapNSuite

323[info] - IO#map2 should yield value successfully

324[info] - IO#map2 should propagate error when one argument failed

325[info] - IO#map2 should protect against user code

326[info] - IO#map2 should run effects in strict sequence

327[info] - IO#map3 should yield value successfully

328[info] - IO#map3 should propagate error when one argument failed

329[info] - IO#map3 should protect against user code

330[info] - IO#map3 should run effects in strict sequence

331[info] - IO#map4 should yield value successfully

332[info] - IO#map4 should propagate error when one argument failed

333[info] - IO#map4 should protect against user code

334[info] - IO#map4 should run effects in strict sequence

335[info] - IO#map5 should yield value successfully

336[info] - IO#map5 should propagate error when one argument failed

337[info] - IO#map5 should protect against user code

338[info] - IO#map5 should run effects in strict sequence

339[info] - IO#map6 should yield value successfully

340[info] - IO#map6 should propagate error when one argument failed

341[info] - IO#map6 should protect against user code

342[info] - IO#map6 should run effects in strict sequence

343[info] monix.bio.TaskTimedSuite

344[info] - measure tasks with no errors

345[info] - not measure tasks with typed errors

346[info] - not measure tasks with terminal errors

347[info] - measure tasks with typed errors followed by `.attempt`

348[info] - not measure tasks with terminal errors followed by `.attempt`

349[info] - stack safety

350[info] monix.bio.TaskLikeConversionsSuite

351[info] - IO.from(task.to[IO]) <-> task

352[info] - IO.from converts successful Future

353[info] - IO.from converts failed Future

354[info] - IO.from converts successful sync IO

355[info] - IO.from converts successful async IO

356[info] - IO.from converts failed sync CIO

357[info] - IO.from converts failed async IO

358[info] - IO.from preserves cancellability of an IO

359[info] - IO.from converts successful Eval

360[info] - IO.from converts failed Eval

361[info] - IO.from preserves Eval laziness

362[info] - IO.from converts successful SyncIO

363[info] - IO.from converts failed SyncIO

364[info] - IO.from converts successful Try

365[info] - IO.from converts failed Try

366[info] - IO.from converts right Either

367[info] - IO.from converts left Either

368[info] - IO.from converts successful custom Effect

369[info] - IO.from converts failed custom Effect

370[info] - IO.from converts successful custom ConcurrentEffect

371[info] - IO.from converts failed custom ConcurrentEffect

372[info] - IO.from converts Function0

373[info] - IO.from converts CancelablePromise

374[info] monix.bio.TaskTerminationSuite

375[info] - IO#redeemCause should mirror source on success

376[info] - IO#redeemCause should recover typed error

377[info] - IO#redeemCause should recover unexpected error

378[info] - IO#redeemCause should protect against user code

379[info] - IO#redeemCauseWith derives flatMap

380[info] - IO#redeemCauseWith should mirror source on success

381[info] - IO#redeemCauseWith should recover typed error

382[info] - IO#redeemCauseWith should recover unexpected error

383[info] - IO#redeemCauseWith should protect against user code

384[info] monix.bio.TaskBlockingSuite

385[info] - blocking on future should work

386[info] - blocking on async

387[info] - blocking on async.flatMap

388[info] - blocking with Termination result

389[info] - IO.eval(throw ex).attempt.runSyncUnsafe

390[info] - IO.evalTotal(throw ex).onErrorHandle.runSyncUnsafe

391[info] - IO.suspend(throw ex).attempt.runSyncUnsafe

392[info] - IO.suspendTotal(throw ex).onErrorHandle.runSyncUnsafe

393[info] - blocking on memoize

395[info] - IO.attempt.runSyncUnsafe works

396[info] monix.bio.TaskToFutureSuite

397[info] - Task.fromFuture for already completed references

398[info] - Task.deferFuture for already completed references

399[info] - Task.deferFutureAction for already completed references

400[info] - Task.fromFuture(error) for already completed references

401[info] - Task.deferFuture(error) for already completed references

402[info] - Task.deferFutureAction(typed) for already completed references

403[info] - Task.fromFuture for completed reference is stack safe (flatMap)

404[info] - Task.deferFuture for completed reference is stack safe (flatMap)

405[info] - Task.deferFutureAction for completed reference is stack safe (flatMap)

406[info] - Task.fromFuture async result

407[info] - Task.fromFuture(error) async result

408[info] - Task.deferFuture async result

409[info] - Task.deferFuture(error) async result

410[info] - Task.deferFuture(throw error) async result

411[info] - Task.deferFutureAction async result

412[info] - Task.deferFutureAction(error) async result

413[info] - Task.deferFutureAction(throw error) async result

414[info] - Task.fromFuture(cancelable)

415[info] - Task.fromFuture(cancelable) is cancelable

416[info] - Task.deferFuture(cancelable)

417[info] - Task.deferFuture(cancelable) is cancelable

418[info] - Task.deferFutureAction(cancelable)

419[info] - Task.deferFutureAction(cancelable) is cancelable

420[info] monix.bio.TaskConnectionRefSuite

421[info] - assign and cancel a Cancelable

422[info] - assign and cancel a CancelableF

423[info] - assign and cancel a CancelToken[Task]

424[info] - cancel a Cancelable on single assignment

425[info] - cancel a CancelableF on single assignment

426[info] - cancel a Task on single assignment

427[info] monix.bio.TaskEvalOnceSuite

428[info] - IO.evalOnce should protect against user code errors

429[info] - IO.evalOnce.flatMap should be equivalent with Task.evalOnce

430[info] - IO.evalOnce.flatMap should protect against user code

431[info] - IO.evalOnce.map should work

432[info] - IO.evalOnce.flatMap should be tail recursive

433[info] - IO.EvalOnce.runAsync override

434[info] - IO.evalOnce.materialize should work for success

435[info] - IO.evalOnce.materialize should work for failure

436[info] monix.bio.IOStartAndForgetSuite

437[info] - IO#startAndForget triggers execution in background thread

438[info] - IO#startAndForget does not affect execution of main thread with raised errors

439[info] - IO#startAndForget triggers fatal errors in background thread

440[info] - IO#startAndForget is stack safe

441[info] monix.bio.IOLocalSuite

442[info] - IOLocal.apply

443[info] - IOLocal.wrap

444[info] - IOLocal!.bind

445[info] - IOLocal!.bindL

446[info] - IOLocal!.bindClear

447[info] - IOLocal canceled

448[info] - IOLocal!.local

449[info] - TaskLocals get restored in IO.create on error

450[info] - TaskLocals get restored in IO.create on termination

451[info] - IOLocal should work with bracket

452[info] - IOLocal.isolate should prevent context changes

453[info] - IOLocal interop with future via deferFutureAction

454[info] - IOLocal.bind scoping works

455[info] - IOLocal.bind actually isolates reads

456[info] - IOLocal.isolate with ConcurrentChannel

457[info] monix.bio.TaskConnectionSuite

458[info] - initial push

459[info] - cancels Task after being canceled

460[info] - cancels Cancelable after being canceled

461[info] - cancels CancelableF after being canceled

462[info] - push two, pop one

463[info] - cancel the second time is a no-op

464[info] - push two, pop two

465[info] - push(Cancelable)

466[info] - push(Cancelable) then pop

467[info] - push(CancelToken)

468[info] - push(CancelToken) then pop

469[info] - pop when self is empty

470[info] - pop when self is canceled

471[info] - cancel mixture

472[info] - cancel mixture after being cancelled

473[info] - tryReactive

474[info] - toCancelable

475[info] - uncancelable ref is shared

476[info] - uncancelable ops

477[info] - throwing error in Task on cancel all

478[info] - throwing multiple errors in Tasks on cancel all

479[info] - throwing error in Task after cancel

480[info] - throwing error in Cancelable on cancel all

481[info] - throwing multiple errors in Cancelables on cancel all

482[info] - throwing error in Cancelable after cancel

483[info] monix.bio.TaskParSequenceSuite

484[info] - IO.parSequence should execute in parallel for async tasks

485[info] - IO.parSequence should onError if one of the tasks terminates in error

486[info] - IO.parSequence should onTerminate if one of the tasks terminates in a fatal error

487[info] - IO.parSequence should be canceled

488[info] - IO.parSequence should be stack safe for synchronous tasks

489[info] - IO.parSequence runAsync multiple times

490[info] - IO.parSequence should log errors if multiple errors happen

491[info] - IO.parSequence should log terminal errors if multiple errors happen

492[info] monix.bio.TaskDoOnCancelSuite

493[info] - doOnCancel should normally mirror the source

494[info] - doOnCancel should mirror failed sources

495[info] - doOnCancel should mirror terminated sources

496[info] - doOnCancel should cancel delayResult #1

497[info] - doOnCancel should cancel delayResult #2

498[info] - doOnCancel should cancel delayResult #3

499[info] - doOnCancel should cancel delayExecution #1

500[info] - doOnCancel should cancel delayExecution #2

501[info] - doOnCancel is stack safe in flatMap loops

502[info] - local.write.doOnCancel works

503[info] monix.bio.TaskMemoizeSuite

504[info] - IO.memoize should work asynchronously for first subscriber

505[info] - IO.memoize should work synchronously for next subscribers

506[info] - IO.memoize should be stack safe

507[info] - IO.flatMap.memoize should be stack safe, test 1

508[info] - IO.flatMap.memoize should be stack safe, test 2

509[info] - IO.raiseError(error).memoize should work

510[info] - IO.terminate(error).memoize should work

511[info] - IO.memoize.materialize

512[info] - IO.apply(error).memoize.materialize

513[info] - IO.eval.memoize should work for first subscriber

514[info] - IO.eval.memoize should work synchronously for next subscribers

515[info] - IO.eval(error).memoize should work

516[info] - IO.eval.memoize

517[info] - IO.eval.memoize should be stack safe

518[info] - IO.eval.flatMap.memoize should be stack safe

519[info] - IO.defer(evalAlways).memoize

520[info] - IO.evalOnce.memoize should work for first subscriber

521[info] - IO.evalOnce.memoize should work synchronously for next subscribers

522[info] - IO.evalOnce(error).memoize should work

523[info] - IO.evalOnce.memoize should be stack safe

524[info] - IO.evalOnce.flatMap.memoize should be stack safe

525[info] - IO.now.memoize should work synchronously for first subscriber

526[info] - IO.now.memoize should work synchronously for next subscribers

527[info] - IO.error.memoize should work

528[info] - IO.now.memoize should be stack safe

529[info] - IO.now.flatMap.memoize should be stack safe

530[info] - IO.defer.memoize should be stack safe

531[info] - IO.memoize effects, sequential

532[info] - IO.memoize effects, parallel

533[info] - IO.suspend.memoize effects

534[info] - IO.suspend.flatMap.memoize effects

535[info] - IO.memoize should make subsequent subscribers wait for the result, as future

536[info] - IO.memoize should make subsequent subscribers wait for the result, as callback

537[info] - Task.memoize should be synchronous for subsequent subscribers, as callback

538[info] - IO.memoize should not be cancelable (future)

539[info] - IO.memoize should be cancelable (callback, #1)

540[info] - IO.memoize should be cancelable (callback, #2)

541[info] - IO.memoize should be re-executable after cancel

542[info] - IO.memoize should not be uninterruptible

543[info] - IO.memoize serves error after async boundary

544[info] - TaskRunLoop.startLightWithBiCallback for success

545[info] - TaskRunLoop.startLightWithBiCallback for failure

546[info] - IO.evalOnce eq IO.evalOnce.memoize

547[info] - IO.eval.memoize eq IO.eval.memoize.memoize

548[info] - IO.eval.map.memoize eq IO.eval.map.memoize.memoize

549[info] - IO.now.memoize eq IO.now

550[info] - IO.raiseError.memoize eq IO.raiseError

551[info] - IO.terminate.memoize eq IO.raiseError

552[info] - IO.eval.memoizeOnSuccess.memoize !== IO.eval.memoizeOnSuccess

553[info] monix.bio.TaskAsyncBoundarySuite

554[info] - IO.asyncBoundary should work

555[info] - IO.asyncBoundary(other) should work

556[info] - IO.asyncBoundary should preserve locals

557[info] - IO.asyncBoundary(scheduler) should preserve locals

558[info] - IO.asyncBoundary is stack safe in flatMap loops, test 1

559[info] - IO.asyncBoundary is stack safe in flatMap loops, test 2

560[info] monix.bio.IOLocalJVMSuite

561[info] - locals get transported with executeOn and shift

562[info] - locals get transported with executeWithModel

563[info] - locals get transported with executeWithOptions

564[info] - IOLocal.isolate can be nested with executeWithOptions

565[info] - local.write.executeOn(forceAsync = false) works

566[info] - local.write.executeOn(forceAsync = true) works

567[info] - local state is encapsulated by Task run loop with TracingScheduler

568[info] - local state is encapsulated by Task run loop without TracingScheduler

569[info] - local state is encapsulated by Task run loop on single thread

570[info] - IOLocal.isolate should properly isolate during async boundaries

571[info] - IOLocal.isolate should properly isolate during async boundaries on error

572[info] - IOLocal.isolate should properly isolate during async boundaries on cancelation

573[info] - IOLocal.isolate should isolate contexts from Future

574[info] - Task.evalAsync.runToFuture isolates but preserves context for Future continuation

575[info] - Task.eval.runToFuture isolates but preserves context for Future continuation

576[info] - Task.evalAsync.runToFuture isolates but preserves context for Future continuation on a single thread

577[info] - Task.eval.runToFuture continuations keep isolated context in longer continuations

578[info] - Task.eval.runToFuture can isolate future continuations

579[info] - Task.eval.runToFuture can isolate future continuations on failure

580[info] - Task.runToFuture resulting future can be reused

581[info] - Task.eval.runToFuture is isolated from outside changes

582[info] monix.bio.TaskTraverseSuite

583[info] - IO.traverse should not execute in parallel

584[info] - IO.traverse should onError if one of the tasks terminates in error

585[info] - IO.traverse should onError if one of the tasks terminates in error

586[info] - IO.traverse should be canceled

587[info] monix.bio.TaskDelaySuite

588[info] - IO#delayExecution should work

589[info] - IO#delayExecution is stack safe, test 1

590[info] - IO#delayExecution is stack safe, test 2

591[info] - IO#delayExecution is cancelable

592[info] - IO#delayResult should work

593[info] - IO#delayResult is stack safe, test 1

594[info] - IO#delayResult is stack safe, test 2

595[info] - IO#delayResult is cancelable

596[info] - IO#delayResult should not delay in case of error

597[info] - IO#delayResult should not delay in case of terminal error

598[info] monix.bio.IODoOnFinishSuite

599[info] - IO#doOnFinish should work on successful task

600[info] - IO#doOnFinish should work on task with raised error

601[info] - IO#doOnFinish should work on terminated task

602[info] - IO#doOnFinish should not trigger any finishing action when IO is cancelled

603[info] monix.bio.BIOAppSuite

604[info] - run works

605[info] - options are configurable

606[info] - ConcurrentEffect[Task]

607[info] monix.bio.TypeClassLawsForTaskWithCallbackSuite

608[info] - CoflatMap[Task].coflatMap.coflatMap associativity

609[info] - CoflatMap[Task].coflatMap.coflatMap identity

610[info] - CoflatMap[Task].coflatMap.coflatten coherence

611[info] - CoflatMap[Task].coflatMap.coflatten throughMap

612[info] - CoflatMap[Task].coflatMap.covariant composition

613[info] - CoflatMap[Task].coflatMap.covariant identity

614[info] - CoflatMap[Task].coflatMap.invariant composition

615[info] - CoflatMap[Task].coflatMap.invariant identity

616[info] - Concurrent[Task].async.acquire and release of bracket are uncancelable

617[info] - Concurrent[Task].async.ap consistent with product + map

618[info] - Concurrent[Task].async.applicative homomorphism

619[info] - Concurrent[Task].async.applicative identity

620[info] - Concurrent[Task].async.applicative interchange

621[info] - Concurrent[Task].async.applicative map

622[info] - Concurrent[Task].async.applicative unit

623[info] - Concurrent[Task].async.applicativeError adaptError pure

624[info] - Concurrent[Task].async.applicativeError adaptError raise

625[info] - Concurrent[Task].async.applicativeError attempt consistent with attemptT

626[info] - Concurrent[Task].async.applicativeError attempt fromEither consistent with pure

627[info] - Concurrent[Task].async.applicativeError handle

628[info] - Concurrent[Task].async.applicativeError handleError . raiseError left-distributes over ap

629[info] - Concurrent[Task].async.applicativeError handleError . raiseError right-distributes over ap

630[info] - Concurrent[Task].async.applicativeError handleError consistent with recover

631[info] - Concurrent[Task].async.applicativeError handleError pure

632[info] - Concurrent[Task].async.applicativeError handleErrorWith consistent with recoverWith

633[info] - Concurrent[Task].async.applicativeError handleErrorWith pure

634[info] - Concurrent[Task].async.applicativeError handleWith

635[info] - Concurrent[Task].async.applicativeError onError pure

636[info] - Concurrent[Task].async.applicativeError onError raise

637[info] - Concurrent[Task].async.applicativeError pure attempt

638[info] - Concurrent[Task].async.applicativeError raiseError attempt

639[info] - Concurrent[Task].async.applicativeError recover consistent with recoverWith

640[info] - Concurrent[Task].async.applicativeError redeem is derived from attempt and map

641[info] - Concurrent[Task].async.apply composition

642[info] - Concurrent[Task].async.async can be derived from asyncF

643[info] - Concurrent[Task].async.async left is raiseError

644[info] - Concurrent[Task].async.async right is pure

645[info] - Concurrent[Task].async.bind suspends evaluation

646[info] - Concurrent[Task].async.bracket is derived from bracketCase

647[info] - Concurrent[Task].async.bracket release is called on Completed or Error

648[info] - Concurrent[Task].async.bracketCase with failure in acquisition remains failure

649[info] - Concurrent[Task].async.bracketCase with pure unit on release is eqv to map

650[info] - Concurrent[Task].async.bracketCase with pure unit on release is eqv to uncancelable(..).flatMap

651[info] - Concurrent[Task].async.covariant composition

652[info] - Concurrent[Task].async.covariant identity

653[info] - Concurrent[Task].async.delay constant is pure

654[info] - Concurrent[Task].async.flatMap associativity

655[info] - Concurrent[Task].async.flatMap consistent apply

656[info] - Concurrent[Task].async.flatMap from tailRecM consistency

657[info] - Concurrent[Task].async.guarantee is derived from bracket

658[info] - Concurrent[Task].async.guaranteeCase is derived from bracketCase

659[info] - Concurrent[Task].async.invariant composition

660[info] - Concurrent[Task].async.invariant identity

661[info] - Concurrent[Task].async.map flatMap coherence

662[info] - Concurrent[Task].async.map suspends evaluation

663[info] - Concurrent[Task].async.map2/map2Eval consistency

664[info] - Concurrent[Task].async.map2/product-map consistency

665[info] - Concurrent[Task].async.monad left identity

666[info] - Concurrent[Task].async.monad right identity

667[info] - Concurrent[Task].async.monadError ensure consistency

668[info] - Concurrent[Task].async.monadError ensureOr consistency

669[info] - Concurrent[Task].async.monadError left zero

670[info] - Concurrent[Task].async.monadError redeemWith is derived from attempt and flatMap

671[info] - Concurrent[Task].async.monadError rethrow attempt

672[info] - Concurrent[Task].async.monoidal left identity

673[info] - Concurrent[Task].async.monoidal right identity

674[info] - Concurrent[Task].async.mproduct consistent flatMap

675[info] - Concurrent[Task].async.never is derived from async

676[info] - Concurrent[Task].async.onCancel is derived from guaranteeCase

677[info] - Concurrent[Task].async.productL consistent map2

678[info] - Concurrent[Task].async.productR consistent map2

679[info] - Concurrent[Task].async.propagate errors through bind (async)

680[info] - Concurrent[Task].async.propagate errors through bind (suspend)

681[info] - Concurrent[Task].async.repeated async evaluation not memoized

682[info] - Concurrent[Task].async.repeated asyncF evaluation not memoized

683[info] - Concurrent[Task].async.repeated sync evaluation not memoized

684[info] - Concurrent[Task].async.semigroupal associativity

685[info] - Concurrent[Task].async.stack-safe on bracket with left-associated binds

686[info] - Concurrent[Task].async.stack-safe on bracket with right-associated binds

687[info] - Concurrent[Task].async.stack-safe on guarantee with left-associated binds

688[info] - Concurrent[Task].async.stack-safe on guarantee with right-associated binds

689[info] - Concurrent[Task].async.stack-safe on left-associated binds

690[info] - Concurrent[Task].async.stack-safe on repeated attempts

691[info] - Concurrent[Task].async.stack-safe on repeated maps

692[info] - Concurrent[Task].async.stack-safe on right-associated binds

693[info] - Concurrent[Task].async.suspend constant is pure join

694[info] - Concurrent[Task].async.tailRecM consistent flatMap

695[info] - Concurrent[Task].async.tailRecM stack safety

696[info] - Concurrent[Task].async.throw in delay is raiseError

697[info] - Concurrent[Task].async.throw in suspend is raiseError

698[info] - Concurrent[Task].async.uncancelable prevents Cancelled case

699[info] - Concurrent[Task].async.unsequenced delay is no-op

700[info] - ConcurrentEffect[Task].effect.acquire and release of bracket are uncancelable

701[info] - ConcurrentEffect[Task].effect.ap consistent with product + map

702[info] - ConcurrentEffect[Task].effect.applicative homomorphism

703[info] - ConcurrentEffect[Task].effect.applicative identity

704[info] - ConcurrentEffect[Task].effect.applicative interchange

705[info] - ConcurrentEffect[Task].effect.applicative map

706[info] - ConcurrentEffect[Task].effect.applicative unit

707[info] - ConcurrentEffect[Task].effect.applicativeError adaptError pure

708[info] - ConcurrentEffect[Task].effect.applicativeError adaptError raise

709[info] - ConcurrentEffect[Task].effect.applicativeError attempt consistent with attemptT

710[info] - ConcurrentEffect[Task].effect.applicativeError attempt fromEither consistent with pure

711[info] - ConcurrentEffect[Task].effect.applicativeError handle

712[info] - ConcurrentEffect[Task].effect.applicativeError handleError . raiseError left-distributes over ap

713[info] - ConcurrentEffect[Task].effect.applicativeError handleError . raiseError right-distributes over ap

714[info] - ConcurrentEffect[Task].effect.applicativeError handleError consistent with recover

715[info] - ConcurrentEffect[Task].effect.applicativeError handleError pure

716[info] - ConcurrentEffect[Task].effect.applicativeError handleErrorWith consistent with recoverWith

717[info] - ConcurrentEffect[Task].effect.applicativeError handleErrorWith pure

718[info] - ConcurrentEffect[Task].effect.applicativeError handleWith

719[info] - ConcurrentEffect[Task].effect.applicativeError onError pure

720[info] - ConcurrentEffect[Task].effect.applicativeError onError raise

721[info] - ConcurrentEffect[Task].effect.applicativeError pure attempt

722[info] - ConcurrentEffect[Task].effect.applicativeError raiseError attempt

723[info] - ConcurrentEffect[Task].effect.applicativeError recover consistent with recoverWith

724[info] - ConcurrentEffect[Task].effect.applicativeError redeem is derived from attempt and map

725[info] - ConcurrentEffect[Task].effect.apply composition

726[info] - ConcurrentEffect[Task].effect.async can be derived from asyncF

727[info] - ConcurrentEffect[Task].effect.async left is raiseError

728[info] - ConcurrentEffect[Task].effect.async right is pure

729[info] - ConcurrentEffect[Task].effect.bind suspends evaluation

730[info] - ConcurrentEffect[Task].effect.bracket is derived from bracketCase

731[info] - ConcurrentEffect[Task].effect.bracket release is called on Completed or Error

732[info] - ConcurrentEffect[Task].effect.bracketCase with failure in acquisition remains failure

733[info] - ConcurrentEffect[Task].effect.bracketCase with pure unit on release is eqv to map

734[info] - ConcurrentEffect[Task].effect.bracketCase with pure unit on release is eqv to uncancelable(..).flatMap

735[info] - ConcurrentEffect[Task].effect.covariant composition

736[info] - ConcurrentEffect[Task].effect.covariant identity

737[info] - ConcurrentEffect[Task].effect.delay constant is pure

738[info] - ConcurrentEffect[Task].effect.flatMap associativity

739[info] - ConcurrentEffect[Task].effect.flatMap consistent apply

740[info] - ConcurrentEffect[Task].effect.flatMap from tailRecM consistency

741[info] - ConcurrentEffect[Task].effect.guarantee is derived from bracket

742[info] - ConcurrentEffect[Task].effect.guaranteeCase is derived from bracketCase

743[info] - ConcurrentEffect[Task].effect.invariant composition

744[info] - ConcurrentEffect[Task].effect.invariant identity

745[info] - ConcurrentEffect[Task].effect.map flatMap coherence

746[info] - ConcurrentEffect[Task].effect.map suspends evaluation

747[info] - ConcurrentEffect[Task].effect.map2/map2Eval consistency

748[info] - ConcurrentEffect[Task].effect.map2/product-map consistency

749[info] - ConcurrentEffect[Task].effect.monad left identity

750[info] - ConcurrentEffect[Task].effect.monad right identity

751[info] - ConcurrentEffect[Task].effect.monadError ensure consistency

752[info] - ConcurrentEffect[Task].effect.monadError ensureOr consistency

753[info] - ConcurrentEffect[Task].effect.monadError left zero

754[info] - ConcurrentEffect[Task].effect.monadError redeemWith is derived from attempt and flatMap

755[info] - ConcurrentEffect[Task].effect.monadError rethrow attempt

756[info] - ConcurrentEffect[Task].effect.monoidal left identity

757[info] - ConcurrentEffect[Task].effect.monoidal right identity

758[info] - ConcurrentEffect[Task].effect.mproduct consistent flatMap

759[info] - ConcurrentEffect[Task].effect.never is derived from async

760[info] - ConcurrentEffect[Task].effect.onCancel is derived from guaranteeCase

761[info] - ConcurrentEffect[Task].effect.productL consistent map2

762[info] - ConcurrentEffect[Task].effect.productR consistent map2

763[info] - ConcurrentEffect[Task].effect.propagate errors through bind (async)

764[info] - ConcurrentEffect[Task].effect.propagate errors through bind (suspend)

765[info] - ConcurrentEffect[Task].effect.repeated async evaluation not memoized

766[info] - ConcurrentEffect[Task].effect.repeated asyncF evaluation not memoized

767[info] - ConcurrentEffect[Task].effect.repeated callback ignored

768[info] - ConcurrentEffect[Task].effect.repeated sync evaluation not memoized

769[info] - ConcurrentEffect[Task].effect.runAsync ignores error in handler

770[info] - ConcurrentEffect[Task].effect.runAsync pure produces right IO

771[info] - ConcurrentEffect[Task].effect.runAsync raiseError produces left IO

772[info] - ConcurrentEffect[Task].effect.semigroupal associativity

773[info] - ConcurrentEffect[Task].effect.stack-safe on bracket with left-associated binds

774[info] - ConcurrentEffect[Task].effect.stack-safe on bracket with right-associated binds

775[info] - ConcurrentEffect[Task].effect.stack-safe on guarantee with left-associated binds

776[info] - ConcurrentEffect[Task].effect.stack-safe on guarantee with right-associated binds

777[info] - ConcurrentEffect[Task].effect.stack-safe on left-associated binds

778[info] - ConcurrentEffect[Task].effect.stack-safe on repeated attempts

779[info] - ConcurrentEffect[Task].effect.stack-safe on repeated maps

780[info] - ConcurrentEffect[Task].effect.stack-safe on right-associated binds

781[info] - ConcurrentEffect[Task].effect.suspend constant is pure join

782[info] - ConcurrentEffect[Task].effect.tailRecM consistent flatMap

783[info] - ConcurrentEffect[Task].effect.tailRecM stack safety

784[info] - ConcurrentEffect[Task].effect.throw in delay is raiseError

785[info] - ConcurrentEffect[Task].effect.throw in suspend is raiseError

786[info] - ConcurrentEffect[Task].effect.toIO is consistent with runAsync

787[info] - ConcurrentEffect[Task].effect.toIO is the inverse of liftIO

788[info] - ConcurrentEffect[Task].effect.toIO stack safety

789[info] - ConcurrentEffect[Task].effect.uncancelable prevents Cancelled case

790[info] - ConcurrentEffect[Task].effect.unsequenced delay is no-op

791[info] - CommutativeApplicative[IO.Par].commutative applicative.ap consistent with product + map

792[info] - CommutativeApplicative[IO.Par].commutative applicative.applicative homomorphism

793[info] - CommutativeApplicative[IO.Par].commutative applicative.applicative identity

794[info] - CommutativeApplicative[IO.Par].commutative applicative.applicative interchange

795[info] - CommutativeApplicative[IO.Par].commutative applicative.applicative map

796[info] - CommutativeApplicative[IO.Par].commutative applicative.applicative unit

797[info] - CommutativeApplicative[IO.Par].commutative applicative.apply commutativity

798[info] - CommutativeApplicative[IO.Par].commutative applicative.apply composition

799[info] - CommutativeApplicative[IO.Par].commutative applicative.covariant composition

800[info] - CommutativeApplicative[IO.Par].commutative applicative.covariant identity

801[info] - CommutativeApplicative[IO.Par].commutative applicative.invariant composition

802[info] - CommutativeApplicative[IO.Par].commutative applicative.invariant identity

803[info] - CommutativeApplicative[IO.Par].commutative applicative.map2/map2Eval consistency

804[info] - CommutativeApplicative[IO.Par].commutative applicative.map2/product-map consistency

805[info] - CommutativeApplicative[IO.Par].commutative applicative.monoidal left identity

806[info] - CommutativeApplicative[IO.Par].commutative applicative.monoidal right identity

807[info] - CommutativeApplicative[IO.Par].commutative applicative.productL consistent map2

808[info] - CommutativeApplicative[IO.Par].commutative applicative.productR consistent map2

809[info] - CommutativeApplicative[IO.Par].commutative applicative.semigroupal associativity

810[info] - Parallel[Task, Task.Par].parallel.isomorphic functor

811[info] - Parallel[Task, Task.Par].parallel.isomorphic pure

812[info] - Parallel[Task, Task.Par].parallel.parallel round trip

813[info] - Parallel[Task, Task.Par].parallel.sequential round trip

814[info] - Monoid[IO[Throwable, Int]].monoid.associative

815[info] - Monoid[IO[Throwable, Int]].monoid.collect0

816[info] - Monoid[IO[Throwable, Int]].monoid.combine all

817[info] - Monoid[IO[Throwable, Int]].monoid.combineAllOption

818[info] - Monoid[IO[Throwable, Int]].monoid.intercalateCombineAllOption

819[info] - Monoid[IO[Throwable, Int]].monoid.intercalateIntercalates

820[info] - Monoid[IO[Throwable, Int]].monoid.intercalateRepeat1

821[info] - Monoid[IO[Throwable, Int]].monoid.intercalateRepeat2

822[info] - Monoid[IO[Throwable, Int]].monoid.is id

823[info] - Monoid[IO[Throwable, Int]].monoid.left identity

824[info] - Monoid[IO[Throwable, Int]].monoid.repeat0

825[info] - Monoid[IO[Throwable, Int]].monoid.repeat1

826[info] - Monoid[IO[Throwable, Int]].monoid.repeat2

827[info] - Monoid[IO[Throwable, Int]].monoid.reverseCombineAllOption

828[info] - Monoid[IO[Throwable, Int]].monoid.reverseRepeat1

829[info] - Monoid[IO[Throwable, Int]].monoid.reverseRepeat2

830[info] - Monoid[IO[Throwable, Int]].monoid.reverseReverses

831[info] - Monoid[IO[Throwable, Int]].monoid.right identity

832[info] - Bifunctor[IO[String, Int]].Bifunctor.Bifunctor Identity

833[info] - Bifunctor[IO[String, Int]].Bifunctor.Bifunctor associativity

834[info] - Bifunctor[IO[String, Int]].Bifunctor.Bifunctor leftMap Identity

835[info] - Bifunctor[IO[String, Int]].Bifunctor.Bifunctor leftMap associativity

836[info] monix.bio.TypeClassLawsForTaskAutoCancelableWithCallbackSuite

837[info] - CoflatMap[Task].coflatMap.coflatMap associativity

838[info] - CoflatMap[Task].coflatMap.coflatMap identity

839[info] - CoflatMap[Task].coflatMap.coflatten coherence

840[info] - CoflatMap[Task].coflatMap.coflatten throughMap

841[info] - CoflatMap[Task].coflatMap.covariant composition

842[info] - CoflatMap[Task].coflatMap.covariant identity

843[info] - CoflatMap[Task].coflatMap.invariant composition

844[info] - CoflatMap[Task].coflatMap.invariant identity

845[info] - Concurrent[Task].async.acquire and release of bracket are uncancelable

846[info] - Concurrent[Task].async.ap consistent with product + map

847[info] - Concurrent[Task].async.applicative homomorphism

848[info] - Concurrent[Task].async.applicative identity

849[info] - Concurrent[Task].async.applicative interchange

850[info] - Concurrent[Task].async.applicative map

851[info] - Concurrent[Task].async.applicative unit

852[info] - Concurrent[Task].async.applicativeError adaptError pure

853[info] - Concurrent[Task].async.applicativeError adaptError raise

854[info] - Concurrent[Task].async.applicativeError attempt consistent with attemptT

855[info] - Concurrent[Task].async.applicativeError attempt fromEither consistent with pure

856[info] - Concurrent[Task].async.applicativeError handle

857[info] - Concurrent[Task].async.applicativeError handleError . raiseError left-distributes over ap

858[info] - Concurrent[Task].async.applicativeError handleError . raiseError right-distributes over ap

859[info] - Concurrent[Task].async.applicativeError handleError consistent with recover

860[info] - Concurrent[Task].async.applicativeError handleError pure

861[info] - Concurrent[Task].async.applicativeError handleErrorWith consistent with recoverWith

862[info] - Concurrent[Task].async.applicativeError handleErrorWith pure

863[info] - Concurrent[Task].async.applicativeError handleWith

864[info] - Concurrent[Task].async.applicativeError onError pure

865[info] - Concurrent[Task].async.applicativeError onError raise

866[info] - Concurrent[Task].async.applicativeError pure attempt

867[info] - Concurrent[Task].async.applicativeError raiseError attempt

868[info] - Concurrent[Task].async.applicativeError recover consistent with recoverWith

869[info] - Concurrent[Task].async.applicativeError redeem is derived from attempt and map

870[info] - Concurrent[Task].async.apply composition

871[info] - Concurrent[Task].async.async can be derived from asyncF

872[info] - Concurrent[Task].async.async left is raiseError

873[info] - Concurrent[Task].async.async right is pure

874[info] - Concurrent[Task].async.bind suspends evaluation

875[info] - Concurrent[Task].async.bracket is derived from bracketCase

876[info] - Concurrent[Task].async.bracket release is called on Completed or Error

877[info] - Concurrent[Task].async.bracketCase with failure in acquisition remains failure

878[info] - Concurrent[Task].async.bracketCase with pure unit on release is eqv to map

879[info] - Concurrent[Task].async.bracketCase with pure unit on release is eqv to uncancelable(..).flatMap

880[info] - Concurrent[Task].async.covariant composition

881[info] - Concurrent[Task].async.covariant identity

882[info] - Concurrent[Task].async.delay constant is pure

883[info] - Concurrent[Task].async.flatMap associativity

884[info] - Concurrent[Task].async.flatMap consistent apply

885[info] - Concurrent[Task].async.flatMap from tailRecM consistency

886[info] - Concurrent[Task].async.guarantee is derived from bracket

887[info] - Concurrent[Task].async.guaranteeCase is derived from bracketCase

888[info] - Concurrent[Task].async.invariant composition

889[info] - Concurrent[Task].async.invariant identity

890[info] - Concurrent[Task].async.map flatMap coherence

891[info] - Concurrent[Task].async.map suspends evaluation

892[info] - Concurrent[Task].async.map2/map2Eval consistency

893[info] - Concurrent[Task].async.map2/product-map consistency

894[info] - Concurrent[Task].async.monad left identity

895[info] - Concurrent[Task].async.monad right identity

896[info] - Concurrent[Task].async.monadError ensure consistency

897[info] - Concurrent[Task].async.monadError ensureOr consistency

898[info] - Concurrent[Task].async.monadError left zero

899[info] - Concurrent[Task].async.monadError redeemWith is derived from attempt and flatMap

900[info] - Concurrent[Task].async.monadError rethrow attempt

901[info] - Concurrent[Task].async.monoidal left identity

902[info] - Concurrent[Task].async.monoidal right identity

903[info] - Concurrent[Task].async.mproduct consistent flatMap

904[info] - Concurrent[Task].async.never is derived from async

905[info] - Concurrent[Task].async.onCancel is derived from guaranteeCase

906[info] - Concurrent[Task].async.productL consistent map2

907[info] - Concurrent[Task].async.productR consistent map2

908[info] - Concurrent[Task].async.propagate errors through bind (async)

909[info] - Concurrent[Task].async.propagate errors through bind (suspend)

910[info] - Concurrent[Task].async.repeated async evaluation not memoized

911[info] - Concurrent[Task].async.repeated asyncF evaluation not memoized

912[info] - Concurrent[Task].async.repeated sync evaluation not memoized

913[info] - Concurrent[Task].async.semigroupal associativity

914[info] - Concurrent[Task].async.stack-safe on bracket with left-associated binds

915[info] - Concurrent[Task].async.stack-safe on bracket with right-associated binds

916[info] - Concurrent[Task].async.stack-safe on guarantee with left-associated binds

917[info] - Concurrent[Task].async.stack-safe on guarantee with right-associated binds

918[info] - Concurrent[Task].async.stack-safe on left-associated binds

919[info] - Concurrent[Task].async.stack-safe on repeated attempts

920[info] - Concurrent[Task].async.stack-safe on repeated maps

921[info] - Concurrent[Task].async.stack-safe on right-associated binds

922[info] - Concurrent[Task].async.suspend constant is pure join

923[info] - Concurrent[Task].async.tailRecM consistent flatMap

924[info] - Concurrent[Task].async.tailRecM stack safety

925[info] - Concurrent[Task].async.throw in delay is raiseError

926[info] - Concurrent[Task].async.throw in suspend is raiseError

927[info] - Concurrent[Task].async.uncancelable prevents Cancelled case

928[info] - Concurrent[Task].async.unsequenced delay is no-op

929[info] - ConcurrentEffect[Task].effect.acquire and release of bracket are uncancelable

930[info] - ConcurrentEffect[Task].effect.ap consistent with product + map

931[info] - ConcurrentEffect[Task].effect.applicative homomorphism

932[info] - ConcurrentEffect[Task].effect.applicative identity

933[info] - ConcurrentEffect[Task].effect.applicative interchange

934[info] - ConcurrentEffect[Task].effect.applicative map

935[info] - ConcurrentEffect[Task].effect.applicative unit

936[info] - ConcurrentEffect[Task].effect.applicativeError adaptError pure

937[info] - ConcurrentEffect[Task].effect.applicativeError adaptError raise

938[info] - ConcurrentEffect[Task].effect.applicativeError attempt consistent with attemptT

939[info] - ConcurrentEffect[Task].effect.applicativeError attempt fromEither consistent with pure

940[info] - ConcurrentEffect[Task].effect.applicativeError handle

941[info] - ConcurrentEffect[Task].effect.applicativeError handleError . raiseError left-distributes over ap

942[info] - ConcurrentEffect[Task].effect.applicativeError handleError . raiseError right-distributes over ap

943[info] - ConcurrentEffect[Task].effect.applicativeError handleError consistent with recover

944[info] - ConcurrentEffect[Task].effect.applicativeError handleError pure

945[info] - ConcurrentEffect[Task].effect.applicativeError handleErrorWith consistent with recoverWith

946[info] - ConcurrentEffect[Task].effect.applicativeError handleErrorWith pure

947[info] - ConcurrentEffect[Task].effect.applicativeError handleWith

948[info] - ConcurrentEffect[Task].effect.applicativeError onError pure

949[info] - ConcurrentEffect[Task].effect.applicativeError onError raise

950[info] - ConcurrentEffect[Task].effect.applicativeError pure attempt

951[info] - ConcurrentEffect[Task].effect.applicativeError raiseError attempt

952[info] - ConcurrentEffect[Task].effect.applicativeError recover consistent with recoverWith

953[info] - ConcurrentEffect[Task].effect.applicativeError redeem is derived from attempt and map

954[info] - ConcurrentEffect[Task].effect.apply composition

955[info] - ConcurrentEffect[Task].effect.async can be derived from asyncF

956[info] - ConcurrentEffect[Task].effect.async left is raiseError

957[info] - ConcurrentEffect[Task].effect.async right is pure

958[info] - ConcurrentEffect[Task].effect.bind suspends evaluation

959[info] - ConcurrentEffect[Task].effect.bracket is derived from bracketCase

960[info] - ConcurrentEffect[Task].effect.bracket release is called on Completed or Error

961[info] - ConcurrentEffect[Task].effect.bracketCase with failure in acquisition remains failure

962[info] - ConcurrentEffect[Task].effect.bracketCase with pure unit on release is eqv to map

963[info] - ConcurrentEffect[Task].effect.bracketCase with pure unit on release is eqv to uncancelable(..).flatMap

964[info] - ConcurrentEffect[Task].effect.covariant composition

965[info] - ConcurrentEffect[Task].effect.covariant identity

966[info] - ConcurrentEffect[Task].effect.delay constant is pure

967[info] - ConcurrentEffect[Task].effect.flatMap associativity

968[info] - ConcurrentEffect[Task].effect.flatMap consistent apply

969[info] - ConcurrentEffect[Task].effect.flatMap from tailRecM consistency

970[info] - ConcurrentEffect[Task].effect.guarantee is derived from bracket

971[info] - ConcurrentEffect[Task].effect.guaranteeCase is derived from bracketCase

972[info] - ConcurrentEffect[Task].effect.invariant composition

973[info] - ConcurrentEffect[Task].effect.invariant identity

974[info] - ConcurrentEffect[Task].effect.map flatMap coherence

975[info] - ConcurrentEffect[Task].effect.map suspends evaluation

976[info] - ConcurrentEffect[Task].effect.map2/map2Eval consistency

977[info] - ConcurrentEffect[Task].effect.map2/product-map consistency

978[info] - ConcurrentEffect[Task].effect.monad left identity

979[info] - ConcurrentEffect[Task].effect.monad right identity

980[info] - ConcurrentEffect[Task].effect.monadError ensure consistency

981[info] - ConcurrentEffect[Task].effect.monadError ensureOr consistency

982[info] - ConcurrentEffect[Task].effect.monadError left zero

983[info] - ConcurrentEffect[Task].effect.monadError redeemWith is derived from attempt and flatMap

984[info] - ConcurrentEffect[Task].effect.monadError rethrow attempt

985[info] - ConcurrentEffect[Task].effect.monoidal left identity

986[info] - ConcurrentEffect[Task].effect.monoidal right identity

987[info] - ConcurrentEffect[Task].effect.mproduct consistent flatMap

988[info] - ConcurrentEffect[Task].effect.never is derived from async

989[info] - ConcurrentEffect[Task].effect.onCancel is derived from guaranteeCase

990[info] - ConcurrentEffect[Task].effect.productL consistent map2

991[info] - ConcurrentEffect[Task].effect.productR consistent map2

992[info] - ConcurrentEffect[Task].effect.propagate errors through bind (async)

993[info] - ConcurrentEffect[Task].effect.propagate errors through bind (suspend)

994[info] - ConcurrentEffect[Task].effect.repeated async evaluation not memoized

995[info] - ConcurrentEffect[Task].effect.repeated asyncF evaluation not memoized

996[info] - ConcurrentEffect[Task].effect.repeated callback ignored

997[info] - ConcurrentEffect[Task].effect.repeated sync evaluation not memoized

998[info] - ConcurrentEffect[Task].effect.runAsync ignores error in handler

999[info] - ConcurrentEffect[Task].effect.runAsync pure produces right IO

1000[info] - ConcurrentEffect[Task].effect.runAsync raiseError produces left IO

1001[info] - ConcurrentEffect[Task].effect.semigroupal associativity

1002[info] - ConcurrentEffect[Task].effect.stack-safe on bracket with left-associated binds

1003[info] - ConcurrentEffect[Task].effect.stack-safe on bracket with right-associated binds

1004[info] - ConcurrentEffect[Task].effect.stack-safe on guarantee with left-associated binds

1005[info] - ConcurrentEffect[Task].effect.stack-safe on guarantee with right-associated binds

1006[info] - ConcurrentEffect[Task].effect.stack-safe on left-associated binds

1007[info] - ConcurrentEffect[Task].effect.stack-safe on repeated attempts

1008[info] - ConcurrentEffect[Task].effect.stack-safe on repeated maps

1009[info] - ConcurrentEffect[Task].effect.stack-safe on right-associated binds

1010[info] - ConcurrentEffect[Task].effect.suspend constant is pure join

1011[info] - ConcurrentEffect[Task].effect.tailRecM consistent flatMap

1012[info] - ConcurrentEffect[Task].effect.tailRecM stack safety

1013[info] - ConcurrentEffect[Task].effect.throw in delay is raiseError

1014[info] - ConcurrentEffect[Task].effect.throw in suspend is raiseError

1015[info] - ConcurrentEffect[Task].effect.toIO is consistent with runAsync

1016[info] - ConcurrentEffect[Task].effect.toIO is the inverse of liftIO

1017[info] - ConcurrentEffect[Task].effect.toIO stack safety

1018[info] - ConcurrentEffect[Task].effect.uncancelable prevents Cancelled case

1019[info] - ConcurrentEffect[Task].effect.unsequenced delay is no-op

1020[info] - CommutativeApplicative[IO.Par].commutative applicative.ap consistent with product + map

1021[info] - CommutativeApplicative[IO.Par].commutative applicative.applicative homomorphism

1022[info] - CommutativeApplicative[IO.Par].commutative applicative.applicative identity

1023[info] - CommutativeApplicative[IO.Par].commutative applicative.applicative interchange

1024[info] - CommutativeApplicative[IO.Par].commutative applicative.applicative map

1025[info] - CommutativeApplicative[IO.Par].commutative applicative.applicative unit

1026[info] - CommutativeApplicative[IO.Par].commutative applicative.apply commutativity

1027[info] - CommutativeApplicative[IO.Par].commutative applicative.apply composition

1028[info] - CommutativeApplicative[IO.Par].commutative applicative.covariant composition

1029[info] - CommutativeApplicative[IO.Par].commutative applicative.covariant identity

1030[info] - CommutativeApplicative[IO.Par].commutative applicative.invariant composition

1031[info] - CommutativeApplicative[IO.Par].commutative applicative.invariant identity

1032[info] - CommutativeApplicative[IO.Par].commutative applicative.map2/map2Eval consistency

1033[info] - CommutativeApplicative[IO.Par].commutative applicative.map2/product-map consistency

1034[info] - CommutativeApplicative[IO.Par].commutative applicative.monoidal left identity

1035[info] - CommutativeApplicative[IO.Par].commutative applicative.monoidal right identity

1036[info] - CommutativeApplicative[IO.Par].commutative applicative.productL consistent map2

1037[info] - CommutativeApplicative[IO.Par].commutative applicative.productR consistent map2

1038[info] - CommutativeApplicative[IO.Par].commutative applicative.semigroupal associativity

1039[info] - Parallel[Task, Task.Par].parallel.isomorphic functor

1040[info] - Parallel[Task, Task.Par].parallel.isomorphic pure

1041[info] - Parallel[Task, Task.Par].parallel.parallel round trip

1042[info] - Parallel[Task, Task.Par].parallel.sequential round trip

1043[info] - Monoid[IO[Throwable, Int]].monoid.associative

1044[info] - Monoid[IO[Throwable, Int]].monoid.collect0

1045[info] - Monoid[IO[Throwable, Int]].monoid.combine all

1046[info] - Monoid[IO[Throwable, Int]].monoid.combineAllOption

1047[info] - Monoid[IO[Throwable, Int]].monoid.intercalateCombineAllOption

1048[info] - Monoid[IO[Throwable, Int]].monoid.intercalateIntercalates

1049[info] - Monoid[IO[Throwable, Int]].monoid.intercalateRepeat1

1050[info] - Monoid[IO[Throwable, Int]].monoid.intercalateRepeat2

1051[info] - Monoid[IO[Throwable, Int]].monoid.is id

1052[info] - Monoid[IO[Throwable, Int]].monoid.left identity

1053[info] - Monoid[IO[Throwable, Int]].monoid.repeat0

1054[info] - Monoid[IO[Throwable, Int]].monoid.repeat1

1055[info] - Monoid[IO[Throwable, Int]].monoid.repeat2

1056[info] - Monoid[IO[Throwable, Int]].monoid.reverseCombineAllOption

1057[info] - Monoid[IO[Throwable, Int]].monoid.reverseRepeat1

1058[info] - Monoid[IO[Throwable, Int]].monoid.reverseRepeat2

1059[info] - Monoid[IO[Throwable, Int]].monoid.reverseReverses

1060[info] - Monoid[IO[Throwable, Int]].monoid.right identity

1061[info] - Bifunctor[IO[String, Int]].Bifunctor.Bifunctor Identity

1062[info] - Bifunctor[IO[String, Int]].Bifunctor.Bifunctor associativity

1063[info] - Bifunctor[IO[String, Int]].Bifunctor.Bifunctor leftMap Identity

1064[info] - Bifunctor[IO[String, Int]].Bifunctor.Bifunctor leftMap associativity

1065[info] monix.bio.TaskExecuteWithModelSuite

1066[info] - executeWithModel works

1067[info] - local.write.executeWithModel(AlwaysAsyncExecution) works

1068[info] - local.write.executeWithModel(SynchronousExecution) works

1069[info] - executeWithModel is stack safe in flatMap loops

1070[info] monix.bio.TaskFlipSuite

1071[info] - flip successfully swaps the error and value parameters

1072[info] - flipWith should successfully apply the provided function to the swapped error value

1073[info] - flip should not alter original successful value

1074[info] - flipWith should not alter original successful value

1075[info] - F.flip.map(f) <-> F.mapError(f).flip

1076[info] - F.flipWith(f) <-> F.mapError(f)

1077[info] monix.bio.TaskCancellationSuite

1078[info] - cancellation works for async actions

1079[info] - cancellation works for autoCancelableRunLoops

1080[info] - task.start.flatMap(fa => fa.cancel.flatMap(_ => fa)) <-> UIO.never

1081[info] - uncancelable works for async actions

1082[info] - uncancelable works for autoCancelableRunLoops

1083[info] - uncancelable is stack safe in flatMap loop, take 1

1084[info] - uncancelable is stack safe in flatMap loop, take 2

1085[info] - fa.onCancelRaiseError <-> fa

1086[info] - fa.onCancelRaiseError(e).start.flatMap(fa => fa.cancel.flatMap(_ => fa)) <-> raiseError(e)

1087[info] - cancelBoundary happy path

1088[info] - cancelBoundary execution is immediate

1089[info] - cancelBoundary is stack safe

1090[info] - cancelBoundary cancels

1091[info] - onCancelRaiseError resets cancellation flag

1092[info] - errors raised after cancel get reported

1093[info] - terminal errors raised after cancel get reported

1094[info] - onCancelRaiseError is stack safe in flatMap loop, take 1

1095[info] - onCancelRaiseError is stack safe in flatMap loop, take 2

1096[info] - local.write.uncancelable works

1097[info] - local.write.onCancelRaiseError works

1098[info] monix.bio.TaskFromFutureSuite

1099[info] - Task.fromFuture should be faster for completed futures, success

1100[info] - Task.fromFuture should be faster for completed futures, failure

1101[info] - Task.fromFuture should work onSuccess

1102[info] - Task.fromFuture should work onError

1103[info] - Task.fromFuture should be short-circuited onSuccess

1104[info] - Task.fromFuture should be short-circuited onError

1105[info] - Task.fromFuture(cancelable) should work for synchronous results onSuccess

1106[info] - Task.fromFuture(cancelable) should work for synchronous results onFailure

1107[info] - Task.fromFuture(cancelable) should be short-circuited onSuccess

1108[info] - Task.fromFuture(cancelable) should be short-circuited onError

1109[info] - Task.fromFuture(cancelable) should work onSuccess

1110[info] - Task.fromFuture(cancelable) should work onError

1111[info] - Task.fromFuture(cancelable) should be cancelable

1112[info] - Task.fromFuture should be stack safe

1113[info] - Task.now.fromFuture should be stack safe

1114[info] monix.bio.TypeClassLawsForTaskAutoCancelableRunSyncUnsafeSuite

1115[info] - CoflatMap[Task].coflatMap.coflatMap associativity

1116[info] - CoflatMap[Task].coflatMap.coflatMap identity

1117[info] - CoflatMap[Task].coflatMap.coflatten coherence

1118[info] - CoflatMap[Task].coflatMap.coflatten throughMap

1119[info] - CoflatMap[Task].coflatMap.covariant composition

1120[info] - CoflatMap[Task].coflatMap.covariant identity

1121[info] - CoflatMap[Task].coflatMap.invariant composition

1122[info] - CoflatMap[Task].coflatMap.invariant identity

1123[info] - Concurrent[Task].concurrent.acquire and release of bracket are uncancelable

1124[info] - Concurrent[Task].concurrent.acquire of bracket is not cancelable

1125[info] - Concurrent[Task].concurrent.an action run concurrently with a pure value is the same as just doing that action

1126[info] - Concurrent[Task].concurrent.ap consistent with product + map

1127[info] - Concurrent[Task].concurrent.applicative homomorphism

1128[info] - Concurrent[Task].concurrent.applicative identity

1129[info] - Concurrent[Task].concurrent.applicative interchange

1130[info] - Concurrent[Task].concurrent.applicative map

1131[info] - Concurrent[Task].concurrent.applicative unit

1132[info] - Concurrent[Task].concurrent.applicativeError adaptError pure

1133[info] - Concurrent[Task].concurrent.applicativeError adaptError raise

1134[info] - Concurrent[Task].concurrent.applicativeError attempt consistent with attemptT

1135[info] - Concurrent[Task].concurrent.applicativeError attempt fromEither consistent with pure

1136[info] - Concurrent[Task].concurrent.applicativeError handle

1137[info] - Concurrent[Task].concurrent.applicativeError handleError . raiseError left-distributes over ap

1138[info] - Concurrent[Task].concurrent.applicativeError handleError . raiseError right-distributes over ap

1139[info] - Concurrent[Task].concurrent.applicativeError handleError consistent with recover

1140[info] - Concurrent[Task].concurrent.applicativeError handleError pure

1141[info] - Concurrent[Task].concurrent.applicativeError handleErrorWith consistent with recoverWith

1142[info] - Concurrent[Task].concurrent.applicativeError handleErrorWith pure

1143[info] - Concurrent[Task].concurrent.applicativeError handleWith

1144[info] - Concurrent[Task].concurrent.applicativeError onError pure

1145[info] - Concurrent[Task].concurrent.applicativeError onError raise

1146[info] - Concurrent[Task].concurrent.applicativeError pure attempt

1147[info] - Concurrent[Task].concurrent.applicativeError raiseError attempt

1148[info] - Concurrent[Task].concurrent.applicativeError recover consistent with recoverWith

1149[info] - Concurrent[Task].concurrent.applicativeError redeem is derived from attempt and map

1150[info] - Concurrent[Task].concurrent.apply composition

1151[info] - Concurrent[Task].concurrent.async can be derived from asyncF

1152[info] - Concurrent[Task].concurrent.async cancelable coherence

1153[info] - Concurrent[Task].concurrent.async cancelable receives cancel signal

1154[info] - Concurrent[Task].concurrent.async left is raiseError

1155[info] - Concurrent[Task].concurrent.async right is pure

1156[info] - Concurrent[Task].concurrent.asyncF registration can be cancelled

1157[info] - Concurrent[Task].concurrent.bind suspends evaluation

1158[info] - Concurrent[Task].concurrent.bracket is derived from bracketCase

1159[info] - Concurrent[Task].concurrent.bracket release is called on Completed or Error

1160[info] - Concurrent[Task].concurrent.bracket release is called on cancel

1161[info] - Concurrent[Task].concurrent.bracketCase with failure in acquisition remains failure

1162[info] - Concurrent[Task].concurrent.bracketCase with pure unit on release is eqv to map

1163[info] - Concurrent[Task].concurrent.bracketCase with pure unit on release is eqv to uncancelable(..).flatMap

1164[info] - Concurrent[Task].concurrent.covariant composition

1165[info] - Concurrent[Task].concurrent.covariant identity

1166[info] - Concurrent[Task].concurrent.delay constant is pure

1167[info] - Concurrent[Task].concurrent.flatMap associativity

1168[info] - Concurrent[Task].concurrent.flatMap consistent apply

1169[info] - Concurrent[Task].concurrent.flatMap from tailRecM consistency

1170[info] - Concurrent[Task].concurrent.guarantee is derived from bracket

1171[info] - Concurrent[Task].concurrent.guaranteeCase is derived from bracketCase

1172[info] - Concurrent[Task].concurrent.invariant composition

1173[info] - Concurrent[Task].concurrent.invariant identity

1174[info] - Concurrent[Task].concurrent.join is idempotent

1175[info] - Concurrent[Task].concurrent.map flatMap coherence

1176[info] - Concurrent[Task].concurrent.map suspends evaluation

1177[info] - Concurrent[Task].concurrent.map2/map2Eval consistency

1178[info] - Concurrent[Task].concurrent.map2/product-map consistency

1179[info] - Concurrent[Task].concurrent.monad left identity

1180[info] - Concurrent[Task].concurrent.monad right identity

1181[info] - Concurrent[Task].concurrent.monadError ensure consistency

1182[info] - Concurrent[Task].concurrent.monadError ensureOr consistency

1183[info] - Concurrent[Task].concurrent.monadError left zero

1184[info] - Concurrent[Task].concurrent.monadError redeemWith is derived from attempt and flatMap

1185[info] - Concurrent[Task].concurrent.monadError rethrow attempt

1186[info] - Concurrent[Task].concurrent.monoidal left identity

1187[info] - Concurrent[Task].concurrent.monoidal right identity

1188[info] - Concurrent[Task].concurrent.mproduct consistent flatMap

1189[info] - Concurrent[Task].concurrent.onCancel is derived from guaranteeCase

1190[info] - Concurrent[Task].concurrent.productL consistent map2

1191[info] - Concurrent[Task].concurrent.productR consistent map2

1192[info] - Concurrent[Task].concurrent.propagate errors through bind (async)

1193[info] - Concurrent[Task].concurrent.propagate errors through bind (suspend)

1194[info] - Concurrent[Task].concurrent.race cancels both

1195[info] - Concurrent[Task].concurrent.race cancels loser

1196[info] - Concurrent[Task].concurrent.race mirrors left winner

1197[info] - Concurrent[Task].concurrent.race mirrors right winner

1198[info] - Concurrent[Task].concurrent.racePair can join left

1199[info] - Concurrent[Task].concurrent.racePair can join right

1200[info] - Concurrent[Task].concurrent.racePair cancels both

1201[info] - Concurrent[Task].concurrent.racePair cancels loser

1202[info] - Concurrent[Task].concurrent.racePair mirrors left winner

1203[info] - Concurrent[Task].concurrent.racePair mirrors right winner

1204[info] - Concurrent[Task].concurrent.release of bracket is not cancelable

1205[info] - Concurrent[Task].concurrent.repeated async evaluation not memoized

1206[info] - Concurrent[Task].concurrent.repeated asyncF evaluation not memoized

1207[info] - Concurrent[Task].concurrent.repeated sync evaluation not memoized

1208[info] - Concurrent[Task].concurrent.semigroupal associativity

1209[info] - Concurrent[Task].concurrent.stack-safe on bracket with left-associated binds

1210[info] - Concurrent[Task].concurrent.stack-safe on bracket with right-associated binds

1211[info] - Concurrent[Task].concurrent.stack-safe on guarantee with left-associated binds

1212[info] - Concurrent[Task].concurrent.stack-safe on guarantee with right-associated binds

1213[info] - Concurrent[Task].concurrent.stack-safe on left-associated binds

1214[info] - Concurrent[Task].concurrent.stack-safe on repeated attempts

1215[info] - Concurrent[Task].concurrent.stack-safe on repeated maps

1216[info] - Concurrent[Task].concurrent.stack-safe on right-associated binds

1217[info] - Concurrent[Task].concurrent.start then join is identity

1218[info] - Concurrent[Task].concurrent.start.flatMap(_.cancel) is unit

1219[info] - Concurrent[Task].concurrent.suspend constant is pure join

1220[info] - Concurrent[Task].concurrent.tailRecM consistent flatMap

1221[info] - Concurrent[Task].concurrent.tailRecM stack safety

1222[info] - Concurrent[Task].concurrent.throw in delay is raiseError

1223[info] - Concurrent[Task].concurrent.throw in suspend is raiseError

1224[info] - Concurrent[Task].concurrent.uncancelable mirrors source

1225[info] - Concurrent[Task].concurrent.uncancelable prevents Cancelled case

1226[info] - Concurrent[Task].concurrent.unsequenced delay is no-op

1227[info] - ConcurrentEffect[Task].concurrentEffect.acquire and release of bracket are uncancelable

1228[info] - ConcurrentEffect[Task].concurrentEffect.acquire of bracket is not cancelable

1229[info] - ConcurrentEffect[Task].concurrentEffect.an action run concurrently with a pure value is the same as just doing that action

1230[info] - ConcurrentEffect[Task].concurrentEffect.ap consistent with product + map

1231[info] - ConcurrentEffect[Task].concurrentEffect.applicative homomorphism

1232[info] - ConcurrentEffect[Task].concurrentEffect.applicative identity

1233[info] - ConcurrentEffect[Task].concurrentEffect.applicative interchange

1234[info] - ConcurrentEffect[Task].concurrentEffect.applicative map

1235[info] - ConcurrentEffect[Task].concurrentEffect.applicative unit

1236[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError adaptError pure

1237[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError adaptError raise

1238[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError attempt consistent with attemptT

1239[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError attempt fromEither consistent with pure

1240[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError handle

1241[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError handleError . raiseError left-distributes over ap

1242[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError handleError . raiseError right-distributes over ap

1243[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError handleError consistent with recover

1244[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError handleError pure

1245[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError handleErrorWith consistent with recoverWith

1246[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError handleErrorWith pure

1247[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError handleWith

1248[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError onError pure

1249[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError onError raise

1250[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError pure attempt

1251[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError raiseError attempt

1252[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError recover consistent with recoverWith

1253[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError redeem is derived from attempt and map

1254[info] - ConcurrentEffect[Task].concurrentEffect.apply composition

1255[info] - ConcurrentEffect[Task].concurrentEffect.async can be derived from asyncF

1256[info] - ConcurrentEffect[Task].concurrentEffect.async cancelable coherence

1257[info] - ConcurrentEffect[Task].concurrentEffect.async cancelable receives cancel signal

1258[info] - ConcurrentEffect[Task].concurrentEffect.async left is raiseError

1259[info] - ConcurrentEffect[Task].concurrentEffect.async right is pure

1260[info] - ConcurrentEffect[Task].concurrentEffect.asyncF registration can be cancelled

1261[info] - ConcurrentEffect[Task].concurrentEffect.bind suspends evaluation

1262[info] - ConcurrentEffect[Task].concurrentEffect.bracket is derived from bracketCase

1263[info] - ConcurrentEffect[Task].concurrentEffect.bracket release is called on Completed or Error

1264[info] - ConcurrentEffect[Task].concurrentEffect.bracket release is called on cancel

1265[info] - ConcurrentEffect[Task].concurrentEffect.bracketCase with failure in acquisition remains failure

1266[info] - ConcurrentEffect[Task].concurrentEffect.bracketCase with pure unit on release is eqv to map

1267[info] - ConcurrentEffect[Task].concurrentEffect.bracketCase with pure unit on release is eqv to uncancelable(..).flatMap

1268[info] - ConcurrentEffect[Task].concurrentEffect.covariant composition

1269[info] - ConcurrentEffect[Task].concurrentEffect.covariant identity

1270[info] - ConcurrentEffect[Task].concurrentEffect.delay constant is pure

1271[info] - ConcurrentEffect[Task].concurrentEffect.flatMap associativity

1272[info] - ConcurrentEffect[Task].concurrentEffect.flatMap consistent apply

1273[info] - ConcurrentEffect[Task].concurrentEffect.flatMap from tailRecM consistency

1274[info] - ConcurrentEffect[Task].concurrentEffect.guarantee is derived from bracket

1275[info] - ConcurrentEffect[Task].concurrentEffect.guaranteeCase is derived from bracketCase

1276[info] - ConcurrentEffect[Task].concurrentEffect.invariant composition

1277[info] - ConcurrentEffect[Task].concurrentEffect.invariant identity

1278[info] - ConcurrentEffect[Task].concurrentEffect.join is idempotent

1279[info] - ConcurrentEffect[Task].concurrentEffect.map flatMap coherence

1280[info] - ConcurrentEffect[Task].concurrentEffect.map suspends evaluation

1281[info] - ConcurrentEffect[Task].concurrentEffect.map2/map2Eval consistency

1282[info] - ConcurrentEffect[Task].concurrentEffect.map2/product-map consistency

1283[info] - ConcurrentEffect[Task].concurrentEffect.monad left identity

1284[info] - ConcurrentEffect[Task].concurrentEffect.monad right identity

1285[info] - ConcurrentEffect[Task].concurrentEffect.monadError ensure consistency

1286[info] - ConcurrentEffect[Task].concurrentEffect.monadError ensureOr consistency

1287[info] - ConcurrentEffect[Task].concurrentEffect.monadError left zero

1288[info] - ConcurrentEffect[Task].concurrentEffect.monadError redeemWith is derived from attempt and flatMap

1289[info] - ConcurrentEffect[Task].concurrentEffect.monadError rethrow attempt

1290[info] - ConcurrentEffect[Task].concurrentEffect.monoidal left identity

1291[info] - ConcurrentEffect[Task].concurrentEffect.monoidal right identity

1292[info] - ConcurrentEffect[Task].concurrentEffect.mproduct consistent flatMap

1293[info] - ConcurrentEffect[Task].concurrentEffect.onCancel is derived from guaranteeCase

1294[info] - ConcurrentEffect[Task].concurrentEffect.productL consistent map2

1295[info] - ConcurrentEffect[Task].concurrentEffect.productR consistent map2

1296[info] - ConcurrentEffect[Task].concurrentEffect.propagate errors through bind (async)

1297[info] - ConcurrentEffect[Task].concurrentEffect.propagate errors through bind (suspend)

1298[info] - ConcurrentEffect[Task].concurrentEffect.race cancels both

1299[info] - ConcurrentEffect[Task].concurrentEffect.race cancels loser

1300[info] - ConcurrentEffect[Task].concurrentEffect.race mirrors left winner

1301[info] - ConcurrentEffect[Task].concurrentEffect.race mirrors right winner

1302[info] - ConcurrentEffect[Task].concurrentEffect.racePair can join left

1303[info] - ConcurrentEffect[Task].concurrentEffect.racePair can join right

1304[info] - ConcurrentEffect[Task].concurrentEffect.racePair cancels both

1305[info] - ConcurrentEffect[Task].concurrentEffect.racePair cancels loser

1306[info] - ConcurrentEffect[Task].concurrentEffect.racePair mirrors left winner

1307[info] - ConcurrentEffect[Task].concurrentEffect.racePair mirrors right winner

1308[info] - ConcurrentEffect[Task].concurrentEffect.release of bracket is not cancelable

1309[info] - ConcurrentEffect[Task].concurrentEffect.repeated async evaluation not memoized

1310[info] - ConcurrentEffect[Task].concurrentEffect.repeated asyncF evaluation not memoized

1311[info] - ConcurrentEffect[Task].concurrentEffect.repeated callback ignored

1312[info] - ConcurrentEffect[Task].concurrentEffect.repeated sync evaluation not memoized

1313[info] - ConcurrentEffect[Task].concurrentEffect.runAsync ignores error in handler

1314[info] - ConcurrentEffect[Task].concurrentEffect.runAsync pure produces right IO

1315[info] - ConcurrentEffect[Task].concurrentEffect.runAsync raiseError produces left IO

1316[info] - ConcurrentEffect[Task].concurrentEffect.runAsync runCancelable coherence

1317[info] - ConcurrentEffect[Task].concurrentEffect.runCancelable is synchronous

1318[info] - ConcurrentEffect[Task].concurrentEffect.runCancelable start.flatMap(_.cancel) coherence

1319[info] - ConcurrentEffect[Task].concurrentEffect.semigroupal associativity

1320[info] - ConcurrentEffect[Task].concurrentEffect.stack-safe on bracket with left-associated binds

1321[info] - ConcurrentEffect[Task].concurrentEffect.stack-safe on bracket with right-associated binds

1322[info] - ConcurrentEffect[Task].concurrentEffect.stack-safe on guarantee with left-associated binds

1323[info] - ConcurrentEffect[Task].concurrentEffect.stack-safe on guarantee with right-associated binds

1324[info] - ConcurrentEffect[Task].concurrentEffect.stack-safe on left-associated binds

1325[info] - ConcurrentEffect[Task].concurrentEffect.stack-safe on repeated attempts

1326[info] - ConcurrentEffect[Task].concurrentEffect.stack-safe on repeated maps

1327[info] - ConcurrentEffect[Task].concurrentEffect.stack-safe on right-associated binds

1328[info] - ConcurrentEffect[Task].concurrentEffect.start then join is identity

1329[info] - ConcurrentEffect[Task].concurrentEffect.start.flatMap(_.cancel) is unit

1330[info] - ConcurrentEffect[Task].concurrentEffect.suspend constant is pure join

1331[info] - ConcurrentEffect[Task].concurrentEffect.tailRecM consistent flatMap

1332[info] - ConcurrentEffect[Task].concurrentEffect.tailRecM stack safety

1333[info] - ConcurrentEffect[Task].concurrentEffect.throw in delay is raiseError

1334[info] - ConcurrentEffect[Task].concurrentEffect.throw in suspend is raiseError

1335[info] - ConcurrentEffect[Task].concurrentEffect.toIO is consistent with runAsync

1336[info] - ConcurrentEffect[Task].concurrentEffect.toIO is consistent with runCancelable

1337[info] - ConcurrentEffect[Task].concurrentEffect.toIO is the inverse of liftIO

1338[info] - ConcurrentEffect[Task].concurrentEffect.toIO stack safety

1339[info] - ConcurrentEffect[Task].concurrentEffect.uncancelable mirrors source

1340[info] - ConcurrentEffect[Task].concurrentEffect.uncancelable prevents Cancelled case

1341[info] - ConcurrentEffect[Task].concurrentEffect.unsequenced delay is no-op

1342[info] - Applicative[Task.Par].applicative.ap consistent with product + map

1343[info] - Applicative[Task.Par].applicative.applicative homomorphism

1344[info] - Applicative[Task.Par].applicative.applicative identity

1345[info] - Applicative[Task.Par].applicative.applicative interchange

1346[info] - Applicative[Task.Par].applicative.applicative map

1347[info] - Applicative[Task.Par].applicative.applicative unit

1348[info] - Applicative[Task.Par].applicative.apply composition

1349[info] - Applicative[Task.Par].applicative.covariant composition

1350[info] - Applicative[Task.Par].applicative.covariant identity

1351[info] - Applicative[Task.Par].applicative.invariant composition

1352[info] - Applicative[Task.Par].applicative.invariant identity

1353[info] - Applicative[Task.Par].applicative.map2/map2Eval consistency

1354[info] - Applicative[Task.Par].applicative.map2/product-map consistency

1355[info] - Applicative[Task.Par].applicative.monoidal left identity

1356[info] - Applicative[Task.Par].applicative.monoidal right identity

1357[info] - Applicative[Task.Par].applicative.productL consistent map2

1358[info] - Applicative[Task.Par].applicative.productR consistent map2

1359[info] - Applicative[Task.Par].applicative.semigroupal associativity

1360[info] - Parallel[Task, Task.Par].parallel.isomorphic functor

1361[info] - Parallel[Task, Task.Par].parallel.isomorphic pure

1362[info] - Parallel[Task, Task.Par].parallel.parallel round trip

1363[info] - Parallel[Task, Task.Par].parallel.sequential round trip

1364[info] - Monoid[IO[Throwable, Int]].monoid.associative

1365[info] - Monoid[IO[Throwable, Int]].monoid.collect0

1366[info] - Monoid[IO[Throwable, Int]].monoid.combine all

1367[info] - Monoid[IO[Throwable, Int]].monoid.combineAllOption

1368[info] - Monoid[IO[Throwable, Int]].monoid.intercalateCombineAllOption

1369[info] - Monoid[IO[Throwable, Int]].monoid.intercalateIntercalates

1370[info] - Monoid[IO[Throwable, Int]].monoid.intercalateRepeat1

1371[info] - Monoid[IO[Throwable, Int]].monoid.intercalateRepeat2

1372[info] - Monoid[IO[Throwable, Int]].monoid.is id

1373[info] - Monoid[IO[Throwable, Int]].monoid.left identity

1374[info] - Monoid[IO[Throwable, Int]].monoid.repeat0

1375[info] - Monoid[IO[Throwable, Int]].monoid.repeat1

1376[info] - Monoid[IO[Throwable, Int]].monoid.repeat2

1377[info] - Monoid[IO[Throwable, Int]].monoid.reverseCombineAllOption

1378[info] - Monoid[IO[Throwable, Int]].monoid.reverseRepeat1

1379[info] - Monoid[IO[Throwable, Int]].monoid.reverseRepeat2

1380[info] - Monoid[IO[Throwable, Int]].monoid.reverseReverses

1381[info] - Monoid[IO[Throwable, Int]].monoid.right identity

1382[info] - Bifunctor[IO[String, Int]].Bifunctor.Bifunctor Identity

1383[info] - Bifunctor[IO[String, Int]].Bifunctor.Bifunctor associativity

1384[info] - Bifunctor[IO[String, Int]].Bifunctor.Bifunctor leftMap Identity

1385[info] - Bifunctor[IO[String, Int]].Bifunctor.Bifunctor leftMap associativity

1386[info] monix.bio.TypeClassLawsForTaskRunSyncUnsafeSuite

1387[info] - CoflatMap[Task].coflatMap.coflatMap associativity

1388[info] - CoflatMap[Task].coflatMap.coflatMap identity

1389[info] - CoflatMap[Task].coflatMap.coflatten coherence

1390[info] - CoflatMap[Task].coflatMap.coflatten throughMap

1391[info] - CoflatMap[Task].coflatMap.covariant composition

1392[info] - CoflatMap[Task].coflatMap.covariant identity

1393[info] - CoflatMap[Task].coflatMap.invariant composition

1394[info] - CoflatMap[Task].coflatMap.invariant identity

1395[info] - Concurrent[Task].concurrent.acquire and release of bracket are uncancelable

1396[info] - Concurrent[Task].concurrent.acquire of bracket is not cancelable

1397[info] - Concurrent[Task].concurrent.an action run concurrently with a pure value is the same as just doing that action

1398[info] - Concurrent[Task].concurrent.ap consistent with product + map

1399[info] - Concurrent[Task].concurrent.applicative homomorphism

1400[info] - Concurrent[Task].concurrent.applicative identity

1401[info] - Concurrent[Task].concurrent.applicative interchange

1402[info] - Concurrent[Task].concurrent.applicative map

1403[info] - Concurrent[Task].concurrent.applicative unit

1404[info] - Concurrent[Task].concurrent.applicativeError adaptError pure

1405[info] - Concurrent[Task].concurrent.applicativeError adaptError raise

1406[info] - Concurrent[Task].concurrent.applicativeError attempt consistent with attemptT

1407[info] - Concurrent[Task].concurrent.applicativeError attempt fromEither consistent with pure

1408[info] - Concurrent[Task].concurrent.applicativeError handle

1409[info] - Concurrent[Task].concurrent.applicativeError handleError . raiseError left-distributes over ap

1410[info] - Concurrent[Task].concurrent.applicativeError handleError . raiseError right-distributes over ap

1411[info] - Concurrent[Task].concurrent.applicativeError handleError consistent with recover

1412[info] - Concurrent[Task].concurrent.applicativeError handleError pure

1413[info] - Concurrent[Task].concurrent.applicativeError handleErrorWith consistent with recoverWith

1414[info] - Concurrent[Task].concurrent.applicativeError handleErrorWith pure

1415[info] - Concurrent[Task].concurrent.applicativeError handleWith

1416[info] - Concurrent[Task].concurrent.applicativeError onError pure

1417[info] - Concurrent[Task].concurrent.applicativeError onError raise

1418[info] - Concurrent[Task].concurrent.applicativeError pure attempt

1419[info] - Concurrent[Task].concurrent.applicativeError raiseError attempt

1420[info] - Concurrent[Task].concurrent.applicativeError recover consistent with recoverWith

1421[info] - Concurrent[Task].concurrent.applicativeError redeem is derived from attempt and map

1422[info] - Concurrent[Task].concurrent.apply composition

1423[info] - Concurrent[Task].concurrent.async can be derived from asyncF

1424[info] - Concurrent[Task].concurrent.async cancelable coherence

1425[info] - Concurrent[Task].concurrent.async cancelable receives cancel signal

1426[info] - Concurrent[Task].concurrent.async left is raiseError

1427[info] - Concurrent[Task].concurrent.async right is pure

1428[info] - Concurrent[Task].concurrent.asyncF registration can be cancelled

1429[info] - Concurrent[Task].concurrent.bind suspends evaluation

1430[info] - Concurrent[Task].concurrent.bracket is derived from bracketCase

1431[info] - Concurrent[Task].concurrent.bracket release is called on Completed or Error

1432[info] - Concurrent[Task].concurrent.bracket release is called on cancel

1433[info] - Concurrent[Task].concurrent.bracketCase with failure in acquisition remains failure

1434[info] - Concurrent[Task].concurrent.bracketCase with pure unit on release is eqv to map

1435[info] - Concurrent[Task].concurrent.bracketCase with pure unit on release is eqv to uncancelable(..).flatMap

1436[info] - Concurrent[Task].concurrent.covariant composition

1437[info] - Concurrent[Task].concurrent.covariant identity

1438[info] - Concurrent[Task].concurrent.delay constant is pure

1439[info] - Concurrent[Task].concurrent.flatMap associativity

1440[info] - Concurrent[Task].concurrent.flatMap consistent apply

1441[info] - Concurrent[Task].concurrent.flatMap from tailRecM consistency

1442[info] - Concurrent[Task].concurrent.guarantee is derived from bracket

1443[info] - Concurrent[Task].concurrent.guaranteeCase is derived from bracketCase

1444[info] - Concurrent[Task].concurrent.invariant composition

1445[info] - Concurrent[Task].concurrent.invariant identity

1446[info] - Concurrent[Task].concurrent.join is idempotent

1447[info] - Concurrent[Task].concurrent.map flatMap coherence

1448[info] - Concurrent[Task].concurrent.map suspends evaluation

1449[info] - Concurrent[Task].concurrent.map2/map2Eval consistency

1450[info] - Concurrent[Task].concurrent.map2/product-map consistency

1451[info] - Concurrent[Task].concurrent.monad left identity

1452[info] - Concurrent[Task].concurrent.monad right identity

1453[info] - Concurrent[Task].concurrent.monadError ensure consistency

1454[info] - Concurrent[Task].concurrent.monadError ensureOr consistency

1455[info] - Concurrent[Task].concurrent.monadError left zero

1456[info] - Concurrent[Task].concurrent.monadError redeemWith is derived from attempt and flatMap

1457[info] - Concurrent[Task].concurrent.monadError rethrow attempt

1458[info] - Concurrent[Task].concurrent.monoidal left identity

1459[info] - Concurrent[Task].concurrent.monoidal right identity

1460[info] - Concurrent[Task].concurrent.mproduct consistent flatMap

1461[info] - Concurrent[Task].concurrent.onCancel is derived from guaranteeCase

1462[info] - Concurrent[Task].concurrent.productL consistent map2

1463[info] - Concurrent[Task].concurrent.productR consistent map2

1464[info] - Concurrent[Task].concurrent.propagate errors through bind (async)

1465[info] - Concurrent[Task].concurrent.propagate errors through bind (suspend)

1466[info] - Concurrent[Task].concurrent.race cancels both

1467[info] - Concurrent[Task].concurrent.race cancels loser

1468[info] - Concurrent[Task].concurrent.race mirrors left winner

1469[info] - Concurrent[Task].concurrent.race mirrors right winner

1470[info] - Concurrent[Task].concurrent.racePair can join left

1471[info] - Concurrent[Task].concurrent.racePair can join right

1472[info] - Concurrent[Task].concurrent.racePair cancels both

1473[info] - Concurrent[Task].concurrent.racePair cancels loser

1474[info] - Concurrent[Task].concurrent.racePair mirrors left winner

1475[info] - Concurrent[Task].concurrent.racePair mirrors right winner

1476[info] - Concurrent[Task].concurrent.release of bracket is not cancelable

1477[info] - Concurrent[Task].concurrent.repeated async evaluation not memoized

1478[info] - Concurrent[Task].concurrent.repeated asyncF evaluation not memoized

1479[info] - Concurrent[Task].concurrent.repeated sync evaluation not memoized

1480[info] - Concurrent[Task].concurrent.semigroupal associativity

1481[info] - Concurrent[Task].concurrent.stack-safe on bracket with left-associated binds

1482[info] - Concurrent[Task].concurrent.stack-safe on bracket with right-associated binds

1483[info] - Concurrent[Task].concurrent.stack-safe on guarantee with left-associated binds

1484[info] - Concurrent[Task].concurrent.stack-safe on guarantee with right-associated binds

1485[info] - Concurrent[Task].concurrent.stack-safe on left-associated binds

1486[info] - Concurrent[Task].concurrent.stack-safe on repeated attempts

1487[info] - Concurrent[Task].concurrent.stack-safe on repeated maps

1488[info] - Concurrent[Task].concurrent.stack-safe on right-associated binds

1489[info] - Concurrent[Task].concurrent.start then join is identity

1490[info] - Concurrent[Task].concurrent.start.flatMap(_.cancel) is unit

1491[info] - Concurrent[Task].concurrent.suspend constant is pure join

1492[info] - Concurrent[Task].concurrent.tailRecM consistent flatMap

1493[info] - Concurrent[Task].concurrent.tailRecM stack safety

1494[info] - Concurrent[Task].concurrent.throw in delay is raiseError

1495[info] - Concurrent[Task].concurrent.throw in suspend is raiseError

1496[info] - Concurrent[Task].concurrent.uncancelable mirrors source

1497[info] - Concurrent[Task].concurrent.uncancelable prevents Cancelled case

1498[info] - Concurrent[Task].concurrent.unsequenced delay is no-op

1499[info] - ConcurrentEffect[Task].concurrentEffect.acquire and release of bracket are uncancelable

1500[info] - ConcurrentEffect[Task].concurrentEffect.acquire of bracket is not cancelable

1501[info] - ConcurrentEffect[Task].concurrentEffect.an action run concurrently with a pure value is the same as just doing that action

1502[info] - ConcurrentEffect[Task].concurrentEffect.ap consistent with product + map

1503[info] - ConcurrentEffect[Task].concurrentEffect.applicative homomorphism

1504[info] - ConcurrentEffect[Task].concurrentEffect.applicative identity

1505[info] - ConcurrentEffect[Task].concurrentEffect.applicative interchange

1506[info] - ConcurrentEffect[Task].concurrentEffect.applicative map

1507[info] - ConcurrentEffect[Task].concurrentEffect.applicative unit

1508[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError adaptError pure

1509[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError adaptError raise

1510[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError attempt consistent with attemptT

1511[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError attempt fromEither consistent with pure

1512[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError handle

1513[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError handleError . raiseError left-distributes over ap

1514[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError handleError . raiseError right-distributes over ap

1515[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError handleError consistent with recover

1516[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError handleError pure

1517[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError handleErrorWith consistent with recoverWith

1518[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError handleErrorWith pure

1519[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError handleWith

1520[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError onError pure

1521[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError onError raise

1522[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError pure attempt

1523[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError raiseError attempt

1524[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError recover consistent with recoverWith

1525[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError redeem is derived from attempt and map

1526[info] - ConcurrentEffect[Task].concurrentEffect.apply composition

1527[info] - ConcurrentEffect[Task].concurrentEffect.async can be derived from asyncF

1528[info] - ConcurrentEffect[Task].concurrentEffect.async cancelable coherence

1529[info] - ConcurrentEffect[Task].concurrentEffect.async cancelable receives cancel signal

1530[info] - ConcurrentEffect[Task].concurrentEffect.async left is raiseError

1531[info] - ConcurrentEffect[Task].concurrentEffect.async right is pure

1532[info] - ConcurrentEffect[Task].concurrentEffect.asyncF registration can be cancelled

1533[info] - ConcurrentEffect[Task].concurrentEffect.bind suspends evaluation

1534[info] - ConcurrentEffect[Task].concurrentEffect.bracket is derived from bracketCase

1535[info] - ConcurrentEffect[Task].concurrentEffect.bracket release is called on Completed or Error

1536[info] - ConcurrentEffect[Task].concurrentEffect.bracket release is called on cancel

1537[info] - ConcurrentEffect[Task].concurrentEffect.bracketCase with failure in acquisition remains failure

1538[info] - ConcurrentEffect[Task].concurrentEffect.bracketCase with pure unit on release is eqv to map

1539[info] - ConcurrentEffect[Task].concurrentEffect.bracketCase with pure unit on release is eqv to uncancelable(..).flatMap

1540[info] - ConcurrentEffect[Task].concurrentEffect.covariant composition

1541[info] - ConcurrentEffect[Task].concurrentEffect.covariant identity

1542[info] - ConcurrentEffect[Task].concurrentEffect.delay constant is pure

1543[info] - ConcurrentEffect[Task].concurrentEffect.flatMap associativity

1544[info] - ConcurrentEffect[Task].concurrentEffect.flatMap consistent apply

1545[info] - ConcurrentEffect[Task].concurrentEffect.flatMap from tailRecM consistency

1546[info] - ConcurrentEffect[Task].concurrentEffect.guarantee is derived from bracket

1547[info] - ConcurrentEffect[Task].concurrentEffect.guaranteeCase is derived from bracketCase

1548[info] - ConcurrentEffect[Task].concurrentEffect.invariant composition

1549[info] - ConcurrentEffect[Task].concurrentEffect.invariant identity

1550[info] - ConcurrentEffect[Task].concurrentEffect.join is idempotent

1551[info] - ConcurrentEffect[Task].concurrentEffect.map flatMap coherence

1552[info] - ConcurrentEffect[Task].concurrentEffect.map suspends evaluation

1553[info] - ConcurrentEffect[Task].concurrentEffect.map2/map2Eval consistency

1554[info] - ConcurrentEffect[Task].concurrentEffect.map2/product-map consistency

1555[info] - ConcurrentEffect[Task].concurrentEffect.monad left identity

1556[info] - ConcurrentEffect[Task].concurrentEffect.monad right identity

1557[info] - ConcurrentEffect[Task].concurrentEffect.monadError ensure consistency

1558[info] - ConcurrentEffect[Task].concurrentEffect.monadError ensureOr consistency

1559[info] - ConcurrentEffect[Task].concurrentEffect.monadError left zero

1560[info] - ConcurrentEffect[Task].concurrentEffect.monadError redeemWith is derived from attempt and flatMap

1561[info] - ConcurrentEffect[Task].concurrentEffect.monadError rethrow attempt

1562[info] - ConcurrentEffect[Task].concurrentEffect.monoidal left identity

1563[info] - ConcurrentEffect[Task].concurrentEffect.monoidal right identity

1564[info] - ConcurrentEffect[Task].concurrentEffect.mproduct consistent flatMap

1565[info] - ConcurrentEffect[Task].concurrentEffect.onCancel is derived from guaranteeCase

1566[info] - ConcurrentEffect[Task].concurrentEffect.productL consistent map2

1567[info] - ConcurrentEffect[Task].concurrentEffect.productR consistent map2

1568[info] - ConcurrentEffect[Task].concurrentEffect.propagate errors through bind (async)

1569[info] - ConcurrentEffect[Task].concurrentEffect.propagate errors through bind (suspend)

1570[info] - ConcurrentEffect[Task].concurrentEffect.race cancels both

1571[info] - ConcurrentEffect[Task].concurrentEffect.race cancels loser

1572[info] - ConcurrentEffect[Task].concurrentEffect.race mirrors left winner

1573[info] - ConcurrentEffect[Task].concurrentEffect.race mirrors right winner

1574[info] - ConcurrentEffect[Task].concurrentEffect.racePair can join left

1575[info] - ConcurrentEffect[Task].concurrentEffect.racePair can join right

1576[info] - ConcurrentEffect[Task].concurrentEffect.racePair cancels both

1577[info] - ConcurrentEffect[Task].concurrentEffect.racePair cancels loser

1578[info] - ConcurrentEffect[Task].concurrentEffect.racePair mirrors left winner

1579[info] - ConcurrentEffect[Task].concurrentEffect.racePair mirrors right winner

1580[info] - ConcurrentEffect[Task].concurrentEffect.release of bracket is not cancelable

1581[info] - ConcurrentEffect[Task].concurrentEffect.repeated async evaluation not memoized

1582[info] - ConcurrentEffect[Task].concurrentEffect.repeated asyncF evaluation not memoized

1583[info] - ConcurrentEffect[Task].concurrentEffect.repeated callback ignored

1584[info] - ConcurrentEffect[Task].concurrentEffect.repeated sync evaluation not memoized

1585[info] - ConcurrentEffect[Task].concurrentEffect.runAsync ignores error in handler

1586[info] - ConcurrentEffect[Task].concurrentEffect.runAsync pure produces right IO

1587[info] - ConcurrentEffect[Task].concurrentEffect.runAsync raiseError produces left IO

1588[info] - ConcurrentEffect[Task].concurrentEffect.runAsync runCancelable coherence

1589[info] - ConcurrentEffect[Task].concurrentEffect.runCancelable is synchronous

1590[info] - ConcurrentEffect[Task].concurrentEffect.runCancelable start.flatMap(_.cancel) coherence

1591[info] - ConcurrentEffect[Task].concurrentEffect.semigroupal associativity

1592[info] - ConcurrentEffect[Task].concurrentEffect.stack-safe on bracket with left-associated binds

1593[info] - ConcurrentEffect[Task].concurrentEffect.stack-safe on bracket with right-associated binds

1594[info] - ConcurrentEffect[Task].concurrentEffect.stack-safe on guarantee with left-associated binds

1595[info] - ConcurrentEffect[Task].concurrentEffect.stack-safe on guarantee with right-associated binds

1596[info] - ConcurrentEffect[Task].concurrentEffect.stack-safe on left-associated binds

1597[info] - ConcurrentEffect[Task].concurrentEffect.stack-safe on repeated attempts

1598[info] - ConcurrentEffect[Task].concurrentEffect.stack-safe on repeated maps

1599[info] - ConcurrentEffect[Task].concurrentEffect.stack-safe on right-associated binds

1600[info] - ConcurrentEffect[Task].concurrentEffect.start then join is identity

1601[info] - ConcurrentEffect[Task].concurrentEffect.start.flatMap(_.cancel) is unit

1602[info] - ConcurrentEffect[Task].concurrentEffect.suspend constant is pure join

1603[info] - ConcurrentEffect[Task].concurrentEffect.tailRecM consistent flatMap

1604[info] - ConcurrentEffect[Task].concurrentEffect.tailRecM stack safety

1605[info] - ConcurrentEffect[Task].concurrentEffect.throw in delay is raiseError

1606[info] - ConcurrentEffect[Task].concurrentEffect.throw in suspend is raiseError

1607[info] - ConcurrentEffect[Task].concurrentEffect.toIO is consistent with runAsync

1608[info] - ConcurrentEffect[Task].concurrentEffect.toIO is consistent with runCancelable

1609[info] - ConcurrentEffect[Task].concurrentEffect.toIO is the inverse of liftIO

1610[info] - ConcurrentEffect[Task].concurrentEffect.toIO stack safety

1611[info] - ConcurrentEffect[Task].concurrentEffect.uncancelable mirrors source

1612[info] - ConcurrentEffect[Task].concurrentEffect.uncancelable prevents Cancelled case

1613[info] - ConcurrentEffect[Task].concurrentEffect.unsequenced delay is no-op

1614[info] - Applicative[Task.Par].applicative.ap consistent with product + map

1615[info] - Applicative[Task.Par].applicative.applicative homomorphism

1616[info] - Applicative[Task.Par].applicative.applicative identity

1617[info] - Applicative[Task.Par].applicative.applicative interchange

1618[info] - Applicative[Task.Par].applicative.applicative map

1619[info] - Applicative[Task.Par].applicative.applicative unit

1620[info] - Applicative[Task.Par].applicative.apply composition

1621[info] - Applicative[Task.Par].applicative.covariant composition

1622[info] - Applicative[Task.Par].applicative.covariant identity

1623[info] - Applicative[Task.Par].applicative.invariant composition

1624[info] - Applicative[Task.Par].applicative.invariant identity

1625[info] - Applicative[Task.Par].applicative.map2/map2Eval consistency

1626[info] - Applicative[Task.Par].applicative.map2/product-map consistency

1627[info] - Applicative[Task.Par].applicative.monoidal left identity

1628[info] - Applicative[Task.Par].applicative.monoidal right identity

1629[info] - Applicative[Task.Par].applicative.productL consistent map2

1630[info] - Applicative[Task.Par].applicative.productR consistent map2

1631[info] - Applicative[Task.Par].applicative.semigroupal associativity

1632[info] - Parallel[Task, Task.Par].parallel.isomorphic functor

1633[info] - Parallel[Task, Task.Par].parallel.isomorphic pure

1634[info] - Parallel[Task, Task.Par].parallel.parallel round trip

1635[info] - Parallel[Task, Task.Par].parallel.sequential round trip

1636[info] - Monoid[IO[Throwable, Int]].monoid.associative

1637[info] - Monoid[IO[Throwable, Int]].monoid.collect0

1638[info] - Monoid[IO[Throwable, Int]].monoid.combine all

1639[info] - Monoid[IO[Throwable, Int]].monoid.combineAllOption

1640[info] - Monoid[IO[Throwable, Int]].monoid.intercalateCombineAllOption

1641[info] - Monoid[IO[Throwable, Int]].monoid.intercalateIntercalates

1642[info] - Monoid[IO[Throwable, Int]].monoid.intercalateRepeat1

1643[info] - Monoid[IO[Throwable, Int]].monoid.intercalateRepeat2

1644[info] - Monoid[IO[Throwable, Int]].monoid.is id

1645[info] - Monoid[IO[Throwable, Int]].monoid.left identity

1646[info] - Monoid[IO[Throwable, Int]].monoid.repeat0

1647[info] - Monoid[IO[Throwable, Int]].monoid.repeat1

1648[info] - Monoid[IO[Throwable, Int]].monoid.repeat2

1649[info] - Monoid[IO[Throwable, Int]].monoid.reverseCombineAllOption

1650[info] - Monoid[IO[Throwable, Int]].monoid.reverseRepeat1

1651[info] - Monoid[IO[Throwable, Int]].monoid.reverseRepeat2

1652[info] - Monoid[IO[Throwable, Int]].monoid.reverseReverses

1653[info] - Monoid[IO[Throwable, Int]].monoid.right identity

1654[info] - Bifunctor[IO[String, Int]].Bifunctor.Bifunctor Identity

1655[info] - Bifunctor[IO[String, Int]].Bifunctor.Bifunctor associativity

1656[info] - Bifunctor[IO[String, Int]].Bifunctor.Bifunctor leftMap Identity

1657[info] - Bifunctor[IO[String, Int]].Bifunctor.Bifunctor leftMap associativity

1658[info] monix.bio.TaskConversionsKSuite

1659[info] - Task.liftTo[CIO]

1660[info] - Task.liftToAsync[IO]

1661[info] - Task.liftToConcurrent[IO]

1662[info] - Task.liftFrom[IO]

1663[info] - Task.liftFromEffect[IO]

1664[info] - Task.liftFromConcurrentEffect[IO]

1665[info] monix.bio.tracing.StackTracedContextSuite

1666[info] - push traces

1667[info] - track omitted frames

1668[info] monix.bio.FiberDoctest

1669[info] - Fiber.scala:22: Fiber

1670[info] monix.bio.TaskMaterializeSuite

1671[info] - IO.now.materialize

1672[info] - IO.error.materialize

1673[info] - IO.terminate.materialize

1674[info] - IO.evalOnce.materialize should be stack safe

1675[info] - IO.eval.materialize

1676[info] - IO.defer.materialize

1677[info] - IO.defer.flatMap.materialize

1678[info] - IO.flatMap.materialize

1679[info] - IO.evalAsync.materialize

1680[info] - IO.evalAsync.flatMap.materialize

1681[info] - IO.evalAsync(error).flatMap.materialize

1682[info] - IO.now.flatMap(error).materialize

1683[info] - IO.defer(error).materialize

1684[info] - IO.deferTotal(error).materialize

1685[info] - IO.defer(error).flatMap.materialize

1686[info] - IO.now.dematerialize

1687[info] - IO.error.dematerialize

1688[info] - IO.materialize should be stack safe

1689[info] - IO.eval.materialize should work for failure

1690[info] - IO.eval.materialize should be stack safe

1691[info] - IO.now.materialize should work

1692[info] - IO.materialize on failing flatMap

1693[info] - IO.now.materialize should be stack safe

1694[info] - IO.raiseError.dematerialize

1695[info] - IO.terminate.dematerialize

1696[info] monix.bio.TaskBracketSuite

1697[info] - equivalence with onErrorHandleWith

1698[info] - equivalence with flatMap + redeemWith

1699[info] - equivalence with flatMap + redeemCauseWith

1700[info] - use is protected against user error

1701[info] - release is evaluated on success

1702[info] - release is evaluated on error

1703[info] - release is evaluated on terminal error

1704[info] - release is evaluated on cancel

1705[info] - if both use and release throw, report release error, signal use error

1706[info] - bracket works with auto-cancelable run-loops

1707[info] - bracket is stack safe (1)

1708[info] - bracket is stack safe (2)

1709[info] - bracket is stack safe (3)

1710[info] - bracket is stack safe (4)

1711[info] - use is not evaluated on cancel

1712[info] - cancel should wait for already started finalizers on success

1713[info] - cancel should wait for already started finalizers on failure

1714[info] - cancel should wait for already started use finalizers

1715[info] - second cancel should wait for use finalizers

1716[info] - second cancel during acquire should wait for it and finalizers to complete

1717[info] - second cancel during acquire should wait for it and finalizers to complete (non-terminating)

1718[info] - Multiple cancel should not hang

1719[info] - bracket can be canceled while failing to acquire

1720[info] - bracket can be canceled while terminating

1721[info] monix.bio.TaskBimapSuite

1722[info] - IO.bimap should map the success channel

1723[info] - IO.bimap should map the error channel

1724[info] monix.bio.TaskFlatMapSuite

1725[info] - runAsync flatMap loop is not cancelable if autoCancelableRunLoops=false

1726[info] - runAsync flatMap loop is cancelable if ExecutionModel permits

1727[info] - runAsync(callback) flatMap loop is cancelable if ExecutionModel permits

1728[info] - redeemWith derives flatMap

1729[info] - redeemWith derives onErrorHandleWith

1730[info] - redeem derives map . onErrorHandle

1731[info] - redeem derives onErrorHandle

1732[info] - redeemWith can recover

1733[info] - redeem can recover

1734[info] - >> is stack safe for infinite loops

1735[info] - flatMapLoop enables loops

1736[info] monix.bio.TaskMemoizeOnSuccessSuite

1737[info] - IO.memoizeOnSuccess should work asynchronously for first subscriber

1738[info] - IO.memoizeOnSuccess should work synchronously for next subscribers

1739[info] - IO.memoizeOnSuccess should be stack safe

1740[info] - IO.flatMap.memoizeOnSuccess should be stack safe, test 1

1741[info] - IO.flatMap.memoizeOnSuccess should be stack safe, test 2

1742[info] - IO.raiseError(error).memoizeOnSuccess should not be idempotent

1743[info] - IO.terminate(error).memoizeOnSuccess should not be idempotent

1744[info] - IO.memoizeOnSuccess.materialize

1745[info] - IO.raiseError(error).memoizeOnSuccess.materialize

1746[info] - IO.terminate(error).memoizeOnSuccess.materialize

1747[info] - IO.eval.memoizeOnSuccess should work for first subscriber

1748[info] - IO.eval.memoizeOnSuccess should work synchronously for next subscribers

1749[info] - IO.eval(error).memoizeOnSuccess should not be idempotent

1750[info] - IO.eval.memoizeOnSuccess

1751[info] - IO.eval.memoizeOnSuccess should be stack safe

1752[info] - IO.eval.flatMap.memoizeOnSuccess should be stack safe

1753[info] - IO.defer(evalAlways).memoizeOnSuccess

1754[info] - IO.evalOnce.memoizeOnSuccess should work for first subscriber

1755[info] - IO.evalOnce.memoizeOnSuccess should work synchronously for next subscribers

1756[info] - IO.evalOnce(error).memoizeOnSuccess should work

1757[info] - IO.evalOnce.memoizeOnSuccess should be stack safe

1758[info] - IO.evalOnce.flatMap.memoizeOnSuccess should be stack safe

1759[info] - IO.now.memoizeOnSuccess should work synchronously for first subscriber

1760[info] - IO.now.memoizeOnSuccess should work synchronously for next subscribers

1761[info] - IO.raiseError.memoizeOnSuccess should work

1762[info] - IO.terminate.memoizeOnSuccess should work

1763[info] - IO.now.memoizeOnSuccess should be stack safe

1764[info] - IO.now.flatMap.memoizeOnSuccess should be stack safe

1765[info] - IO.suspend.memoizeOnSuccess should be stack safe

1766[info] - IO.memoizeOnSuccess effects, sequential

1767[info] - IO.memoizeOnSuccess effects, parallel

1768[info] - IO.suspend.memoizeOnSuccess effects

1769[info] - IO.suspend.flatMap.memoizeOnSuccess effects

1770[info] - IO.memoizeOnSuccess should make subsequent subscribers wait for the result, as future

1771[info] - IO.memoizeOnSuccess should make subsequent subscribers wait for the result, as callback

1772[info] - IO.memoizeOnSuccess should be synchronous for subsequent subscribers, as callback

1773[info] - IO.memoizeOnSuccess should be cancellable (future)

1774[info] - IO.memoizeOnSuccess should be cancellable (callback #1)

1775[info] - IO.memoizeOnSuccess should be cancellable (callback #2)

1776[info] - IO.memoizeOnSuccess should not be cancelable

1777[info] - IO.evalAsync(error).memoizeOnSuccess can register multiple listeners

1778[info] - IO.evalOnce eq IO.evalOnce.memoizeOnSuccess

1779[info] - IO.eval.memoizeOnSuccess eq IO.eval.memoizeOnSuccess.memoizeOnSuccess

1780[info] - IO.eval.memoize eq IO.eval.memoize.memoizeOnSuccess

1781[info] - IO.eval.map.memoize eq IO.eval.map.memoize.memoizeOnSuccess

1782[info] - IO.now.memoizeOnSuccess eq IO.now

1783[info] - IO.raiseError.memoizeOnSuccess eq IO.raiseError

1784[info] - IO.terminate.memoizeOnSuccess eq IO.terminate

1785[info] monix.bio.TypeClassLawsForTaskAutoCancelableSuite

1786[info] - CoflatMap[Task].coflatMap.coflatMap associativity

1787[info] - CoflatMap[Task].coflatMap.coflatMap identity

1788[info] - CoflatMap[Task].coflatMap.coflatten coherence

1789[info] - CoflatMap[Task].coflatMap.coflatten throughMap

1790[info] - CoflatMap[Task].coflatMap.covariant composition

1791[info] - CoflatMap[Task].coflatMap.covariant identity

1792[info] - CoflatMap[Task].coflatMap.invariant composition

1793[info] - CoflatMap[Task].coflatMap.invariant identity

1794[info] - Concurrent[Task].concurrent.acquire and release of bracket are uncancelable

1795[info] - Concurrent[Task].concurrent.acquire of bracket is not cancelable

1796[info] - Concurrent[Task].concurrent.an action run concurrently with a pure value is the same as just doing that action

1797[info] - Concurrent[Task].concurrent.ap consistent with product + map

1798[info] - Concurrent[Task].concurrent.applicative homomorphism

1799[info] - Concurrent[Task].concurrent.applicative identity

1800[info] - Concurrent[Task].concurrent.applicative interchange

1801[info] - Concurrent[Task].concurrent.applicative map

1802[info] - Concurrent[Task].concurrent.applicative unit

1803[info] - Concurrent[Task].concurrent.applicativeError adaptError pure

1804[info] - Concurrent[Task].concurrent.applicativeError adaptError raise

1805[info] - Concurrent[Task].concurrent.applicativeError attempt consistent with attemptT

1806[info] - Concurrent[Task].concurrent.applicativeError attempt fromEither consistent with pure

1807[info] - Concurrent[Task].concurrent.applicativeError handle

1808[info] - Concurrent[Task].concurrent.applicativeError handleError . raiseError left-distributes over ap

1809[info] - Concurrent[Task].concurrent.applicativeError handleError . raiseError right-distributes over ap

1810[info] - Concurrent[Task].concurrent.applicativeError handleError consistent with recover

1811[info] - Concurrent[Task].concurrent.applicativeError handleError pure

1812[info] - Concurrent[Task].concurrent.applicativeError handleErrorWith consistent with recoverWith

1813[info] - Concurrent[Task].concurrent.applicativeError handleErrorWith pure

1814[info] - Concurrent[Task].concurrent.applicativeError handleWith

1815[info] - Concurrent[Task].concurrent.applicativeError onError pure

1816[info] - Concurrent[Task].concurrent.applicativeError onError raise

1817[info] - Concurrent[Task].concurrent.applicativeError pure attempt

1818[info] - Concurrent[Task].concurrent.applicativeError raiseError attempt

1819[info] - Concurrent[Task].concurrent.applicativeError recover consistent with recoverWith

1820[info] - Concurrent[Task].concurrent.applicativeError redeem is derived from attempt and map

1821[info] - Concurrent[Task].concurrent.apply composition

1822[info] - Concurrent[Task].concurrent.async can be derived from asyncF

1823[info] - Concurrent[Task].concurrent.async cancelable coherence

1824[info] - Concurrent[Task].concurrent.async cancelable receives cancel signal

1825[info] - Concurrent[Task].concurrent.async left is raiseError

1826[info] - Concurrent[Task].concurrent.async right is pure

1827[info] - Concurrent[Task].concurrent.asyncF registration can be cancelled

1828[info] - Concurrent[Task].concurrent.bind suspends evaluation

1829[info] - Concurrent[Task].concurrent.bracket is derived from bracketCase

1830[info] - Concurrent[Task].concurrent.bracket release is called on Completed or Error

1831[info] - Concurrent[Task].concurrent.bracket release is called on cancel

1832[info] - Concurrent[Task].concurrent.bracketCase with failure in acquisition remains failure

1833[info] - Concurrent[Task].concurrent.bracketCase with pure unit on release is eqv to map

1834[info] - Concurrent[Task].concurrent.bracketCase with pure unit on release is eqv to uncancelable(..).flatMap

1835[info] - Concurrent[Task].concurrent.covariant composition

1836[info] - Concurrent[Task].concurrent.covariant identity

1837[info] - Concurrent[Task].concurrent.delay constant is pure

1838[info] - Concurrent[Task].concurrent.flatMap associativity

1839[info] - Concurrent[Task].concurrent.flatMap consistent apply

1840[info] - Concurrent[Task].concurrent.flatMap from tailRecM consistency

1841[info] - Concurrent[Task].concurrent.guarantee is derived from bracket

1842[info] - Concurrent[Task].concurrent.guaranteeCase is derived from bracketCase

1843[info] - Concurrent[Task].concurrent.invariant composition

1844[info] - Concurrent[Task].concurrent.invariant identity

1845[info] - Concurrent[Task].concurrent.join is idempotent

1846[info] - Concurrent[Task].concurrent.map flatMap coherence

1847[info] - Concurrent[Task].concurrent.map suspends evaluation

1848[info] - Concurrent[Task].concurrent.map2/map2Eval consistency

1849[info] - Concurrent[Task].concurrent.map2/product-map consistency

1850[info] - Concurrent[Task].concurrent.monad left identity

1851[info] - Concurrent[Task].concurrent.monad right identity

1852[info] - Concurrent[Task].concurrent.monadError ensure consistency

1853[info] - Concurrent[Task].concurrent.monadError ensureOr consistency

1854[info] - Concurrent[Task].concurrent.monadError left zero

1855[info] - Concurrent[Task].concurrent.monadError redeemWith is derived from attempt and flatMap

1856[info] - Concurrent[Task].concurrent.monadError rethrow attempt

1857[info] - Concurrent[Task].concurrent.monoidal left identity

1858[info] - Concurrent[Task].concurrent.monoidal right identity

1859[info] - Concurrent[Task].concurrent.mproduct consistent flatMap

1860[info] - Concurrent[Task].concurrent.never is derived from async

1861[info] - Concurrent[Task].concurrent.onCancel is derived from guaranteeCase

1862[info] - Concurrent[Task].concurrent.productL consistent map2

1863[info] - Concurrent[Task].concurrent.productR consistent map2

1864[info] - Concurrent[Task].concurrent.propagate errors through bind (async)

1865[info] - Concurrent[Task].concurrent.propagate errors through bind (suspend)

1866[info] - Concurrent[Task].concurrent.race cancels both

1867[info] - Concurrent[Task].concurrent.race cancels loser

1868[info] - Concurrent[Task].concurrent.race mirrors left winner

1869[info] - Concurrent[Task].concurrent.race mirrors right winner

1870[info] - Concurrent[Task].concurrent.racePair can join left

1871[info] - Concurrent[Task].concurrent.racePair can join right

1872[info] - Concurrent[Task].concurrent.racePair cancels both

1873[info] - Concurrent[Task].concurrent.racePair cancels loser

1874[info] - Concurrent[Task].concurrent.racePair mirrors left winner

1875[info] - Concurrent[Task].concurrent.racePair mirrors right winner

1876[info] - Concurrent[Task].concurrent.release of bracket is not cancelable

1877[info] - Concurrent[Task].concurrent.repeated async evaluation not memoized

1878[info] - Concurrent[Task].concurrent.repeated asyncF evaluation not memoized

1879[info] - Concurrent[Task].concurrent.repeated sync evaluation not memoized

1880[info] - Concurrent[Task].concurrent.semigroupal associativity

1881[info] - Concurrent[Task].concurrent.stack-safe on bracket with left-associated binds

1882[info] - Concurrent[Task].concurrent.stack-safe on bracket with right-associated binds

1883[info] - Concurrent[Task].concurrent.stack-safe on guarantee with left-associated binds

1884[info] - Concurrent[Task].concurrent.stack-safe on guarantee with right-associated binds

1885[info] - Concurrent[Task].concurrent.stack-safe on left-associated binds

1886[info] - Concurrent[Task].concurrent.stack-safe on repeated attempts

1887[info] - Concurrent[Task].concurrent.stack-safe on repeated maps

1888[info] - Concurrent[Task].concurrent.stack-safe on right-associated binds

1889[info] - Concurrent[Task].concurrent.start then join is identity

1890[info] - Concurrent[Task].concurrent.start.flatMap(_.cancel) is unit

1891[info] - Concurrent[Task].concurrent.suspend constant is pure join

1892[info] - Concurrent[Task].concurrent.tailRecM consistent flatMap

1893[info] - Concurrent[Task].concurrent.tailRecM stack safety

1894[info] - Concurrent[Task].concurrent.throw in delay is raiseError

1895[info] - Concurrent[Task].concurrent.throw in suspend is raiseError

1896[info] - Concurrent[Task].concurrent.uncancelable mirrors source

1897[info] - Concurrent[Task].concurrent.uncancelable prevents Cancelled case

1898[info] - Concurrent[Task].concurrent.uncancelable prevents cancellation

1899[info] - Concurrent[Task].concurrent.unsequenced delay is no-op

1900[info] - ConcurrentEffect[Task].concurrentEffect.acquire and release of bracket are uncancelable

1901[info] - ConcurrentEffect[Task].concurrentEffect.acquire of bracket is not cancelable

1902[info] - ConcurrentEffect[Task].concurrentEffect.an action run concurrently with a pure value is the same as just doing that action

1903[info] - ConcurrentEffect[Task].concurrentEffect.ap consistent with product + map

1904[info] - ConcurrentEffect[Task].concurrentEffect.applicative homomorphism

1905[info] - ConcurrentEffect[Task].concurrentEffect.applicative identity

1906[info] - ConcurrentEffect[Task].concurrentEffect.applicative interchange

1907[info] - ConcurrentEffect[Task].concurrentEffect.applicative map

1908[info] - ConcurrentEffect[Task].concurrentEffect.applicative unit

1909[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError adaptError pure

1910[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError adaptError raise

1911[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError attempt consistent with attemptT

1912[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError attempt fromEither consistent with pure

1913[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError handle

1914[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError handleError . raiseError left-distributes over ap

1915[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError handleError . raiseError right-distributes over ap

1916[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError handleError consistent with recover

1917[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError handleError pure

1918[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError handleErrorWith consistent with recoverWith

1919[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError handleErrorWith pure

1920[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError handleWith

1921[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError onError pure

1922[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError onError raise

1923[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError pure attempt

1924[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError raiseError attempt

1925[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError recover consistent with recoverWith

1926[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError redeem is derived from attempt and map

1927[info] - ConcurrentEffect[Task].concurrentEffect.apply composition

1928[info] - ConcurrentEffect[Task].concurrentEffect.async can be derived from asyncF

1929[info] - ConcurrentEffect[Task].concurrentEffect.async cancelable coherence

1930[info] - ConcurrentEffect[Task].concurrentEffect.async cancelable receives cancel signal

1931[info] - ConcurrentEffect[Task].concurrentEffect.async left is raiseError

1932[info] - ConcurrentEffect[Task].concurrentEffect.async right is pure

1933[info] - ConcurrentEffect[Task].concurrentEffect.asyncF registration can be cancelled

1934[info] - ConcurrentEffect[Task].concurrentEffect.bind suspends evaluation

1935[info] - ConcurrentEffect[Task].concurrentEffect.bracket is derived from bracketCase

1936[info] - ConcurrentEffect[Task].concurrentEffect.bracket release is called on Completed or Error

1937[info] - ConcurrentEffect[Task].concurrentEffect.bracket release is called on cancel

1938[info] - ConcurrentEffect[Task].concurrentEffect.bracketCase with failure in acquisition remains failure

1939[info] - ConcurrentEffect[Task].concurrentEffect.bracketCase with pure unit on release is eqv to map

1940[info] - ConcurrentEffect[Task].concurrentEffect.bracketCase with pure unit on release is eqv to uncancelable(..).flatMap

1941[info] - ConcurrentEffect[Task].concurrentEffect.covariant composition

1942[info] - ConcurrentEffect[Task].concurrentEffect.covariant identity

1943[info] - ConcurrentEffect[Task].concurrentEffect.delay constant is pure

1944[info] - ConcurrentEffect[Task].concurrentEffect.flatMap associativity

1945[info] - ConcurrentEffect[Task].concurrentEffect.flatMap consistent apply

1946[info] - ConcurrentEffect[Task].concurrentEffect.flatMap from tailRecM consistency

1947[info] - ConcurrentEffect[Task].concurrentEffect.guarantee is derived from bracket

1948[info] - ConcurrentEffect[Task].concurrentEffect.guaranteeCase is derived from bracketCase

1949[info] - ConcurrentEffect[Task].concurrentEffect.invariant composition

1950[info] - ConcurrentEffect[Task].concurrentEffect.invariant identity

1951[info] - ConcurrentEffect[Task].concurrentEffect.join is idempotent

1952[info] - ConcurrentEffect[Task].concurrentEffect.map flatMap coherence

1953[info] - ConcurrentEffect[Task].concurrentEffect.map suspends evaluation

1954[info] - ConcurrentEffect[Task].concurrentEffect.map2/map2Eval consistency

1955[info] - ConcurrentEffect[Task].concurrentEffect.map2/product-map consistency

1956[info] - ConcurrentEffect[Task].concurrentEffect.monad left identity

1957[info] - ConcurrentEffect[Task].concurrentEffect.monad right identity

1958[info] - ConcurrentEffect[Task].concurrentEffect.monadError ensure consistency

1959[info] - ConcurrentEffect[Task].concurrentEffect.monadError ensureOr consistency

1960[info] - ConcurrentEffect[Task].concurrentEffect.monadError left zero

1961[info] - ConcurrentEffect[Task].concurrentEffect.monadError redeemWith is derived from attempt and flatMap

1962[info] - ConcurrentEffect[Task].concurrentEffect.monadError rethrow attempt

1963[info] - ConcurrentEffect[Task].concurrentEffect.monoidal left identity

1964[info] - ConcurrentEffect[Task].concurrentEffect.monoidal right identity

1965[info] - ConcurrentEffect[Task].concurrentEffect.mproduct consistent flatMap

1966[info] - ConcurrentEffect[Task].concurrentEffect.never is derived from async

1967[info] - ConcurrentEffect[Task].concurrentEffect.onCancel is derived from guaranteeCase

1968[info] - ConcurrentEffect[Task].concurrentEffect.productL consistent map2

1969[info] - ConcurrentEffect[Task].concurrentEffect.productR consistent map2

1970[info] - ConcurrentEffect[Task].concurrentEffect.propagate errors through bind (async)

1971[info] - ConcurrentEffect[Task].concurrentEffect.propagate errors through bind (suspend)

1972[info] - ConcurrentEffect[Task].concurrentEffect.race cancels both

1973[info] - ConcurrentEffect[Task].concurrentEffect.race cancels loser

1974[info] - ConcurrentEffect[Task].concurrentEffect.race mirrors left winner

1975[info] - ConcurrentEffect[Task].concurrentEffect.race mirrors right winner

1976[info] - ConcurrentEffect[Task].concurrentEffect.racePair can join left

1977[info] - ConcurrentEffect[Task].concurrentEffect.racePair can join right

1978[info] - ConcurrentEffect[Task].concurrentEffect.racePair cancels both

1979[info] - ConcurrentEffect[Task].concurrentEffect.racePair cancels loser

1980[info] - ConcurrentEffect[Task].concurrentEffect.racePair mirrors left winner

1981[info] - ConcurrentEffect[Task].concurrentEffect.racePair mirrors right winner

1982[info] - ConcurrentEffect[Task].concurrentEffect.release of bracket is not cancelable

1983[info] - ConcurrentEffect[Task].concurrentEffect.repeated async evaluation not memoized

1984[info] - ConcurrentEffect[Task].concurrentEffect.repeated asyncF evaluation not memoized

1985[info] - ConcurrentEffect[Task].concurrentEffect.repeated callback ignored

1986[info] - ConcurrentEffect[Task].concurrentEffect.repeated sync evaluation not memoized

1987[info] - ConcurrentEffect[Task].concurrentEffect.runAsync ignores error in handler

1988[info] - ConcurrentEffect[Task].concurrentEffect.runAsync pure produces right IO

1989[info] - ConcurrentEffect[Task].concurrentEffect.runAsync raiseError produces left IO

1990[info] - ConcurrentEffect[Task].concurrentEffect.runAsync runCancelable coherence

1991[info] - ConcurrentEffect[Task].concurrentEffect.runCancelable is synchronous

1992[info] - ConcurrentEffect[Task].concurrentEffect.runCancelable start.flatMap(_.cancel) coherence

1993[info] - ConcurrentEffect[Task].concurrentEffect.semigroupal associativity

1994[info] - ConcurrentEffect[Task].concurrentEffect.stack-safe on bracket with left-associated binds

1995[info] - ConcurrentEffect[Task].concurrentEffect.stack-safe on bracket with right-associated binds

1996[info] - ConcurrentEffect[Task].concurrentEffect.stack-safe on guarantee with left-associated binds

1997[info] - ConcurrentEffect[Task].concurrentEffect.stack-safe on guarantee with right-associated binds

1998[info] - ConcurrentEffect[Task].concurrentEffect.stack-safe on left-associated binds

1999[info] - ConcurrentEffect[Task].concurrentEffect.stack-safe on repeated attempts

2000[info] - ConcurrentEffect[Task].concurrentEffect.stack-safe on repeated maps

2001[info] - ConcurrentEffect[Task].concurrentEffect.stack-safe on right-associated binds

2002[info] - ConcurrentEffect[Task].concurrentEffect.start then join is identity

2003[info] - ConcurrentEffect[Task].concurrentEffect.start.flatMap(_.cancel) is unit

2004[info] - ConcurrentEffect[Task].concurrentEffect.suspend constant is pure join

2005[info] - ConcurrentEffect[Task].concurrentEffect.tailRecM consistent flatMap

2006[info] - ConcurrentEffect[Task].concurrentEffect.tailRecM stack safety

2007[info] - ConcurrentEffect[Task].concurrentEffect.throw in delay is raiseError

2008[info] - ConcurrentEffect[Task].concurrentEffect.throw in suspend is raiseError

2009[info] - ConcurrentEffect[Task].concurrentEffect.toIO is consistent with runAsync

2010[info] - ConcurrentEffect[Task].concurrentEffect.toIO is consistent with runCancelable

2011[info] - ConcurrentEffect[Task].concurrentEffect.toIO is the inverse of liftIO

2012[info] - ConcurrentEffect[Task].concurrentEffect.toIO stack safety

2013[info] - ConcurrentEffect[Task].concurrentEffect.uncancelable mirrors source

2014[info] - ConcurrentEffect[Task].concurrentEffect.uncancelable prevents Cancelled case

2015[info] - ConcurrentEffect[Task].concurrentEffect.uncancelable prevents cancellation

2016[info] - ConcurrentEffect[Task].concurrentEffect.unsequenced delay is no-op

2017[info] - CommutativeApplicative[IO.Par].commutative applicative.ap consistent with product + map

2018[info] - CommutativeApplicative[IO.Par].commutative applicative.applicative homomorphism

2019[info] - CommutativeApplicative[IO.Par].commutative applicative.applicative identity

2020[info] - CommutativeApplicative[IO.Par].commutative applicative.applicative interchange

2021[info] - CommutativeApplicative[IO.Par].commutative applicative.applicative map

2022[info] - CommutativeApplicative[IO.Par].commutative applicative.applicative unit

2023[info] - CommutativeApplicative[IO.Par].commutative applicative.apply commutativity

2024[info] - CommutativeApplicative[IO.Par].commutative applicative.apply composition

2025[info] - CommutativeApplicative[IO.Par].commutative applicative.covariant composition

2026[info] - CommutativeApplicative[IO.Par].commutative applicative.covariant identity

2027[info] - CommutativeApplicative[IO.Par].commutative applicative.invariant composition

2028[info] - CommutativeApplicative[IO.Par].commutative applicative.invariant identity

2029[info] - CommutativeApplicative[IO.Par].commutative applicative.map2/map2Eval consistency

2030[info] - CommutativeApplicative[IO.Par].commutative applicative.map2/product-map consistency

2031[info] - CommutativeApplicative[IO.Par].commutative applicative.monoidal left identity

2032[info] - CommutativeApplicative[IO.Par].commutative applicative.monoidal right identity

2033[info] - CommutativeApplicative[IO.Par].commutative applicative.productL consistent map2

2034[info] - CommutativeApplicative[IO.Par].commutative applicative.productR consistent map2

2035[info] - CommutativeApplicative[IO.Par].commutative applicative.semigroupal associativity

2036[info] - Parallel[IO, IO.Par].parallel.isomorphic functor

2037[info] - Parallel[IO, IO.Par].parallel.isomorphic pure

2038[info] - Parallel[IO, IO.Par].parallel.parallel round trip

2039[info] - Parallel[IO, IO.Par].parallel.sequential round trip

2040[info] - Monoid[IO[String, Int]].monoid.associative

2041[info] - Monoid[IO[String, Int]].monoid.collect0

2042[info] - Monoid[IO[String, Int]].monoid.combine all

2043[info] - Monoid[IO[String, Int]].monoid.combineAllOption

2044[info] - Monoid[IO[String, Int]].monoid.intercalateCombineAllOption

2045[info] - Monoid[IO[String, Int]].monoid.intercalateIntercalates

2046[info] - Monoid[IO[String, Int]].monoid.intercalateRepeat1

2047[info] - Monoid[IO[String, Int]].monoid.intercalateRepeat2

2048[info] - Monoid[IO[String, Int]].monoid.is id

2049[info] - Monoid[IO[String, Int]].monoid.left identity

2050[info] - Monoid[IO[String, Int]].monoid.repeat0

2051[info] - Monoid[IO[String, Int]].monoid.repeat1

2052[info] - Monoid[IO[String, Int]].monoid.repeat2

2053[info] - Monoid[IO[String, Int]].monoid.reverseCombineAllOption

2054[info] - Monoid[IO[String, Int]].monoid.reverseRepeat1

2055[info] - Monoid[IO[String, Int]].monoid.reverseRepeat2

2056[info] - Monoid[IO[String, Int]].monoid.reverseReverses

2057[info] - Monoid[IO[String, Int]].monoid.right identity

2058[info] - SemigroupK[Task[Int]].semigroupK.semigroupK associative

2059[info] - Bifunctor[IO[String, Int]].Bifunctor.Bifunctor Identity

2060[info] - Bifunctor[IO[String, Int]].Bifunctor.Bifunctor associativity

2061[info] - Bifunctor[IO[String, Int]].Bifunctor.Bifunctor leftMap Identity

2062[info] - Bifunctor[IO[String, Int]].Bifunctor.Bifunctor leftMap associativity

2063[info] monix.bio.TaskCreateSuite

2064[info] - can use Unit as return type

2065[info] - can use Cancelable.empty as return type

2066[info] - returning Unit yields non-cancelable tasks

2067[info] - can use Cancelable as return type

2068[info] - returning Cancelable yields a cancelable task

2069[info] - can use CIO[Unit] as return type

2070[info] - returning CIO[Unit] yields a cancelable task

2071[info] - can use IO[E, Unit] as return type

2072[info] - returning IO[E, Unit] yields a cancelable task

2073[info] - throwing error when returning Unit

2074[info] - throwing error when returning Cancelable

2075[info] monix.bio.TaskParTraverseSuite

2076[info] - IO.parTraverse should execute in parallel for async tasks

2077[info] - IO.parTraverse should onError if one of the tasks terminates in error

2078[info] - IO.parTraverse should onTerminate if one of the tasks terminates in unexpected error

2079[info] - IO.parTraverse should be canceled

2080[info] - IO.parTraverse should be stack safe for synchronous tasks

2081[info] - IO.parTraverse runAsync multiple times

2083[info] monix.bio.TaskCallbackSuite

2084[info] - onValue should invoke onSuccess

2085[info] - apply Success(Right(value)) should invoke onSuccess

2086[info] - apply Success(Left(value)) should invoke onError

2087[info] - apply Failure(ex) should invoke onTermination

2088[info] - contramap should pipe onError

2089[info] - contramap should invoke function before invoking callback

2090[info] - BiCallback.fromPromise (success)

2091[info] - BiCallback.fromPromise (failure)

2092[info] - BiCallback.fromPromise (terminal failure)

2093[info] - BiCallback.fromPromise(Cause) (terminal failure)

2094[info] - BiCallback.empty reports errors

2095[info] - BiCallback.empty reports terminal errors

2096[info] - BiCallback.safe protects against errors in onSuccess

2097[info] - BiCallback.safe protects against errors in onError

2098[info] - BiCallback.safe protects against errors in onTermination

2099[info] - callback(Right(a))

2100[info] - callback(Left(e))

2101[info] - callback(Left(ex))

2102[info] - fromAttempt success

2103[info] - fromAttempt error

2104[info] - fromAttempt termination

2105[info] monix.bio.TaskRejectedExecutionSuite

2107[info] monix.bio.TaskErrorSuite

2108[info] - IO.attempt should expose typed error

2109[info] - IO.attempt should not expose unexpected error

2110[info] - IO.attempt should work for successful values

2111[info] - IO.rethrow should turn Left to typed error

2112[info] - IO.rethrow should turn Right to success value

2113[info] - IO.failed should expose typed error

2114[info] - IO.failed should fail for unexpected error

2115[info] - IO.failed should fail for successful values

2116[info] - IO#onErrorRecover should mirror source on success

2117[info] - IO#onErrorRecover should recover typed error

2118[info] - IO#onErrorRecover should not recover unexpected error

2119[info] - IO#onErrorRecover should protect against user code

2120[info] - IO#onErrorHandle should mirror source on success

2121[info] - IO#onErrorHandle should recover typed error

2122[info] - IO#onErrorHandle should not recover unexpected error

2123[info] - IO#onErrorHandle should protect against user code

2124[info] - IO.onErrorFallbackTo should mirror source onSuccess

2125[info] - IO.onErrorFallbackTo should fallback to backup onError

2126[info] - IO.onErrorFallbackTo should not fallback to backup onTermination

2127[info] - IO.onErrorFallbackTo should protect against user code

2128[info] - IO.onErrorFallbackTo should be cancelable if the ExecutionModel allows it

2129[info] - IO.onErrorRestart should mirror the source onSuccess

2130[info] - IO.onErrorRestart should retry onError

2131[info] - IO.onErrorRestart should emit onError after max retries

2132[info] - IO.onErrorRestart should be cancelable if ExecutionModel permits

2133[info] - IO.onErrorRestart should not restart on terminate error

2134[info] - IO.onErrorRestartIf should mirror the source onSuccess

2135[info] - IO.onErrorRestartIf should retry onError

2136[info] - IO.onErrorRestartIf should emit onError

2137[info] - IO.onErrorRestartIf should be cancelable if ExecutionModel permits

2138[info] - IO.onErrorRestartIf should not restart on terminate error

2139[info] - IO.onErrorRestartIf should restart on typed error

2140[info] - IO#onErrorRecoverWith should mirror source on success

2141[info] - IO#onErrorRecoverWith should recover

2146[info] - IO#onErrorRecoverWith should protect against user code

2147[info] - IO#onErrorRecoverWith has a cancelable fallback

2148[info] - IO#onErrorRecover should emit error if not matches

2149[info] - IO#onErrorRecoverWith should emit error if not matches

2150[info] - IO.eval.flatMap.redeemCauseWith should work

2151[info] - IO.evalAsync.flatMap.redeemCauseWith should work

2152[info] - IO.now.onErrorRecoverWith should be stack safe

2153[info] - onErrorRecoverWith should be stack safe for loop with executeAsync boundaries

2154[info] - Task.onErrorRestartLoop works for success

2155[info] - Task.onErrorRestartLoop can throw different error

2156[info] - Task.onErrorRestartLoop can rethrow

2157[info] monix.bio.IOParZipSuite

2158[info] - IO.parZip2 should work if source finishes first

2159[info] - IO.parZip2 should work if other finishes first

2160[info] - IO.parZip2 should cancel both

2161[info] - IO.parZip2 should cancel just the source

2162[info] - IO.parZip2 should cancel just the other

2163[info] - IO.parZip2 should onError from the source before other

2164[info] - IO.parZip2 handle terminal errors from the source before other

2165[info] - IO.parZip2 should onError from the other after the source

2166[info] - IO.parZip2 should handle terminal errors from the other after the source

2167[info] - IO.parZip2 should onError from the other before the source

2168[info] - IO.parZip2 works

2169[info] - IO.map2 works

2170[info] - IO#map2 should protect against user code

2171[info] - IO.map2 runs effects in strict sequence

2172[info] - IO.parMap2 works

2173[info] - IO#parMap2 should protect against user code

2174[info] - IO.parZip3 works

2175[info] - IO#map3 works

2176[info] - IO#parMap3 works

2177[info] - IO.parZip4 works

2178[info] - IO#map4 works

2179[info] - IO#parMap4 works

2180[info] - IO.parZip5 works

2181[info] - IO#map5 works

2182[info] - IO#parMap5 works

2183[info] - IO.parZip6 works

2184[info] - IO#map6 works

2185[info] - IO#parMap6 works

2186[info] monix.bio.TaskParSequenceUnorderedSuite

2187[info] - IO.parSequenceUnordered should execute in parallel

2188[info] - IO.parSequenceUnordered should onError if one of the tasks terminates in error

2189[info] - IO.parSequenceUnordered should onTerminate if one of the tasks terminates in a fatal error

2190[info] - IO.parSequenceUnordered should be canceled

2191[info] - IO.parSequenceUnordered should run over an iterable

2192[info] - IO.parSequenceUnordered should be stack-safe on handling many tasks

2193[info] - IO.parSequenceUnordered should be stack safe on success

2194[info] - IO.parSequenceUnordered should log errors if multiple errors happen

2195[info] - IO.parSequenceUnordered should log terminal errors if multiple errors happen

2196[info] - IO.parSequenceUnordered runAsync multiple times

2197[info] monix.bio.TaskSequenceSuite

2198[info] - IO.sequence should not execute in parallel

2199[info] - IO.sequence should onError if one of the tasks terminates in error

2200[info] - IO.sequence should onTerminate if one of the tasks terminates in error

2201[info] - IO.sequence should be canceled

2202[info] monix.bio.TaskParTraverseNSuite

2203[info] - IO.parTraverseN allows fully sequential execution

2204[info] - IO.parTraverseN allows fully concurrent execution

2205[info] - IO.parTraverseN allows partially concurrent execution

2206[info] - IO.parTraverseN returns an error when fully sequential execution fails in a typed way

2207[info] - IO.parTraverseN returns an error when fully sequential execution fails in a terminal way

2208[info] - IO.parTraverseN returns an error when fully concurrent execution fails in a typed way

2209[info] - IO.parTraverseN returns an error when fully concurrent execution fails in a terminal way

2210[info] - IO.parTraverseN returns an error when partially concurrent execution fails in a typed way

2211[info] - IO.parTraverseN returns an error when partially concurrent execution fails in a terminal way

2213[info] - IO.parTraverseN should be cancelable

2214[info] - IO.parTraverseN should be stack safe for synchronous tasks with low parallelism

2215[info] - IO.parTraverseN should be stack safe for asynchronous tasks with low parallelism

2216[info] - IO.parTraverseN should be stack safe for synchronous tasks with high parallelism

2217[info] - IO.parTraverseN should be stack safe for asynchronous tasks with high parallelism

2218[info] - IO.parTraverseN allows running the same effect multiple times

2219[info] - IO.parTraverseN allows reusing a memoized effect multiple times

2220[info] monix.bio.TaskLikeConversionsJava8Suite

2221[info] - IO.from converts successful CompletableFuture

2222[info] - IO.from converts failed CompletableFuture

2223[info] - IO.from preserves cancellability of CompletableFuture

2224Hello World!

2225Cancelling!

2226Received: $value

2227Hello!

2228Hello!

2229Success: 42

2230[info] monix.bio.IODoctest

2231[info] - IO.scala:52: IO

2232[info] - IO.scala:474: runToFuture

2233[info] - IO.scala:541: runToFutureOpt

2234[info] - IO.scala:586: runAsync

2235[info] - IO.scala:661: runAsyncOpt

2236[info] - IO.scala:716: runAsyncF

2237[info] - IO.scala:821: runAsyncAndForget

2238[info] - IO.scala:874: runAsyncUncancelable

2239[info] - IO.scala:947: runSyncStep

2240[info] - IO.scala:1011: runSyncUnsafe

2241[info] - IO.scala:1116: memoize

2242[info] - IO.scala:1155: memoizeOnSuccess

2243[info] - IO.scala:1213: >>

2244[info] - IO.scala:1226: *>

2245[info] - IO.scala:1242: <*

2246[info] - IO.scala:1257: asyncBoundary

2247[info] - IO.scala:1306: asyncBoundary

2248[info] - IO.scala:1337: bracket

2249[info] - IO.scala:1525: delayExecution

2250[info] - IO.scala:1554: delayResult

2251[info] - IO.scala:1595: executeOn

2252[info] - IO.scala:1730: executeAsync

2253[info] - IO.scala:1756: executeWithModel

2254[info] - IO.scala:1774: executeWithOptions

2255[info] - IO.scala:1801: flip

2256[info] - IO.scala:1831: flipWith

2257[info] - IO.scala:1879: flatMapLoop

2258[info] - IO.scala:1937: loopForever

2259[info] - IO.scala:2008: onCancelRaiseError

2260[info] - IO.scala:2062: mapErrorPartialWith

2261[info] - IO.scala:2113: tapError

2262[info] - IO.scala:2147: onErrorRestartIf

2263[info] - IO.scala:2167: onErrorRestartLoop

2264[info] - IO.scala:2242: mapError

2265[info] - IO.scala:2261: mapErrorPartial

2266[info] - IO.scala:2296: start

2267[info] - IO.scala:2324: to

2268[info] - IO.scala:2366: toConcurrent

2269[info] - IO.scala:2412: toAsync

2270[info] - IO.scala:2536: uncancelable

2271[info] - IO.scala:2559: timed

2272[info] - IO.scala:2608: timeoutToL

2273[info] - IO.scala:2663: hideErrors

2274[info] - IO.scala:2684: hideErrorsWith

2275[info] - IO.scala:2740: absorb

2276[info] - IO.scala:2758: absorbWith

2277[info] - IO.scala:2782: IO

2278[info] - IO.scala:2843: apply

2279[info] - IO.scala:2905: deferAction

2280[info] - IO.scala:2932: deferFuture

2281[info] - IO.scala:2945: deferFutureAction

2282[info] - IO.scala:3082: fromConcurrentEffect

2283[info] - IO.scala:3119: fromEffect

2284[info] - IO.scala:3149: fromOption

2285[info] - IO.scala:3165: fromOption

2286[info] - IO.scala:3185: fromOptionEval

2287[info] - IO.scala:3243: async

2288[info] - IO.scala:3303: async0

2289[info] - IO.scala:3399: cancelable

2290[info] - IO.scala:3479: cancelable0

2291[info] - IO.scala:3581: cancelBoundary

2292[info] - IO.scala:3617: create

2293[info] - IO.scala:3724: race

2294[info] - IO.scala:3757: raceMany

2295[info] - IO.scala:3778: racePair

2296[info] - IO.scala:3861: sleep

2297[info] - IO.scala:3952: parSequence

2298[info] - IO.scala:4011: parSequenceN

2299[info] - IO.scala:4042: parTraverseN

2300[info] - IO.scala:4079: parSequenceUnordered

2301[info] - IO.scala:4127: mapBoth

2302[info] - IO.scala:4146: map2

2303[info] - IO.scala:4175: map3

2304[info] - IO.scala:4205: map4

2305[info] - IO.scala:4238: map5

2306[info] - IO.scala:4276: map6

2307[info] - IO.scala:4316: parMap2

2308[info] - IO.scala:4351: parMap3

2309[info] - IO.scala:4389: parMap4

2310[info] - IO.scala:4430: parMap5

2311[info] - IO.scala:4476: parMap6

2312[info] - IO.scala:4562: liftTo

2313[info] - IO.scala:4622: liftFrom

2314[info] - IO.scala:5282: catsParallel

2315[info] monix.bio.TaskExecuteOnSuite

2316[info] - executeOn(forceAsync = false)

2317[info] - executeOn(forceAsync = true)

2318[info] - executeOn(forceAsync = false) is stack safe in flatMap loops, test 1

2319[info] - executeOn(forceAsync = false) is stack safe in flatMap loops, test 2

2320[info] - local.write.executeOn(forceAsync = false) works

2321[info] - local.write.executeOn(forceAsync = true) works

2322[info] monix.bio.TaskParTraverseUnorderedSuite

2323[info] - IO.parTraverseUnordered should execute in parallel

2324[info] - IO.parTraverseUnordered should onError if one of the tasks terminates in error

2325[info] - IO.parTraverseUnordered should be canceled

2326[info] - IO.parTraverseUnordered should run over an iterable

2327[info] - IO.parTraverseUnordered should be stack-safe on handling many tasks

2328[info] - IO.parTraverseUnordered should be stack safe on success

2329[info] - IO.parTraverseUnordered should log errors if multiple errors happen

2330[info] - IO.parTraverseUnordered runAsync multiple times

2332[info] monix.bio.TaskEvalAsyncSuite

2333[info] - IO.evalAsync should work, on different thread

2334[info] - IO.evalAsync should protect against user code errors

2335[info] - UIO.evalAsync should protect against user code errors

2336[info] - IO.evalAsync is equivalent with IO.eval

2337[info] - IO.evalAsync is equivalent with IO.evalOnce on first run

2338[info] - IO.evalAsync.flatMap should protect against user code

2339[info] - IO.evalAsync should be tail recursive

2340[info] - IO.evalAsync.flatten is equivalent with flatMap

2341[info] - IO.evalAsync.coeval

2342[info] monix.bio.TaskConversionsSuite

2343[info] - IO.now(value).to[CIO]

2344[info] - IO.eval(thunk).to[CIO]

2345[info] - IO.eval(thunk).executeAsync.to[CIO]

2346[info] - IO.evalTotal(thunk).to[CIO]

2347[info] - IO.evalTotal(thunk).executeAsync.to[CIO]

2348[info] - IO.raiseError(dummy).to[CIO]

2349[info] - IO.raiseError(dummy).executeAsync.to[CIO]

2350[info] - IO.terminate(dummy).to[CIO]

2351[info] - IO.terminate(dummy).executeAsync.to[CIO]

2352[info] - IO.toAsync converts successful tasks

2353[info] - IO.toAsync converts tasks with typed errors

2354[info] - IO.toAsync converts tasks with terminal errors

2355[info] - IO.toConcurrent converts successful tasks

2356[info] - IO.toConcurrent converts tasks with typed errors

2357[info] - IO.toConcurrent converts tasks with terminal errors

2358[info] - IO.fromEffect(task)) <-> task

2359[info] - IO.fromEffect(task.toAsync[Task]) <-> task

2360[info] - IO.fromEffect(task.toAsync[CIO]) <-> task

2361[info] - IO.fromEffect(task.toAsync[F]) <-> task

2362[info] - IO.fromEffect converts `IO`

2363[info] - IO.fromEffect converts valid custom effects

2364[info] - IO.fromEffect doesn't convert invalid custom effects

2365[info] - IO.fromEffect(task.toConcurrent[IO]) preserves cancellability

2366[info] - IO.fromConcurrentEffect(task) <-> task

2367[info] - IO.fromConcurrentEffect(task.toConcurrent[Task]) <-> task

2368[info] - IO.fromConcurrentEffect(task.toConcurrent[IO]) <-> task

2369[info] - IO.fromConcurrentEffect(task.toConcurrent[F]) <-> task

2370[info] - IO.fromConcurrentEffect converts `IO`

2371[info] - IO.fromConcurrentEffect converts valid custom effects

2372[info] - IO.fromConcurrentEffect doesn't convert invalid custom effects

2373[info] - IO.fromConcurrentEffect preserves cancellability of an `IO`

2374[info] - IO.fromConcurrentEffect preserves cancellability of a custom effect

2375[info] - IO.fromConcurrentEffect(task.toConcurrent[IO]) preserves cancellability

2376[info] - IO.fromConcurrentEffect(task.toConcurrent[CIO]) preserves cancellability

2377[info] - IO.fromReactivePublisher converts `.onNext` callbacks

2378[info] - IO.fromReactivePublisher converts `.onComplete` callbacks

2379[info] - IO.fromReactivePublisher converts `.onError` callbacks

2380[info] - IO.fromReactivePublisher protects against user errors

2381[info] - IO.fromReactivePublisher is cancelable

2382[info] - IO.fromReactivePublisher <-> Task

2383[info] monix.bio.TaskDeferActionSuite

2384[info] - IO.deferAction works

2385[info] - IO.deferAction works for failed tasks

2386[info] - IO.deferAction protects against user error

2387[info] - IO.deferAction should properly cast errors

2388[info] - IO.deferAction is stack safe

2389[info] - IO.deferAction(local.write) works

2390[info] monix.bio.TaskNowSuite

2391[info] - IO.now should work synchronously

2392[info] - IO.now.runAsync: CancelableFuture should be synchronous for AlwaysAsyncExecution

2393[info] - IO.now.runAsync(callback) should work synchronously

2394[info] - IO.now.runAsync(callback) should be asynchronous for AlwaysAsyncExecution

2395[info] - IO.raiseError should work synchronously

2396[info] - IO.terminate should work synchronously

2397[info] - IO.raiseError.runAsync: CancelableFuture should be synchronous for AlwaysAsyncExecution

2398[info] - IO.raiseError.runAsync(callback) should work synchronously

2399[info] - IO.raiseError.runAsync(callback) should be asynchronous for AlwaysAsyncExecution

2400[info] - IO.now.map should work

2401[info] - IO.raiseError.map should be the same as IO.raiseError

2402[info] - IO.raiseError.flatMap should be the same as IO.flatMap

2403[info] - IO.raiseError.flatMap should be protected

2404[info] - IO.now.flatMap should protect against user code

2405[info] - IO.now.flatMap should be tail recursive

2406[info] - IO.now should not be cancelable

2407[info] - IO.raiseError should not be cancelable

2408[info] - IO.terminate should not be cancelable

2409[info] - IO.now.runSyncStep

2410[info] - IO.raiseError.runSyncStep

2411[info] monix.bio.TaskGuaranteeSuite

2412[info] - finalizer is evaluated on success

2413[info] - finalizer is evaluated on error

2414[info] - finalizer is evaluated on terminal error

2415[info] - if finalizer throws, report finalizer error and signal use error

2416[info] - finalizer is evaluated on cancelation (1)

2417[info] - finalizer is evaluated on cancellation (2)

2418[info] - stack-safety (1)

2419[info] - stack-safety (2)

2420[info] - stack-safety (3)

2421[info] monix.bio.TaskRaceSuite

2422[info] - IO.raceMany returns fastest success

2423[info] - IO.raceMany returns fastest typed error

2424[info] - IO.raceMany returns fastest terminal error

2425[info] - IO.raceMany returns success that is faster than typed error

2426[info] - IO.raceMany returns success that is faster than terminal error

2427[info] - IO.raceMany returns typed error that is faster than success

2428[info] - IO.raceMany returns typed error that is faster than fatal error

2429[info] - IO.raceMany returns fatal error that is faster than success

2430[info] - IO.raceMany returns fatal error that is faster than typed error

2431[info] - IO.raceMany should allow cancelling all tasks

2432[info] - IO.raceMany should be stack safe for sync values

2433[info] - IO.raceMany should be stack safe for async values

2434[info] - IO.raceMany has a stack safe cancelable

2435[info] - IO#timeout should timeout

2436[info] - IO#timeout should mirror the source in case of success

2437[info] - IO#timeout should mirror the source in case of error

2438[info] - IO#timeout should mirror the source in case of terminal error

2439[info] - IO#timeout should cancel both the source and the timer

2440[info] - IO#timeout with backup should timeout

2441[info] - IO#timeout with backup should timeout with error

2442[info] - IO#timeout with backup should mirror the source in case of success

2443[info] - IO#timeout with backup should mirror the source in case of error

2444[info] - IO#timeout should cancel both the source and the timer

2445[info] - IO#timeout should cancel the backup

2446[info] - IO#timeout should not return the source after timeout

2447[info] - IO#timeout should cancel the source after timeout

2448[info] - IO#timeoutToL should evaluate as specified: lazy, no memoization

2449[info] - IO#timeoutL should evaluate as specified: lazy, with memoization

2450[info] - IO#timeoutL considers time taken to evaluate the duration task

2451[info] - IO#timeoutL: evaluation time took > timeout => timeout is immediately completed

2452[info] - IO.racePair(a,b) should work if a completes first

2453[info] - IO.racePair(a,b) should cancel both

2454[info] - IO.racePair(A,B) should not cancel B if A completes first

2455[info] - IO.racePair(A,B) should not cancel A if B completes first

2456[info] - IO.racePair(A,B) should end both in error if A completes first in error

2457[info] - IO.racePair(A,B) should end both in terminal error if A completes first in terminal error

2458[info] - IO.racePair(A,B) should end both in error if B completes first in error

2459[info] - IO.racePair(A,B) should end both in terminal error if B completes first in terminal error

2460[info] - IO.racePair(A,B) should work if A completes second in error

2461[info] - IO.racePair(A,B) should work if A completes second in terminal error

2462[info] - IO.racePair(A,B) should work if B completes second in error

2463[info] - IO.racePair should be stack safe, take 1

2464[info] - IO.racePair should be stack safe, take 2

2465[info] - IO.racePair has a stack safe cancelable

2466[info] - IO.race(a, b) should work if a completes first

2467[info] - IO.race(a, b) should work if b completes first

2468[info] - IO.race(a, b) should cancel both

2469[info] - IO.race(a, b) should end both in error if `a` completes first in error

2470[info] - IO.race(a, b) should end both in error if `a` completes first in terminal error

2471[info] - IO.race(a, b) should end both in error if `b` completes first in error

2472[info] - IO.race(a, b) should end both in error if `b` completes first in error

2473[info] - IO.race(a, b) should work if `a` completes in typed error

2474[info] - IO.race(a, b) should work if `a` completes in unexpected error

2475[info] - IO.race(a, b) should work if `b` completes in typed error

2476[info] - IO.race(a, b) should work if `b` completes in unexpected error

2477[info] - IO.race should be stack safe, take 1

2478[info] - IO.race should be stack safe, take 2

2479[info] - Task.race has a stack safe cancelable

2480[info] monix.bio.TaskExecutionModelSuite

2481[info] - IO.now.executeWithModel(AlwaysAsyncExecution) should work

2482[info] - IO.now.runAsync (CancelableFuture) should not be async with AlwaysAsyncExecution

2483[info] - IO.eval.executeWithModel(AlwaysAsyncExecution) should work

2484[info] - IO.eval should be async with AlwaysAsyncExecution

2485[info] - IO.now.flatMap loops should work with AlwaysAsyncExecution

2486[info] - IO.eval.flatMap loops should work with AlwaysAsyncExecution

2487[info] - IO.flatMap loops should work with AlwaysAsyncExecution

2488Executing...

2489Received: $str

2490Executing...

2491Executing...

2492Finished via exit code: $exitCode

2493Resources were released!

2494Executing...

2495Received: $str

2496[info] monix.bio.TaskCallbackSafetyJVMSuite

2497[info] - IO.async has a safe callback

2498[info] - IO.async0 has a safe callback

2499[info] - IO.asyncF has a safe callback

2500[info] - IO.cancelable has a safe callback

2501[info] - IO.cancelable0 has a safe callback

2502[info] monix.bio.TaskCallbackSafetySuite

2503[info] - IO.async's callback can be called multiple times

2504[info] - IO.async0's callback can be called multiple times

2505[info] - IO.asyncF's callback can be called multiple times

2506[info] - IO.cancelable's callback can be called multiple times

2507[info] - IO.cancelable0's callback can be called multiple times

2508[info] - IO.async's register throwing is signaled as error

2509[info] - IO.async0's register throwing is signaled as error

2510[info] - IO.asyncF's register throwing is signaled as error (1)

2511[info] - IO.asyncF's register throwing is signaled as error (2)

2512[info] - IO.cancelable's register throwing is signaled as error

2513[info] - IO.cancelable0's register throwing is signaled as error

2514[info] - IO.async's register throwing, after result, is reported

2515[info] - IO.async0's register throwing, after result, is reported

2516[info] - IO.asyncF's register throwing, after result, is reported (1)

2517[info] - IO.asyncF's register throwing, after result, is reported (2)

2518[info] - IO.cancelable's register throwing, after result, is reported

2519[info] - IO.cancelable0's register throwing, after result, is reported

2520[info] monix.bio.TaskExecuteAsyncSuite

2521[info] - IO.now.executeAsync should execute async

2522[info] - IO.now.executeOn should execute async if forceAsync = true

2523[info] - IO.now.executeOn should not execute async if forceAsync = false

2524[info] - IO.create.executeOn should execute async

2525[info] - executeAsync should be stack safe, test 1

2526[info] - IO.executeOn should be stack safe, test 2

2527[info] - executeAsync should be stack safe, test 3

2528[info] monix.bio.TaskAsyncSuite

2529[info] - IO.never should never complete

2530[info] - IO.async should execute

2531[info] - IO.async should signal errors in register

2532[info] - IO.async should be stack safe

2533[info] - IO.async works for immediate successful value

2534[info] - IO.async works for immediate error

2535[info] - IO.async works for immediate terminate error

2536[info] - IO.async is memory safe in flatMap loops

2537[info] - IO.async0 works for immediate successful value

2538[info] - IO.async0 works for async successful value

2539[info] - IO.async0 works for async error

2540[info] - IO.async0 works for async terminate error

2541[info] - IO.async0 is memory safe in synchronous flatMap loops

2542[info] - IO.async0 is memory safe in async flatMap loops

2543[info] monix.bio.TaskAsyncAutoShiftJVMSuite

2544[info] - Task.fromFuture(async) should shift back to the main scheduler

2545[info] - Task.fromFuture(completed) should not shift to the main scheduler

2546[info] - Task.fromFuture(async error) should shift back to the main scheduler

2547[info] - Task.fromFuture(completed error) should not shift to the main scheduler

2548[info] - Task.deferFuture(async) should shift back to the main scheduler

2549[info] - Task.deferFuture(completed) should not shift to the main scheduler

2550[info] - Task.deferFuture(async error) should shift back to the main scheduler

2551[info] - Task.deferFuture(completed error) should not shift to the main scheduler

2552[info] - Task.deferFutureAction(async) should shift back to the main scheduler

2553[info] - Task.deferFutureAction(completed) should not shift to the main scheduler

2554[info] - Task.deferFutureAction(async error) should shift back to the main scheduler

2555[info] - Task.deferFutureAction(completed error) should not shift to the main scheduler

2556[info] - Task.fromFuture(async cancelable) should shift back to the main scheduler

2557[info] - Task.fromFuture(completed cancelable) should not shift to the main scheduler

2558[info] - Task.fromFuture(async error cancelable) should shift back to the main scheduler

2559[info] - Task.fromFuture(completed error cancelable) should not shift to the main scheduler

2560[info] - Task.deferFuture(async cancelable) should shift back to the main scheduler

2561[info] - Task.deferFuture(completed cancelable) should not shift to the main scheduler

2562[info] - Task.deferFuture(async error cancelable) should shift back to the main scheduler

2563[info] - Task.deferFuture(completed error cancelable) should not shift to the main scheduler

2564[info] - Task.deferFutureAction(async cancelable) should shift back to the main scheduler

2565[info] - Task.deferFutureAction(completed cancelable) should not shift to the main scheduler

2566[info] - Task.deferFutureAction(async error cancelable) should shift back to the main scheduler

2567[info] - Task.deferFutureAction(completed error cancelable) should not shift to the main scheduler

2568[info] - Task.async(register) should shift back if register forks

2569[info] - Task.async(register) should not shift back if register does not fork

2570[info] - Task.async(register typed) should shift back if register forks

2571[info] - Task.async(register error) should not shift back if register does not fork

2572[info] - Task.async0(register) should shift back if register forks

2573[info] - Task.async0(register) should not shift back if register does not fork

2574[info] - Task.async0(register error) should shift back if register forks

2575[info] - Task.async0(register error) should not shift back if register does not fork

2576[info] - Task.cancelable(register) should shift back if register forks

2577[info] - Task.cancelable(register) should not shift back if register does not fork

2578[info] - Task.cancelable(register error) should shift back if register forks

2579[info] - Task.cancelable(register error) should not shift back if register does not fork

2580[info] - Task.cancelable0(register) should shift back if register forks

2581[info] - Task.cancelable0(register) should not shift back if register does not fork

2582[info] - Task.cancelable0(register error) should shift back if register forks

2583[info] - Task.cancelable0(register error) should not shift back if register does not fork

2584[info] - Task.create(register) should shift back if register forks

2585[info] - Task.create(register) should not shift back if register does not fork

2586[info] - Task.create(register error) should shift back if register forks

2587[info] - Task.create(register error) should not shift back if register does not fork

2588[info] - Task.asyncF(register) should shift back if register forks

2589[info] - Task.asyncF(register) should not shift back if register does not fork

2590[info] - Task.asyncF(register error) should shift back if register forks

2591[info] - Task.asyncF(register error) should not shift back if register does not fork

2592[info] monix.bio.TaskVoidSuite

2593[info] - IO.void should work

2594value1: 0

2595value2: 100

2596value3: 400

2597value4: 100

2598value5: 0

2599[info] monix.bio.IOLocalDoctest

2600[info] - IOLocal.scala:23: IOLocal

2601[info] - IOLocal.scala:124: bind

2602[info] - IOLocal.scala:148: bindL

2603[info] - IOLocal.scala:179: bindClear

2604[info] monix.bio.TaskMapBothSuite

2605[info] - if both tasks are synchronous, then mapBoth forks

2606[info] - sum two async tasks

2607[info] - sum two synchronous tasks

2608[info] - should be stack-safe for synchronous tasks

2609[info] - should be stack-safe for asynchronous tasks

2610[info] - should have a stack safe cancelable

2611[info] - sum random synchronous tasks

2612[info] - sum random asynchronous tasks

2613[info] - both task can fail with error

2614[info] - both task can fail with terminal error

2615[info] monix.bio.TaskMiscSuite

2616[info] - IO.attempt should succeed

2617[info] - IO.raiseError.attempt should expose error

2618[info] - IO.mapError should map error

2619[info] - IO.terminate.attempt should not expose error

2620[info] - IO.tapError should not alter original successful value

2621[info] - IO.tapError should not alter original error value

2622[info] - IO.tapError should not alter original terminal error

2623[info] - IO.failed should expose error

2624[info] - IO.failed should fail for successful values

2625[info] - IO.map protects against user code

2626[info] - IO.forever

2627[info] - IO.restartUntil should keep retrying IO until predicate succeeds

2628[info] - IO.toReactivePublisher should convert tasks with no errors

2629[info] - IO.toReactivePublisher should convert tasks with typed errors

2630[info] - IO.toReactivePublisher should convert tasks with terminal errors

2631[info] - IO.toReactivePublisher should be cancelable

2632[info] - IO.toReactivePublisher should throw errors on invalid requests

2633[info] - IO.pure is an alias of now

2634[info] - IO.now.runAsync with Try-based callback

2635[info] - Task.error.runAsync with Try-based callback

2636[info] - Task.terminate.runAsync with Try-based callback

2637[info] - task.executeAsync.runAsync with Try-based callback for success

2638[info] - task.executeAsync.runAsync with Try-based callback for error

2639[info] - task.executeAsync.runAsync with Try-based callback for terminal error

2640[info] - task.executeWithOptions protects against user error

2641[info] monix.bio.TaskOptionsSuite

2642[info] - change options with future

2643[info] - change options with callback

2644[info] monix.bio.TypeClassLawsForTaskSuite

2645[info] - CoflatMap[Task].coflatMap.coflatMap associativity

2646[info] - CoflatMap[Task].coflatMap.coflatMap identity

2647[info] - CoflatMap[Task].coflatMap.coflatten coherence

2648[info] - CoflatMap[Task].coflatMap.coflatten throughMap

2649[info] - CoflatMap[Task].coflatMap.covariant composition

2650[info] - CoflatMap[Task].coflatMap.covariant identity

2651[info] - CoflatMap[Task].coflatMap.invariant composition

2652[info] - CoflatMap[Task].coflatMap.invariant identity

2653[info] - Concurrent[Task].concurrent.acquire and release of bracket are uncancelable

2654[info] - Concurrent[Task].concurrent.acquire of bracket is not cancelable

2655[info] - Concurrent[Task].concurrent.an action run concurrently with a pure value is the same as just doing that action

2656[info] - Concurrent[Task].concurrent.ap consistent with product + map

2657[info] - Concurrent[Task].concurrent.applicative homomorphism

2658[info] - Concurrent[Task].concurrent.applicative identity

2659[info] - Concurrent[Task].concurrent.applicative interchange

2660[info] - Concurrent[Task].concurrent.applicative map

2661[info] - Concurrent[Task].concurrent.applicative unit

2662[info] - Concurrent[Task].concurrent.applicativeError adaptError pure

2663[info] - Concurrent[Task].concurrent.applicativeError adaptError raise

2664[info] - Concurrent[Task].concurrent.applicativeError attempt consistent with attemptT

2665[info] - Concurrent[Task].concurrent.applicativeError attempt fromEither consistent with pure

2666[info] - Concurrent[Task].concurrent.applicativeError handle

2667[info] - Concurrent[Task].concurrent.applicativeError handleError . raiseError left-distributes over ap

2668[info] - Concurrent[Task].concurrent.applicativeError handleError . raiseError right-distributes over ap

2669[info] - Concurrent[Task].concurrent.applicativeError handleError consistent with recover

2670[info] - Concurrent[Task].concurrent.applicativeError handleError pure

2671[info] - Concurrent[Task].concurrent.applicativeError handleErrorWith consistent with recoverWith

2672[info] - Concurrent[Task].concurrent.applicativeError handleErrorWith pure

2673[info] - Concurrent[Task].concurrent.applicativeError handleWith

2674[info] - Concurrent[Task].concurrent.applicativeError onError pure

2675[info] - Concurrent[Task].concurrent.applicativeError onError raise

2676[info] - Concurrent[Task].concurrent.applicativeError pure attempt

2677[info] - Concurrent[Task].concurrent.applicativeError raiseError attempt

2678[info] - Concurrent[Task].concurrent.applicativeError recover consistent with recoverWith

2679[info] - Concurrent[Task].concurrent.applicativeError redeem is derived from attempt and map

2680[info] - Concurrent[Task].concurrent.apply composition

2681[info] - Concurrent[Task].concurrent.async can be derived from asyncF

2682[info] - Concurrent[Task].concurrent.async cancelable coherence

2683[info] - Concurrent[Task].concurrent.async cancelable receives cancel signal

2684[info] - Concurrent[Task].concurrent.async left is raiseError

2685[info] - Concurrent[Task].concurrent.async right is pure

2686[info] - Concurrent[Task].concurrent.asyncF registration can be cancelled

2687[info] - Concurrent[Task].concurrent.bind suspends evaluation

2688[info] - Concurrent[Task].concurrent.bracket is derived from bracketCase

2689[info] - Concurrent[Task].concurrent.bracket release is called on Completed or Error

2690[info] - Concurrent[Task].concurrent.bracket release is called on cancel

2691[info] - Concurrent[Task].concurrent.bracketCase with failure in acquisition remains failure

2692[info] - Concurrent[Task].concurrent.bracketCase with pure unit on release is eqv to map

2693[info] - Concurrent[Task].concurrent.bracketCase with pure unit on release is eqv to uncancelable(..).flatMap

2694[info] - Concurrent[Task].concurrent.covariant composition

2695[info] - Concurrent[Task].concurrent.covariant identity

2696[info] - Concurrent[Task].concurrent.delay constant is pure

2697[info] - Concurrent[Task].concurrent.flatMap associativity

2698[info] - Concurrent[Task].concurrent.flatMap consistent apply

2699[info] - Concurrent[Task].concurrent.flatMap from tailRecM consistency

2700[info] - Concurrent[Task].concurrent.guarantee is derived from bracket

2701[info] - Concurrent[Task].concurrent.guaranteeCase is derived from bracketCase

2702[info] - Concurrent[Task].concurrent.invariant composition

2703[info] - Concurrent[Task].concurrent.invariant identity

2704[info] - Concurrent[Task].concurrent.join is idempotent

2705[info] - Concurrent[Task].concurrent.map flatMap coherence

2706[info] - Concurrent[Task].concurrent.map suspends evaluation

2707[info] - Concurrent[Task].concurrent.map2/map2Eval consistency

2708[info] - Concurrent[Task].concurrent.map2/product-map consistency

2709[info] - Concurrent[Task].concurrent.monad left identity

2710[info] - Concurrent[Task].concurrent.monad right identity

2711[info] - Concurrent[Task].concurrent.monadError ensure consistency

2712[info] - Concurrent[Task].concurrent.monadError ensureOr consistency

2713[info] - Concurrent[Task].concurrent.monadError left zero

2714[info] - Concurrent[Task].concurrent.monadError redeemWith is derived from attempt and flatMap

2715[info] - Concurrent[Task].concurrent.monadError rethrow attempt

2716[info] - Concurrent[Task].concurrent.monoidal left identity

2717[info] - Concurrent[Task].concurrent.monoidal right identity

2718[info] - Concurrent[Task].concurrent.mproduct consistent flatMap

2719[info] - Concurrent[Task].concurrent.never is derived from async

2720[info] - Concurrent[Task].concurrent.onCancel is derived from guaranteeCase

2721[info] - Concurrent[Task].concurrent.productL consistent map2

2722[info] - Concurrent[Task].concurrent.productR consistent map2

2723[info] - Concurrent[Task].concurrent.propagate errors through bind (async)

2724[info] - Concurrent[Task].concurrent.propagate errors through bind (suspend)

2725[info] - Concurrent[Task].concurrent.race cancels both

2726[info] - Concurrent[Task].concurrent.race cancels loser

2727[info] - Concurrent[Task].concurrent.race mirrors left winner

2728[info] - Concurrent[Task].concurrent.race mirrors right winner

2729[info] - Concurrent[Task].concurrent.racePair can join left

2730[info] - Concurrent[Task].concurrent.racePair can join right

2731[info] - Concurrent[Task].concurrent.racePair cancels both

2732[info] - Concurrent[Task].concurrent.racePair cancels loser

2733[info] - Concurrent[Task].concurrent.racePair mirrors left winner

2734[info] - Concurrent[Task].concurrent.racePair mirrors right winner

2735[info] - Concurrent[Task].concurrent.release of bracket is not cancelable

2736[info] - Concurrent[Task].concurrent.repeated async evaluation not memoized

2737[info] - Concurrent[Task].concurrent.repeated asyncF evaluation not memoized

2738[info] - Concurrent[Task].concurrent.repeated sync evaluation not memoized

2739[info] - Concurrent[Task].concurrent.semigroupal associativity

2740[info] - Concurrent[Task].concurrent.stack-safe on bracket with left-associated binds

2741[info] - Concurrent[Task].concurrent.stack-safe on bracket with right-associated binds

2742[info] - Concurrent[Task].concurrent.stack-safe on guarantee with left-associated binds

2743[info] - Concurrent[Task].concurrent.stack-safe on guarantee with right-associated binds

2744[info] - Concurrent[Task].concurrent.stack-safe on left-associated binds

2745[info] - Concurrent[Task].concurrent.stack-safe on repeated attempts

2746[info] - Concurrent[Task].concurrent.stack-safe on repeated maps

2747[info] - Concurrent[Task].concurrent.stack-safe on right-associated binds

2748[info] - Concurrent[Task].concurrent.start then join is identity

2749[info] - Concurrent[Task].concurrent.start.flatMap(_.cancel) is unit

2750[info] - Concurrent[Task].concurrent.suspend constant is pure join

2751[info] - Concurrent[Task].concurrent.tailRecM consistent flatMap

2752[info] - Concurrent[Task].concurrent.tailRecM stack safety

2753[info] - Concurrent[Task].concurrent.throw in delay is raiseError

2754[info] - Concurrent[Task].concurrent.throw in suspend is raiseError

2755[info] - Concurrent[Task].concurrent.uncancelable mirrors source

2756[info] - Concurrent[Task].concurrent.uncancelable prevents Cancelled case

2757[info] - Concurrent[Task].concurrent.uncancelable prevents cancellation

2758[info] - Concurrent[Task].concurrent.unsequenced delay is no-op

2759[info] - ConcurrentEffect[Task].concurrentEffect.acquire and release of bracket are uncancelable

2760[info] - ConcurrentEffect[Task].concurrentEffect.acquire of bracket is not cancelable

2761[info] - ConcurrentEffect[Task].concurrentEffect.an action run concurrently with a pure value is the same as just doing that action

2762[info] - ConcurrentEffect[Task].concurrentEffect.ap consistent with product + map

2763[info] - ConcurrentEffect[Task].concurrentEffect.applicative homomorphism

2764[info] - ConcurrentEffect[Task].concurrentEffect.applicative identity

2765[info] - ConcurrentEffect[Task].concurrentEffect.applicative interchange

2766[info] - ConcurrentEffect[Task].concurrentEffect.applicative map

2767[info] - ConcurrentEffect[Task].concurrentEffect.applicative unit

2768[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError adaptError pure

2769[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError adaptError raise

2770[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError attempt consistent with attemptT

2771[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError attempt fromEither consistent with pure

2772[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError handle

2773[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError handleError . raiseError left-distributes over ap

2774[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError handleError . raiseError right-distributes over ap

2775[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError handleError consistent with recover

2776[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError handleError pure

2777[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError handleErrorWith consistent with recoverWith

2778[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError handleErrorWith pure

2779[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError handleWith

2780[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError onError pure

2781[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError onError raise

2782[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError pure attempt

2783[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError raiseError attempt

2784[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError recover consistent with recoverWith

2785[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError redeem is derived from attempt and map

2786[info] - ConcurrentEffect[Task].concurrentEffect.apply composition

2787[info] - ConcurrentEffect[Task].concurrentEffect.async can be derived from asyncF

2788[info] - ConcurrentEffect[Task].concurrentEffect.async cancelable coherence

2789[info] - ConcurrentEffect[Task].concurrentEffect.async cancelable receives cancel signal

2790[info] - ConcurrentEffect[Task].concurrentEffect.async left is raiseError

2791[info] - ConcurrentEffect[Task].concurrentEffect.async right is pure

2792[info] - ConcurrentEffect[Task].concurrentEffect.asyncF registration can be cancelled

2793[info] - ConcurrentEffect[Task].concurrentEffect.bind suspends evaluation

2794[info] - ConcurrentEffect[Task].concurrentEffect.bracket is derived from bracketCase

2795[info] - ConcurrentEffect[Task].concurrentEffect.bracket release is called on Completed or Error

2796[info] - ConcurrentEffect[Task].concurrentEffect.bracket release is called on cancel

2797[info] - ConcurrentEffect[Task].concurrentEffect.bracketCase with failure in acquisition remains failure

2798[info] - ConcurrentEffect[Task].concurrentEffect.bracketCase with pure unit on release is eqv to map

2799[info] - ConcurrentEffect[Task].concurrentEffect.bracketCase with pure unit on release is eqv to uncancelable(..).flatMap

2800[info] - ConcurrentEffect[Task].concurrentEffect.covariant composition

2801[info] - ConcurrentEffect[Task].concurrentEffect.covariant identity

2802[info] - ConcurrentEffect[Task].concurrentEffect.delay constant is pure

2803[info] - ConcurrentEffect[Task].concurrentEffect.flatMap associativity

2804[info] - ConcurrentEffect[Task].concurrentEffect.flatMap consistent apply

2805[info] - ConcurrentEffect[Task].concurrentEffect.flatMap from tailRecM consistency

2806[info] - ConcurrentEffect[Task].concurrentEffect.guarantee is derived from bracket

2807[info] - ConcurrentEffect[Task].concurrentEffect.guaranteeCase is derived from bracketCase

2808[info] - ConcurrentEffect[Task].concurrentEffect.invariant composition

2809[info] - ConcurrentEffect[Task].concurrentEffect.invariant identity

2810[info] - ConcurrentEffect[Task].concurrentEffect.join is idempotent

2811[info] - ConcurrentEffect[Task].concurrentEffect.map flatMap coherence

2812[info] - ConcurrentEffect[Task].concurrentEffect.map suspends evaluation

2813[info] - ConcurrentEffect[Task].concurrentEffect.map2/map2Eval consistency

2814[info] - ConcurrentEffect[Task].concurrentEffect.map2/product-map consistency

2815[info] - ConcurrentEffect[Task].concurrentEffect.monad left identity

2816[info] - ConcurrentEffect[Task].concurrentEffect.monad right identity

2817[info] - ConcurrentEffect[Task].concurrentEffect.monadError ensure consistency

2818[info] - ConcurrentEffect[Task].concurrentEffect.monadError ensureOr consistency

2819[info] - ConcurrentEffect[Task].concurrentEffect.monadError left zero

2820[info] - ConcurrentEffect[Task].concurrentEffect.monadError redeemWith is derived from attempt and flatMap

2821[info] - ConcurrentEffect[Task].concurrentEffect.monadError rethrow attempt

2822[info] - ConcurrentEffect[Task].concurrentEffect.monoidal left identity

2823[info] - ConcurrentEffect[Task].concurrentEffect.monoidal right identity

2824[info] - ConcurrentEffect[Task].concurrentEffect.mproduct consistent flatMap

2825[info] - ConcurrentEffect[Task].concurrentEffect.never is derived from async

2826[info] - ConcurrentEffect[Task].concurrentEffect.onCancel is derived from guaranteeCase

2827[info] - ConcurrentEffect[Task].concurrentEffect.productL consistent map2

2828[info] - ConcurrentEffect[Task].concurrentEffect.productR consistent map2

2829[info] - ConcurrentEffect[Task].concurrentEffect.propagate errors through bind (async)

2830[info] - ConcurrentEffect[Task].concurrentEffect.propagate errors through bind (suspend)

2831[info] - ConcurrentEffect[Task].concurrentEffect.race cancels both

2832[info] - ConcurrentEffect[Task].concurrentEffect.race cancels loser

2833[info] - ConcurrentEffect[Task].concurrentEffect.race mirrors left winner

2834[info] - ConcurrentEffect[Task].concurrentEffect.race mirrors right winner

2835[info] - ConcurrentEffect[Task].concurrentEffect.racePair can join left

2836[info] - ConcurrentEffect[Task].concurrentEffect.racePair can join right

2837[info] - ConcurrentEffect[Task].concurrentEffect.racePair cancels both

2838[info] - ConcurrentEffect[Task].concurrentEffect.racePair cancels loser

2839[info] - ConcurrentEffect[Task].concurrentEffect.racePair mirrors left winner

2840[info] - ConcurrentEffect[Task].concurrentEffect.racePair mirrors right winner

2841[info] - ConcurrentEffect[Task].concurrentEffect.release of bracket is not cancelable

2842[info] - ConcurrentEffect[Task].concurrentEffect.repeated async evaluation not memoized

2843[info] - ConcurrentEffect[Task].concurrentEffect.repeated asyncF evaluation not memoized

2844[info] - ConcurrentEffect[Task].concurrentEffect.repeated callback ignored

2845[info] - ConcurrentEffect[Task].concurrentEffect.repeated sync evaluation not memoized

2846[info] - ConcurrentEffect[Task].concurrentEffect.runAsync ignores error in handler

2847[info] - ConcurrentEffect[Task].concurrentEffect.runAsync pure produces right IO

2848[info] - ConcurrentEffect[Task].concurrentEffect.runAsync raiseError produces left IO

2849[info] - ConcurrentEffect[Task].concurrentEffect.runAsync runCancelable coherence

2850[info] - ConcurrentEffect[Task].concurrentEffect.runCancelable is synchronous

2851[info] - ConcurrentEffect[Task].concurrentEffect.runCancelable start.flatMap(_.cancel) coherence

2852[info] - ConcurrentEffect[Task].concurrentEffect.semigroupal associativity

2853[info] - ConcurrentEffect[Task].concurrentEffect.stack-safe on bracket with left-associated binds

2854[info] - ConcurrentEffect[Task].concurrentEffect.stack-safe on bracket with right-associated binds

2855[info] - ConcurrentEffect[Task].concurrentEffect.stack-safe on guarantee with left-associated binds

2856[info] - ConcurrentEffect[Task].concurrentEffect.stack-safe on guarantee with right-associated binds

2857[info] - ConcurrentEffect[Task].concurrentEffect.stack-safe on left-associated binds

2858[info] - ConcurrentEffect[Task].concurrentEffect.stack-safe on repeated attempts

2859[info] - ConcurrentEffect[Task].concurrentEffect.stack-safe on repeated maps

2860[info] - ConcurrentEffect[Task].concurrentEffect.stack-safe on right-associated binds

2861[info] - ConcurrentEffect[Task].concurrentEffect.start then join is identity

2862[info] - ConcurrentEffect[Task].concurrentEffect.start.flatMap(_.cancel) is unit

2863[info] - ConcurrentEffect[Task].concurrentEffect.suspend constant is pure join

2864[info] - ConcurrentEffect[Task].concurrentEffect.tailRecM consistent flatMap

2865[info] - ConcurrentEffect[Task].concurrentEffect.tailRecM stack safety

2866[info] - ConcurrentEffect[Task].concurrentEffect.throw in delay is raiseError

2867[info] - ConcurrentEffect[Task].concurrentEffect.throw in suspend is raiseError

2868[info] - ConcurrentEffect[Task].concurrentEffect.toIO is consistent with runAsync

2869[info] - ConcurrentEffect[Task].concurrentEffect.toIO is consistent with runCancelable

2870[info] - ConcurrentEffect[Task].concurrentEffect.toIO is the inverse of liftIO

2871[info] - ConcurrentEffect[Task].concurrentEffect.toIO stack safety

2872[info] - ConcurrentEffect[Task].concurrentEffect.uncancelable mirrors source

2873[info] - ConcurrentEffect[Task].concurrentEffect.uncancelable prevents Cancelled case

2874[info] - ConcurrentEffect[Task].concurrentEffect.uncancelable prevents cancellation

2875[info] - ConcurrentEffect[Task].concurrentEffect.unsequenced delay is no-op

2876[info] - CommutativeApplicative[IO.Par].commutative applicative.ap consistent with product + map

2877[info] - CommutativeApplicative[IO.Par].commutative applicative.applicative homomorphism

2878[info] - CommutativeApplicative[IO.Par].commutative applicative.applicative identity

2879[info] - CommutativeApplicative[IO.Par].commutative applicative.applicative interchange

2880[info] - CommutativeApplicative[IO.Par].commutative applicative.applicative map

2881[info] - CommutativeApplicative[IO.Par].commutative applicative.applicative unit

2882[info] - CommutativeApplicative[IO.Par].commutative applicative.apply commutativity

2883[info] - CommutativeApplicative[IO.Par].commutative applicative.apply composition

2884[info] - CommutativeApplicative[IO.Par].commutative applicative.covariant composition

2885[info] - CommutativeApplicative[IO.Par].commutative applicative.covariant identity

2886[info] - CommutativeApplicative[IO.Par].commutative applicative.invariant composition

2887[info] - CommutativeApplicative[IO.Par].commutative applicative.invariant identity

2888[info] - CommutativeApplicative[IO.Par].commutative applicative.map2/map2Eval consistency

2889[info] - CommutativeApplicative[IO.Par].commutative applicative.map2/product-map consistency

2890[info] - CommutativeApplicative[IO.Par].commutative applicative.monoidal left identity

2891[info] - CommutativeApplicative[IO.Par].commutative applicative.monoidal right identity

2892[info] - CommutativeApplicative[IO.Par].commutative applicative.productL consistent map2

2893[info] - CommutativeApplicative[IO.Par].commutative applicative.productR consistent map2

2894[info] - CommutativeApplicative[IO.Par].commutative applicative.semigroupal associativity

2895[info] - Parallel[IO, IO.Par].parallel.isomorphic functor

2896[info] - Parallel[IO, IO.Par].parallel.isomorphic pure

2897[info] - Parallel[IO, IO.Par].parallel.parallel round trip

2898[info] - Parallel[IO, IO.Par].parallel.sequential round trip

2899[info] - Monoid[IO[String, Int]].monoid.associative

2900[info] - Monoid[IO[String, Int]].monoid.collect0

2901[info] - Monoid[IO[String, Int]].monoid.combine all

2902[info] - Monoid[IO[String, Int]].monoid.combineAllOption

2903[info] - Monoid[IO[String, Int]].monoid.intercalateCombineAllOption

2904[info] - Monoid[IO[String, Int]].monoid.intercalateIntercalates

2905[info] - Monoid[IO[String, Int]].monoid.intercalateRepeat1

2906[info] - Monoid[IO[String, Int]].monoid.intercalateRepeat2

2907[info] - Monoid[IO[String, Int]].monoid.is id

2908[info] - Monoid[IO[String, Int]].monoid.left identity

2909[info] - Monoid[IO[String, Int]].monoid.repeat0

2910[info] - Monoid[IO[String, Int]].monoid.repeat1

2911[info] - Monoid[IO[String, Int]].monoid.repeat2

2912[info] - Monoid[IO[String, Int]].monoid.reverseCombineAllOption

2913[info] - Monoid[IO[String, Int]].monoid.reverseRepeat1

2914[info] - Monoid[IO[String, Int]].monoid.reverseRepeat2

2915[info] - Monoid[IO[String, Int]].monoid.reverseReverses

2916[info] - Monoid[IO[String, Int]].monoid.right identity

2917[info] - SemigroupK[Task[Int]].semigroupK.semigroupK associative

2918[info] - Bifunctor[IO[String, Int]].Bifunctor.Bifunctor Identity

2919[info] - Bifunctor[IO[String, Int]].Bifunctor.Bifunctor associativity

2920[info] - Bifunctor[IO[String, Int]].Bifunctor.Bifunctor leftMap Identity

2921[info] - Bifunctor[IO[String, Int]].Bifunctor.Bifunctor leftMap associativity

2922[info] monix.bio.TaskStartSuite

2923[info] - task.start.flatMap(_.join) <-> task

2924[info] - task.start.flatMap(id) is cancelable, but the source is memoized

2925[info] - task.start is stack safe

2926[info] - task.start shares Local.Context with fibers

2927[info] - task.start is stack safe

2928[info] - task.start executes asynchronously

2929[info] monix.bio.IOFromFutureEitherSuite

2930[info] - IO.fromFutureEither should return success channel for Right

2931[info] - IO.fromFutureEither should return checked failure channel for Left

2932[info] - IO.fromFutureEither should return unchecked failure channel for a failed Future

2933[info] - IO.fromFutureEither(cancelable) should work for Right synchronous results onSuccess

2934[info] - IO.fromFutureEither(cancelable) should work for Left synchronous results onSuccess

2935[info] - IO.fromFutureEither(cancelable) should work for synchronous results onFailure

2936[info] - IO.fromFutureEither(cancelable) should be short-circuited for Right onSuccess

2937[info] - IO.fromFutureEither(cancelable) should be short-circuited for Left onSuccess

2938[info] - IO.fromFutureEither(cancelable) should be short-circuited onError

2939[info] - IO.fromFutureEither(cancelable) should work onSuccess

2940[info] - IO.fromFutureEither(cancelable) should work onError

2941[info] - IO.fromFutureEither(cancelable) should be cancelable

2942[info] - IO.fromFutureEither should be stack safe

2943[info] monix.bio.TaskParSequenceNSuite

2944[info] - IO.parSequenceN should execute in parallel bounded by parallelism

2945[info] - IO.parSequenceN should return result in order

2946[info] - IO.parSequenceN should return empty list

2947[info] - IO.parSequenceN should handle single item

2948[info] - IO.parSequenceN should handle parallelism bigger than list

2949[info] - IO.parSequenceN should onError if one of the tasks terminates in error

2950[info] - IO.parSequenceN should onTerminate if one of the tasks terminates in a fatal error

2951[info] - IO.parSequenceN should be canceled

2952[info] - IO.parSequenceN should be stack safe for synchronous tasks

2953[info] - IO.parSequenceN runAsync multiple times

2954[info] - IO.parSequenceN should log errors if multiple errors happen

2955[info] - IO.parSequenceN should log terminal errors if multiple errors happen

2957************************

2958Build summary:

2959[{

2960 "module": "monix-bio",

2961 "compile": {"status": "ok", "tookMs": 20306, "warnings": 0, "errors": 0, "sourceVersion": "3.8"},

2962 "doc": {"status": "skipped", "tookMs": 0, "files": 0, "totalSizeKb": 0},

2963 "test-compile": {"status": "ok", "tookMs": 34806, "warnings": 0, "errors": 0, "sourceVersion": "3.8"},

2964 "test": {"status": "ok", "tookMs": 28884, "passed": 2607, "failed": 0, "ignored": 0, "skipped": 0, "total": 2607, "byFramework": [{"framework": "unknown", "stats": {"passed": 2607, "failed": 0, "ignored": 0, "skipped": 0, "total": 2607}}]},

2965 "publish": {"status": "skipped", "tookMs": 0},

2966 "metadata": {

2967 "crossScalaVersions": ["2.12.13", "2.13.5", "3.0.0"]

2968}

2969}]

2970************************

2971[success] Total time: 103 s (0:01:43.0), completed Dec 22, 2025, 6:03:01 PM

2972[0JHello!

2973Checking patch project/plugins.sbt...

2974Checking patch project/build.properties...

2975Checking patch build.sbt...

2976Applied patch project/plugins.sbt cleanly.

2977Applied patch project/build.properties cleanly.

2978Applied patch build.sbt cleanly.