Build Logs
monix/monix-bio • 3.8.0:2026-01-13
Errors
9
Warnings
42
Total Lines
2978
1##################################
2Clonning https://github.com/monix/monix-bio.git into /build/repo using revision v1.2.0
3##################################
4Note: switching to '471cbe3ecf13687c2c57b1e64b02818684ac2165'.
5
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.
9
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:
12
13 git switch -c <new-branch-name>
14
15Or undo this operation with:
16
17 git switch -
18
19Turn off this advice by setting config variable advice.detachedHead to false
20
21----
22Preparing build for 3.8.0
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
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
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
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"
60"++3.8.0 -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"
65
66moduleMappings
67"runBuild 3.8.0 """{"projects":{"exclude":[],"overrides":{}},"java":{"version":"17"},"sbt":{"commands":[],"options":[]},"mill":{"options":[]},"tests":"full","migrationVersions":[],"sourcePatches":[]}""" io.monix%monix-bio"
68
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 9.49s.
75[info] done compiling
76/build/repo/build.sbt:89: warning: method in in trait ScopingSetting is deprecated (since 1.5.0): `in` is deprecated; migrate to slash syntax - https://www.scala-sbt.org/1.x/docs/Migrating-from-sbt-013x.html#slash
77 unmanagedSourceDirectories in FullTracingTest += {
78 ^
79/build/repo/build.sbt:92: warning: method in in trait ScopingSetting is deprecated (since 1.5.0): `in` is deprecated; migrate to slash syntax - https://www.scala-sbt.org/1.x/docs/Migrating-from-sbt-013x.html#slash
80 test in Test := (test in Test).dependsOn(test in FullTracingTest).value,
81 ^
82/build/repo/build.sbt:92: warning: method in in trait ScopingSetting is deprecated (since 1.5.0): `in` is deprecated; migrate to slash syntax - https://www.scala-sbt.org/1.x/docs/Migrating-from-sbt-013x.html#slash
83 test in Test := (test in Test).dependsOn(test in FullTracingTest).value,
84 ^
85/build/repo/build.sbt:92: warning: method in in trait ScopingSetting is deprecated (since 1.5.0): `in` is deprecated; migrate to slash syntax - https://www.scala-sbt.org/1.x/docs/Migrating-from-sbt-013x.html#slash
86 test in Test := (test in Test).dependsOn(test in FullTracingTest).value,
87 ^
88/build/repo/build.sbt:93: warning: method in in trait ScopingSetting is deprecated (since 1.5.0): `in` is deprecated; migrate to slash syntax - https://www.scala-sbt.org/1.x/docs/Migrating-from-sbt-013x.html#slash
89 fork in Test := true,
90 ^
91/build/repo/build.sbt:94: warning: method in in trait ScopingSetting is deprecated (since 1.5.0): `in` is deprecated; migrate to slash syntax - https://www.scala-sbt.org/1.x/docs/Migrating-from-sbt-013x.html#slash
92 fork in FullTracingTest := true,
93 ^
94/build/repo/build.sbt:95: warning: method in in trait ScopingSetting is deprecated (since 1.5.0): `in` is deprecated; migrate to slash syntax - https://www.scala-sbt.org/1.x/docs/Migrating-from-sbt-013x.html#slash
95 javaOptions in Test ++= Seq(
96 ^
97/build/repo/build.sbt:99: warning: method in in trait ScopingSetting is deprecated (since 1.5.0): `in` is deprecated; migrate to slash syntax - https://www.scala-sbt.org/1.x/docs/Migrating-from-sbt-013x.html#slash
98 javaOptions in FullTracingTest ++= Seq(
99 ^
100/build/repo/build.sbt:108: warning: method in in trait ScopingSetting is deprecated (since 1.5.0): `in` is deprecated; migrate to slash syntax - https://www.scala-sbt.org/1.x/docs/Migrating-from-sbt-013x.html#slash
101 unidocProjectFilter in (ScalaUnidoc, unidoc) := inProjects(coreJVM),
102 ^
103/build/repo/build.sbt:109: warning: method in in trait ScopingSetting is deprecated (since 1.5.0): `in` is deprecated; migrate to slash syntax - https://www.scala-sbt.org/1.x/docs/Migrating-from-sbt-013x.html#slash
104 target in (ScalaUnidoc, unidoc) := (baseDirectory in LocalRootProject).value / "website" / "static" / "api",
105 ^
106/build/repo/build.sbt:109: warning: method in in trait ScopingSetting is deprecated (since 1.5.0): `in` is deprecated; migrate to slash syntax - https://www.scala-sbt.org/1.x/docs/Migrating-from-sbt-013x.html#slash
107 target in (ScalaUnidoc, unidoc) := (baseDirectory in LocalRootProject).value / "website" / "static" / "api",
108 ^
109/build/repo/build.sbt:110: warning: method in in trait ScopingSetting is deprecated (since 1.5.0): `in` is deprecated; migrate to slash syntax - https://www.scala-sbt.org/1.x/docs/Migrating-from-sbt-013x.html#slash
110 cleanFiles += (target in (ScalaUnidoc, unidoc)).value,
111 ^
112/build/repo/build.sbt:112: warning: method in in trait ScopingSetting is deprecated (since 1.5.0): `in` is deprecated; migrate to slash syntax - https://www.scala-sbt.org/1.x/docs/Migrating-from-sbt-013x.html#slash
113 .dependsOn(unidoc in Compile)
114 ^
115/build/repo/build.sbt:113: warning: method in in trait ScopingSetting is deprecated (since 1.5.0): `in` is deprecated; migrate to slash syntax - https://www.scala-sbt.org/1.x/docs/Migrating-from-sbt-013x.html#slash
116 .dependsOn(updateSiteVariables in ThisBuild)
117 ^
118/build/repo/build.sbt:117: warning: method in in trait ScopingSetting is deprecated (since 1.5.0): `in` is deprecated; migrate to slash syntax - https://www.scala-sbt.org/1.x/docs/Migrating-from-sbt-013x.html#slash
119 .dependsOn(unidoc in Compile)
120 ^
121/build/repo/build.sbt:118: warning: method in in trait ScopingSetting is deprecated (since 1.5.0): `in` is deprecated; migrate to slash syntax - https://www.scala-sbt.org/1.x/docs/Migrating-from-sbt-013x.html#slash
122 .dependsOn(updateSiteVariables in ThisBuild)
123 ^
124/build/repo/build.sbt:120: warning: method in in trait ScopingSetting is deprecated (since 1.5.0): `in` is deprecated; migrate to slash syntax - https://www.scala-sbt.org/1.x/docs/Migrating-from-sbt-013x.html#slash
125 scalacOptions in (ScalaUnidoc, unidoc) ++= Seq(
126 ^
127/build/repo/build.sbt:122: warning: method in in trait ScopingSetting is deprecated (since 1.5.0): `in` is deprecated; migrate to slash syntax - https://www.scala-sbt.org/1.x/docs/Migrating-from-sbt-013x.html#slash
128 "-sourcepath", baseDirectory.in(LocalRootProject).value.getAbsolutePath,
129 ^
130/build/repo/build.sbt:128: warning: method in in trait ScopingSetting is deprecated (since 1.5.0): `in` is deprecated; migrate to slash syntax - https://www.scala-sbt.org/1.x/docs/Migrating-from-sbt-013x.html#slash
131 sources in (Compile, doc) ~= (_ filterNot { file =>
132 ^
133/build/repo/build.sbt:175: warning: method in in trait ScopingSetting is deprecated (since 1.5.0): `in` is deprecated; migrate to slash syntax - https://www.scala-sbt.org/1.x/docs/Migrating-from-sbt-013x.html#slash
134 publishArtifact in (Compile, packageDoc) := false,
135 ^
136/build/repo/build.sbt:176: warning: method in in trait ScopingSetting is deprecated (since 1.5.0): `in` is deprecated; migrate to slash syntax - https://www.scala-sbt.org/1.x/docs/Migrating-from-sbt-013x.html#slash
137 publishArtifact in (Compile, packageSrc) := false,
138 ^
139/build/repo/build.sbt:177: warning: method in in trait ScopingSetting is deprecated (since 1.5.0): `in` is deprecated; migrate to slash syntax - https://www.scala-sbt.org/1.x/docs/Migrating-from-sbt-013x.html#slash
140 publishArtifact in (Compile, packageBin) := false
141 ^
142/build/repo/build.sbt:259: warning: method in in trait ScopingSetting is deprecated (since 1.5.0): `in` is deprecated; migrate to slash syntax - https://www.scala-sbt.org/1.x/docs/Migrating-from-sbt-013x.html#slash
143 scalacOptions in (Compile, doc) ~= (_ filterNot (_ == "-Xfatal-warnings")),
144 ^
145/build/repo/build.sbt:281: warning: method in in trait ScopingSetting is deprecated (since 1.5.0): `in` is deprecated; migrate to slash syntax - https://www.scala-sbt.org/1.x/docs/Migrating-from-sbt-013x.html#slash
146 val cp: Seq[Attributed[File]] = (fullClasspath in Compile).value
147 ^
148/build/repo/build.sbt:298: warning: method in in trait ScopingSetting is deprecated (since 1.5.0): `in` is deprecated; migrate to slash syntax - https://www.scala-sbt.org/1.x/docs/Migrating-from-sbt-013x.html#slash
149 scalacOptions in ThisBuild ++= Seq(
150 ^
151/build/repo/build.sbt:309: warning: method sonatypeRepo in class ResolverFunctions is deprecated (since 1.7.0): Sonatype OSS Repository Hosting (OSSRH) was sunset on 2025-06-30; remove this resolver. If snapshots are required, use:
152 resolvers += Resolver.sonatypeCentralSnapshots
153
154 Resolver.sonatypeRepo("releases")
155 ^
156/build/repo/build.sbt:319: warning: method in in trait ScopingSetting is deprecated (since 1.5.0): `in` is deprecated; migrate to slash syntax - https://www.scala-sbt.org/1.x/docs/Migrating-from-sbt-013x.html#slash
157 publishArtifact in Test := false,
158 ^
159/build/repo/build.sbt:348: warning: method in in trait ScopingSetting is deprecated (since 1.5.0): `in` is deprecated; migrate to slash syntax - https://www.scala-sbt.org/1.x/docs/Migrating-from-sbt-013x.html#slash
160 unmanagedSourceDirectories in Compile += {
161 ^
162/build/repo/build.sbt:351: warning: method in in trait ScopingSetting is deprecated (since 1.5.0): `in` is deprecated; migrate to slash syntax - https://www.scala-sbt.org/1.x/docs/Migrating-from-sbt-013x.html#slash
163 unmanagedSourceDirectories in Test += {
164 ^
165/build/repo/build.sbt:379: warning: method in in trait ScopingSetting is deprecated (since 1.5.0): `in` is deprecated; migrate to slash syntax - https://www.scala-sbt.org/1.x/docs/Migrating-from-sbt-013x.html#slash
166 val l = (baseDirectory in LocalRootProject).value.toURI.toString
167 ^
168/build/repo/build.sbt:403: warning: method in in trait ScopingSetting is deprecated (since 1.5.0): `in` is deprecated; migrate to slash syntax - https://www.scala-sbt.org/1.x/docs/Migrating-from-sbt-013x.html#slash
169 skip in publish := true,
170 ^
171/build/repo/build.sbt:141: warning: method in in trait ScopingSetting is deprecated (since 1.5.0): `in` is deprecated; migrate to slash syntax - https://www.scala-sbt.org/1.x/docs/Migrating-from-sbt-013x.html#slash
172updateSiteVariables in ThisBuild := {
173 ^
174/build/repo/build.sbt:151: warning: method in in trait ScopingSetting is deprecated (since 1.5.0): `in` is deprecated; migrate to slash syntax - https://www.scala-sbt.org/1.x/docs/Migrating-from-sbt-013x.html#slash
175 val minorVersions = (crossScalaVersions in coreJVM).value.map(minorVersion)
176 ^
177/build/repo/build.sbt:148: warning: method in in trait ScopingSetting is deprecated (since 1.5.0): `in` is deprecated; migrate to slash syntax - https://www.scala-sbt.org/1.x/docs/Migrating-from-sbt-013x.html#slash
178 "coreModuleName" -> (moduleName in coreJVM).value,
179 ^
180/build/repo/build.sbt:147: warning: method in in trait ScopingSetting is deprecated (since 1.5.0): `in` is deprecated; migrate to slash syntax - https://www.scala-sbt.org/1.x/docs/Migrating-from-sbt-013x.html#slash
181 "organization" -> (organization in LocalRootProject).value,
182 ^
183/build/repo/build.sbt:143: warning: method in in trait ScopingSetting is deprecated (since 1.5.0): `in` is deprecated; migrate to slash syntax - https://www.scala-sbt.org/1.x/docs/Migrating-from-sbt-013x.html#slash
184 (baseDirectory in LocalRootProject).value / "website" / "variables.js"
185 ^
186/build/repo/build.sbt:391: warning: method in in trait ScopingSetting is deprecated (since 1.5.0): `in` is deprecated; migrate to slash syntax - https://www.scala-sbt.org/1.x/docs/Migrating-from-sbt-013x.html#slash
187mimaFailOnNoPrevious in ThisBuild := false
188 ^
189/build/repo/build.sbt:413: warning: method in in trait ScopingSetting is deprecated (since 1.5.0): `in` is deprecated; migrate to slash syntax - https://www.scala-sbt.org/1.x/docs/Migrating-from-sbt-013x.html#slash
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
195OpenCB::Changing crossVersion 3.0.0 -> 3.8.0 in tracingTests/crossScalaVersions
196OpenCB::Changing crossVersion 3.0.0 -> 3.8.0 in coreJVM/crossScalaVersions
197OpenCB::Changing crossVersion 3.0.0 -> 3.8.0 in benchmarks/crossScalaVersions
198OpenCB::Changing crossVersion 3.0.0 -> 3.8.0 in coreJS/crossScalaVersions
199OpenCB::Changing crossVersion 3.0.0 -> 3.8.0 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 on 5 projects.
202[info] Switching Scala version on:
203[info] benchmarks (2.12.13, 2.13.5, 3.8.0)
204[info] tracingTests (2.12.13, 2.13.5, 3.8.0)
205[info] coreJS (2.12.13, 2.13.5, 3.8.0)
206[info] coreJVM (2.12.13, 2.13.5, 3.8.0)
207[info] * monix-bio (2.12.13, 2.13.5, 3.8.0)
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:
223
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 Jan 13, 2026, 3:23:01 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/classes ...
244[warn] Option -Ykind-projector is deprecated: Use -Xkind-projector instead.
245[warn] one warning found
246[info] done compiling
247[info] compiling 80 Scala sources to /build/repo/core/jvm/target/scala-3.8.0/test-classes ...
248[warn] Option -Ykind-projector is deprecated: Use -Xkind-projector instead.
249[warn] one warning found
250[info] done compiling
251[info] monix.bio.TaskRejectedExecutionSuite
252[info] - Tasks should propagate RejectedExecutionException
253[info] monix.bio.TaskNowSuite
254[info] - IO.now should work synchronously
255[info] - IO.now.runAsync: CancelableFuture should be synchronous for AlwaysAsyncExecution
256[info] - IO.now.runAsync(callback) should work synchronously
257[info] - IO.now.runAsync(callback) should be asynchronous for AlwaysAsyncExecution
258[info] - IO.raiseError should work synchronously
259[info] - IO.terminate should work synchronously
260[info] - IO.raiseError.runAsync: CancelableFuture should be synchronous for AlwaysAsyncExecution
261[info] - IO.raiseError.runAsync(callback) should work synchronously
262[info] - IO.raiseError.runAsync(callback) should be asynchronous for AlwaysAsyncExecution
263[info] - IO.now.map should work
264[info] - IO.raiseError.map should be the same as IO.raiseError
265[info] - IO.raiseError.flatMap should be the same as IO.flatMap
266[info] - IO.raiseError.flatMap should be protected
267[info] - IO.now.flatMap should protect against user code
268[info] - IO.now.flatMap should be tail recursive
269[info] - IO.now should not be cancelable
270[info] - IO.raiseError should not be cancelable
271[info] - IO.terminate should not be cancelable
272[info] - IO.now.runSyncStep
273[info] - IO.raiseError.runSyncStep
274[info] monix.bio.TaskTimedSuite
275[info] - measure tasks with no errors
276[info] - not measure tasks with typed errors
277[info] - not measure tasks with terminal errors
278[info] - measure tasks with typed errors followed by `.attempt`
279[info] - not measure tasks with terminal errors followed by `.attempt`
280[info] - stack safety
281[info] monix.bio.IOStartAndForgetSuite
282[info] - IO#startAndForget triggers execution in background thread
283[info] - IO#startAndForget does not affect execution of main thread with raised errors
284[info] - IO#startAndForget triggers fatal errors in background thread
285[info] - IO#startAndForget is stack safe
286[info] monix.bio.TaskMemoizeOnSuccessSuite
287[info] - IO.memoizeOnSuccess should work asynchronously for first subscriber
288[info] - IO.memoizeOnSuccess should work synchronously for next subscribers
289[info] - IO.memoizeOnSuccess should be stack safe
290[info] - IO.flatMap.memoizeOnSuccess should be stack safe, test 1
291[info] - IO.flatMap.memoizeOnSuccess should be stack safe, test 2
292[info] - IO.raiseError(error).memoizeOnSuccess should not be idempotent
293[info] - IO.terminate(error).memoizeOnSuccess should not be idempotent
294[info] - IO.memoizeOnSuccess.materialize
295[info] - IO.raiseError(error).memoizeOnSuccess.materialize
296[info] - IO.terminate(error).memoizeOnSuccess.materialize
297[info] - IO.eval.memoizeOnSuccess should work for first subscriber
298[info] - IO.eval.memoizeOnSuccess should work synchronously for next subscribers
299[info] - IO.eval(error).memoizeOnSuccess should not be idempotent
300[info] - IO.eval.memoizeOnSuccess
301[info] - IO.eval.memoizeOnSuccess should be stack safe
302[info] - IO.eval.flatMap.memoizeOnSuccess should be stack safe
303[info] - IO.defer(evalAlways).memoizeOnSuccess
304[info] - IO.evalOnce.memoizeOnSuccess should work for first subscriber
305[info] - IO.evalOnce.memoizeOnSuccess should work synchronously for next subscribers
306[info] - IO.evalOnce(error).memoizeOnSuccess should work
307[info] - IO.evalOnce.memoizeOnSuccess should be stack safe
308[info] - IO.evalOnce.flatMap.memoizeOnSuccess should be stack safe
309[info] - IO.now.memoizeOnSuccess should work synchronously for first subscriber
310[info] - IO.now.memoizeOnSuccess should work synchronously for next subscribers
311[info] - IO.raiseError.memoizeOnSuccess should work
312[info] - IO.terminate.memoizeOnSuccess should work
313[info] - IO.now.memoizeOnSuccess should be stack safe
314[info] - IO.now.flatMap.memoizeOnSuccess should be stack safe
315[info] - IO.suspend.memoizeOnSuccess should be stack safe
316[info] - IO.memoizeOnSuccess effects, sequential
317[info] - IO.memoizeOnSuccess effects, parallel
318[info] - IO.suspend.memoizeOnSuccess effects
319[info] - IO.suspend.flatMap.memoizeOnSuccess effects
320[info] - IO.memoizeOnSuccess should make subsequent subscribers wait for the result, as future
321[info] - IO.memoizeOnSuccess should make subsequent subscribers wait for the result, as callback
322[info] - IO.memoizeOnSuccess should be synchronous for subsequent subscribers, as callback
323[info] - IO.memoizeOnSuccess should be cancellable (future)
324[info] - IO.memoizeOnSuccess should be cancellable (callback #1)
325[info] - IO.memoizeOnSuccess should be cancellable (callback #2)
326[info] - IO.memoizeOnSuccess should not be cancelable
327[info] - IO.evalAsync(error).memoizeOnSuccess can register multiple listeners
328[info] - IO.evalOnce eq IO.evalOnce.memoizeOnSuccess
329[info] - IO.eval.memoizeOnSuccess eq IO.eval.memoizeOnSuccess.memoizeOnSuccess
330[info] - IO.eval.memoize eq IO.eval.memoize.memoizeOnSuccess
331[info] - IO.eval.map.memoize eq IO.eval.map.memoize.memoizeOnSuccess
332[info] - IO.now.memoizeOnSuccess eq IO.now
333[info] - IO.raiseError.memoizeOnSuccess eq IO.raiseError
334[info] - IO.terminate.memoizeOnSuccess eq IO.terminate
335[info] monix.bio.TaskParSequenceSuite
336[info] - IO.parSequence should execute in parallel for async tasks
337[info] - IO.parSequence should onError if one of the tasks terminates in error
338[info] - IO.parSequence should onTerminate if one of the tasks terminates in a fatal error
339[info] - IO.parSequence should be canceled
340[info] - IO.parSequence should be stack safe for synchronous tasks
341[info] - IO.parSequence runAsync multiple times
342[info] - IO.parSequence should log errors if multiple errors happen
343[info] - IO.parSequence should log terminal errors if multiple errors happen
344[info] monix.bio.TaskConnectionCompositeSuite
345[info] - cancels Cancelable references
346[info] - cancels Cancelable references after cancel on assignment
347[info] - cancels Task references
348[info] - cancels Task references after cancel on assignment
349[info] - cancels CancelableF references
350[info] - cancels CancelableF references after cancel on assignment
351[info] - addAll
352[info] - remove Task
353[info] - remove Cancelable
354[info] - remove CancelableF
355[info] monix.bio.TaskBimapSuite
356[info] - IO.bimap should map the success channel
357[info] - IO.bimap should map the error channel
358[info] monix.bio.TaskParTraverseSuite
359[info] - IO.parTraverse should execute in parallel for async tasks
360[info] - IO.parTraverse should onError if one of the tasks terminates in error
361[info] - IO.parTraverse should onTerminate if one of the tasks terminates in unexpected error
362[info] - IO.parTraverse should be canceled
363[info] - IO.parTraverse should be stack safe for synchronous tasks
364[info] - IO.parTraverse runAsync multiple times
365[info] - IO.parTraverse should wrap exceptions in the function
366[info] monix.bio.IOMapNSuite
367[info] - IO#map2 should yield value successfully
368[info] - IO#map2 should propagate error when one argument failed
369[info] - IO#map2 should protect against user code
370[info] - IO#map2 should run effects in strict sequence
371[info] - IO#map3 should yield value successfully
372[info] - IO#map3 should propagate error when one argument failed
373[info] - IO#map3 should protect against user code
374[info] - IO#map3 should run effects in strict sequence
375[info] - IO#map4 should yield value successfully
376[info] - IO#map4 should propagate error when one argument failed
377[info] - IO#map4 should protect against user code
378[info] - IO#map4 should run effects in strict sequence
379[info] - IO#map5 should yield value successfully
380[info] - IO#map5 should propagate error when one argument failed
381[info] - IO#map5 should protect against user code
382[info] - IO#map5 should run effects in strict sequence
383[info] - IO#map6 should yield value successfully
384[info] - IO#map6 should propagate error when one argument failed
385[info] - IO#map6 should protect against user code
386[info] - IO#map6 should run effects in strict sequence
387[info] monix.bio.TaskConversionsSuite
388[info] - IO.now(value).to[CIO]
389[info] - IO.eval(thunk).to[CIO]
390[info] - IO.eval(thunk).executeAsync.to[CIO]
391[info] - IO.evalTotal(thunk).to[CIO]
392[info] - IO.evalTotal(thunk).executeAsync.to[CIO]
393[info] - IO.raiseError(dummy).to[CIO]
394[info] - IO.raiseError(dummy).executeAsync.to[CIO]
395[info] - IO.terminate(dummy).to[CIO]
396[info] - IO.terminate(dummy).executeAsync.to[CIO]
397[info] - IO.toAsync converts successful tasks
398[info] - IO.toAsync converts tasks with typed errors
399[info] - IO.toAsync converts tasks with terminal errors
400[info] - IO.toConcurrent converts successful tasks
401[info] - IO.toConcurrent converts tasks with typed errors
402[info] - IO.toConcurrent converts tasks with terminal errors
403[info] - IO.fromEffect(task)) <-> task
404[info] - IO.fromEffect(task.toAsync[Task]) <-> task
405[info] - IO.fromEffect(task.toAsync[CIO]) <-> task
406[info] - IO.fromEffect(task.toAsync[F]) <-> task
407[info] - IO.fromEffect converts `IO`
408[info] - IO.fromEffect converts valid custom effects
409[info] - IO.fromEffect doesn't convert invalid custom effects
410[info] - IO.fromEffect(task.toConcurrent[IO]) preserves cancellability
411[info] - IO.fromConcurrentEffect(task) <-> task
412[info] - IO.fromConcurrentEffect(task.toConcurrent[Task]) <-> task
413[info] - IO.fromConcurrentEffect(task.toConcurrent[IO]) <-> task
414[info] - IO.fromConcurrentEffect(task.toConcurrent[F]) <-> task
415[info] - IO.fromConcurrentEffect converts `IO`
416[info] - IO.fromConcurrentEffect converts valid custom effects
417[info] - IO.fromConcurrentEffect doesn't convert invalid custom effects
418[info] - IO.fromConcurrentEffect preserves cancellability of an `IO`
419[info] - IO.fromConcurrentEffect preserves cancellability of a custom effect
420[info] - IO.fromConcurrentEffect(task.toConcurrent[IO]) preserves cancellability
421[info] - IO.fromConcurrentEffect(task.toConcurrent[CIO]) preserves cancellability
422[info] - IO.fromReactivePublisher converts `.onNext` callbacks
423[info] - IO.fromReactivePublisher converts `.onComplete` callbacks
424[info] - IO.fromReactivePublisher converts `.onError` callbacks
425[info] - IO.fromReactivePublisher protects against user errors
426[info] - IO.fromReactivePublisher is cancelable
427[info] - IO.fromReactivePublisher <-> Task
428[info] monix.bio.IOFromFutureEitherSuite
429[info] - IO.fromFutureEither should return success channel for Right
430[info] - IO.fromFutureEither should return checked failure channel for Left
431[info] - IO.fromFutureEither should return unchecked failure channel for a failed Future
432[info] - IO.fromFutureEither(cancelable) should work for Right synchronous results onSuccess
433[info] - IO.fromFutureEither(cancelable) should work for Left synchronous results onSuccess
434[info] - IO.fromFutureEither(cancelable) should work for synchronous results onFailure
435[info] - IO.fromFutureEither(cancelable) should be short-circuited for Right onSuccess
436[info] - IO.fromFutureEither(cancelable) should be short-circuited for Left onSuccess
437[info] - IO.fromFutureEither(cancelable) should be short-circuited onError
438[info] - IO.fromFutureEither(cancelable) should work onSuccess
439[info] - IO.fromFutureEither(cancelable) should work onError
440[info] - IO.fromFutureEither(cancelable) should be cancelable
441[info] - IO.fromFutureEither should be stack safe
442[info] monix.bio.TaskDoOnCancelSuite
443[info] - doOnCancel should normally mirror the source
444[info] - doOnCancel should mirror failed sources
445[info] - doOnCancel should mirror terminated sources
446[info] - doOnCancel should cancel delayResult #1
447[info] - doOnCancel should cancel delayResult #2
448[info] - doOnCancel should cancel delayResult #3
449[info] - doOnCancel should cancel delayExecution #1
450[info] - doOnCancel should cancel delayExecution #2
451[info] - doOnCancel is stack safe in flatMap loops
452[info] - local.write.doOnCancel works
453[info] monix.bio.TaskParTraverseUnorderedSuite
454[info] - IO.parTraverseUnordered should execute in parallel
455[info] - IO.parTraverseUnordered should onError if one of the tasks terminates in error
456[info] - IO.parTraverseUnordered should be canceled
457[info] - IO.parTraverseUnordered should run over an iterable
458[info] - IO.parTraverseUnordered should be stack-safe on handling many tasks
459[info] - IO.parTraverseUnordered should be stack safe on success
460[info] - IO.parTraverseUnordered should log errors if multiple errors happen
461[info] - IO.parTraverseUnordered runAsync multiple times
462[info] - IO.parTraverseUnordered should wrap exceptions in the function
463[info] monix.bio.TaskMemoizeSuite
464[info] - IO.memoize should work asynchronously for first subscriber
465[info] - IO.memoize should work synchronously for next subscribers
466[info] - IO.memoize should be stack safe
467[info] - IO.flatMap.memoize should be stack safe, test 1
468[info] - IO.flatMap.memoize should be stack safe, test 2
469[info] - IO.raiseError(error).memoize should work
470[info] - IO.terminate(error).memoize should work
471[info] - IO.memoize.materialize
472[info] - IO.apply(error).memoize.materialize
473[info] - IO.eval.memoize should work for first subscriber
474[info] - IO.eval.memoize should work synchronously for next subscribers
475[info] - IO.eval(error).memoize should work
476[info] - IO.eval.memoize
477[info] - IO.eval.memoize should be stack safe
478[info] - IO.eval.flatMap.memoize should be stack safe
479[info] - IO.defer(evalAlways).memoize
480[info] - IO.evalOnce.memoize should work for first subscriber
481[info] - IO.evalOnce.memoize should work synchronously for next subscribers
482[info] - IO.evalOnce(error).memoize should work
483[info] - IO.evalOnce.memoize should be stack safe
484[info] - IO.evalOnce.flatMap.memoize should be stack safe
485[info] - IO.now.memoize should work synchronously for first subscriber
486[info] - IO.now.memoize should work synchronously for next subscribers
487[info] - IO.error.memoize should work
488[info] - IO.now.memoize should be stack safe
489[info] - IO.now.flatMap.memoize should be stack safe
490[info] - IO.defer.memoize should be stack safe
491[info] - IO.memoize effects, sequential
492[info] - IO.memoize effects, parallel
493[info] - IO.suspend.memoize effects
494[info] - IO.suspend.flatMap.memoize effects
495[info] - IO.memoize should make subsequent subscribers wait for the result, as future
496[info] - IO.memoize should make subsequent subscribers wait for the result, as callback
497[info] - Task.memoize should be synchronous for subsequent subscribers, as callback
498[info] - IO.memoize should not be cancelable (future)
499[info] - IO.memoize should be cancelable (callback, #1)
500[info] - IO.memoize should be cancelable (callback, #2)
501[info] - IO.memoize should be re-executable after cancel
502[info] - IO.memoize should not be uninterruptible
503[info] - IO.memoize serves error after async boundary
504[info] - TaskRunLoop.startLightWithBiCallback for success
505[info] - TaskRunLoop.startLightWithBiCallback for failure
506[info] - IO.evalOnce eq IO.evalOnce.memoize
507[info] - IO.eval.memoize eq IO.eval.memoize.memoize
508[info] - IO.eval.map.memoize eq IO.eval.map.memoize.memoize
509[info] - IO.now.memoize eq IO.now
510[info] - IO.raiseError.memoize eq IO.raiseError
511[info] - IO.terminate.memoize eq IO.raiseError
512[info] - IO.eval.memoizeOnSuccess.memoize !== IO.eval.memoizeOnSuccess
513[info] monix.bio.TaskConnectionSuite
514[info] - initial push
515[info] - cancels Task after being canceled
516[info] - cancels Cancelable after being canceled
517[info] - cancels CancelableF after being canceled
518[info] - push two, pop one
519[info] - cancel the second time is a no-op
520[info] - push two, pop two
521[info] - push(Cancelable)
522[info] - push(Cancelable) then pop
523[info] - push(CancelToken)
524[info] - push(CancelToken) then pop
525[info] - pop when self is empty
526[info] - pop when self is canceled
527[info] - cancel mixture
528[info] - cancel mixture after being cancelled
529[info] - tryReactive
530[info] - toCancelable
531[info] - uncancelable ref is shared
532[info] - uncancelable ops
533[info] - throwing error in Task on cancel all
534[info] - throwing multiple errors in Tasks on cancel all
535[info] - throwing error in Task after cancel
536[info] - throwing error in Cancelable on cancel all
537[info] - throwing multiple errors in Cancelables on cancel all
538[info] - throwing error in Cancelable after cancel
539[info] monix.bio.TaskBlockingSuite
540[info] - blocking on future should work
541[info] - blocking on async
542[info] - blocking on async.flatMap
543[info] - blocking with Termination result
544[info] - IO.eval(throw ex).attempt.runSyncUnsafe
545[info] - IO.evalTotal(throw ex).onErrorHandle.runSyncUnsafe
546[info] - IO.suspend(throw ex).attempt.runSyncUnsafe
547[info] - IO.suspendTotal(throw ex).onErrorHandle.runSyncUnsafe
548[info] - blocking on memoize
549[info] - timeout exception
550[info] - IO.attempt.runSyncUnsafe works
551[info] monix.bio.TaskTraverseSuite
552[info] - IO.traverse should not execute in parallel
553[info] - IO.traverse should onError if one of the tasks terminates in error
554[info] - IO.traverse should onError if one of the tasks terminates in error
555[info] - IO.traverse should be canceled
556[info] monix.bio.TaskOptionsSuite
557[info] - change options with future
558[info] - change options with callback
559[info] monix.bio.TaskClockTimerAndContextShiftSuite
560[info] - IO.clock is implicit
561[info] - IO.clock.monotonic
562[info] - IO.clock.realTime
563[info] - IO.clock(s2).monotonic
564[info] - IO.clock(s).realTime
565[info] - IO.timer is implicit
566[info] - IO.timer
567[info] - IO.timer(s)
568[info] - IO.timer(s).clock
569[info] - IO.contextShift is implicit
570[info] - IO.contextShift.shift
571[info] - IO.contextShift.evalOn(s2)
572[info] - IO.contextShift.evalOn(s2) failure
573[info] - IO.contextShift.evalOn(s2) fatal failure
574[info] - IO.contextShift.evalOn(s2) uses s2 for async boundaries
575[info] - IO.contextShift.evalOn(s2) injects s2 to IO.deferAction
576[info] - IO.contextShift(s).shift
577[info] - IO.contextShift(s).evalOn(s2)
578[info] - IO.contextShift(s).evalOn(s2) failure
579[info] - IO.contextShift(s).evalOn(s2) fatal failure
580[info] - IO.contextShift(s).evalOn(s2) uses s2 for async boundaries
581[info] - IO.contextShift(s).evalOn(s2) injects s2 to IO.deferAction
582[info] monix.bio.TaskFromFutureSuite
583[info] - Task.fromFuture should be faster for completed futures, success
584[info] - Task.fromFuture should be faster for completed futures, failure
585[info] - Task.fromFuture should work onSuccess
586[info] - Task.fromFuture should work onError
587[info] - Task.fromFuture should be short-circuited onSuccess
588[info] - Task.fromFuture should be short-circuited onError
589[info] - Task.fromFuture(cancelable) should work for synchronous results onSuccess
590[info] - Task.fromFuture(cancelable) should work for synchronous results onFailure
591[info] - Task.fromFuture(cancelable) should be short-circuited onSuccess
592[info] - Task.fromFuture(cancelable) should be short-circuited onError
593[info] - Task.fromFuture(cancelable) should work onSuccess
594[info] - Task.fromFuture(cancelable) should work onError
595[info] - Task.fromFuture(cancelable) should be cancelable
596[info] - Task.fromFuture should be stack safe
597[info] - Task.now.fromFuture should be stack safe
598[info] monix.bio.TaskTerminationSuite
599[info] - IO#redeemCause should mirror source on success
600[info] - IO#redeemCause should recover typed error
601[info] - IO#redeemCause should recover unexpected error
602[info] - IO#redeemCause should protect against user code
603[info] - IO#redeemCauseWith derives flatMap
604[info] - IO#redeemCauseWith should mirror source on success
605[info] - IO#redeemCauseWith should recover typed error
606[info] - IO#redeemCauseWith should recover unexpected error
607[info] - IO#redeemCauseWith should protect against user code
608[info] monix.bio.TaskMaterializeSuite
609[info] - IO.now.materialize
610[info] - IO.error.materialize
611[info] - IO.terminate.materialize
612[info] - IO.evalOnce.materialize should be stack safe
613[info] - IO.eval.materialize
614[info] - IO.defer.materialize
615[info] - IO.defer.flatMap.materialize
616[info] - IO.flatMap.materialize
617[info] - IO.evalAsync.materialize
618[info] - IO.evalAsync.flatMap.materialize
619[info] - IO.evalAsync(error).flatMap.materialize
620[info] - IO.now.flatMap(error).materialize
621[info] - IO.defer(error).materialize
622[info] - IO.deferTotal(error).materialize
623[info] - IO.defer(error).flatMap.materialize
624[info] - IO.now.dematerialize
625[info] - IO.error.dematerialize
626[info] - IO.materialize should be stack safe
627[info] - IO.eval.materialize should work for failure
628[info] - IO.eval.materialize should be stack safe
629[info] - IO.now.materialize should work
630[info] - IO.materialize on failing flatMap
631[info] - IO.now.materialize should be stack safe
632[info] - IO.raiseError.dematerialize
633[info] - IO.terminate.dematerialize
634[info] monix.bio.TaskToFutureSuite
635[info] - Task.fromFuture for already completed references
636[info] - Task.deferFuture for already completed references
637[info] - Task.deferFutureAction for already completed references
638[info] - Task.fromFuture(error) for already completed references
639[info] - Task.deferFuture(error) for already completed references
640[info] - Task.deferFutureAction(typed) for already completed references
641[info] - Task.fromFuture for completed reference is stack safe (flatMap)
642[info] - Task.deferFuture for completed reference is stack safe (flatMap)
643[info] - Task.deferFutureAction for completed reference is stack safe (flatMap)
644[info] - Task.fromFuture async result
645[info] - Task.fromFuture(error) async result
646[info] - Task.deferFuture async result
647[info] - Task.deferFuture(error) async result
648[info] - Task.deferFuture(throw error) async result
649[info] - Task.deferFutureAction async result
650[info] - Task.deferFutureAction(error) async result
651[info] - Task.deferFutureAction(throw error) async result
652[info] - Task.fromFuture(cancelable)
653[info] - Task.fromFuture(cancelable) is cancelable
654[info] - Task.deferFuture(cancelable)
655[info] - Task.deferFuture(cancelable) is cancelable
656[info] - Task.deferFutureAction(cancelable)
657[info] - Task.deferFutureAction(cancelable) is cancelable
658[info] monix.bio.TaskExecutionModelSuite
659[info] - IO.now.executeWithModel(AlwaysAsyncExecution) should work
660[info] - IO.now.runAsync (CancelableFuture) should not be async with AlwaysAsyncExecution
661[info] - IO.eval.executeWithModel(AlwaysAsyncExecution) should work
662[info] - IO.eval should be async with AlwaysAsyncExecution
663[info] - IO.now.flatMap loops should work with AlwaysAsyncExecution
664[info] - IO.eval.flatMap loops should work with AlwaysAsyncExecution
665[info] - IO.flatMap loops should work with AlwaysAsyncExecution
666[info] monix.bio.TaskFlatMapSuite
667[info] - runAsync flatMap loop is not cancelable if autoCancelableRunLoops=false
668[info] - runAsync flatMap loop is cancelable if ExecutionModel permits
669[info] - runAsync(callback) flatMap loop is cancelable if ExecutionModel permits
670[info] - redeemWith derives flatMap
671[info] - redeemWith derives onErrorHandleWith
672[info] - redeem derives map . onErrorHandle
673[info] - redeem derives onErrorHandle
674[info] - redeemWith can recover
675[info] - redeem can recover
676[info] - >> is stack safe for infinite loops
677[info] - flatMapLoop enables loops
678[info] monix.bio.TaskDeferActionSuite
679[info] - IO.deferAction works
680[info] - IO.deferAction works for failed tasks
681[info] - IO.deferAction protects against user error
682[info] - IO.deferAction should properly cast errors
683[info] - IO.deferAction is stack safe
684[info] - IO.deferAction(local.write) works
685[info] monix.bio.TaskCancellationSuite
686[info] - cancellation works for async actions
687[info] - cancellation works for autoCancelableRunLoops
688[info] - task.start.flatMap(fa => fa.cancel.flatMap(_ => fa)) <-> UIO.never
689[info] - uncancelable works for async actions
690[info] - uncancelable works for autoCancelableRunLoops
691[info] - uncancelable is stack safe in flatMap loop, take 1
692[info] - uncancelable is stack safe in flatMap loop, take 2
693[info] - fa.onCancelRaiseError <-> fa
694[info] - fa.onCancelRaiseError(e).start.flatMap(fa => fa.cancel.flatMap(_ => fa)) <-> raiseError(e)
695[info] - cancelBoundary happy path
696[info] - cancelBoundary execution is immediate
697[info] - cancelBoundary is stack safe
698[info] - cancelBoundary cancels
699[info] - onCancelRaiseError resets cancellation flag
700[info] - errors raised after cancel get reported
701[info] - terminal errors raised after cancel get reported
702[info] - onCancelRaiseError is stack safe in flatMap loop, take 1
703[info] - onCancelRaiseError is stack safe in flatMap loop, take 2
704[info] - local.write.uncancelable works
705[info] - local.write.onCancelRaiseError works
706[info] monix.bio.TaskGuaranteeSuite
707[info] - finalizer is evaluated on success
708[info] - finalizer is evaluated on error
709[info] - finalizer is evaluated on terminal error
710[info] - if finalizer throws, report finalizer error and signal use error
711[info] - finalizer is evaluated on cancelation (1)
712[info] - finalizer is evaluated on cancellation (2)
713[info] - stack-safety (1)
714[info] - stack-safety (2)
715[info] - stack-safety (3)
716[info] monix.bio.TaskSequenceSuite
717[info] - IO.sequence should not execute in parallel
718[info] - IO.sequence should onError if one of the tasks terminates in error
719[info] - IO.sequence should onTerminate if one of the tasks terminates in error
720[info] - IO.sequence should be canceled
721[info] monix.bio.TypeClassLawsForTaskAutoCancelableSuite
722[info] - CoflatMap[Task].coflatMap.coflatMap associativity
723[info] - CoflatMap[Task].coflatMap.coflatMap identity
724[info] - CoflatMap[Task].coflatMap.coflatten coherence
725[info] - CoflatMap[Task].coflatMap.coflatten throughMap
726[info] - CoflatMap[Task].coflatMap.covariant composition
727[info] - CoflatMap[Task].coflatMap.covariant identity
728[info] - CoflatMap[Task].coflatMap.invariant composition
729[info] - CoflatMap[Task].coflatMap.invariant identity
730[info] - Concurrent[Task].concurrent.acquire and release of bracket are uncancelable
731[info] - Concurrent[Task].concurrent.acquire of bracket is not cancelable
732[info] - Concurrent[Task].concurrent.an action run concurrently with a pure value is the same as just doing that action
733[info] - Concurrent[Task].concurrent.ap consistent with product + map
734[info] - Concurrent[Task].concurrent.applicative homomorphism
735[info] - Concurrent[Task].concurrent.applicative identity
736[info] - Concurrent[Task].concurrent.applicative interchange
737[info] - Concurrent[Task].concurrent.applicative map
738[info] - Concurrent[Task].concurrent.applicative unit
739[info] - Concurrent[Task].concurrent.applicativeError adaptError pure
740[info] - Concurrent[Task].concurrent.applicativeError adaptError raise
741[info] - Concurrent[Task].concurrent.applicativeError attempt consistent with attemptT
742[info] - Concurrent[Task].concurrent.applicativeError attempt fromEither consistent with pure
743[info] - Concurrent[Task].concurrent.applicativeError handle
744[info] - Concurrent[Task].concurrent.applicativeError handleError . raiseError left-distributes over ap
745[info] - Concurrent[Task].concurrent.applicativeError handleError . raiseError right-distributes over ap
746[info] - Concurrent[Task].concurrent.applicativeError handleError consistent with recover
747[info] - Concurrent[Task].concurrent.applicativeError handleError pure
748[info] - Concurrent[Task].concurrent.applicativeError handleErrorWith consistent with recoverWith
749[info] - Concurrent[Task].concurrent.applicativeError handleErrorWith pure
750[info] - Concurrent[Task].concurrent.applicativeError handleWith
751[info] - Concurrent[Task].concurrent.applicativeError onError pure
752[info] - Concurrent[Task].concurrent.applicativeError onError raise
753[info] - Concurrent[Task].concurrent.applicativeError pure attempt
754[info] - Concurrent[Task].concurrent.applicativeError raiseError attempt
755[info] - Concurrent[Task].concurrent.applicativeError recover consistent with recoverWith
756[info] - Concurrent[Task].concurrent.applicativeError redeem is derived from attempt and map
757[info] - Concurrent[Task].concurrent.apply composition
758[info] - Concurrent[Task].concurrent.async can be derived from asyncF
759[info] - Concurrent[Task].concurrent.async cancelable coherence
760[info] - Concurrent[Task].concurrent.async cancelable receives cancel signal
761[info] - Concurrent[Task].concurrent.async left is raiseError
762[info] - Concurrent[Task].concurrent.async right is pure
763[info] - Concurrent[Task].concurrent.asyncF registration can be cancelled
764[info] - Concurrent[Task].concurrent.bind suspends evaluation
765[info] - Concurrent[Task].concurrent.bracket is derived from bracketCase
766[info] - Concurrent[Task].concurrent.bracket release is called on Completed or Error
767[info] - Concurrent[Task].concurrent.bracket release is called on cancel
768[info] - Concurrent[Task].concurrent.bracketCase with failure in acquisition remains failure
769[info] - Concurrent[Task].concurrent.bracketCase with pure unit on release is eqv to map
770[info] - Concurrent[Task].concurrent.bracketCase with pure unit on release is eqv to uncancelable(..).flatMap
771[info] - Concurrent[Task].concurrent.covariant composition
772[info] - Concurrent[Task].concurrent.covariant identity
773[info] - Concurrent[Task].concurrent.delay constant is pure
774[info] - Concurrent[Task].concurrent.flatMap associativity
775[info] - Concurrent[Task].concurrent.flatMap consistent apply
776[info] - Concurrent[Task].concurrent.flatMap from tailRecM consistency
777[info] - Concurrent[Task].concurrent.guarantee is derived from bracket
778[info] - Concurrent[Task].concurrent.guaranteeCase is derived from bracketCase
779[info] - Concurrent[Task].concurrent.invariant composition
780[info] - Concurrent[Task].concurrent.invariant identity
781[info] - Concurrent[Task].concurrent.join is idempotent
782[info] - Concurrent[Task].concurrent.map flatMap coherence
783[info] - Concurrent[Task].concurrent.map suspends evaluation
784[info] - Concurrent[Task].concurrent.map2/map2Eval consistency
785[info] - Concurrent[Task].concurrent.map2/product-map consistency
786[info] - Concurrent[Task].concurrent.monad left identity
787[info] - Concurrent[Task].concurrent.monad right identity
788[info] - Concurrent[Task].concurrent.monadError ensure consistency
789[info] - Concurrent[Task].concurrent.monadError ensureOr consistency
790[info] - Concurrent[Task].concurrent.monadError left zero
791[info] - Concurrent[Task].concurrent.monadError redeemWith is derived from attempt and flatMap
792[info] - Concurrent[Task].concurrent.monadError rethrow attempt
793[info] - Concurrent[Task].concurrent.monoidal left identity
794[info] - Concurrent[Task].concurrent.monoidal right identity
795[info] - Concurrent[Task].concurrent.mproduct consistent flatMap
796[info] - Concurrent[Task].concurrent.never is derived from async
797[info] - Concurrent[Task].concurrent.onCancel is derived from guaranteeCase
798[info] - Concurrent[Task].concurrent.productL consistent map2
799[info] - Concurrent[Task].concurrent.productR consistent map2
800[info] - Concurrent[Task].concurrent.propagate errors through bind (async)
801[info] - Concurrent[Task].concurrent.propagate errors through bind (suspend)
802[info] - Concurrent[Task].concurrent.race cancels both
803[info] - Concurrent[Task].concurrent.race cancels loser
804[info] - Concurrent[Task].concurrent.race mirrors left winner
805[info] - Concurrent[Task].concurrent.race mirrors right winner
806[info] - Concurrent[Task].concurrent.racePair can join left
807[info] - Concurrent[Task].concurrent.racePair can join right
808[info] - Concurrent[Task].concurrent.racePair cancels both
809[info] - Concurrent[Task].concurrent.racePair cancels loser
810[info] - Concurrent[Task].concurrent.racePair mirrors left winner
811[info] - Concurrent[Task].concurrent.racePair mirrors right winner
812[info] - Concurrent[Task].concurrent.release of bracket is not cancelable
813[info] - Concurrent[Task].concurrent.repeated async evaluation not memoized
814[info] - Concurrent[Task].concurrent.repeated asyncF evaluation not memoized
815[info] - Concurrent[Task].concurrent.repeated sync evaluation not memoized
816[info] - Concurrent[Task].concurrent.semigroupal associativity
817[info] - Concurrent[Task].concurrent.stack-safe on bracket with left-associated binds
818[info] - Concurrent[Task].concurrent.stack-safe on bracket with right-associated binds
819[info] - Concurrent[Task].concurrent.stack-safe on guarantee with left-associated binds
820[info] - Concurrent[Task].concurrent.stack-safe on guarantee with right-associated binds
821[info] - Concurrent[Task].concurrent.stack-safe on left-associated binds
822[info] - Concurrent[Task].concurrent.stack-safe on repeated attempts
823[info] - Concurrent[Task].concurrent.stack-safe on repeated maps
824[info] - Concurrent[Task].concurrent.stack-safe on right-associated binds
825[info] - Concurrent[Task].concurrent.start then join is identity
826[info] - Concurrent[Task].concurrent.start.flatMap(_.cancel) is unit
827[info] - Concurrent[Task].concurrent.suspend constant is pure join
828[info] - Concurrent[Task].concurrent.tailRecM consistent flatMap
829[info] - Concurrent[Task].concurrent.tailRecM stack safety
830[info] - Concurrent[Task].concurrent.throw in delay is raiseError
831[info] - Concurrent[Task].concurrent.throw in suspend is raiseError
832[info] - Concurrent[Task].concurrent.uncancelable mirrors source
833[info] - Concurrent[Task].concurrent.uncancelable prevents Cancelled case
834[info] - Concurrent[Task].concurrent.uncancelable prevents cancellation
835[info] - Concurrent[Task].concurrent.unsequenced delay is no-op
836[info] - ConcurrentEffect[Task].concurrentEffect.acquire and release of bracket are uncancelable
837[info] - ConcurrentEffect[Task].concurrentEffect.acquire of bracket is not cancelable
838[info] - ConcurrentEffect[Task].concurrentEffect.an action run concurrently with a pure value is the same as just doing that action
839[info] - ConcurrentEffect[Task].concurrentEffect.ap consistent with product + map
840[info] - ConcurrentEffect[Task].concurrentEffect.applicative homomorphism
841[info] - ConcurrentEffect[Task].concurrentEffect.applicative identity
842[info] - ConcurrentEffect[Task].concurrentEffect.applicative interchange
843[info] - ConcurrentEffect[Task].concurrentEffect.applicative map
844[info] - ConcurrentEffect[Task].concurrentEffect.applicative unit
845[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError adaptError pure
846[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError adaptError raise
847[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError attempt consistent with attemptT
848[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError attempt fromEither consistent with pure
849[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError handle
850[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError handleError . raiseError left-distributes over ap
851[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError handleError . raiseError right-distributes over ap
852[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError handleError consistent with recover
853[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError handleError pure
854[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError handleErrorWith consistent with recoverWith
855[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError handleErrorWith pure
856[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError handleWith
857[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError onError pure
858[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError onError raise
859[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError pure attempt
860[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError raiseError attempt
861[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError recover consistent with recoverWith
862[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError redeem is derived from attempt and map
863[info] - ConcurrentEffect[Task].concurrentEffect.apply composition
864[info] - ConcurrentEffect[Task].concurrentEffect.async can be derived from asyncF
865[info] - ConcurrentEffect[Task].concurrentEffect.async cancelable coherence
866[info] - ConcurrentEffect[Task].concurrentEffect.async cancelable receives cancel signal
867[info] - ConcurrentEffect[Task].concurrentEffect.async left is raiseError
868[info] - ConcurrentEffect[Task].concurrentEffect.async right is pure
869[info] - ConcurrentEffect[Task].concurrentEffect.asyncF registration can be cancelled
870[info] - ConcurrentEffect[Task].concurrentEffect.bind suspends evaluation
871[info] - ConcurrentEffect[Task].concurrentEffect.bracket is derived from bracketCase
872[info] - ConcurrentEffect[Task].concurrentEffect.bracket release is called on Completed or Error
873[info] - ConcurrentEffect[Task].concurrentEffect.bracket release is called on cancel
874[info] - ConcurrentEffect[Task].concurrentEffect.bracketCase with failure in acquisition remains failure
875[info] - ConcurrentEffect[Task].concurrentEffect.bracketCase with pure unit on release is eqv to map
876[info] - ConcurrentEffect[Task].concurrentEffect.bracketCase with pure unit on release is eqv to uncancelable(..).flatMap
877[info] - ConcurrentEffect[Task].concurrentEffect.covariant composition
878[info] - ConcurrentEffect[Task].concurrentEffect.covariant identity
879[info] - ConcurrentEffect[Task].concurrentEffect.delay constant is pure
880[info] - ConcurrentEffect[Task].concurrentEffect.flatMap associativity
881[info] - ConcurrentEffect[Task].concurrentEffect.flatMap consistent apply
882[info] - ConcurrentEffect[Task].concurrentEffect.flatMap from tailRecM consistency
883[info] - ConcurrentEffect[Task].concurrentEffect.guarantee is derived from bracket
884[info] - ConcurrentEffect[Task].concurrentEffect.guaranteeCase is derived from bracketCase
885[info] - ConcurrentEffect[Task].concurrentEffect.invariant composition
886[info] - ConcurrentEffect[Task].concurrentEffect.invariant identity
887[info] - ConcurrentEffect[Task].concurrentEffect.join is idempotent
888[info] - ConcurrentEffect[Task].concurrentEffect.map flatMap coherence
889[info] - ConcurrentEffect[Task].concurrentEffect.map suspends evaluation
890[info] - ConcurrentEffect[Task].concurrentEffect.map2/map2Eval consistency
891[info] - ConcurrentEffect[Task].concurrentEffect.map2/product-map consistency
892[info] - ConcurrentEffect[Task].concurrentEffect.monad left identity
893[info] - ConcurrentEffect[Task].concurrentEffect.monad right identity
894[info] - ConcurrentEffect[Task].concurrentEffect.monadError ensure consistency
895[info] - ConcurrentEffect[Task].concurrentEffect.monadError ensureOr consistency
896[info] - ConcurrentEffect[Task].concurrentEffect.monadError left zero
897[info] - ConcurrentEffect[Task].concurrentEffect.monadError redeemWith is derived from attempt and flatMap
898[info] - ConcurrentEffect[Task].concurrentEffect.monadError rethrow attempt
899[info] - ConcurrentEffect[Task].concurrentEffect.monoidal left identity
900[info] - ConcurrentEffect[Task].concurrentEffect.monoidal right identity
901[info] - ConcurrentEffect[Task].concurrentEffect.mproduct consistent flatMap
902[info] - ConcurrentEffect[Task].concurrentEffect.never is derived from async
903[info] - ConcurrentEffect[Task].concurrentEffect.onCancel is derived from guaranteeCase
904[info] - ConcurrentEffect[Task].concurrentEffect.productL consistent map2
905[info] - ConcurrentEffect[Task].concurrentEffect.productR consistent map2
906[info] - ConcurrentEffect[Task].concurrentEffect.propagate errors through bind (async)
907[info] - ConcurrentEffect[Task].concurrentEffect.propagate errors through bind (suspend)
908[info] - ConcurrentEffect[Task].concurrentEffect.race cancels both
909[info] - ConcurrentEffect[Task].concurrentEffect.race cancels loser
910[info] - ConcurrentEffect[Task].concurrentEffect.race mirrors left winner
911[info] - ConcurrentEffect[Task].concurrentEffect.race mirrors right winner
912[info] - ConcurrentEffect[Task].concurrentEffect.racePair can join left
913[info] - ConcurrentEffect[Task].concurrentEffect.racePair can join right
914[info] - ConcurrentEffect[Task].concurrentEffect.racePair cancels both
915[info] - ConcurrentEffect[Task].concurrentEffect.racePair cancels loser
916[info] - ConcurrentEffect[Task].concurrentEffect.racePair mirrors left winner
917[info] - ConcurrentEffect[Task].concurrentEffect.racePair mirrors right winner
918[info] - ConcurrentEffect[Task].concurrentEffect.release of bracket is not cancelable
919[info] - ConcurrentEffect[Task].concurrentEffect.repeated async evaluation not memoized
920[info] - ConcurrentEffect[Task].concurrentEffect.repeated asyncF evaluation not memoized
921[info] - ConcurrentEffect[Task].concurrentEffect.repeated callback ignored
922[info] - ConcurrentEffect[Task].concurrentEffect.repeated sync evaluation not memoized
923[info] - ConcurrentEffect[Task].concurrentEffect.runAsync ignores error in handler
924[info] - ConcurrentEffect[Task].concurrentEffect.runAsync pure produces right IO
925[info] - ConcurrentEffect[Task].concurrentEffect.runAsync raiseError produces left IO
926[info] - ConcurrentEffect[Task].concurrentEffect.runAsync runCancelable coherence
927[info] - ConcurrentEffect[Task].concurrentEffect.runCancelable is synchronous
928[info] - ConcurrentEffect[Task].concurrentEffect.runCancelable start.flatMap(_.cancel) coherence
929[info] - ConcurrentEffect[Task].concurrentEffect.semigroupal associativity
930[info] - ConcurrentEffect[Task].concurrentEffect.stack-safe on bracket with left-associated binds
931[info] - ConcurrentEffect[Task].concurrentEffect.stack-safe on bracket with right-associated binds
932[info] - ConcurrentEffect[Task].concurrentEffect.stack-safe on guarantee with left-associated binds
933[info] - ConcurrentEffect[Task].concurrentEffect.stack-safe on guarantee with right-associated binds
934[info] - ConcurrentEffect[Task].concurrentEffect.stack-safe on left-associated binds
935[info] - ConcurrentEffect[Task].concurrentEffect.stack-safe on repeated attempts
936[info] - ConcurrentEffect[Task].concurrentEffect.stack-safe on repeated maps
937[info] - ConcurrentEffect[Task].concurrentEffect.stack-safe on right-associated binds
938[info] - ConcurrentEffect[Task].concurrentEffect.start then join is identity
939[info] - ConcurrentEffect[Task].concurrentEffect.start.flatMap(_.cancel) is unit
940[info] - ConcurrentEffect[Task].concurrentEffect.suspend constant is pure join
941[info] - ConcurrentEffect[Task].concurrentEffect.tailRecM consistent flatMap
942[info] - ConcurrentEffect[Task].concurrentEffect.tailRecM stack safety
943[info] - ConcurrentEffect[Task].concurrentEffect.throw in delay is raiseError
944[info] - ConcurrentEffect[Task].concurrentEffect.throw in suspend is raiseError
945[info] - ConcurrentEffect[Task].concurrentEffect.toIO is consistent with runAsync
946[info] - ConcurrentEffect[Task].concurrentEffect.toIO is consistent with runCancelable
947[info] - ConcurrentEffect[Task].concurrentEffect.toIO is the inverse of liftIO
948[info] - ConcurrentEffect[Task].concurrentEffect.toIO stack safety
949[info] - ConcurrentEffect[Task].concurrentEffect.uncancelable mirrors source
950[info] - ConcurrentEffect[Task].concurrentEffect.uncancelable prevents Cancelled case
951[info] - ConcurrentEffect[Task].concurrentEffect.uncancelable prevents cancellation
952[info] - ConcurrentEffect[Task].concurrentEffect.unsequenced delay is no-op
953[info] - CommutativeApplicative[IO.Par].commutative applicative.ap consistent with product + map
954[info] - CommutativeApplicative[IO.Par].commutative applicative.applicative homomorphism
955[info] - CommutativeApplicative[IO.Par].commutative applicative.applicative identity
956[info] - CommutativeApplicative[IO.Par].commutative applicative.applicative interchange
957[info] - CommutativeApplicative[IO.Par].commutative applicative.applicative map
958[info] - CommutativeApplicative[IO.Par].commutative applicative.applicative unit
959[info] - CommutativeApplicative[IO.Par].commutative applicative.apply commutativity
960[info] - CommutativeApplicative[IO.Par].commutative applicative.apply composition
961[info] - CommutativeApplicative[IO.Par].commutative applicative.covariant composition
962[info] - CommutativeApplicative[IO.Par].commutative applicative.covariant identity
963[info] - CommutativeApplicative[IO.Par].commutative applicative.invariant composition
964[info] - CommutativeApplicative[IO.Par].commutative applicative.invariant identity
965[info] - CommutativeApplicative[IO.Par].commutative applicative.map2/map2Eval consistency
966[info] - CommutativeApplicative[IO.Par].commutative applicative.map2/product-map consistency
967[info] - CommutativeApplicative[IO.Par].commutative applicative.monoidal left identity
968[info] - CommutativeApplicative[IO.Par].commutative applicative.monoidal right identity
969[info] - CommutativeApplicative[IO.Par].commutative applicative.productL consistent map2
970[info] - CommutativeApplicative[IO.Par].commutative applicative.productR consistent map2
971[info] - CommutativeApplicative[IO.Par].commutative applicative.semigroupal associativity
972[info] - Parallel[IO, IO.Par].parallel.isomorphic functor
973[info] - Parallel[IO, IO.Par].parallel.isomorphic pure
974[info] - Parallel[IO, IO.Par].parallel.parallel round trip
975[info] - Parallel[IO, IO.Par].parallel.sequential round trip
976[info] - Monoid[IO[String, Int]].monoid.associative
977[info] - Monoid[IO[String, Int]].monoid.collect0
978[info] - Monoid[IO[String, Int]].monoid.combine all
979[info] - Monoid[IO[String, Int]].monoid.combineAllOption
980[info] - Monoid[IO[String, Int]].monoid.intercalateCombineAllOption
981[info] - Monoid[IO[String, Int]].monoid.intercalateIntercalates
982[info] - Monoid[IO[String, Int]].monoid.intercalateRepeat1
983[info] - Monoid[IO[String, Int]].monoid.intercalateRepeat2
984[info] - Monoid[IO[String, Int]].monoid.is id
985[info] - Monoid[IO[String, Int]].monoid.left identity
986[info] - Monoid[IO[String, Int]].monoid.repeat0
987[info] - Monoid[IO[String, Int]].monoid.repeat1
988[info] - Monoid[IO[String, Int]].monoid.repeat2
989[info] - Monoid[IO[String, Int]].monoid.reverseCombineAllOption
990[info] - Monoid[IO[String, Int]].monoid.reverseRepeat1
991[info] - Monoid[IO[String, Int]].monoid.reverseRepeat2
992[info] - Monoid[IO[String, Int]].monoid.reverseReverses
993[info] - Monoid[IO[String, Int]].monoid.right identity
994[info] - SemigroupK[Task[Int]].semigroupK.semigroupK associative
995[info] - Bifunctor[IO[String, Int]].Bifunctor.Bifunctor Identity
996[info] - Bifunctor[IO[String, Int]].Bifunctor.Bifunctor associativity
997[info] - Bifunctor[IO[String, Int]].Bifunctor.Bifunctor leftMap Identity
998[info] - Bifunctor[IO[String, Int]].Bifunctor.Bifunctor leftMap associativity
999[info] monix.bio.TaskLikeConversionsSuite
1000[info] - IO.from(task.to[IO]) <-> task
1001[info] - IO.from converts successful Future
1002[info] - IO.from converts failed Future
1003[info] - IO.from converts successful sync IO
1004[info] - IO.from converts successful async IO
1005[info] - IO.from converts failed sync CIO
1006[info] - IO.from converts failed async IO
1007[info] - IO.from preserves cancellability of an IO
1008[info] - IO.from converts successful Eval
1009[info] - IO.from converts failed Eval
1010[info] - IO.from preserves Eval laziness
1011[info] - IO.from converts successful SyncIO
1012[info] - IO.from converts failed SyncIO
1013[info] - IO.from converts successful Try
1014[info] - IO.from converts failed Try
1015[info] - IO.from converts right Either
1016[info] - IO.from converts left Either
1017[info] - IO.from converts successful custom Effect
1018[info] - IO.from converts failed custom Effect
1019[info] - IO.from converts successful custom ConcurrentEffect
1020[info] - IO.from converts failed custom ConcurrentEffect
1021[info] - IO.from converts Function0
1022[info] - IO.from converts CancelablePromise
1023[info] monix.bio.TaskAsyncSuite
1024[info] - IO.never should never complete
1025[info] - IO.async should execute
1026[info] - IO.async should signal errors in register
1027[info] - IO.async should be stack safe
1028[info] - IO.async works for immediate successful value
1029[info] - IO.async works for immediate error
1030[info] - IO.async works for immediate terminate error
1031[info] - IO.async is memory safe in flatMap loops
1032[info] - IO.async0 works for immediate successful value
1033[info] - IO.async0 works for async successful value
1034[info] - IO.async0 works for async error
1035[info] - IO.async0 works for async terminate error
1036[info] - IO.async0 is memory safe in synchronous flatMap loops
1037[info] - IO.async0 is memory safe in async flatMap loops
1038[info] monix.bio.IOParZipSuite
1039[info] - IO.parZip2 should work if source finishes first
1040[info] - IO.parZip2 should work if other finishes first
1041[info] - IO.parZip2 should cancel both
1042[info] - IO.parZip2 should cancel just the source
1043[info] - IO.parZip2 should cancel just the other
1044[info] - IO.parZip2 should onError from the source before other
1045[info] - IO.parZip2 handle terminal errors from the source before other
1046[info] - IO.parZip2 should onError from the other after the source
1047[info] - IO.parZip2 should handle terminal errors from the other after the source
1048[info] - IO.parZip2 should onError from the other before the source
1049[info] - IO.parZip2 works
1050[info] - IO.map2 works
1051[info] - IO#map2 should protect against user code
1052[info] - IO.map2 runs effects in strict sequence
1053[info] - IO.parMap2 works
1054[info] - IO#parMap2 should protect against user code
1055[info] - IO.parZip3 works
1056[info] - IO#map3 works
1057[info] - IO#parMap3 works
1058[info] - IO.parZip4 works
1059[info] - IO#map4 works
1060[info] - IO#parMap4 works
1061[info] - IO.parZip5 works
1062[info] - IO#map5 works
1063[info] - IO#parMap5 works
1064[info] - IO.parZip6 works
1065[info] - IO#map6 works
1066[info] - IO#parMap6 works
1067[info] monix.bio.TypeClassLawsForTaskRunSyncUnsafeSuite
1068[info] - CoflatMap[Task].coflatMap.coflatMap associativity
1069[info] - CoflatMap[Task].coflatMap.coflatMap identity
1070[info] - CoflatMap[Task].coflatMap.coflatten coherence
1071[info] - CoflatMap[Task].coflatMap.coflatten throughMap
1072[info] - CoflatMap[Task].coflatMap.covariant composition
1073[info] - CoflatMap[Task].coflatMap.covariant identity
1074[info] - CoflatMap[Task].coflatMap.invariant composition
1075[info] - CoflatMap[Task].coflatMap.invariant identity
1076[info] - Concurrent[Task].concurrent.acquire and release of bracket are uncancelable
1077[info] - Concurrent[Task].concurrent.acquire of bracket is not cancelable
1078[info] - Concurrent[Task].concurrent.an action run concurrently with a pure value is the same as just doing that action
1079[info] - Concurrent[Task].concurrent.ap consistent with product + map
1080[info] - Concurrent[Task].concurrent.applicative homomorphism
1081[info] - Concurrent[Task].concurrent.applicative identity
1082[info] - Concurrent[Task].concurrent.applicative interchange
1083[info] - Concurrent[Task].concurrent.applicative map
1084[info] - Concurrent[Task].concurrent.applicative unit
1085[info] - Concurrent[Task].concurrent.applicativeError adaptError pure
1086[info] - Concurrent[Task].concurrent.applicativeError adaptError raise
1087[info] - Concurrent[Task].concurrent.applicativeError attempt consistent with attemptT
1088[info] - Concurrent[Task].concurrent.applicativeError attempt fromEither consistent with pure
1089[info] - Concurrent[Task].concurrent.applicativeError handle
1090[info] - Concurrent[Task].concurrent.applicativeError handleError . raiseError left-distributes over ap
1091[info] - Concurrent[Task].concurrent.applicativeError handleError . raiseError right-distributes over ap
1092[info] - Concurrent[Task].concurrent.applicativeError handleError consistent with recover
1093[info] - Concurrent[Task].concurrent.applicativeError handleError pure
1094[info] - Concurrent[Task].concurrent.applicativeError handleErrorWith consistent with recoverWith
1095[info] - Concurrent[Task].concurrent.applicativeError handleErrorWith pure
1096[info] - Concurrent[Task].concurrent.applicativeError handleWith
1097[info] - Concurrent[Task].concurrent.applicativeError onError pure
1098[info] - Concurrent[Task].concurrent.applicativeError onError raise
1099[info] - Concurrent[Task].concurrent.applicativeError pure attempt
1100[info] - Concurrent[Task].concurrent.applicativeError raiseError attempt
1101[info] - Concurrent[Task].concurrent.applicativeError recover consistent with recoverWith
1102[info] - Concurrent[Task].concurrent.applicativeError redeem is derived from attempt and map
1103[info] - Concurrent[Task].concurrent.apply composition
1104[info] - Concurrent[Task].concurrent.async can be derived from asyncF
1105[info] - Concurrent[Task].concurrent.async cancelable coherence
1106[info] - Concurrent[Task].concurrent.async cancelable receives cancel signal
1107[info] - Concurrent[Task].concurrent.async left is raiseError
1108[info] - Concurrent[Task].concurrent.async right is pure
1109[info] - Concurrent[Task].concurrent.asyncF registration can be cancelled
1110[info] - Concurrent[Task].concurrent.bind suspends evaluation
1111[info] - Concurrent[Task].concurrent.bracket is derived from bracketCase
1112[info] - Concurrent[Task].concurrent.bracket release is called on Completed or Error
1113[info] - Concurrent[Task].concurrent.bracket release is called on cancel
1114[info] - Concurrent[Task].concurrent.bracketCase with failure in acquisition remains failure
1115[info] - Concurrent[Task].concurrent.bracketCase with pure unit on release is eqv to map
1116[info] - Concurrent[Task].concurrent.bracketCase with pure unit on release is eqv to uncancelable(..).flatMap
1117[info] - Concurrent[Task].concurrent.covariant composition
1118[info] - Concurrent[Task].concurrent.covariant identity
1119[info] - Concurrent[Task].concurrent.delay constant is pure
1120[info] - Concurrent[Task].concurrent.flatMap associativity
1121[info] - Concurrent[Task].concurrent.flatMap consistent apply
1122[info] - Concurrent[Task].concurrent.flatMap from tailRecM consistency
1123[info] - Concurrent[Task].concurrent.guarantee is derived from bracket
1124[info] - Concurrent[Task].concurrent.guaranteeCase is derived from bracketCase
1125[info] - Concurrent[Task].concurrent.invariant composition
1126[info] - Concurrent[Task].concurrent.invariant identity
1127[info] - Concurrent[Task].concurrent.join is idempotent
1128[info] - Concurrent[Task].concurrent.map flatMap coherence
1129[info] - Concurrent[Task].concurrent.map suspends evaluation
1130[info] - Concurrent[Task].concurrent.map2/map2Eval consistency
1131[info] - Concurrent[Task].concurrent.map2/product-map consistency
1132[info] - Concurrent[Task].concurrent.monad left identity
1133[info] - Concurrent[Task].concurrent.monad right identity
1134[info] - Concurrent[Task].concurrent.monadError ensure consistency
1135[info] - Concurrent[Task].concurrent.monadError ensureOr consistency
1136[info] - Concurrent[Task].concurrent.monadError left zero
1137[info] - Concurrent[Task].concurrent.monadError redeemWith is derived from attempt and flatMap
1138[info] - Concurrent[Task].concurrent.monadError rethrow attempt
1139[info] - Concurrent[Task].concurrent.monoidal left identity
1140[info] - Concurrent[Task].concurrent.monoidal right identity
1141[info] - Concurrent[Task].concurrent.mproduct consistent flatMap
1142[info] - Concurrent[Task].concurrent.onCancel is derived from guaranteeCase
1143[info] - Concurrent[Task].concurrent.productL consistent map2
1144[info] - Concurrent[Task].concurrent.productR consistent map2
1145[info] - Concurrent[Task].concurrent.propagate errors through bind (async)
1146[info] - Concurrent[Task].concurrent.propagate errors through bind (suspend)
1147[info] - Concurrent[Task].concurrent.race cancels both
1148[info] - Concurrent[Task].concurrent.race cancels loser
1149[info] - Concurrent[Task].concurrent.race mirrors left winner
1150[info] - Concurrent[Task].concurrent.race mirrors right winner
1151[info] - Concurrent[Task].concurrent.racePair can join left
1152[info] - Concurrent[Task].concurrent.racePair can join right
1153[info] - Concurrent[Task].concurrent.racePair cancels both
1154[info] - Concurrent[Task].concurrent.racePair cancels loser
1155[info] - Concurrent[Task].concurrent.racePair mirrors left winner
1156[info] - Concurrent[Task].concurrent.racePair mirrors right winner
1157[info] - Concurrent[Task].concurrent.release of bracket is not cancelable
1158[info] - Concurrent[Task].concurrent.repeated async evaluation not memoized
1159[info] - Concurrent[Task].concurrent.repeated asyncF evaluation not memoized
1160[info] - Concurrent[Task].concurrent.repeated sync evaluation not memoized
1161[info] - Concurrent[Task].concurrent.semigroupal associativity
1162[info] - Concurrent[Task].concurrent.stack-safe on bracket with left-associated binds
1163[info] - Concurrent[Task].concurrent.stack-safe on bracket with right-associated binds
1164[info] - Concurrent[Task].concurrent.stack-safe on guarantee with left-associated binds
1165[info] - Concurrent[Task].concurrent.stack-safe on guarantee with right-associated binds
1166[info] - Concurrent[Task].concurrent.stack-safe on left-associated binds
1167[info] - Concurrent[Task].concurrent.stack-safe on repeated attempts
1168[info] - Concurrent[Task].concurrent.stack-safe on repeated maps
1169[info] - Concurrent[Task].concurrent.stack-safe on right-associated binds
1170[info] - Concurrent[Task].concurrent.start then join is identity
1171[info] - Concurrent[Task].concurrent.start.flatMap(_.cancel) is unit
1172[info] - Concurrent[Task].concurrent.suspend constant is pure join
1173[info] - Concurrent[Task].concurrent.tailRecM consistent flatMap
1174[info] - Concurrent[Task].concurrent.tailRecM stack safety
1175[info] - Concurrent[Task].concurrent.throw in delay is raiseError
1176[info] - Concurrent[Task].concurrent.throw in suspend is raiseError
1177[info] - Concurrent[Task].concurrent.uncancelable mirrors source
1178[info] - Concurrent[Task].concurrent.uncancelable prevents Cancelled case
1179[info] - Concurrent[Task].concurrent.unsequenced delay is no-op
1180[info] - ConcurrentEffect[Task].concurrentEffect.acquire and release of bracket are uncancelable
1181[info] - ConcurrentEffect[Task].concurrentEffect.acquire of bracket is not cancelable
1182[info] - ConcurrentEffect[Task].concurrentEffect.an action run concurrently with a pure value is the same as just doing that action
1183[info] - ConcurrentEffect[Task].concurrentEffect.ap consistent with product + map
1184[info] - ConcurrentEffect[Task].concurrentEffect.applicative homomorphism
1185[info] - ConcurrentEffect[Task].concurrentEffect.applicative identity
1186[info] - ConcurrentEffect[Task].concurrentEffect.applicative interchange
1187[info] - ConcurrentEffect[Task].concurrentEffect.applicative map
1188[info] - ConcurrentEffect[Task].concurrentEffect.applicative unit
1189[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError adaptError pure
1190[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError adaptError raise
1191[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError attempt consistent with attemptT
1192[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError attempt fromEither consistent with pure
1193[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError handle
1194[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError handleError . raiseError left-distributes over ap
1195[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError handleError . raiseError right-distributes over ap
1196[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError handleError consistent with recover
1197[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError handleError pure
1198[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError handleErrorWith consistent with recoverWith
1199[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError handleErrorWith pure
1200[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError handleWith
1201[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError onError pure
1202[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError onError raise
1203[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError pure attempt
1204[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError raiseError attempt
1205[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError recover consistent with recoverWith
1206[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError redeem is derived from attempt and map
1207[info] - ConcurrentEffect[Task].concurrentEffect.apply composition
1208[info] - ConcurrentEffect[Task].concurrentEffect.async can be derived from asyncF
1209[info] - ConcurrentEffect[Task].concurrentEffect.async cancelable coherence
1210[info] - ConcurrentEffect[Task].concurrentEffect.async cancelable receives cancel signal
1211[info] - ConcurrentEffect[Task].concurrentEffect.async left is raiseError
1212[info] - ConcurrentEffect[Task].concurrentEffect.async right is pure
1213[info] - ConcurrentEffect[Task].concurrentEffect.asyncF registration can be cancelled
1214[info] - ConcurrentEffect[Task].concurrentEffect.bind suspends evaluation
1215[info] - ConcurrentEffect[Task].concurrentEffect.bracket is derived from bracketCase
1216[info] - ConcurrentEffect[Task].concurrentEffect.bracket release is called on Completed or Error
1217[info] - ConcurrentEffect[Task].concurrentEffect.bracket release is called on cancel
1218[info] - ConcurrentEffect[Task].concurrentEffect.bracketCase with failure in acquisition remains failure
1219[info] - ConcurrentEffect[Task].concurrentEffect.bracketCase with pure unit on release is eqv to map
1220[info] - ConcurrentEffect[Task].concurrentEffect.bracketCase with pure unit on release is eqv to uncancelable(..).flatMap
1221[info] - ConcurrentEffect[Task].concurrentEffect.covariant composition
1222[info] - ConcurrentEffect[Task].concurrentEffect.covariant identity
1223[info] - ConcurrentEffect[Task].concurrentEffect.delay constant is pure
1224[info] - ConcurrentEffect[Task].concurrentEffect.flatMap associativity
1225[info] - ConcurrentEffect[Task].concurrentEffect.flatMap consistent apply
1226[info] - ConcurrentEffect[Task].concurrentEffect.flatMap from tailRecM consistency
1227[info] - ConcurrentEffect[Task].concurrentEffect.guarantee is derived from bracket
1228[info] - ConcurrentEffect[Task].concurrentEffect.guaranteeCase is derived from bracketCase
1229[info] - ConcurrentEffect[Task].concurrentEffect.invariant composition
1230[info] - ConcurrentEffect[Task].concurrentEffect.invariant identity
1231[info] - ConcurrentEffect[Task].concurrentEffect.join is idempotent
1232[info] - ConcurrentEffect[Task].concurrentEffect.map flatMap coherence
1233[info] - ConcurrentEffect[Task].concurrentEffect.map suspends evaluation
1234[info] - ConcurrentEffect[Task].concurrentEffect.map2/map2Eval consistency
1235[info] - ConcurrentEffect[Task].concurrentEffect.map2/product-map consistency
1236[info] - ConcurrentEffect[Task].concurrentEffect.monad left identity
1237[info] - ConcurrentEffect[Task].concurrentEffect.monad right identity
1238[info] - ConcurrentEffect[Task].concurrentEffect.monadError ensure consistency
1239[info] - ConcurrentEffect[Task].concurrentEffect.monadError ensureOr consistency
1240[info] - ConcurrentEffect[Task].concurrentEffect.monadError left zero
1241[info] - ConcurrentEffect[Task].concurrentEffect.monadError redeemWith is derived from attempt and flatMap
1242[info] - ConcurrentEffect[Task].concurrentEffect.monadError rethrow attempt
1243[info] - ConcurrentEffect[Task].concurrentEffect.monoidal left identity
1244[info] - ConcurrentEffect[Task].concurrentEffect.monoidal right identity
1245[info] - ConcurrentEffect[Task].concurrentEffect.mproduct consistent flatMap
1246[info] - ConcurrentEffect[Task].concurrentEffect.onCancel is derived from guaranteeCase
1247[info] - ConcurrentEffect[Task].concurrentEffect.productL consistent map2
1248[info] - ConcurrentEffect[Task].concurrentEffect.productR consistent map2
1249[info] - ConcurrentEffect[Task].concurrentEffect.propagate errors through bind (async)
1250[info] - ConcurrentEffect[Task].concurrentEffect.propagate errors through bind (suspend)
1251[info] - ConcurrentEffect[Task].concurrentEffect.race cancels both
1252[info] - ConcurrentEffect[Task].concurrentEffect.race cancels loser
1253[info] - ConcurrentEffect[Task].concurrentEffect.race mirrors left winner
1254[info] - ConcurrentEffect[Task].concurrentEffect.race mirrors right winner
1255[info] - ConcurrentEffect[Task].concurrentEffect.racePair can join left
1256[info] - ConcurrentEffect[Task].concurrentEffect.racePair can join right
1257[info] - ConcurrentEffect[Task].concurrentEffect.racePair cancels both
1258[info] - ConcurrentEffect[Task].concurrentEffect.racePair cancels loser
1259[info] - ConcurrentEffect[Task].concurrentEffect.racePair mirrors left winner
1260[info] - ConcurrentEffect[Task].concurrentEffect.racePair mirrors right winner
1261[info] - ConcurrentEffect[Task].concurrentEffect.release of bracket is not cancelable
1262[info] - ConcurrentEffect[Task].concurrentEffect.repeated async evaluation not memoized
1263[info] - ConcurrentEffect[Task].concurrentEffect.repeated asyncF evaluation not memoized
1264[info] - ConcurrentEffect[Task].concurrentEffect.repeated callback ignored
1265[info] - ConcurrentEffect[Task].concurrentEffect.repeated sync evaluation not memoized
1266[info] - ConcurrentEffect[Task].concurrentEffect.runAsync ignores error in handler
1267[info] - ConcurrentEffect[Task].concurrentEffect.runAsync pure produces right IO
1268[info] - ConcurrentEffect[Task].concurrentEffect.runAsync raiseError produces left IO
1269[info] - ConcurrentEffect[Task].concurrentEffect.runAsync runCancelable coherence
1270[info] - ConcurrentEffect[Task].concurrentEffect.runCancelable is synchronous
1271[info] - ConcurrentEffect[Task].concurrentEffect.runCancelable start.flatMap(_.cancel) coherence
1272[info] - ConcurrentEffect[Task].concurrentEffect.semigroupal associativity
1273[info] - ConcurrentEffect[Task].concurrentEffect.stack-safe on bracket with left-associated binds
1274[info] - ConcurrentEffect[Task].concurrentEffect.stack-safe on bracket with right-associated binds
1275[info] - ConcurrentEffect[Task].concurrentEffect.stack-safe on guarantee with left-associated binds
1276[info] - ConcurrentEffect[Task].concurrentEffect.stack-safe on guarantee with right-associated binds
1277[info] - ConcurrentEffect[Task].concurrentEffect.stack-safe on left-associated binds
1278[info] - ConcurrentEffect[Task].concurrentEffect.stack-safe on repeated attempts
1279[info] - ConcurrentEffect[Task].concurrentEffect.stack-safe on repeated maps
1280[info] - ConcurrentEffect[Task].concurrentEffect.stack-safe on right-associated binds
1281[info] - ConcurrentEffect[Task].concurrentEffect.start then join is identity
1282[info] - ConcurrentEffect[Task].concurrentEffect.start.flatMap(_.cancel) is unit
1283[info] - ConcurrentEffect[Task].concurrentEffect.suspend constant is pure join
1284[info] - ConcurrentEffect[Task].concurrentEffect.tailRecM consistent flatMap
1285[info] - ConcurrentEffect[Task].concurrentEffect.tailRecM stack safety
1286[info] - ConcurrentEffect[Task].concurrentEffect.throw in delay is raiseError
1287[info] - ConcurrentEffect[Task].concurrentEffect.throw in suspend is raiseError
1288[info] - ConcurrentEffect[Task].concurrentEffect.toIO is consistent with runAsync
1289[info] - ConcurrentEffect[Task].concurrentEffect.toIO is consistent with runCancelable
1290[info] - ConcurrentEffect[Task].concurrentEffect.toIO is the inverse of liftIO
1291[info] - ConcurrentEffect[Task].concurrentEffect.toIO stack safety
1292[info] - ConcurrentEffect[Task].concurrentEffect.uncancelable mirrors source
1293[info] - ConcurrentEffect[Task].concurrentEffect.uncancelable prevents Cancelled case
1294[info] - ConcurrentEffect[Task].concurrentEffect.unsequenced delay is no-op
1295[info] - Applicative[Task.Par].applicative.ap consistent with product + map
1296[info] - Applicative[Task.Par].applicative.applicative homomorphism
1297[info] - Applicative[Task.Par].applicative.applicative identity
1298[info] - Applicative[Task.Par].applicative.applicative interchange
1299[info] - Applicative[Task.Par].applicative.applicative map
1300[info] - Applicative[Task.Par].applicative.applicative unit
1301[info] - Applicative[Task.Par].applicative.apply composition
1302[info] - Applicative[Task.Par].applicative.covariant composition
1303[info] - Applicative[Task.Par].applicative.covariant identity
1304[info] - Applicative[Task.Par].applicative.invariant composition
1305[info] - Applicative[Task.Par].applicative.invariant identity
1306[info] - Applicative[Task.Par].applicative.map2/map2Eval consistency
1307[info] - Applicative[Task.Par].applicative.map2/product-map consistency
1308[info] - Applicative[Task.Par].applicative.monoidal left identity
1309[info] - Applicative[Task.Par].applicative.monoidal right identity
1310[info] - Applicative[Task.Par].applicative.productL consistent map2
1311[info] - Applicative[Task.Par].applicative.productR consistent map2
1312[info] - Applicative[Task.Par].applicative.semigroupal associativity
1313[info] - Parallel[Task, Task.Par].parallel.isomorphic functor
1314[info] - Parallel[Task, Task.Par].parallel.isomorphic pure
1315[info] - Parallel[Task, Task.Par].parallel.parallel round trip
1316[info] - Parallel[Task, Task.Par].parallel.sequential round trip
1317[info] - Monoid[IO[Throwable, Int]].monoid.associative
1318[info] - Monoid[IO[Throwable, Int]].monoid.collect0
1319[info] - Monoid[IO[Throwable, Int]].monoid.combine all
1320[info] - Monoid[IO[Throwable, Int]].monoid.combineAllOption
1321[info] - Monoid[IO[Throwable, Int]].monoid.intercalateCombineAllOption
1322[info] - Monoid[IO[Throwable, Int]].monoid.intercalateIntercalates
1323[info] - Monoid[IO[Throwable, Int]].monoid.intercalateRepeat1
1324[info] - Monoid[IO[Throwable, Int]].monoid.intercalateRepeat2
1325[info] - Monoid[IO[Throwable, Int]].monoid.is id
1326[info] - Monoid[IO[Throwable, Int]].monoid.left identity
1327[info] - Monoid[IO[Throwable, Int]].monoid.repeat0
1328[info] - Monoid[IO[Throwable, Int]].monoid.repeat1
1329[info] - Monoid[IO[Throwable, Int]].monoid.repeat2
1330[info] - Monoid[IO[Throwable, Int]].monoid.reverseCombineAllOption
1331[info] - Monoid[IO[Throwable, Int]].monoid.reverseRepeat1
1332[info] - Monoid[IO[Throwable, Int]].monoid.reverseRepeat2
1333[info] - Monoid[IO[Throwable, Int]].monoid.reverseReverses
1334[info] - Monoid[IO[Throwable, Int]].monoid.right identity
1335[info] - Bifunctor[IO[String, Int]].Bifunctor.Bifunctor Identity
1336[info] - Bifunctor[IO[String, Int]].Bifunctor.Bifunctor associativity
1337[info] - Bifunctor[IO[String, Int]].Bifunctor.Bifunctor leftMap Identity
1338[info] - Bifunctor[IO[String, Int]].Bifunctor.Bifunctor leftMap associativity
1339[info] monix.bio.TaskParSequenceUnorderedSuite
1340[info] - IO.parSequenceUnordered should execute in parallel
1341[info] - IO.parSequenceUnordered should onError if one of the tasks terminates in error
1342[info] - IO.parSequenceUnordered should onTerminate if one of the tasks terminates in a fatal error
1343[info] - IO.parSequenceUnordered should be canceled
1344[info] - IO.parSequenceUnordered should run over an iterable
1345[info] - IO.parSequenceUnordered should be stack-safe on handling many tasks
1346[info] - IO.parSequenceUnordered should be stack safe on success
1347[info] - IO.parSequenceUnordered should log errors if multiple errors happen
1348[info] - IO.parSequenceUnordered should log terminal errors if multiple errors happen
1349[info] - IO.parSequenceUnordered runAsync multiple times
1350[info] monix.bio.IODoOnFinishSuite
1351[info] - IO#doOnFinish should work on successful task
1352[info] - IO#doOnFinish should work on task with raised error
1353[info] - IO#doOnFinish should work on terminated task
1354[info] - IO#doOnFinish should not trigger any finishing action when IO is cancelled
1355[info] monix.bio.TypeClassLawsForTaskAutoCancelableRunSyncUnsafeSuite
1356[info] - CoflatMap[Task].coflatMap.coflatMap associativity
1357[info] - CoflatMap[Task].coflatMap.coflatMap identity
1358[info] - CoflatMap[Task].coflatMap.coflatten coherence
1359[info] - CoflatMap[Task].coflatMap.coflatten throughMap
1360[info] - CoflatMap[Task].coflatMap.covariant composition
1361[info] - CoflatMap[Task].coflatMap.covariant identity
1362[info] - CoflatMap[Task].coflatMap.invariant composition
1363[info] - CoflatMap[Task].coflatMap.invariant identity
1364[info] - Concurrent[Task].concurrent.acquire and release of bracket are uncancelable
1365[info] - Concurrent[Task].concurrent.acquire of bracket is not cancelable
1366[info] - Concurrent[Task].concurrent.an action run concurrently with a pure value is the same as just doing that action
1367[info] - Concurrent[Task].concurrent.ap consistent with product + map
1368[info] - Concurrent[Task].concurrent.applicative homomorphism
1369[info] - Concurrent[Task].concurrent.applicative identity
1370[info] - Concurrent[Task].concurrent.applicative interchange
1371[info] - Concurrent[Task].concurrent.applicative map
1372[info] - Concurrent[Task].concurrent.applicative unit
1373[info] - Concurrent[Task].concurrent.applicativeError adaptError pure
1374[info] - Concurrent[Task].concurrent.applicativeError adaptError raise
1375[info] - Concurrent[Task].concurrent.applicativeError attempt consistent with attemptT
1376[info] - Concurrent[Task].concurrent.applicativeError attempt fromEither consistent with pure
1377[info] - Concurrent[Task].concurrent.applicativeError handle
1378[info] - Concurrent[Task].concurrent.applicativeError handleError . raiseError left-distributes over ap
1379[info] - Concurrent[Task].concurrent.applicativeError handleError . raiseError right-distributes over ap
1380[info] - Concurrent[Task].concurrent.applicativeError handleError consistent with recover
1381[info] - Concurrent[Task].concurrent.applicativeError handleError pure
1382[info] - Concurrent[Task].concurrent.applicativeError handleErrorWith consistent with recoverWith
1383[info] - Concurrent[Task].concurrent.applicativeError handleErrorWith pure
1384[info] - Concurrent[Task].concurrent.applicativeError handleWith
1385[info] - Concurrent[Task].concurrent.applicativeError onError pure
1386[info] - Concurrent[Task].concurrent.applicativeError onError raise
1387[info] - Concurrent[Task].concurrent.applicativeError pure attempt
1388[info] - Concurrent[Task].concurrent.applicativeError raiseError attempt
1389[info] - Concurrent[Task].concurrent.applicativeError recover consistent with recoverWith
1390[info] - Concurrent[Task].concurrent.applicativeError redeem is derived from attempt and map
1391[info] - Concurrent[Task].concurrent.apply composition
1392[info] - Concurrent[Task].concurrent.async can be derived from asyncF
1393[info] - Concurrent[Task].concurrent.async cancelable coherence
1394[info] - Concurrent[Task].concurrent.async cancelable receives cancel signal
1395[info] - Concurrent[Task].concurrent.async left is raiseError
1396[info] - Concurrent[Task].concurrent.async right is pure
1397[info] - Concurrent[Task].concurrent.asyncF registration can be cancelled
1398[info] - Concurrent[Task].concurrent.bind suspends evaluation
1399[info] - Concurrent[Task].concurrent.bracket is derived from bracketCase
1400[info] - Concurrent[Task].concurrent.bracket release is called on Completed or Error
1401[info] - Concurrent[Task].concurrent.bracket release is called on cancel
1402[info] - Concurrent[Task].concurrent.bracketCase with failure in acquisition remains failure
1403[info] - Concurrent[Task].concurrent.bracketCase with pure unit on release is eqv to map
1404[info] - Concurrent[Task].concurrent.bracketCase with pure unit on release is eqv to uncancelable(..).flatMap
1405[info] - Concurrent[Task].concurrent.covariant composition
1406[info] - Concurrent[Task].concurrent.covariant identity
1407[info] - Concurrent[Task].concurrent.delay constant is pure
1408[info] - Concurrent[Task].concurrent.flatMap associativity
1409[info] - Concurrent[Task].concurrent.flatMap consistent apply
1410[info] - Concurrent[Task].concurrent.flatMap from tailRecM consistency
1411[info] - Concurrent[Task].concurrent.guarantee is derived from bracket
1412[info] - Concurrent[Task].concurrent.guaranteeCase is derived from bracketCase
1413[info] - Concurrent[Task].concurrent.invariant composition
1414[info] - Concurrent[Task].concurrent.invariant identity
1415[info] - Concurrent[Task].concurrent.join is idempotent
1416[info] - Concurrent[Task].concurrent.map flatMap coherence
1417[info] - Concurrent[Task].concurrent.map suspends evaluation
1418[info] - Concurrent[Task].concurrent.map2/map2Eval consistency
1419[info] - Concurrent[Task].concurrent.map2/product-map consistency
1420[info] - Concurrent[Task].concurrent.monad left identity
1421[info] - Concurrent[Task].concurrent.monad right identity
1422[info] - Concurrent[Task].concurrent.monadError ensure consistency
1423[info] - Concurrent[Task].concurrent.monadError ensureOr consistency
1424[info] - Concurrent[Task].concurrent.monadError left zero
1425[info] - Concurrent[Task].concurrent.monadError redeemWith is derived from attempt and flatMap
1426[info] - Concurrent[Task].concurrent.monadError rethrow attempt
1427[info] - Concurrent[Task].concurrent.monoidal left identity
1428[info] - Concurrent[Task].concurrent.monoidal right identity
1429[info] - Concurrent[Task].concurrent.mproduct consistent flatMap
1430[info] - Concurrent[Task].concurrent.onCancel is derived from guaranteeCase
1431[info] - Concurrent[Task].concurrent.productL consistent map2
1432[info] - Concurrent[Task].concurrent.productR consistent map2
1433[info] - Concurrent[Task].concurrent.propagate errors through bind (async)
1434[info] - Concurrent[Task].concurrent.propagate errors through bind (suspend)
1435[info] - Concurrent[Task].concurrent.race cancels both
1436[info] - Concurrent[Task].concurrent.race cancels loser
1437[info] - Concurrent[Task].concurrent.race mirrors left winner
1438[info] - Concurrent[Task].concurrent.race mirrors right winner
1439[info] - Concurrent[Task].concurrent.racePair can join left
1440[info] - Concurrent[Task].concurrent.racePair can join right
1441[info] - Concurrent[Task].concurrent.racePair cancels both
1442[info] - Concurrent[Task].concurrent.racePair cancels loser
1443[info] - Concurrent[Task].concurrent.racePair mirrors left winner
1444[info] - Concurrent[Task].concurrent.racePair mirrors right winner
1445[info] - Concurrent[Task].concurrent.release of bracket is not cancelable
1446[info] - Concurrent[Task].concurrent.repeated async evaluation not memoized
1447[info] - Concurrent[Task].concurrent.repeated asyncF evaluation not memoized
1448[info] - Concurrent[Task].concurrent.repeated sync evaluation not memoized
1449[info] - Concurrent[Task].concurrent.semigroupal associativity
1450[info] - Concurrent[Task].concurrent.stack-safe on bracket with left-associated binds
1451[info] - Concurrent[Task].concurrent.stack-safe on bracket with right-associated binds
1452[info] - Concurrent[Task].concurrent.stack-safe on guarantee with left-associated binds
1453[info] - Concurrent[Task].concurrent.stack-safe on guarantee with right-associated binds
1454[info] - Concurrent[Task].concurrent.stack-safe on left-associated binds
1455[info] - Concurrent[Task].concurrent.stack-safe on repeated attempts
1456[info] - Concurrent[Task].concurrent.stack-safe on repeated maps
1457[info] - Concurrent[Task].concurrent.stack-safe on right-associated binds
1458[info] - Concurrent[Task].concurrent.start then join is identity
1459[info] - Concurrent[Task].concurrent.start.flatMap(_.cancel) is unit
1460[info] - Concurrent[Task].concurrent.suspend constant is pure join
1461[info] - Concurrent[Task].concurrent.tailRecM consistent flatMap
1462[info] - Concurrent[Task].concurrent.tailRecM stack safety
1463[info] - Concurrent[Task].concurrent.throw in delay is raiseError
1464[info] - Concurrent[Task].concurrent.throw in suspend is raiseError
1465[info] - Concurrent[Task].concurrent.uncancelable mirrors source
1466[info] - Concurrent[Task].concurrent.uncancelable prevents Cancelled case
1467[info] - Concurrent[Task].concurrent.unsequenced delay is no-op
1468[info] - ConcurrentEffect[Task].concurrentEffect.acquire and release of bracket are uncancelable
1469[info] - ConcurrentEffect[Task].concurrentEffect.acquire of bracket is not cancelable
1470[info] - ConcurrentEffect[Task].concurrentEffect.an action run concurrently with a pure value is the same as just doing that action
1471[info] - ConcurrentEffect[Task].concurrentEffect.ap consistent with product + map
1472[info] - ConcurrentEffect[Task].concurrentEffect.applicative homomorphism
1473[info] - ConcurrentEffect[Task].concurrentEffect.applicative identity
1474[info] - ConcurrentEffect[Task].concurrentEffect.applicative interchange
1475[info] - ConcurrentEffect[Task].concurrentEffect.applicative map
1476[info] - ConcurrentEffect[Task].concurrentEffect.applicative unit
1477[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError adaptError pure
1478[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError adaptError raise
1479[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError attempt consistent with attemptT
1480[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError attempt fromEither consistent with pure
1481[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError handle
1482[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError handleError . raiseError left-distributes over ap
1483[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError handleError . raiseError right-distributes over ap
1484[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError handleError consistent with recover
1485[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError handleError pure
1486[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError handleErrorWith consistent with recoverWith
1487[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError handleErrorWith pure
1488[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError handleWith
1489[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError onError pure
1490[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError onError raise
1491[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError pure attempt
1492[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError raiseError attempt
1493[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError recover consistent with recoverWith
1494[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError redeem is derived from attempt and map
1495[info] - ConcurrentEffect[Task].concurrentEffect.apply composition
1496[info] - ConcurrentEffect[Task].concurrentEffect.async can be derived from asyncF
1497[info] - ConcurrentEffect[Task].concurrentEffect.async cancelable coherence
1498[info] - ConcurrentEffect[Task].concurrentEffect.async cancelable receives cancel signal
1499[info] - ConcurrentEffect[Task].concurrentEffect.async left is raiseError
1500[info] - ConcurrentEffect[Task].concurrentEffect.async right is pure
1501[info] - ConcurrentEffect[Task].concurrentEffect.asyncF registration can be cancelled
1502[info] - ConcurrentEffect[Task].concurrentEffect.bind suspends evaluation
1503[info] - ConcurrentEffect[Task].concurrentEffect.bracket is derived from bracketCase
1504[info] - ConcurrentEffect[Task].concurrentEffect.bracket release is called on Completed or Error
1505[info] - ConcurrentEffect[Task].concurrentEffect.bracket release is called on cancel
1506[info] - ConcurrentEffect[Task].concurrentEffect.bracketCase with failure in acquisition remains failure
1507[info] - ConcurrentEffect[Task].concurrentEffect.bracketCase with pure unit on release is eqv to map
1508[info] - ConcurrentEffect[Task].concurrentEffect.bracketCase with pure unit on release is eqv to uncancelable(..).flatMap
1509[info] - ConcurrentEffect[Task].concurrentEffect.covariant composition
1510[info] - ConcurrentEffect[Task].concurrentEffect.covariant identity
1511[info] - ConcurrentEffect[Task].concurrentEffect.delay constant is pure
1512[info] - ConcurrentEffect[Task].concurrentEffect.flatMap associativity
1513[info] - ConcurrentEffect[Task].concurrentEffect.flatMap consistent apply
1514[info] - ConcurrentEffect[Task].concurrentEffect.flatMap from tailRecM consistency
1515[info] - ConcurrentEffect[Task].concurrentEffect.guarantee is derived from bracket
1516[info] - ConcurrentEffect[Task].concurrentEffect.guaranteeCase is derived from bracketCase
1517[info] - ConcurrentEffect[Task].concurrentEffect.invariant composition
1518[info] - ConcurrentEffect[Task].concurrentEffect.invariant identity
1519[info] - ConcurrentEffect[Task].concurrentEffect.join is idempotent
1520[info] - ConcurrentEffect[Task].concurrentEffect.map flatMap coherence
1521[info] - ConcurrentEffect[Task].concurrentEffect.map suspends evaluation
1522[info] - ConcurrentEffect[Task].concurrentEffect.map2/map2Eval consistency
1523[info] - ConcurrentEffect[Task].concurrentEffect.map2/product-map consistency
1524[info] - ConcurrentEffect[Task].concurrentEffect.monad left identity
1525[info] - ConcurrentEffect[Task].concurrentEffect.monad right identity
1526[info] - ConcurrentEffect[Task].concurrentEffect.monadError ensure consistency
1527[info] - ConcurrentEffect[Task].concurrentEffect.monadError ensureOr consistency
1528[info] - ConcurrentEffect[Task].concurrentEffect.monadError left zero
1529[info] - ConcurrentEffect[Task].concurrentEffect.monadError redeemWith is derived from attempt and flatMap
1530[info] - ConcurrentEffect[Task].concurrentEffect.monadError rethrow attempt
1531[info] - ConcurrentEffect[Task].concurrentEffect.monoidal left identity
1532[info] - ConcurrentEffect[Task].concurrentEffect.monoidal right identity
1533[info] - ConcurrentEffect[Task].concurrentEffect.mproduct consistent flatMap
1534[info] - ConcurrentEffect[Task].concurrentEffect.onCancel is derived from guaranteeCase
1535[info] - ConcurrentEffect[Task].concurrentEffect.productL consistent map2
1536[info] - ConcurrentEffect[Task].concurrentEffect.productR consistent map2
1537[info] - ConcurrentEffect[Task].concurrentEffect.propagate errors through bind (async)
1538[info] - ConcurrentEffect[Task].concurrentEffect.propagate errors through bind (suspend)
1539[info] - ConcurrentEffect[Task].concurrentEffect.race cancels both
1540[info] - ConcurrentEffect[Task].concurrentEffect.race cancels loser
1541[info] - ConcurrentEffect[Task].concurrentEffect.race mirrors left winner
1542[info] - ConcurrentEffect[Task].concurrentEffect.race mirrors right winner
1543[info] - ConcurrentEffect[Task].concurrentEffect.racePair can join left
1544[info] - ConcurrentEffect[Task].concurrentEffect.racePair can join right
1545[info] - ConcurrentEffect[Task].concurrentEffect.racePair cancels both
1546[info] - ConcurrentEffect[Task].concurrentEffect.racePair cancels loser
1547[info] - ConcurrentEffect[Task].concurrentEffect.racePair mirrors left winner
1548[info] - ConcurrentEffect[Task].concurrentEffect.racePair mirrors right winner
1549[info] - ConcurrentEffect[Task].concurrentEffect.release of bracket is not cancelable
1550[info] - ConcurrentEffect[Task].concurrentEffect.repeated async evaluation not memoized
1551[info] - ConcurrentEffect[Task].concurrentEffect.repeated asyncF evaluation not memoized
1552[info] - ConcurrentEffect[Task].concurrentEffect.repeated callback ignored
1553[info] - ConcurrentEffect[Task].concurrentEffect.repeated sync evaluation not memoized
1554[info] - ConcurrentEffect[Task].concurrentEffect.runAsync ignores error in handler
1555[info] - ConcurrentEffect[Task].concurrentEffect.runAsync pure produces right IO
1556[info] - ConcurrentEffect[Task].concurrentEffect.runAsync raiseError produces left IO
1557[info] - ConcurrentEffect[Task].concurrentEffect.runAsync runCancelable coherence
1558[info] - ConcurrentEffect[Task].concurrentEffect.runCancelable is synchronous
1559[info] - ConcurrentEffect[Task].concurrentEffect.runCancelable start.flatMap(_.cancel) coherence
1560[info] - ConcurrentEffect[Task].concurrentEffect.semigroupal associativity
1561[info] - ConcurrentEffect[Task].concurrentEffect.stack-safe on bracket with left-associated binds
1562[info] - ConcurrentEffect[Task].concurrentEffect.stack-safe on bracket with right-associated binds
1563[info] - ConcurrentEffect[Task].concurrentEffect.stack-safe on guarantee with left-associated binds
1564[info] - ConcurrentEffect[Task].concurrentEffect.stack-safe on guarantee with right-associated binds
1565[info] - ConcurrentEffect[Task].concurrentEffect.stack-safe on left-associated binds
1566[info] - ConcurrentEffect[Task].concurrentEffect.stack-safe on repeated attempts
1567[info] - ConcurrentEffect[Task].concurrentEffect.stack-safe on repeated maps
1568[info] - ConcurrentEffect[Task].concurrentEffect.stack-safe on right-associated binds
1569[info] - ConcurrentEffect[Task].concurrentEffect.start then join is identity
1570[info] - ConcurrentEffect[Task].concurrentEffect.start.flatMap(_.cancel) is unit
1571[info] - ConcurrentEffect[Task].concurrentEffect.suspend constant is pure join
1572[info] - ConcurrentEffect[Task].concurrentEffect.tailRecM consistent flatMap
1573[info] - ConcurrentEffect[Task].concurrentEffect.tailRecM stack safety
1574[info] - ConcurrentEffect[Task].concurrentEffect.throw in delay is raiseError
1575[info] - ConcurrentEffect[Task].concurrentEffect.throw in suspend is raiseError
1576[info] - ConcurrentEffect[Task].concurrentEffect.toIO is consistent with runAsync
1577[info] - ConcurrentEffect[Task].concurrentEffect.toIO is consistent with runCancelable
1578[info] - ConcurrentEffect[Task].concurrentEffect.toIO is the inverse of liftIO
1579[info] - ConcurrentEffect[Task].concurrentEffect.toIO stack safety
1580[info] - ConcurrentEffect[Task].concurrentEffect.uncancelable mirrors source
1581[info] - ConcurrentEffect[Task].concurrentEffect.uncancelable prevents Cancelled case
1582[info] - ConcurrentEffect[Task].concurrentEffect.unsequenced delay is no-op
1583[info] - Applicative[Task.Par].applicative.ap consistent with product + map
1584[info] - Applicative[Task.Par].applicative.applicative homomorphism
1585[info] - Applicative[Task.Par].applicative.applicative identity
1586[info] - Applicative[Task.Par].applicative.applicative interchange
1587[info] - Applicative[Task.Par].applicative.applicative map
1588[info] - Applicative[Task.Par].applicative.applicative unit
1589[info] - Applicative[Task.Par].applicative.apply composition
1590[info] - Applicative[Task.Par].applicative.covariant composition
1591[info] - Applicative[Task.Par].applicative.covariant identity
1592[info] - Applicative[Task.Par].applicative.invariant composition
1593[info] - Applicative[Task.Par].applicative.invariant identity
1594[info] - Applicative[Task.Par].applicative.map2/map2Eval consistency
1595[info] - Applicative[Task.Par].applicative.map2/product-map consistency
1596[info] - Applicative[Task.Par].applicative.monoidal left identity
1597[info] - Applicative[Task.Par].applicative.monoidal right identity
1598[info] - Applicative[Task.Par].applicative.productL consistent map2
1599[info] - Applicative[Task.Par].applicative.productR consistent map2
1600[info] - Applicative[Task.Par].applicative.semigroupal associativity
1601[info] - Parallel[Task, Task.Par].parallel.isomorphic functor
1602[info] - Parallel[Task, Task.Par].parallel.isomorphic pure
1603[info] - Parallel[Task, Task.Par].parallel.parallel round trip
1604[info] - Parallel[Task, Task.Par].parallel.sequential round trip
1605[info] - Monoid[IO[Throwable, Int]].monoid.associative
1606[info] - Monoid[IO[Throwable, Int]].monoid.collect0
1607[info] - Monoid[IO[Throwable, Int]].monoid.combine all
1608[info] - Monoid[IO[Throwable, Int]].monoid.combineAllOption
1609[info] - Monoid[IO[Throwable, Int]].monoid.intercalateCombineAllOption
1610[info] - Monoid[IO[Throwable, Int]].monoid.intercalateIntercalates
1611[info] - Monoid[IO[Throwable, Int]].monoid.intercalateRepeat1
1612[info] - Monoid[IO[Throwable, Int]].monoid.intercalateRepeat2
1613[info] - Monoid[IO[Throwable, Int]].monoid.is id
1614[info] - Monoid[IO[Throwable, Int]].monoid.left identity
1615[info] - Monoid[IO[Throwable, Int]].monoid.repeat0
1616[info] - Monoid[IO[Throwable, Int]].monoid.repeat1
1617[info] - Monoid[IO[Throwable, Int]].monoid.repeat2
1618[info] - Monoid[IO[Throwable, Int]].monoid.reverseCombineAllOption
1619[info] - Monoid[IO[Throwable, Int]].monoid.reverseRepeat1
1620[info] - Monoid[IO[Throwable, Int]].monoid.reverseRepeat2
1621[info] - Monoid[IO[Throwable, Int]].monoid.reverseReverses
1622[info] - Monoid[IO[Throwable, Int]].monoid.right identity
1623[info] - Bifunctor[IO[String, Int]].Bifunctor.Bifunctor Identity
1624[info] - Bifunctor[IO[String, Int]].Bifunctor.Bifunctor associativity
1625[info] - Bifunctor[IO[String, Int]].Bifunctor.Bifunctor leftMap Identity
1626[info] - Bifunctor[IO[String, Int]].Bifunctor.Bifunctor leftMap associativity
1627[info] monix.bio.TaskCallbackSuite
1628[info] - onValue should invoke onSuccess
1629[info] - apply Success(Right(value)) should invoke onSuccess
1630[info] - apply Success(Left(value)) should invoke onError
1631[info] - apply Failure(ex) should invoke onTermination
1632[info] - contramap should pipe onError
1633[info] - contramap should invoke function before invoking callback
1634[info] - BiCallback.fromPromise (success)
1635[info] - BiCallback.fromPromise (failure)
1636[info] - BiCallback.fromPromise (terminal failure)
1637[info] - BiCallback.fromPromise(Cause) (terminal failure)
1638[info] - BiCallback.empty reports errors
1639[info] - BiCallback.empty reports terminal errors
1640[info] - BiCallback.safe protects against errors in onSuccess
1641[info] - BiCallback.safe protects against errors in onError
1642[info] - BiCallback.safe protects against errors in onTermination
1643[info] - callback(Right(a))
1644[info] - callback(Left(e))
1645[info] - callback(Left(ex))
1646[info] - fromAttempt success
1647[info] - fromAttempt error
1648[info] - fromAttempt termination
1649[info] monix.bio.TaskStartSuite
1650[info] - task.start.flatMap(_.join) <-> task
1651[info] - task.start.flatMap(id) is cancelable, but the source is memoized
1652[info] - task.start is stack safe
1653[info] - task.start shares Local.Context with fibers
1654[info] - task.start is stack safe
1655[info] - task.start executes asynchronously
1656[info] monix.bio.TaskErrorSuite
1657[info] - IO.attempt should expose typed error
1658[info] - IO.attempt should not expose unexpected error
1659[info] - IO.attempt should work for successful values
1660[info] - IO.rethrow should turn Left to typed error
1661[info] - IO.rethrow should turn Right to success value
1662[info] - IO.failed should expose typed error
1663[info] - IO.failed should fail for unexpected error
1664[info] - IO.failed should fail for successful values
1665[info] - IO#onErrorRecover should mirror source on success
1666[info] - IO#onErrorRecover should recover typed error
1667[info] - IO#onErrorRecover should not recover unexpected error
1668[info] - IO#onErrorRecover should protect against user code
1669[info] - IO#onErrorHandle should mirror source on success
1670[info] - IO#onErrorHandle should recover typed error
1671[info] - IO#onErrorHandle should not recover unexpected error
1672[info] - IO#onErrorHandle should protect against user code
1673[info] - IO.onErrorFallbackTo should mirror source onSuccess
1674[info] - IO.onErrorFallbackTo should fallback to backup onError
1675[info] - IO.onErrorFallbackTo should not fallback to backup onTermination
1676[info] - IO.onErrorFallbackTo should protect against user code
1677[info] - IO.onErrorFallbackTo should be cancelable if the ExecutionModel allows it
1678[info] - IO.onErrorRestart should mirror the source onSuccess
1679[info] - IO.onErrorRestart should retry onError
1680[info] - IO.onErrorRestart should emit onError after max retries
1681[info] - IO.onErrorRestart should be cancelable if ExecutionModel permits
1682[info] - IO.onErrorRestart should not restart on terminate error
1683[info] - IO.onErrorRestartIf should mirror the source onSuccess
1684[info] - IO.onErrorRestartIf should retry onError
1685[info] - IO.onErrorRestartIf should emit onError
1686[info] - IO.onErrorRestartIf should be cancelable if ExecutionModel permits
1687[info] - IO.onErrorRestartIf should not restart on terminate error
1688[info] - IO.onErrorRestartIf should restart on typed error
1689[info] - IO#onErrorRecoverWith should mirror source on success
1690[info] - IO#onErrorRecoverWith should recover
1691[info] - IO#mapErrorPartial should handle recoverable exceptions
1692[info] - IO#mapErrorPartial should terminate on non-recoverable exceptions
1693[info] - IO#mapErrorPartialWith should handle recoverable exceptions
1694[info] - IO#mapErrorPartialWith should terminate on non-recoverable exceptions
1695[info] - IO#onErrorRecoverWith should protect against user code
1696[info] - IO#onErrorRecoverWith has a cancelable fallback
1697[info] - IO#onErrorRecover should emit error if not matches
1698[info] - IO#onErrorRecoverWith should emit error if not matches
1699[info] - IO.eval.flatMap.redeemCauseWith should work
1700[info] - IO.evalAsync.flatMap.redeemCauseWith should work
1701[info] - IO.now.onErrorRecoverWith should be stack safe
1702[info] - onErrorRecoverWith should be stack safe for loop with executeAsync boundaries
1703[info] - Task.onErrorRestartLoop works for success
1704[info] - Task.onErrorRestartLoop can throw different error
1705[info] - Task.onErrorRestartLoop can rethrow
1706[info] monix.bio.TaskLikeConversionsJava8Suite
1707[info] - IO.from converts successful CompletableFuture
1708[info] - IO.from converts failed CompletableFuture
1709[info] - IO.from preserves cancellability of CompletableFuture
1710[info] monix.bio.TaskConversionsKSuite
1711[info] - Task.liftTo[CIO]
1712[info] - Task.liftToAsync[IO]
1713[info] - Task.liftToConcurrent[IO]
1714[info] - Task.liftFrom[IO]
1715[info] - Task.liftFromEffect[IO]
1716[info] - Task.liftFromConcurrentEffect[IO]
1717Hello World!
1718Cancelling!
1719Received: $value
1720Hello!
1721Hello!
1722Success: 42
1723[info] monix.bio.IODoctest
1724[info] - IO.scala:52: IO
1725[info] - IO.scala:474: runToFuture
1726[info] - IO.scala:541: runToFutureOpt
1727[info] - IO.scala:586: runAsync
1728[info] - IO.scala:661: runAsyncOpt
1729[info] - IO.scala:716: runAsyncF
1730[info] - IO.scala:821: runAsyncAndForget
1731[info] - IO.scala:874: runAsyncUncancelable
1732[info] - IO.scala:947: runSyncStep
1733[info] - IO.scala:1011: runSyncUnsafe
1734[info] - IO.scala:1116: memoize
1735[info] - IO.scala:1155: memoizeOnSuccess
1736[info] - IO.scala:1213: >>
1737[info] - IO.scala:1226: *>
1738[info] - IO.scala:1242: <*
1739[info] - IO.scala:1257: asyncBoundary
1740[info] - IO.scala:1306: asyncBoundary
1741[info] - IO.scala:1337: bracket
1742[info] - IO.scala:1525: delayExecution
1743[info] - IO.scala:1554: delayResult
1744[info] - IO.scala:1595: executeOn
1745[info] - IO.scala:1730: executeAsync
1746[info] - IO.scala:1756: executeWithModel
1747[info] - IO.scala:1774: executeWithOptions
1748[info] - IO.scala:1801: flip
1749[info] - IO.scala:1831: flipWith
1750[info] - IO.scala:1879: flatMapLoop
1751[info] - IO.scala:1937: loopForever
1752[info] - IO.scala:2008: onCancelRaiseError
1753[info] - IO.scala:2062: mapErrorPartialWith
1754[info] - IO.scala:2113: tapError
1755[info] - IO.scala:2147: onErrorRestartIf
1756[info] - IO.scala:2167: onErrorRestartLoop
1757[info] - IO.scala:2242: mapError
1758[info] - IO.scala:2261: mapErrorPartial
1759[info] - IO.scala:2296: start
1760[info] - IO.scala:2324: to
1761[info] - IO.scala:2366: toConcurrent
1762[info] - IO.scala:2412: toAsync
1763[info] - IO.scala:2536: uncancelable
1764[info] - IO.scala:2559: timed
1765[info] - IO.scala:2608: timeoutToL
1766[info] - IO.scala:2663: hideErrors
1767[info] - IO.scala:2684: hideErrorsWith
1768[info] - IO.scala:2740: absorb
1769[info] - IO.scala:2758: absorbWith
1770[info] - IO.scala:2782: IO
1771[info] - IO.scala:2843: apply
1772[info] - IO.scala:2905: deferAction
1773[info] - IO.scala:2932: deferFuture
1774[info] - IO.scala:2945: deferFutureAction
1775[info] - IO.scala:3082: fromConcurrentEffect
1776[info] - IO.scala:3119: fromEffect
1777[info] - IO.scala:3149: fromOption
1778[info] - IO.scala:3165: fromOption
1779[info] - IO.scala:3185: fromOptionEval
1780[info] - IO.scala:3243: async
1781[info] - IO.scala:3303: async0
1782[info] - IO.scala:3399: cancelable
1783[info] - IO.scala:3479: cancelable0
1784[info] - IO.scala:3581: cancelBoundary
1785[info] - IO.scala:3617: create
1786[info] - IO.scala:3724: race
1787[info] - IO.scala:3757: raceMany
1788[info] - IO.scala:3778: racePair
1789[info] - IO.scala:3861: sleep
1790[info] - IO.scala:3952: parSequence
1791[info] - IO.scala:4011: parSequenceN
1792[info] - IO.scala:4042: parTraverseN
1793[info] - IO.scala:4079: parSequenceUnordered
1794[info] - IO.scala:4127: mapBoth
1795[info] - IO.scala:4146: map2
1796[info] - IO.scala:4175: map3
1797[info] - IO.scala:4205: map4
1798[info] - IO.scala:4238: map5
1799[info] - IO.scala:4276: map6
1800[info] - IO.scala:4316: parMap2
1801[info] - IO.scala:4351: parMap3
1802[info] - IO.scala:4389: parMap4
1803[info] - IO.scala:4430: parMap5
1804[info] - IO.scala:4476: parMap6
1805[info] - IO.scala:4562: liftTo
1806[info] - IO.scala:4622: liftFrom
1807[info] - IO.scala:5282: catsParallel
1808[info] monix.bio.TaskParTraverseNSuite
1809[info] - IO.parTraverseN allows fully sequential execution
1810[info] - IO.parTraverseN allows fully concurrent execution
1811[info] - IO.parTraverseN allows partially concurrent execution
1812[info] - IO.parTraverseN returns an error when fully sequential execution fails in a typed way
1813[info] - IO.parTraverseN returns an error when fully sequential execution fails in a terminal way
1814[info] - IO.parTraverseN returns an error when fully concurrent execution fails in a typed way
1815[info] - IO.parTraverseN returns an error when fully concurrent execution fails in a terminal way
1816[info] - IO.parTraverseN returns an error when partially concurrent execution fails in a typed way
1817[info] - IO.parTraverseN returns an error when partially concurrent execution fails in a terminal way
1818[info] - IO.parTraverseN returns a terminal error when an exception is thrown
1819[info] - IO.parTraverseN should be cancelable
1820[info] - IO.parTraverseN should be stack safe for synchronous tasks with low parallelism
1821[info] - IO.parTraverseN should be stack safe for asynchronous tasks with low parallelism
1822[info] - IO.parTraverseN should be stack safe for synchronous tasks with high parallelism
1823[info] - IO.parTraverseN should be stack safe for asynchronous tasks with high parallelism
1824[info] - IO.parTraverseN allows running the same effect multiple times
1825[info] - IO.parTraverseN allows reusing a memoized effect multiple times
1826Executing...
1827Executing...
1828Executing...
1829Received: $str
1830Finished via exit code: $exitCode
1831Resources were released!
1832Executing...
1833Received: $str
1834[info] monix.bio.TaskBracketSuite
1835[info] - equivalence with onErrorHandleWith
1836[info] - equivalence with flatMap + redeemWith
1837[info] - equivalence with flatMap + redeemCauseWith
1838[info] - use is protected against user error
1839[info] - release is evaluated on success
1840[info] - release is evaluated on error
1841[info] - release is evaluated on terminal error
1842[info] - release is evaluated on cancel
1843[info] - if both use and release throw, report release error, signal use error
1844[info] - bracket works with auto-cancelable run-loops
1845[info] - bracket is stack safe (1)
1846[info] - bracket is stack safe (2)
1847[info] - bracket is stack safe (3)
1848[info] - bracket is stack safe (4)
1849[info] - use is not evaluated on cancel
1850[info] - cancel should wait for already started finalizers on success
1851[info] - cancel should wait for already started finalizers on failure
1852[info] - cancel should wait for already started use finalizers
1853[info] - second cancel should wait for use finalizers
1854[info] - second cancel during acquire should wait for it and finalizers to complete
1855[info] - second cancel during acquire should wait for it and finalizers to complete (non-terminating)
1856[info] - Multiple cancel should not hang
1857[info] - bracket can be canceled while failing to acquire
1858[info] - bracket can be canceled while terminating
1859[info] monix.bio.TaskSuspendSuite
1860[info] - IO.suspend should suspend evaluation
1861[info] - IO.suspend should protect against user code errors
1862[info] - IO.suspendTotal should protect against unexpected errors
1863[info] monix.bio.TaskToStringSuite
1864[info] - IO.Now
1865[info] - IO.Error
1866[info] - IO.Termination
1867[info] - IO.Eval
1868[info] - IO.EvalTotal
1869[info] - IO.Async
1870[info] - IO.FlatMap
1871[info] - IO.Suspend
1872[info] - IO.SuspendTotal
1873[info] - IO.Map
1874[info] monix.bio.TaskEvalAlwaysSuite
1875[info] - IO.eval should work synchronously
1876[info] - IO.eval should protect against user code errors
1877[info] - IO.eval is equivalent with IO.evalOnce on first run
1878[info] - IO.eval.flatMap should be equivalent with IO.eval
1879[info] - IO.eval.flatMap should protect against user code
1880[info] - IO.eval.flatMap should be tail recursive
1881[info] - IO.eval should not be cancelable
1882[info] - IO.eval.coeval
1883[info] - IO.eval.flatMap should protect against user code errors
1884[info] - IO.delay is an alias for IO.eval
1885[info] - IO.evalTotal should protect against unexpected errors
1886[info] monix.bio.TaskConnectionRefSuite
1887[info] - assign and cancel a Cancelable
1888[info] - assign and cancel a CancelableF
1889[info] - assign and cancel a CancelToken[Task]
1890[info] - cancel a Cancelable on single assignment
1891[info] - cancel a CancelableF on single assignment
1892[info] - cancel a Task on single assignment
1893[info] monix.bio.TaskAsyncBoundarySuite
1894[info] - IO.asyncBoundary should work
1895[info] - IO.asyncBoundary(other) should work
1896[info] - IO.asyncBoundary should preserve locals
1897[info] - IO.asyncBoundary(scheduler) should preserve locals
1898[info] - IO.asyncBoundary is stack safe in flatMap loops, test 1
1899[info] - IO.asyncBoundary is stack safe in flatMap loops, test 2
1900[info] monix.bio.IOLocalJVMSuite
1901[info] - locals get transported with executeOn and shift
1902[info] - locals get transported with executeWithModel
1903[info] - locals get transported with executeWithOptions
1904[info] - IOLocal.isolate can be nested with executeWithOptions
1905[info] - local.write.executeOn(forceAsync = false) works
1906[info] - local.write.executeOn(forceAsync = true) works
1907[info] - local state is encapsulated by Task run loop with TracingScheduler
1908[info] - local state is encapsulated by Task run loop without TracingScheduler
1909[info] - local state is encapsulated by Task run loop on single thread
1910[info] - IOLocal.isolate should properly isolate during async boundaries
1911[info] - IOLocal.isolate should properly isolate during async boundaries on error
1912[info] - IOLocal.isolate should properly isolate during async boundaries on cancelation
1913[info] - IOLocal.isolate should isolate contexts from Future
1914[info] - Task.evalAsync.runToFuture isolates but preserves context for Future continuation
1915[info] - Task.eval.runToFuture isolates but preserves context for Future continuation
1916[info] - Task.evalAsync.runToFuture isolates but preserves context for Future continuation on a single thread
1917[info] - Task.eval.runToFuture continuations keep isolated context in longer continuations
1918[info] - Task.eval.runToFuture can isolate future continuations
1919[info] - Task.eval.runToFuture can isolate future continuations on failure
1920[info] - Task.runToFuture resulting future can be reused
1921[info] - Task.eval.runToFuture is isolated from outside changes
1922[info] monix.bio.TaskAsyncAutoShiftJVMSuite
1923[info] - Task.fromFuture(async) should shift back to the main scheduler
1924[info] - Task.fromFuture(completed) should not shift to the main scheduler
1925[info] - Task.fromFuture(async error) should shift back to the main scheduler
1926[info] - Task.fromFuture(completed error) should not shift to the main scheduler
1927[info] - Task.deferFuture(async) should shift back to the main scheduler
1928[info] - Task.deferFuture(completed) should not shift to the main scheduler
1929[info] - Task.deferFuture(async error) should shift back to the main scheduler
1930[info] - Task.deferFuture(completed error) should not shift to the main scheduler
1931[info] - Task.deferFutureAction(async) should shift back to the main scheduler
1932[info] - Task.deferFutureAction(completed) should not shift to the main scheduler
1933[info] - Task.deferFutureAction(async error) should shift back to the main scheduler
1934[info] - Task.deferFutureAction(completed error) should not shift to the main scheduler
1935[info] - Task.fromFuture(async cancelable) should shift back to the main scheduler
1936[info] - Task.fromFuture(completed cancelable) should not shift to the main scheduler
1937[info] - Task.fromFuture(async error cancelable) should shift back to the main scheduler
1938[info] - Task.fromFuture(completed error cancelable) should not shift to the main scheduler
1939[info] - Task.deferFuture(async cancelable) should shift back to the main scheduler
1940[info] - Task.deferFuture(completed cancelable) should not shift to the main scheduler
1941[info] - Task.deferFuture(async error cancelable) should shift back to the main scheduler
1942[info] - Task.deferFuture(completed error cancelable) should not shift to the main scheduler
1943[info] - Task.deferFutureAction(async cancelable) should shift back to the main scheduler
1944[info] - Task.deferFutureAction(completed cancelable) should not shift to the main scheduler
1945[info] - Task.deferFutureAction(async error cancelable) should shift back to the main scheduler
1946[info] - Task.deferFutureAction(completed error cancelable) should not shift to the main scheduler
1947[info] - Task.async(register) should shift back if register forks
1948[info] - Task.async(register) should not shift back if register does not fork
1949[info] - Task.async(register typed) should shift back if register forks
1950[info] - Task.async(register error) should not shift back if register does not fork
1951[info] - Task.async0(register) should shift back if register forks
1952[info] - Task.async0(register) should not shift back if register does not fork
1953[info] - Task.async0(register error) should shift back if register forks
1954[info] - Task.async0(register error) should not shift back if register does not fork
1955[info] - Task.cancelable(register) should shift back if register forks
1956[info] - Task.cancelable(register) should not shift back if register does not fork
1957[info] - Task.cancelable(register error) should shift back if register forks
1958[info] - Task.cancelable(register error) should not shift back if register does not fork
1959[info] - Task.cancelable0(register) should shift back if register forks
1960[info] - Task.cancelable0(register) should not shift back if register does not fork
1961[info] - Task.cancelable0(register error) should shift back if register forks
1962[info] - Task.cancelable0(register error) should not shift back if register does not fork
1963[info] - Task.create(register) should shift back if register forks
1964[info] - Task.create(register) should not shift back if register does not fork
1965[info] - Task.create(register error) should shift back if register forks
1966[info] - Task.create(register error) should not shift back if register does not fork
1967[info] - Task.asyncF(register) should shift back if register forks
1968[info] - Task.asyncF(register) should not shift back if register does not fork
1969[info] - Task.asyncF(register error) should shift back if register forks
1970[info] - Task.asyncF(register error) should not shift back if register does not fork
1971[info] monix.bio.FiberDoctest
1972[info] - Fiber.scala:22: Fiber
1973[info] monix.bio.TaskFlipSuite
1974[info] - flip successfully swaps the error and value parameters
1975[info] - flipWith should successfully apply the provided function to the swapped error value
1976[info] - flip should not alter original successful value
1977[info] - flipWith should not alter original successful value
1978[info] - F.flip.map(f) <-> F.mapError(f).flip
1979[info] - F.flipWith(f) <-> F.mapError(f)
1980[info] monix.bio.TaskParSequenceNSuite
1981[info] - IO.parSequenceN should execute in parallel bounded by parallelism
1982[info] - IO.parSequenceN should return result in order
1983[info] - IO.parSequenceN should return empty list
1984[info] - IO.parSequenceN should handle single item
1985[info] - IO.parSequenceN should handle parallelism bigger than list
1986[info] - IO.parSequenceN should onError if one of the tasks terminates in error
1987[info] - IO.parSequenceN should onTerminate if one of the tasks terminates in a fatal error
1988[info] - IO.parSequenceN should be canceled
1989[info] - IO.parSequenceN should be stack safe for synchronous tasks
1990[info] - IO.parSequenceN runAsync multiple times
1991[info] - IO.parSequenceN should log errors if multiple errors happen
1992[info] - IO.parSequenceN should log terminal errors if multiple errors happen
1993[info] monix.bio.TaskExecuteAsyncSuite
1994[info] - IO.now.executeAsync should execute async
1995[info] - IO.now.executeOn should execute async if forceAsync = true
1996[info] - IO.now.executeOn should not execute async if forceAsync = false
1997[info] - IO.create.executeOn should execute async
1998[info] - executeAsync should be stack safe, test 1
1999[info] - IO.executeOn should be stack safe, test 2
2000[info] - executeAsync should be stack safe, test 3
2001[info] monix.bio.TaskCallbackSafetySuite
2002[info] - IO.async's callback can be called multiple times
2003[info] - IO.async0's callback can be called multiple times
2004[info] - IO.asyncF's callback can be called multiple times
2005[info] - IO.cancelable's callback can be called multiple times
2006[info] - IO.cancelable0's callback can be called multiple times
2007[info] - IO.async's register throwing is signaled as error
2008[info] - IO.async0's register throwing is signaled as error
2009[info] - IO.asyncF's register throwing is signaled as error (1)
2010[info] - IO.asyncF's register throwing is signaled as error (2)
2011[info] - IO.cancelable's register throwing is signaled as error
2012[info] - IO.cancelable0's register throwing is signaled as error
2013[info] - IO.async's register throwing, after result, is reported
2014[info] - IO.async0's register throwing, after result, is reported
2015[info] - IO.asyncF's register throwing, after result, is reported (1)
2016[info] - IO.asyncF's register throwing, after result, is reported (2)
2017[info] - IO.cancelable's register throwing, after result, is reported
2018[info] - IO.cancelable0's register throwing, after result, is reported
2019[info] monix.bio.BIOAppSuite
2020[info] - run works
2021[info] - options are configurable
2022[info] - ConcurrentEffect[Task]
2023value1: 0
2024value2: 100
2025value3: 400
2026value4: 100
2027value5: 0
2028[info] monix.bio.IOLocalDoctest
2029[info] - IOLocal.scala:23: IOLocal
2030[info] - IOLocal.scala:124: bind
2031[info] - IOLocal.scala:148: bindL
2032[info] - IOLocal.scala:179: bindClear
2033[info] monix.bio.TaskRaceSuite
2034[info] - IO.raceMany returns fastest success
2035[info] - IO.raceMany returns fastest typed error
2036[info] - IO.raceMany returns fastest terminal error
2037[info] - IO.raceMany returns success that is faster than typed error
2038[info] - IO.raceMany returns success that is faster than terminal error
2039[info] - IO.raceMany returns typed error that is faster than success
2040[info] - IO.raceMany returns typed error that is faster than fatal error
2041[info] - IO.raceMany returns fatal error that is faster than success
2042[info] - IO.raceMany returns fatal error that is faster than typed error
2043[info] - IO.raceMany should allow cancelling all tasks
2044[info] - IO.raceMany should be stack safe for sync values
2045[info] - IO.raceMany should be stack safe for async values
2046[info] - IO.raceMany has a stack safe cancelable
2047[info] - IO#timeout should timeout
2048[info] - IO#timeout should mirror the source in case of success
2049[info] - IO#timeout should mirror the source in case of error
2050[info] - IO#timeout should mirror the source in case of terminal error
2051[info] - IO#timeout should cancel both the source and the timer
2052[info] - IO#timeout with backup should timeout
2053[info] - IO#timeout with backup should timeout with error
2054[info] - IO#timeout with backup should mirror the source in case of success
2055[info] - IO#timeout with backup should mirror the source in case of error
2056[info] - IO#timeout should cancel both the source and the timer
2057[info] - IO#timeout should cancel the backup
2058[info] - IO#timeout should not return the source after timeout
2059[info] - IO#timeout should cancel the source after timeout
2060[info] - IO#timeoutToL should evaluate as specified: lazy, no memoization
2061[info] - IO#timeoutL should evaluate as specified: lazy, with memoization
2062[info] - IO#timeoutL considers time taken to evaluate the duration task
2063[info] - IO#timeoutL: evaluation time took > timeout => timeout is immediately completed
2064[info] - IO.racePair(a,b) should work if a completes first
2065[info] - IO.racePair(a,b) should cancel both
2066[info] - IO.racePair(A,B) should not cancel B if A completes first
2067[info] - IO.racePair(A,B) should not cancel A if B completes first
2068[info] - IO.racePair(A,B) should end both in error if A completes first in error
2069[info] - IO.racePair(A,B) should end both in terminal error if A completes first in terminal error
2070[info] - IO.racePair(A,B) should end both in error if B completes first in error
2071[info] - IO.racePair(A,B) should end both in terminal error if B completes first in terminal error
2072[info] - IO.racePair(A,B) should work if A completes second in error
2073[info] - IO.racePair(A,B) should work if A completes second in terminal error
2074[info] - IO.racePair(A,B) should work if B completes second in error
2075[info] - IO.racePair should be stack safe, take 1
2076[info] - IO.racePair should be stack safe, take 2
2077[info] - IO.racePair has a stack safe cancelable
2078[info] - IO.race(a, b) should work if a completes first
2079[info] - IO.race(a, b) should work if b completes first
2080[info] - IO.race(a, b) should cancel both
2081[info] - IO.race(a, b) should end both in error if `a` completes first in error
2082[info] - IO.race(a, b) should end both in error if `a` completes first in terminal error
2083[info] - IO.race(a, b) should end both in error if `b` completes first in error
2084[info] - IO.race(a, b) should end both in error if `b` completes first in error
2085[info] - IO.race(a, b) should work if `a` completes in typed error
2086[info] - IO.race(a, b) should work if `a` completes in unexpected error
2087[info] - IO.race(a, b) should work if `b` completes in typed error
2088[info] - IO.race(a, b) should work if `b` completes in unexpected error
2089[info] - IO.race should be stack safe, take 1
2090[info] - IO.race should be stack safe, take 2
2091[info] - Task.race has a stack safe cancelable
2092[info] monix.bio.TaskEffectInstanceSuite
2093[info] - Effect instance should make use of implicit TaskOptions
2094[info] - Effect instance should use Task.defaultOptions with default TestScheduler
2095[info] - Effect instance should use Task.defaultOptions.withSchedulerFeatures
2096[info] monix.bio.TaskDelaySuite
2097[info] - IO#delayExecution should work
2098[info] - IO#delayExecution is stack safe, test 1
2099[info] - IO#delayExecution is stack safe, test 2
2100[info] - IO#delayExecution is cancelable
2101[info] - IO#delayResult should work
2102[info] - IO#delayResult is stack safe, test 1
2103[info] - IO#delayResult is stack safe, test 2
2104[info] - IO#delayResult is cancelable
2105[info] - IO#delayResult should not delay in case of error
2106[info] - IO#delayResult should not delay in case of terminal error
2107[info] monix.bio.TaskMiscSuite
2108[info] - IO.attempt should succeed
2109[info] - IO.raiseError.attempt should expose error
2110[info] - IO.mapError should map error
2111[info] - IO.terminate.attempt should not expose error
2112[info] - IO.tapError should not alter original successful value
2113[info] - IO.tapError should not alter original error value
2114[info] - IO.tapError should not alter original terminal error
2115[info] - IO.failed should expose error
2116[info] - IO.failed should fail for successful values
2117[info] - IO.map protects against user code
2118[info] - IO.forever
2119[info] - IO.restartUntil should keep retrying IO until predicate succeeds
2120[info] - IO.toReactivePublisher should convert tasks with no errors
2121[info] - IO.toReactivePublisher should convert tasks with typed errors
2122[info] - IO.toReactivePublisher should convert tasks with terminal errors
2123[info] - IO.toReactivePublisher should be cancelable
2124[info] - IO.toReactivePublisher should throw errors on invalid requests
2125[info] - IO.pure is an alias of now
2126[info] - IO.now.runAsync with Try-based callback
2127[info] - Task.error.runAsync with Try-based callback
2128[info] - Task.terminate.runAsync with Try-based callback
2129[info] - task.executeAsync.runAsync with Try-based callback for success
2130[info] - task.executeAsync.runAsync with Try-based callback for error
2131[info] - task.executeAsync.runAsync with Try-based callback for terminal error
2132[info] - task.executeWithOptions protects against user error
2133[info] monix.bio.tracing.StackTracedContextSuite
2134[info] - push traces
2135[info] monix.bio.TaskCallbackSafetyJVMSuite
2136[info] - track omitted frames
2137[info] - IO.async has a safe callback
2138[info] - IO.async0 has a safe callback
2139[info] - IO.asyncF has a safe callback
2140[info] - IO.cancelable has a safe callback
2141[info] - IO.cancelable0 has a safe callback
2142[info] monix.bio.IOLikeDoctest
2143[info] - IOLike.scala:29: IOLike
2144[info] monix.bio.TaskEvalOnceSuite
2145[info] - IO.evalOnce should protect against user code errors
2146[info] - IO.evalOnce.flatMap should be equivalent with Task.evalOnce
2147[info] - IO.evalOnce.flatMap should protect against user code
2148[info] - IO.evalOnce.map should work
2149[info] - IO.evalOnce.flatMap should be tail recursive
2150[info] - IO.EvalOnce.runAsync override
2151[info] - IO.evalOnce.materialize should work for success
2152[info] - IO.evalOnce.materialize should work for failure
2153[info] monix.bio.TaskExecuteWithModelSuite
2154[info] - executeWithModel works
2155[info] - local.write.executeWithModel(AlwaysAsyncExecution) works
2156[info] - local.write.executeWithModel(SynchronousExecution) works
2157[info] - executeWithModel is stack safe in flatMap loops
2158[info] monix.bio.TaskVoidSuite
2159[info] - IO.void should work
2160Hello!
2161[info] monix.bio.IOLocalSuite
2162[info] - IOLocal.apply
2163[info] - IOLocal.wrap
2164[info] - IOLocal!.bind
2165[info] - IOLocal!.bindL
2166[info] - IOLocal!.bindClear
2167[info] - IOLocal canceled
2168[info] - IOLocal!.local
2169[info] - TaskLocals get restored in IO.create on error
2170[info] - TaskLocals get restored in IO.create on termination
2171[info] - IOLocal should work with bracket
2172[info] - IOLocal.isolate should prevent context changes
2173[info] - IOLocal interop with future via deferFutureAction
2174[info] - IOLocal.bind scoping works
2175[info] - IOLocal.bind actually isolates reads
2176[info] - IOLocal.isolate with ConcurrentChannel
2177[info] monix.bio.TypeClassLawsForTaskAutoCancelableWithCallbackSuite
2178[info] - CoflatMap[Task].coflatMap.coflatMap associativity
2179[info] - CoflatMap[Task].coflatMap.coflatMap identity
2180[info] - CoflatMap[Task].coflatMap.coflatten coherence
2181[info] - CoflatMap[Task].coflatMap.coflatten throughMap
2182[info] - CoflatMap[Task].coflatMap.covariant composition
2183[info] - CoflatMap[Task].coflatMap.covariant identity
2184[info] - CoflatMap[Task].coflatMap.invariant composition
2185[info] - CoflatMap[Task].coflatMap.invariant identity
2186[info] - Concurrent[Task].async.acquire and release of bracket are uncancelable
2187[info] - Concurrent[Task].async.ap consistent with product + map
2188[info] - Concurrent[Task].async.applicative homomorphism
2189[info] - Concurrent[Task].async.applicative identity
2190[info] - Concurrent[Task].async.applicative interchange
2191[info] - Concurrent[Task].async.applicative map
2192[info] - Concurrent[Task].async.applicative unit
2193[info] - Concurrent[Task].async.applicativeError adaptError pure
2194[info] - Concurrent[Task].async.applicativeError adaptError raise
2195[info] - Concurrent[Task].async.applicativeError attempt consistent with attemptT
2196[info] - Concurrent[Task].async.applicativeError attempt fromEither consistent with pure
2197[info] - Concurrent[Task].async.applicativeError handle
2198[info] - Concurrent[Task].async.applicativeError handleError . raiseError left-distributes over ap
2199[info] - Concurrent[Task].async.applicativeError handleError . raiseError right-distributes over ap
2200[info] - Concurrent[Task].async.applicativeError handleError consistent with recover
2201[info] - Concurrent[Task].async.applicativeError handleError pure
2202[info] - Concurrent[Task].async.applicativeError handleErrorWith consistent with recoverWith
2203[info] - Concurrent[Task].async.applicativeError handleErrorWith pure
2204[info] - Concurrent[Task].async.applicativeError handleWith
2205[info] - Concurrent[Task].async.applicativeError onError pure
2206[info] - Concurrent[Task].async.applicativeError onError raise
2207[info] - Concurrent[Task].async.applicativeError pure attempt
2208[info] - Concurrent[Task].async.applicativeError raiseError attempt
2209[info] - Concurrent[Task].async.applicativeError recover consistent with recoverWith
2210[info] - Concurrent[Task].async.applicativeError redeem is derived from attempt and map
2211[info] - Concurrent[Task].async.apply composition
2212[info] - Concurrent[Task].async.async can be derived from asyncF
2213[info] - Concurrent[Task].async.async left is raiseError
2214[info] - Concurrent[Task].async.async right is pure
2215[info] - Concurrent[Task].async.bind suspends evaluation
2216[info] - Concurrent[Task].async.bracket is derived from bracketCase
2217[info] - Concurrent[Task].async.bracket release is called on Completed or Error
2218[info] - Concurrent[Task].async.bracketCase with failure in acquisition remains failure
2219[info] - Concurrent[Task].async.bracketCase with pure unit on release is eqv to map
2220[info] - Concurrent[Task].async.bracketCase with pure unit on release is eqv to uncancelable(..).flatMap
2221[info] - Concurrent[Task].async.covariant composition
2222[info] - Concurrent[Task].async.covariant identity
2223[info] - Concurrent[Task].async.delay constant is pure
2224[info] - Concurrent[Task].async.flatMap associativity
2225[info] - Concurrent[Task].async.flatMap consistent apply
2226[info] - Concurrent[Task].async.flatMap from tailRecM consistency
2227[info] - Concurrent[Task].async.guarantee is derived from bracket
2228[info] - Concurrent[Task].async.guaranteeCase is derived from bracketCase
2229[info] - Concurrent[Task].async.invariant composition
2230[info] - Concurrent[Task].async.invariant identity
2231[info] - Concurrent[Task].async.map flatMap coherence
2232[info] - Concurrent[Task].async.map suspends evaluation
2233[info] - Concurrent[Task].async.map2/map2Eval consistency
2234[info] - Concurrent[Task].async.map2/product-map consistency
2235[info] - Concurrent[Task].async.monad left identity
2236[info] - Concurrent[Task].async.monad right identity
2237[info] - Concurrent[Task].async.monadError ensure consistency
2238[info] - Concurrent[Task].async.monadError ensureOr consistency
2239[info] - Concurrent[Task].async.monadError left zero
2240[info] - Concurrent[Task].async.monadError redeemWith is derived from attempt and flatMap
2241[info] - Concurrent[Task].async.monadError rethrow attempt
2242[info] - Concurrent[Task].async.monoidal left identity
2243[info] - Concurrent[Task].async.monoidal right identity
2244[info] - Concurrent[Task].async.mproduct consistent flatMap
2245[info] - Concurrent[Task].async.never is derived from async
2246[info] - Concurrent[Task].async.onCancel is derived from guaranteeCase
2247[info] - Concurrent[Task].async.productL consistent map2
2248[info] - Concurrent[Task].async.productR consistent map2
2249[info] - Concurrent[Task].async.propagate errors through bind (async)
2250[info] - Concurrent[Task].async.propagate errors through bind (suspend)
2251[info] - Concurrent[Task].async.repeated async evaluation not memoized
2252[info] - Concurrent[Task].async.repeated asyncF evaluation not memoized
2253[info] - Concurrent[Task].async.repeated sync evaluation not memoized
2254[info] - Concurrent[Task].async.semigroupal associativity
2255[info] - Concurrent[Task].async.stack-safe on bracket with left-associated binds
2256[info] - Concurrent[Task].async.stack-safe on bracket with right-associated binds
2257[info] - Concurrent[Task].async.stack-safe on guarantee with left-associated binds
2258[info] - Concurrent[Task].async.stack-safe on guarantee with right-associated binds
2259[info] - Concurrent[Task].async.stack-safe on left-associated binds
2260[info] - Concurrent[Task].async.stack-safe on repeated attempts
2261[info] - Concurrent[Task].async.stack-safe on repeated maps
2262[info] - Concurrent[Task].async.stack-safe on right-associated binds
2263[info] - Concurrent[Task].async.suspend constant is pure join
2264[info] - Concurrent[Task].async.tailRecM consistent flatMap
2265[info] - Concurrent[Task].async.tailRecM stack safety
2266[info] - Concurrent[Task].async.throw in delay is raiseError
2267[info] - Concurrent[Task].async.throw in suspend is raiseError
2268[info] - Concurrent[Task].async.uncancelable prevents Cancelled case
2269[info] - Concurrent[Task].async.unsequenced delay is no-op
2270[info] - ConcurrentEffect[Task].effect.acquire and release of bracket are uncancelable
2271[info] - ConcurrentEffect[Task].effect.ap consistent with product + map
2272[info] - ConcurrentEffect[Task].effect.applicative homomorphism
2273[info] - ConcurrentEffect[Task].effect.applicative identity
2274[info] - ConcurrentEffect[Task].effect.applicative interchange
2275[info] - ConcurrentEffect[Task].effect.applicative map
2276[info] - ConcurrentEffect[Task].effect.applicative unit
2277[info] - ConcurrentEffect[Task].effect.applicativeError adaptError pure
2278[info] - ConcurrentEffect[Task].effect.applicativeError adaptError raise
2279[info] - ConcurrentEffect[Task].effect.applicativeError attempt consistent with attemptT
2280[info] - ConcurrentEffect[Task].effect.applicativeError attempt fromEither consistent with pure
2281[info] - ConcurrentEffect[Task].effect.applicativeError handle
2282[info] - ConcurrentEffect[Task].effect.applicativeError handleError . raiseError left-distributes over ap
2283[info] - ConcurrentEffect[Task].effect.applicativeError handleError . raiseError right-distributes over ap
2284[info] - ConcurrentEffect[Task].effect.applicativeError handleError consistent with recover
2285[info] - ConcurrentEffect[Task].effect.applicativeError handleError pure
2286[info] - ConcurrentEffect[Task].effect.applicativeError handleErrorWith consistent with recoverWith
2287[info] - ConcurrentEffect[Task].effect.applicativeError handleErrorWith pure
2288[info] - ConcurrentEffect[Task].effect.applicativeError handleWith
2289[info] - ConcurrentEffect[Task].effect.applicativeError onError pure
2290[info] - ConcurrentEffect[Task].effect.applicativeError onError raise
2291[info] - ConcurrentEffect[Task].effect.applicativeError pure attempt
2292[info] - ConcurrentEffect[Task].effect.applicativeError raiseError attempt
2293[info] - ConcurrentEffect[Task].effect.applicativeError recover consistent with recoverWith
2294[info] - ConcurrentEffect[Task].effect.applicativeError redeem is derived from attempt and map
2295[info] - ConcurrentEffect[Task].effect.apply composition
2296[info] - ConcurrentEffect[Task].effect.async can be derived from asyncF
2297[info] - ConcurrentEffect[Task].effect.async left is raiseError
2298[info] - ConcurrentEffect[Task].effect.async right is pure
2299[info] - ConcurrentEffect[Task].effect.bind suspends evaluation
2300[info] - ConcurrentEffect[Task].effect.bracket is derived from bracketCase
2301[info] - ConcurrentEffect[Task].effect.bracket release is called on Completed or Error
2302[info] - ConcurrentEffect[Task].effect.bracketCase with failure in acquisition remains failure
2303[info] - ConcurrentEffect[Task].effect.bracketCase with pure unit on release is eqv to map
2304[info] - ConcurrentEffect[Task].effect.bracketCase with pure unit on release is eqv to uncancelable(..).flatMap
2305[info] - ConcurrentEffect[Task].effect.covariant composition
2306[info] - ConcurrentEffect[Task].effect.covariant identity
2307[info] - ConcurrentEffect[Task].effect.delay constant is pure
2308[info] - ConcurrentEffect[Task].effect.flatMap associativity
2309[info] - ConcurrentEffect[Task].effect.flatMap consistent apply
2310[info] - ConcurrentEffect[Task].effect.flatMap from tailRecM consistency
2311[info] - ConcurrentEffect[Task].effect.guarantee is derived from bracket
2312[info] - ConcurrentEffect[Task].effect.guaranteeCase is derived from bracketCase
2313[info] - ConcurrentEffect[Task].effect.invariant composition
2314[info] - ConcurrentEffect[Task].effect.invariant identity
2315[info] - ConcurrentEffect[Task].effect.map flatMap coherence
2316[info] - ConcurrentEffect[Task].effect.map suspends evaluation
2317[info] - ConcurrentEffect[Task].effect.map2/map2Eval consistency
2318[info] - ConcurrentEffect[Task].effect.map2/product-map consistency
2319[info] - ConcurrentEffect[Task].effect.monad left identity
2320[info] - ConcurrentEffect[Task].effect.monad right identity
2321[info] - ConcurrentEffect[Task].effect.monadError ensure consistency
2322[info] - ConcurrentEffect[Task].effect.monadError ensureOr consistency
2323[info] - ConcurrentEffect[Task].effect.monadError left zero
2324[info] - ConcurrentEffect[Task].effect.monadError redeemWith is derived from attempt and flatMap
2325[info] - ConcurrentEffect[Task].effect.monadError rethrow attempt
2326[info] - ConcurrentEffect[Task].effect.monoidal left identity
2327[info] - ConcurrentEffect[Task].effect.monoidal right identity
2328[info] - ConcurrentEffect[Task].effect.mproduct consistent flatMap
2329[info] - ConcurrentEffect[Task].effect.never is derived from async
2330[info] - ConcurrentEffect[Task].effect.onCancel is derived from guaranteeCase
2331[info] - ConcurrentEffect[Task].effect.productL consistent map2
2332[info] - ConcurrentEffect[Task].effect.productR consistent map2
2333[info] - ConcurrentEffect[Task].effect.propagate errors through bind (async)
2334[info] - ConcurrentEffect[Task].effect.propagate errors through bind (suspend)
2335[info] - ConcurrentEffect[Task].effect.repeated async evaluation not memoized
2336[info] - ConcurrentEffect[Task].effect.repeated asyncF evaluation not memoized
2337[info] - ConcurrentEffect[Task].effect.repeated callback ignored
2338[info] - ConcurrentEffect[Task].effect.repeated sync evaluation not memoized
2339[info] - ConcurrentEffect[Task].effect.runAsync ignores error in handler
2340[info] - ConcurrentEffect[Task].effect.runAsync pure produces right IO
2341[info] - ConcurrentEffect[Task].effect.runAsync raiseError produces left IO
2342[info] - ConcurrentEffect[Task].effect.semigroupal associativity
2343[info] - ConcurrentEffect[Task].effect.stack-safe on bracket with left-associated binds
2344[info] - ConcurrentEffect[Task].effect.stack-safe on bracket with right-associated binds
2345[info] - ConcurrentEffect[Task].effect.stack-safe on guarantee with left-associated binds
2346[info] - ConcurrentEffect[Task].effect.stack-safe on guarantee with right-associated binds
2347[info] - ConcurrentEffect[Task].effect.stack-safe on left-associated binds
2348[info] - ConcurrentEffect[Task].effect.stack-safe on repeated attempts
2349[info] - ConcurrentEffect[Task].effect.stack-safe on repeated maps
2350[info] - ConcurrentEffect[Task].effect.stack-safe on right-associated binds
2351[info] - ConcurrentEffect[Task].effect.suspend constant is pure join
2352[info] - ConcurrentEffect[Task].effect.tailRecM consistent flatMap
2353[info] - ConcurrentEffect[Task].effect.tailRecM stack safety
2354[info] - ConcurrentEffect[Task].effect.throw in delay is raiseError
2355[info] - ConcurrentEffect[Task].effect.throw in suspend is raiseError
2356[info] - ConcurrentEffect[Task].effect.toIO is consistent with runAsync
2357[info] - ConcurrentEffect[Task].effect.toIO is the inverse of liftIO
2358[info] - ConcurrentEffect[Task].effect.toIO stack safety
2359[info] - ConcurrentEffect[Task].effect.uncancelable prevents Cancelled case
2360[info] - ConcurrentEffect[Task].effect.unsequenced delay is no-op
2361[info] - CommutativeApplicative[IO.Par].commutative applicative.ap consistent with product + map
2362[info] - CommutativeApplicative[IO.Par].commutative applicative.applicative homomorphism
2363[info] - CommutativeApplicative[IO.Par].commutative applicative.applicative identity
2364[info] - CommutativeApplicative[IO.Par].commutative applicative.applicative interchange
2365[info] - CommutativeApplicative[IO.Par].commutative applicative.applicative map
2366[info] - CommutativeApplicative[IO.Par].commutative applicative.applicative unit
2367[info] - CommutativeApplicative[IO.Par].commutative applicative.apply commutativity
2368[info] - CommutativeApplicative[IO.Par].commutative applicative.apply composition
2369[info] - CommutativeApplicative[IO.Par].commutative applicative.covariant composition
2370[info] - CommutativeApplicative[IO.Par].commutative applicative.covariant identity
2371[info] - CommutativeApplicative[IO.Par].commutative applicative.invariant composition
2372[info] - CommutativeApplicative[IO.Par].commutative applicative.invariant identity
2373[info] - CommutativeApplicative[IO.Par].commutative applicative.map2/map2Eval consistency
2374[info] - CommutativeApplicative[IO.Par].commutative applicative.map2/product-map consistency
2375[info] - CommutativeApplicative[IO.Par].commutative applicative.monoidal left identity
2376[info] - CommutativeApplicative[IO.Par].commutative applicative.monoidal right identity
2377[info] - CommutativeApplicative[IO.Par].commutative applicative.productL consistent map2
2378[info] - CommutativeApplicative[IO.Par].commutative applicative.productR consistent map2
2379[info] - CommutativeApplicative[IO.Par].commutative applicative.semigroupal associativity
2380[info] - Parallel[Task, Task.Par].parallel.isomorphic functor
2381[info] - Parallel[Task, Task.Par].parallel.isomorphic pure
2382[info] - Parallel[Task, Task.Par].parallel.parallel round trip
2383[info] - Parallel[Task, Task.Par].parallel.sequential round trip
2384[info] - Monoid[IO[Throwable, Int]].monoid.associative
2385[info] - Monoid[IO[Throwable, Int]].monoid.collect0
2386[info] - Monoid[IO[Throwable, Int]].monoid.combine all
2387[info] - Monoid[IO[Throwable, Int]].monoid.combineAllOption
2388[info] - Monoid[IO[Throwable, Int]].monoid.intercalateCombineAllOption
2389[info] - Monoid[IO[Throwable, Int]].monoid.intercalateIntercalates
2390[info] - Monoid[IO[Throwable, Int]].monoid.intercalateRepeat1
2391[info] - Monoid[IO[Throwable, Int]].monoid.intercalateRepeat2
2392[info] - Monoid[IO[Throwable, Int]].monoid.is id
2393[info] - Monoid[IO[Throwable, Int]].monoid.left identity
2394[info] - Monoid[IO[Throwable, Int]].monoid.repeat0
2395[info] - Monoid[IO[Throwable, Int]].monoid.repeat1
2396[info] - Monoid[IO[Throwable, Int]].monoid.repeat2
2397[info] - Monoid[IO[Throwable, Int]].monoid.reverseCombineAllOption
2398[info] - Monoid[IO[Throwable, Int]].monoid.reverseRepeat1
2399[info] - Monoid[IO[Throwable, Int]].monoid.reverseRepeat2
2400[info] - Monoid[IO[Throwable, Int]].monoid.reverseReverses
2401[info] - Monoid[IO[Throwable, Int]].monoid.right identity
2402[info] - Bifunctor[IO[String, Int]].Bifunctor.Bifunctor Identity
2403[info] - Bifunctor[IO[String, Int]].Bifunctor.Bifunctor associativity
2404[info] - Bifunctor[IO[String, Int]].Bifunctor.Bifunctor leftMap Identity
2405[info] - Bifunctor[IO[String, Int]].Bifunctor.Bifunctor leftMap associativity
2406[info] monix.bio.TaskExecuteWithOptionsSuite
2407[info] - executeWithOptions works
2408[info] - local.write.executeWithOptions
2409[info] - executeWithOptions is stack safe in flatMap loops
2410[info] monix.bio.TaskCreateSuite
2411[info] - can use Unit as return type
2412[info] - can use Cancelable.empty as return type
2413[info] - returning Unit yields non-cancelable tasks
2414[info] - can use Cancelable as return type
2415[info] - returning Cancelable yields a cancelable task
2416[info] - can use CIO[Unit] as return type
2417[info] - returning CIO[Unit] yields a cancelable task
2418[info] - can use IO[E, Unit] as return type
2419[info] - returning IO[E, Unit] yields a cancelable task
2420[info] - throwing error when returning Unit
2421[info] - throwing error when returning Cancelable
2422[info] monix.bio.TaskMapBothSuite
2423[info] - if both tasks are synchronous, then mapBoth forks
2424[info] - sum two async tasks
2425[info] - sum two synchronous tasks
2426[info] - should be stack-safe for synchronous tasks
2427[info] - should be stack-safe for asynchronous tasks
2428[info] - should have a stack safe cancelable
2429[info] - sum random synchronous tasks
2430[info] - sum random asynchronous tasks
2431[info] - both task can fail with error
2432[info] - both task can fail with terminal error
2433[info] monix.bio.TaskExecuteOnSuite
2434[info] - executeOn(forceAsync = false)
2435[info] - executeOn(forceAsync = true)
2436[info] - executeOn(forceAsync = false) is stack safe in flatMap loops, test 1
2437[info] - executeOn(forceAsync = false) is stack safe in flatMap loops, test 2
2438[info] - local.write.executeOn(forceAsync = false) works
2439[info] - local.write.executeOn(forceAsync = true) works
2440[info] monix.bio.TaskEvalAsyncSuite
2441[info] - IO.evalAsync should work, on different thread
2442[info] - IO.evalAsync should protect against user code errors
2443[info] - UIO.evalAsync should protect against user code errors
2444[info] - IO.evalAsync is equivalent with IO.eval
2445[info] - IO.evalAsync is equivalent with IO.evalOnce on first run
2446[info] - IO.evalAsync.flatMap should protect against user code
2447[info] - IO.evalAsync should be tail recursive
2448[info] - IO.evalAsync.flatten is equivalent with flatMap
2449[info] - IO.evalAsync.coeval
2450[info] monix.bio.TypeClassLawsForTaskSuite
2451[info] - CoflatMap[Task].coflatMap.coflatMap associativity
2452[info] - CoflatMap[Task].coflatMap.coflatMap identity
2453[info] - CoflatMap[Task].coflatMap.coflatten coherence
2454[info] - CoflatMap[Task].coflatMap.coflatten throughMap
2455[info] - CoflatMap[Task].coflatMap.covariant composition
2456[info] - CoflatMap[Task].coflatMap.covariant identity
2457[info] - CoflatMap[Task].coflatMap.invariant composition
2458[info] - CoflatMap[Task].coflatMap.invariant identity
2459[info] - Concurrent[Task].concurrent.acquire and release of bracket are uncancelable
2460[info] - Concurrent[Task].concurrent.acquire of bracket is not cancelable
2461[info] - Concurrent[Task].concurrent.an action run concurrently with a pure value is the same as just doing that action
2462[info] - Concurrent[Task].concurrent.ap consistent with product + map
2463[info] - Concurrent[Task].concurrent.applicative homomorphism
2464[info] - Concurrent[Task].concurrent.applicative identity
2465[info] - Concurrent[Task].concurrent.applicative interchange
2466[info] - Concurrent[Task].concurrent.applicative map
2467[info] - Concurrent[Task].concurrent.applicative unit
2468[info] - Concurrent[Task].concurrent.applicativeError adaptError pure
2469[info] - Concurrent[Task].concurrent.applicativeError adaptError raise
2470[info] - Concurrent[Task].concurrent.applicativeError attempt consistent with attemptT
2471[info] - Concurrent[Task].concurrent.applicativeError attempt fromEither consistent with pure
2472[info] - Concurrent[Task].concurrent.applicativeError handle
2473[info] - Concurrent[Task].concurrent.applicativeError handleError . raiseError left-distributes over ap
2474[info] - Concurrent[Task].concurrent.applicativeError handleError . raiseError right-distributes over ap
2475[info] - Concurrent[Task].concurrent.applicativeError handleError consistent with recover
2476[info] - Concurrent[Task].concurrent.applicativeError handleError pure
2477[info] - Concurrent[Task].concurrent.applicativeError handleErrorWith consistent with recoverWith
2478[info] - Concurrent[Task].concurrent.applicativeError handleErrorWith pure
2479[info] - Concurrent[Task].concurrent.applicativeError handleWith
2480[info] - Concurrent[Task].concurrent.applicativeError onError pure
2481[info] - Concurrent[Task].concurrent.applicativeError onError raise
2482[info] - Concurrent[Task].concurrent.applicativeError pure attempt
2483[info] - Concurrent[Task].concurrent.applicativeError raiseError attempt
2484[info] - Concurrent[Task].concurrent.applicativeError recover consistent with recoverWith
2485[info] - Concurrent[Task].concurrent.applicativeError redeem is derived from attempt and map
2486[info] - Concurrent[Task].concurrent.apply composition
2487[info] - Concurrent[Task].concurrent.async can be derived from asyncF
2488[info] - Concurrent[Task].concurrent.async cancelable coherence
2489[info] - Concurrent[Task].concurrent.async cancelable receives cancel signal
2490[info] - Concurrent[Task].concurrent.async left is raiseError
2491[info] - Concurrent[Task].concurrent.async right is pure
2492[info] - Concurrent[Task].concurrent.asyncF registration can be cancelled
2493[info] - Concurrent[Task].concurrent.bind suspends evaluation
2494[info] - Concurrent[Task].concurrent.bracket is derived from bracketCase
2495[info] - Concurrent[Task].concurrent.bracket release is called on Completed or Error
2496[info] - Concurrent[Task].concurrent.bracket release is called on cancel
2497[info] - Concurrent[Task].concurrent.bracketCase with failure in acquisition remains failure
2498[info] - Concurrent[Task].concurrent.bracketCase with pure unit on release is eqv to map
2499[info] - Concurrent[Task].concurrent.bracketCase with pure unit on release is eqv to uncancelable(..).flatMap
2500[info] - Concurrent[Task].concurrent.covariant composition
2501[info] - Concurrent[Task].concurrent.covariant identity
2502[info] - Concurrent[Task].concurrent.delay constant is pure
2503[info] - Concurrent[Task].concurrent.flatMap associativity
2504[info] - Concurrent[Task].concurrent.flatMap consistent apply
2505[info] - Concurrent[Task].concurrent.flatMap from tailRecM consistency
2506[info] - Concurrent[Task].concurrent.guarantee is derived from bracket
2507[info] - Concurrent[Task].concurrent.guaranteeCase is derived from bracketCase
2508[info] - Concurrent[Task].concurrent.invariant composition
2509[info] - Concurrent[Task].concurrent.invariant identity
2510[info] - Concurrent[Task].concurrent.join is idempotent
2511[info] - Concurrent[Task].concurrent.map flatMap coherence
2512[info] - Concurrent[Task].concurrent.map suspends evaluation
2513[info] - Concurrent[Task].concurrent.map2/map2Eval consistency
2514[info] - Concurrent[Task].concurrent.map2/product-map consistency
2515[info] - Concurrent[Task].concurrent.monad left identity
2516[info] - Concurrent[Task].concurrent.monad right identity
2517[info] - Concurrent[Task].concurrent.monadError ensure consistency
2518[info] - Concurrent[Task].concurrent.monadError ensureOr consistency
2519[info] - Concurrent[Task].concurrent.monadError left zero
2520[info] - Concurrent[Task].concurrent.monadError redeemWith is derived from attempt and flatMap
2521[info] - Concurrent[Task].concurrent.monadError rethrow attempt
2522[info] - Concurrent[Task].concurrent.monoidal left identity
2523[info] - Concurrent[Task].concurrent.monoidal right identity
2524[info] - Concurrent[Task].concurrent.mproduct consistent flatMap
2525[info] - Concurrent[Task].concurrent.never is derived from async
2526[info] - Concurrent[Task].concurrent.onCancel is derived from guaranteeCase
2527[info] - Concurrent[Task].concurrent.productL consistent map2
2528[info] - Concurrent[Task].concurrent.productR consistent map2
2529[info] - Concurrent[Task].concurrent.propagate errors through bind (async)
2530[info] - Concurrent[Task].concurrent.propagate errors through bind (suspend)
2531[info] - Concurrent[Task].concurrent.race cancels both
2532[info] - Concurrent[Task].concurrent.race cancels loser
2533[info] - Concurrent[Task].concurrent.race mirrors left winner
2534[info] - Concurrent[Task].concurrent.race mirrors right winner
2535[info] - Concurrent[Task].concurrent.racePair can join left
2536[info] - Concurrent[Task].concurrent.racePair can join right
2537[info] - Concurrent[Task].concurrent.racePair cancels both
2538[info] - Concurrent[Task].concurrent.racePair cancels loser
2539[info] - Concurrent[Task].concurrent.racePair mirrors left winner
2540[info] - Concurrent[Task].concurrent.racePair mirrors right winner
2541[info] - Concurrent[Task].concurrent.release of bracket is not cancelable
2542[info] - Concurrent[Task].concurrent.repeated async evaluation not memoized
2543[info] - Concurrent[Task].concurrent.repeated asyncF evaluation not memoized
2544[info] - Concurrent[Task].concurrent.repeated sync evaluation not memoized
2545[info] - Concurrent[Task].concurrent.semigroupal associativity
2546[info] - Concurrent[Task].concurrent.stack-safe on bracket with left-associated binds
2547[info] - Concurrent[Task].concurrent.stack-safe on bracket with right-associated binds
2548[info] - Concurrent[Task].concurrent.stack-safe on guarantee with left-associated binds
2549[info] - Concurrent[Task].concurrent.stack-safe on guarantee with right-associated binds
2550[info] - Concurrent[Task].concurrent.stack-safe on left-associated binds
2551[info] - Concurrent[Task].concurrent.stack-safe on repeated attempts
2552[info] - Concurrent[Task].concurrent.stack-safe on repeated maps
2553[info] - Concurrent[Task].concurrent.stack-safe on right-associated binds
2554[info] - Concurrent[Task].concurrent.start then join is identity
2555[info] - Concurrent[Task].concurrent.start.flatMap(_.cancel) is unit
2556[info] - Concurrent[Task].concurrent.suspend constant is pure join
2557[info] - Concurrent[Task].concurrent.tailRecM consistent flatMap
2558[info] - Concurrent[Task].concurrent.tailRecM stack safety
2559[info] - Concurrent[Task].concurrent.throw in delay is raiseError
2560[info] - Concurrent[Task].concurrent.throw in suspend is raiseError
2561[info] - Concurrent[Task].concurrent.uncancelable mirrors source
2562[info] - Concurrent[Task].concurrent.uncancelable prevents Cancelled case
2563[info] - Concurrent[Task].concurrent.uncancelable prevents cancellation
2564[info] - Concurrent[Task].concurrent.unsequenced delay is no-op
2565[info] - ConcurrentEffect[Task].concurrentEffect.acquire and release of bracket are uncancelable
2566[info] - ConcurrentEffect[Task].concurrentEffect.acquire of bracket is not cancelable
2567[info] - ConcurrentEffect[Task].concurrentEffect.an action run concurrently with a pure value is the same as just doing that action
2568[info] - ConcurrentEffect[Task].concurrentEffect.ap consistent with product + map
2569[info] - ConcurrentEffect[Task].concurrentEffect.applicative homomorphism
2570[info] - ConcurrentEffect[Task].concurrentEffect.applicative identity
2571[info] - ConcurrentEffect[Task].concurrentEffect.applicative interchange
2572[info] - ConcurrentEffect[Task].concurrentEffect.applicative map
2573[info] - ConcurrentEffect[Task].concurrentEffect.applicative unit
2574[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError adaptError pure
2575[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError adaptError raise
2576[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError attempt consistent with attemptT
2577[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError attempt fromEither consistent with pure
2578[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError handle
2579[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError handleError . raiseError left-distributes over ap
2580[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError handleError . raiseError right-distributes over ap
2581[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError handleError consistent with recover
2582[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError handleError pure
2583[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError handleErrorWith consistent with recoverWith
2584[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError handleErrorWith pure
2585[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError handleWith
2586[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError onError pure
2587[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError onError raise
2588[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError pure attempt
2589[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError raiseError attempt
2590[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError recover consistent with recoverWith
2591[info] - ConcurrentEffect[Task].concurrentEffect.applicativeError redeem is derived from attempt and map
2592[info] - ConcurrentEffect[Task].concurrentEffect.apply composition
2593[info] - ConcurrentEffect[Task].concurrentEffect.async can be derived from asyncF
2594[info] - ConcurrentEffect[Task].concurrentEffect.async cancelable coherence
2595[info] - ConcurrentEffect[Task].concurrentEffect.async cancelable receives cancel signal
2596[info] - ConcurrentEffect[Task].concurrentEffect.async left is raiseError
2597[info] - ConcurrentEffect[Task].concurrentEffect.async right is pure
2598[info] - ConcurrentEffect[Task].concurrentEffect.asyncF registration can be cancelled
2599[info] - ConcurrentEffect[Task].concurrentEffect.bind suspends evaluation
2600[info] - ConcurrentEffect[Task].concurrentEffect.bracket is derived from bracketCase
2601[info] - ConcurrentEffect[Task].concurrentEffect.bracket release is called on Completed or Error
2602[info] - ConcurrentEffect[Task].concurrentEffect.bracket release is called on cancel
2603[info] - ConcurrentEffect[Task].concurrentEffect.bracketCase with failure in acquisition remains failure
2604[info] - ConcurrentEffect[Task].concurrentEffect.bracketCase with pure unit on release is eqv to map
2605[info] - ConcurrentEffect[Task].concurrentEffect.bracketCase with pure unit on release is eqv to uncancelable(..).flatMap
2606[info] - ConcurrentEffect[Task].concurrentEffect.covariant composition
2607[info] - ConcurrentEffect[Task].concurrentEffect.covariant identity
2608[info] - ConcurrentEffect[Task].concurrentEffect.delay constant is pure
2609[info] - ConcurrentEffect[Task].concurrentEffect.flatMap associativity
2610[info] - ConcurrentEffect[Task].concurrentEffect.flatMap consistent apply
2611[info] - ConcurrentEffect[Task].concurrentEffect.flatMap from tailRecM consistency
2612[info] - ConcurrentEffect[Task].concurrentEffect.guarantee is derived from bracket
2613[info] - ConcurrentEffect[Task].concurrentEffect.guaranteeCase is derived from bracketCase
2614[info] - ConcurrentEffect[Task].concurrentEffect.invariant composition
2615[info] - ConcurrentEffect[Task].concurrentEffect.invariant identity
2616[info] - ConcurrentEffect[Task].concurrentEffect.join is idempotent
2617[info] - ConcurrentEffect[Task].concurrentEffect.map flatMap coherence
2618[info] - ConcurrentEffect[Task].concurrentEffect.map suspends evaluation
2619[info] - ConcurrentEffect[Task].concurrentEffect.map2/map2Eval consistency
2620[info] - ConcurrentEffect[Task].concurrentEffect.map2/product-map consistency
2621[info] - ConcurrentEffect[Task].concurrentEffect.monad left identity
2622[info] - ConcurrentEffect[Task].concurrentEffect.monad right identity
2623[info] - ConcurrentEffect[Task].concurrentEffect.monadError ensure consistency
2624[info] - ConcurrentEffect[Task].concurrentEffect.monadError ensureOr consistency
2625[info] - ConcurrentEffect[Task].concurrentEffect.monadError left zero
2626[info] - ConcurrentEffect[Task].concurrentEffect.monadError redeemWith is derived from attempt and flatMap
2627[info] - ConcurrentEffect[Task].concurrentEffect.monadError rethrow attempt
2628[info] - ConcurrentEffect[Task].concurrentEffect.monoidal left identity
2629[info] - ConcurrentEffect[Task].concurrentEffect.monoidal right identity
2630[info] - ConcurrentEffect[Task].concurrentEffect.mproduct consistent flatMap
2631[info] - ConcurrentEffect[Task].concurrentEffect.never is derived from async
2632[info] - ConcurrentEffect[Task].concurrentEffect.onCancel is derived from guaranteeCase
2633[info] - ConcurrentEffect[Task].concurrentEffect.productL consistent map2
2634[info] - ConcurrentEffect[Task].concurrentEffect.productR consistent map2
2635[info] - ConcurrentEffect[Task].concurrentEffect.propagate errors through bind (async)
2636[info] - ConcurrentEffect[Task].concurrentEffect.propagate errors through bind (suspend)
2637[info] - ConcurrentEffect[Task].concurrentEffect.race cancels both
2638[info] - ConcurrentEffect[Task].concurrentEffect.race cancels loser
2639[info] - ConcurrentEffect[Task].concurrentEffect.race mirrors left winner
2640[info] - ConcurrentEffect[Task].concurrentEffect.race mirrors right winner
2641[info] - ConcurrentEffect[Task].concurrentEffect.racePair can join left
2642[info] - ConcurrentEffect[Task].concurrentEffect.racePair can join right
2643[info] - ConcurrentEffect[Task].concurrentEffect.racePair cancels both
2644[info] - ConcurrentEffect[Task].concurrentEffect.racePair cancels loser
2645[info] - ConcurrentEffect[Task].concurrentEffect.racePair mirrors left winner
2646[info] - ConcurrentEffect[Task].concurrentEffect.racePair mirrors right winner
2647[info] - ConcurrentEffect[Task].concurrentEffect.release of bracket is not cancelable
2648[info] - ConcurrentEffect[Task].concurrentEffect.repeated async evaluation not memoized
2649[info] - ConcurrentEffect[Task].concurrentEffect.repeated asyncF evaluation not memoized
2650[info] - ConcurrentEffect[Task].concurrentEffect.repeated callback ignored
2651[info] - ConcurrentEffect[Task].concurrentEffect.repeated sync evaluation not memoized
2652[info] - ConcurrentEffect[Task].concurrentEffect.runAsync ignores error in handler
2653[info] - ConcurrentEffect[Task].concurrentEffect.runAsync pure produces right IO
2654[info] - ConcurrentEffect[Task].concurrentEffect.runAsync raiseError produces left IO
2655[info] - ConcurrentEffect[Task].concurrentEffect.runAsync runCancelable coherence
2656[info] - ConcurrentEffect[Task].concurrentEffect.runCancelable is synchronous
2657[info] - ConcurrentEffect[Task].concurrentEffect.runCancelable start.flatMap(_.cancel) coherence
2658[info] - ConcurrentEffect[Task].concurrentEffect.semigroupal associativity
2659[info] - ConcurrentEffect[Task].concurrentEffect.stack-safe on bracket with left-associated binds
2660[info] - ConcurrentEffect[Task].concurrentEffect.stack-safe on bracket with right-associated binds
2661[info] - ConcurrentEffect[Task].concurrentEffect.stack-safe on guarantee with left-associated binds
2662[info] - ConcurrentEffect[Task].concurrentEffect.stack-safe on guarantee with right-associated binds
2663[info] - ConcurrentEffect[Task].concurrentEffect.stack-safe on left-associated binds
2664[info] - ConcurrentEffect[Task].concurrentEffect.stack-safe on repeated attempts
2665[info] - ConcurrentEffect[Task].concurrentEffect.stack-safe on repeated maps
2666[info] - ConcurrentEffect[Task].concurrentEffect.stack-safe on right-associated binds
2667[info] - ConcurrentEffect[Task].concurrentEffect.start then join is identity
2668[info] - ConcurrentEffect[Task].concurrentEffect.start.flatMap(_.cancel) is unit
2669[info] - ConcurrentEffect[Task].concurrentEffect.suspend constant is pure join
2670[info] - ConcurrentEffect[Task].concurrentEffect.tailRecM consistent flatMap
2671[info] - ConcurrentEffect[Task].concurrentEffect.tailRecM stack safety
2672[info] - ConcurrentEffect[Task].concurrentEffect.throw in delay is raiseError
2673[info] - ConcurrentEffect[Task].concurrentEffect.throw in suspend is raiseError
2674[info] - ConcurrentEffect[Task].concurrentEffect.toIO is consistent with runAsync
2675[info] - ConcurrentEffect[Task].concurrentEffect.toIO is consistent with runCancelable
2676[info] - ConcurrentEffect[Task].concurrentEffect.toIO is the inverse of liftIO
2677[info] - ConcurrentEffect[Task].concurrentEffect.toIO stack safety
2678[info] - ConcurrentEffect[Task].concurrentEffect.uncancelable mirrors source
2679[info] - ConcurrentEffect[Task].concurrentEffect.uncancelable prevents Cancelled case
2680[info] - ConcurrentEffect[Task].concurrentEffect.uncancelable prevents cancellation
2681[info] - ConcurrentEffect[Task].concurrentEffect.unsequenced delay is no-op
2682[info] - CommutativeApplicative[IO.Par].commutative applicative.ap consistent with product + map
2683[info] - CommutativeApplicative[IO.Par].commutative applicative.applicative homomorphism
2684[info] - CommutativeApplicative[IO.Par].commutative applicative.applicative identity
2685[info] - CommutativeApplicative[IO.Par].commutative applicative.applicative interchange
2686[info] - CommutativeApplicative[IO.Par].commutative applicative.applicative map
2687[info] - CommutativeApplicative[IO.Par].commutative applicative.applicative unit
2688[info] - CommutativeApplicative[IO.Par].commutative applicative.apply commutativity
2689[info] - CommutativeApplicative[IO.Par].commutative applicative.apply composition
2690[info] - CommutativeApplicative[IO.Par].commutative applicative.covariant composition
2691[info] - CommutativeApplicative[IO.Par].commutative applicative.covariant identity
2692[info] - CommutativeApplicative[IO.Par].commutative applicative.invariant composition
2693[info] - CommutativeApplicative[IO.Par].commutative applicative.invariant identity
2694[info] - CommutativeApplicative[IO.Par].commutative applicative.map2/map2Eval consistency
2695[info] - CommutativeApplicative[IO.Par].commutative applicative.map2/product-map consistency
2696[info] - CommutativeApplicative[IO.Par].commutative applicative.monoidal left identity
2697[info] - CommutativeApplicative[IO.Par].commutative applicative.monoidal right identity
2698[info] - CommutativeApplicative[IO.Par].commutative applicative.productL consistent map2
2699[info] - CommutativeApplicative[IO.Par].commutative applicative.productR consistent map2
2700[info] - CommutativeApplicative[IO.Par].commutative applicative.semigroupal associativity
2701[info] - Parallel[IO, IO.Par].parallel.isomorphic functor
2702[info] - Parallel[IO, IO.Par].parallel.isomorphic pure
2703[info] - Parallel[IO, IO.Par].parallel.parallel round trip
2704[info] - Parallel[IO, IO.Par].parallel.sequential round trip
2705[info] - Monoid[IO[String, Int]].monoid.associative
2706[info] - Monoid[IO[String, Int]].monoid.collect0
2707[info] - Monoid[IO[String, Int]].monoid.combine all
2708[info] - Monoid[IO[String, Int]].monoid.combineAllOption
2709[info] - Monoid[IO[String, Int]].monoid.intercalateCombineAllOption
2710[info] - Monoid[IO[String, Int]].monoid.intercalateIntercalates
2711[info] - Monoid[IO[String, Int]].monoid.intercalateRepeat1
2712[info] - Monoid[IO[String, Int]].monoid.intercalateRepeat2
2713[info] - Monoid[IO[String, Int]].monoid.is id
2714[info] - Monoid[IO[String, Int]].monoid.left identity
2715[info] - Monoid[IO[String, Int]].monoid.repeat0
2716[info] - Monoid[IO[String, Int]].monoid.repeat1
2717[info] - Monoid[IO[String, Int]].monoid.repeat2
2718[info] - Monoid[IO[String, Int]].monoid.reverseCombineAllOption
2719[info] - Monoid[IO[String, Int]].monoid.reverseRepeat1
2720[info] - Monoid[IO[String, Int]].monoid.reverseRepeat2
2721[info] - Monoid[IO[String, Int]].monoid.reverseReverses
2722[info] - Monoid[IO[String, Int]].monoid.right identity
2723[info] - SemigroupK[Task[Int]].semigroupK.semigroupK associative
2724[info] - Bifunctor[IO[String, Int]].Bifunctor.Bifunctor Identity
2725[info] - Bifunctor[IO[String, Int]].Bifunctor.Bifunctor associativity
2726[info] - Bifunctor[IO[String, Int]].Bifunctor.Bifunctor leftMap Identity
2727[info] - Bifunctor[IO[String, Int]].Bifunctor.Bifunctor leftMap associativity
2728[info] monix.bio.TypeClassLawsForTaskWithCallbackSuite
2729[info] - CoflatMap[Task].coflatMap.coflatMap associativity
2730[info] - CoflatMap[Task].coflatMap.coflatMap identity
2731[info] - CoflatMap[Task].coflatMap.coflatten coherence
2732[info] - CoflatMap[Task].coflatMap.coflatten throughMap
2733[info] - CoflatMap[Task].coflatMap.covariant composition
2734[info] - CoflatMap[Task].coflatMap.covariant identity
2735[info] - CoflatMap[Task].coflatMap.invariant composition
2736[info] - CoflatMap[Task].coflatMap.invariant identity
2737[info] - Concurrent[Task].async.acquire and release of bracket are uncancelable
2738[info] - Concurrent[Task].async.ap consistent with product + map
2739[info] - Concurrent[Task].async.applicative homomorphism
2740[info] - Concurrent[Task].async.applicative identity
2741[info] - Concurrent[Task].async.applicative interchange
2742[info] - Concurrent[Task].async.applicative map
2743[info] - Concurrent[Task].async.applicative unit
2744[info] - Concurrent[Task].async.applicativeError adaptError pure
2745[info] - Concurrent[Task].async.applicativeError adaptError raise
2746[info] - Concurrent[Task].async.applicativeError attempt consistent with attemptT
2747[info] - Concurrent[Task].async.applicativeError attempt fromEither consistent with pure
2748[info] - Concurrent[Task].async.applicativeError handle
2749[info] - Concurrent[Task].async.applicativeError handleError . raiseError left-distributes over ap
2750[info] - Concurrent[Task].async.applicativeError handleError . raiseError right-distributes over ap
2751[info] - Concurrent[Task].async.applicativeError handleError consistent with recover
2752[info] - Concurrent[Task].async.applicativeError handleError pure
2753[info] - Concurrent[Task].async.applicativeError handleErrorWith consistent with recoverWith
2754[info] - Concurrent[Task].async.applicativeError handleErrorWith pure
2755[info] - Concurrent[Task].async.applicativeError handleWith
2756[info] - Concurrent[Task].async.applicativeError onError pure
2757[info] - Concurrent[Task].async.applicativeError onError raise
2758[info] - Concurrent[Task].async.applicativeError pure attempt
2759[info] - Concurrent[Task].async.applicativeError raiseError attempt
2760[info] - Concurrent[Task].async.applicativeError recover consistent with recoverWith
2761[info] - Concurrent[Task].async.applicativeError redeem is derived from attempt and map
2762[info] - Concurrent[Task].async.apply composition
2763[info] - Concurrent[Task].async.async can be derived from asyncF
2764[info] - Concurrent[Task].async.async left is raiseError
2765[info] - Concurrent[Task].async.async right is pure
2766[info] - Concurrent[Task].async.bind suspends evaluation
2767[info] - Concurrent[Task].async.bracket is derived from bracketCase
2768[info] - Concurrent[Task].async.bracket release is called on Completed or Error
2769[info] - Concurrent[Task].async.bracketCase with failure in acquisition remains failure
2770[info] - Concurrent[Task].async.bracketCase with pure unit on release is eqv to map
2771[info] - Concurrent[Task].async.bracketCase with pure unit on release is eqv to uncancelable(..).flatMap
2772[info] - Concurrent[Task].async.covariant composition
2773[info] - Concurrent[Task].async.covariant identity
2774[info] - Concurrent[Task].async.delay constant is pure
2775[info] - Concurrent[Task].async.flatMap associativity
2776[info] - Concurrent[Task].async.flatMap consistent apply
2777[info] - Concurrent[Task].async.flatMap from tailRecM consistency
2778[info] - Concurrent[Task].async.guarantee is derived from bracket
2779[info] - Concurrent[Task].async.guaranteeCase is derived from bracketCase
2780[info] - Concurrent[Task].async.invariant composition
2781[info] - Concurrent[Task].async.invariant identity
2782[info] - Concurrent[Task].async.map flatMap coherence
2783[info] - Concurrent[Task].async.map suspends evaluation
2784[info] - Concurrent[Task].async.map2/map2Eval consistency
2785[info] - Concurrent[Task].async.map2/product-map consistency
2786[info] - Concurrent[Task].async.monad left identity
2787[info] - Concurrent[Task].async.monad right identity
2788[info] - Concurrent[Task].async.monadError ensure consistency
2789[info] - Concurrent[Task].async.monadError ensureOr consistency
2790[info] - Concurrent[Task].async.monadError left zero
2791[info] - Concurrent[Task].async.monadError redeemWith is derived from attempt and flatMap
2792[info] - Concurrent[Task].async.monadError rethrow attempt
2793[info] - Concurrent[Task].async.monoidal left identity
2794[info] - Concurrent[Task].async.monoidal right identity
2795[info] - Concurrent[Task].async.mproduct consistent flatMap
2796[info] - Concurrent[Task].async.never is derived from async
2797[info] - Concurrent[Task].async.onCancel is derived from guaranteeCase
2798[info] - Concurrent[Task].async.productL consistent map2
2799[info] - Concurrent[Task].async.productR consistent map2
2800[info] - Concurrent[Task].async.propagate errors through bind (async)
2801[info] - Concurrent[Task].async.propagate errors through bind (suspend)
2802[info] - Concurrent[Task].async.repeated async evaluation not memoized
2803[info] - Concurrent[Task].async.repeated asyncF evaluation not memoized
2804[info] - Concurrent[Task].async.repeated sync evaluation not memoized
2805[info] - Concurrent[Task].async.semigroupal associativity
2806[info] - Concurrent[Task].async.stack-safe on bracket with left-associated binds
2807[info] - Concurrent[Task].async.stack-safe on bracket with right-associated binds
2808[info] - Concurrent[Task].async.stack-safe on guarantee with left-associated binds
2809[info] - Concurrent[Task].async.stack-safe on guarantee with right-associated binds
2810[info] - Concurrent[Task].async.stack-safe on left-associated binds
2811[info] - Concurrent[Task].async.stack-safe on repeated attempts
2812[info] - Concurrent[Task].async.stack-safe on repeated maps
2813[info] - Concurrent[Task].async.stack-safe on right-associated binds
2814[info] - Concurrent[Task].async.suspend constant is pure join
2815[info] - Concurrent[Task].async.tailRecM consistent flatMap
2816[info] - Concurrent[Task].async.tailRecM stack safety
2817[info] - Concurrent[Task].async.throw in delay is raiseError
2818[info] - Concurrent[Task].async.throw in suspend is raiseError
2819[info] - Concurrent[Task].async.uncancelable prevents Cancelled case
2820[info] - Concurrent[Task].async.unsequenced delay is no-op
2821[info] - ConcurrentEffect[Task].effect.acquire and release of bracket are uncancelable
2822[info] - ConcurrentEffect[Task].effect.ap consistent with product + map
2823[info] - ConcurrentEffect[Task].effect.applicative homomorphism
2824[info] - ConcurrentEffect[Task].effect.applicative identity
2825[info] - ConcurrentEffect[Task].effect.applicative interchange
2826[info] - ConcurrentEffect[Task].effect.applicative map
2827[info] - ConcurrentEffect[Task].effect.applicative unit
2828[info] - ConcurrentEffect[Task].effect.applicativeError adaptError pure
2829[info] - ConcurrentEffect[Task].effect.applicativeError adaptError raise
2830[info] - ConcurrentEffect[Task].effect.applicativeError attempt consistent with attemptT
2831[info] - ConcurrentEffect[Task].effect.applicativeError attempt fromEither consistent with pure
2832[info] - ConcurrentEffect[Task].effect.applicativeError handle
2833[info] - ConcurrentEffect[Task].effect.applicativeError handleError . raiseError left-distributes over ap
2834[info] - ConcurrentEffect[Task].effect.applicativeError handleError . raiseError right-distributes over ap
2835[info] - ConcurrentEffect[Task].effect.applicativeError handleError consistent with recover
2836[info] - ConcurrentEffect[Task].effect.applicativeError handleError pure
2837[info] - ConcurrentEffect[Task].effect.applicativeError handleErrorWith consistent with recoverWith
2838[info] - ConcurrentEffect[Task].effect.applicativeError handleErrorWith pure
2839[info] - ConcurrentEffect[Task].effect.applicativeError handleWith
2840[info] - ConcurrentEffect[Task].effect.applicativeError onError pure
2841[info] - ConcurrentEffect[Task].effect.applicativeError onError raise
2842[info] - ConcurrentEffect[Task].effect.applicativeError pure attempt
2843[info] - ConcurrentEffect[Task].effect.applicativeError raiseError attempt
2844[info] - ConcurrentEffect[Task].effect.applicativeError recover consistent with recoverWith
2845[info] - ConcurrentEffect[Task].effect.applicativeError redeem is derived from attempt and map
2846[info] - ConcurrentEffect[Task].effect.apply composition
2847[info] - ConcurrentEffect[Task].effect.async can be derived from asyncF
2848[info] - ConcurrentEffect[Task].effect.async left is raiseError
2849[info] - ConcurrentEffect[Task].effect.async right is pure
2850[info] - ConcurrentEffect[Task].effect.bind suspends evaluation
2851[info] - ConcurrentEffect[Task].effect.bracket is derived from bracketCase
2852[info] - ConcurrentEffect[Task].effect.bracket release is called on Completed or Error
2853[info] - ConcurrentEffect[Task].effect.bracketCase with failure in acquisition remains failure
2854[info] - ConcurrentEffect[Task].effect.bracketCase with pure unit on release is eqv to map
2855[info] - ConcurrentEffect[Task].effect.bracketCase with pure unit on release is eqv to uncancelable(..).flatMap
2856[info] - ConcurrentEffect[Task].effect.covariant composition
2857[info] - ConcurrentEffect[Task].effect.covariant identity
2858[info] - ConcurrentEffect[Task].effect.delay constant is pure
2859[info] - ConcurrentEffect[Task].effect.flatMap associativity
2860[info] - ConcurrentEffect[Task].effect.flatMap consistent apply
2861[info] - ConcurrentEffect[Task].effect.flatMap from tailRecM consistency
2862[info] - ConcurrentEffect[Task].effect.guarantee is derived from bracket
2863[info] - ConcurrentEffect[Task].effect.guaranteeCase is derived from bracketCase
2864[info] - ConcurrentEffect[Task].effect.invariant composition
2865[info] - ConcurrentEffect[Task].effect.invariant identity
2866[info] - ConcurrentEffect[Task].effect.map flatMap coherence
2867[info] - ConcurrentEffect[Task].effect.map suspends evaluation
2868[info] - ConcurrentEffect[Task].effect.map2/map2Eval consistency
2869[info] - ConcurrentEffect[Task].effect.map2/product-map consistency
2870[info] - ConcurrentEffect[Task].effect.monad left identity
2871[info] - ConcurrentEffect[Task].effect.monad right identity
2872[info] - ConcurrentEffect[Task].effect.monadError ensure consistency
2873[info] - ConcurrentEffect[Task].effect.monadError ensureOr consistency
2874[info] - ConcurrentEffect[Task].effect.monadError left zero
2875[info] - ConcurrentEffect[Task].effect.monadError redeemWith is derived from attempt and flatMap
2876[info] - ConcurrentEffect[Task].effect.monadError rethrow attempt
2877[info] - ConcurrentEffect[Task].effect.monoidal left identity
2878[info] - ConcurrentEffect[Task].effect.monoidal right identity
2879[info] - ConcurrentEffect[Task].effect.mproduct consistent flatMap
2880[info] - ConcurrentEffect[Task].effect.never is derived from async
2881[info] - ConcurrentEffect[Task].effect.onCancel is derived from guaranteeCase
2882[info] - ConcurrentEffect[Task].effect.productL consistent map2
2883[info] - ConcurrentEffect[Task].effect.productR consistent map2
2884[info] - ConcurrentEffect[Task].effect.propagate errors through bind (async)
2885[info] - ConcurrentEffect[Task].effect.propagate errors through bind (suspend)
2886[info] - ConcurrentEffect[Task].effect.repeated async evaluation not memoized
2887[info] - ConcurrentEffect[Task].effect.repeated asyncF evaluation not memoized
2888[info] - ConcurrentEffect[Task].effect.repeated callback ignored
2889[info] - ConcurrentEffect[Task].effect.repeated sync evaluation not memoized
2890[info] - ConcurrentEffect[Task].effect.runAsync ignores error in handler
2891[info] - ConcurrentEffect[Task].effect.runAsync pure produces right IO
2892[info] - ConcurrentEffect[Task].effect.runAsync raiseError produces left IO
2893[info] - ConcurrentEffect[Task].effect.semigroupal associativity
2894[info] - ConcurrentEffect[Task].effect.stack-safe on bracket with left-associated binds
2895[info] - ConcurrentEffect[Task].effect.stack-safe on bracket with right-associated binds
2896[info] - ConcurrentEffect[Task].effect.stack-safe on guarantee with left-associated binds
2897[info] - ConcurrentEffect[Task].effect.stack-safe on guarantee with right-associated binds
2898[info] - ConcurrentEffect[Task].effect.stack-safe on left-associated binds
2899[info] - ConcurrentEffect[Task].effect.stack-safe on repeated attempts
2900[info] - ConcurrentEffect[Task].effect.stack-safe on repeated maps
2901[info] - ConcurrentEffect[Task].effect.stack-safe on right-associated binds
2902[info] - ConcurrentEffect[Task].effect.suspend constant is pure join
2903[info] - ConcurrentEffect[Task].effect.tailRecM consistent flatMap
2904[info] - ConcurrentEffect[Task].effect.tailRecM stack safety
2905[info] - ConcurrentEffect[Task].effect.throw in delay is raiseError
2906[info] - ConcurrentEffect[Task].effect.throw in suspend is raiseError
2907[info] - ConcurrentEffect[Task].effect.toIO is consistent with runAsync
2908[info] - ConcurrentEffect[Task].effect.toIO is the inverse of liftIO
2909[info] - ConcurrentEffect[Task].effect.toIO stack safety
2910[info] - ConcurrentEffect[Task].effect.uncancelable prevents Cancelled case
2911[info] - ConcurrentEffect[Task].effect.unsequenced delay is no-op
2912[info] - CommutativeApplicative[IO.Par].commutative applicative.ap consistent with product + map
2913[info] - CommutativeApplicative[IO.Par].commutative applicative.applicative homomorphism
2914[info] - CommutativeApplicative[IO.Par].commutative applicative.applicative identity
2915[info] - CommutativeApplicative[IO.Par].commutative applicative.applicative interchange
2916[info] - CommutativeApplicative[IO.Par].commutative applicative.applicative map
2917[info] - CommutativeApplicative[IO.Par].commutative applicative.applicative unit
2918[info] - CommutativeApplicative[IO.Par].commutative applicative.apply commutativity
2919[info] - CommutativeApplicative[IO.Par].commutative applicative.apply composition
2920[info] - CommutativeApplicative[IO.Par].commutative applicative.covariant composition
2921[info] - CommutativeApplicative[IO.Par].commutative applicative.covariant identity
2922[info] - CommutativeApplicative[IO.Par].commutative applicative.invariant composition
2923[info] - CommutativeApplicative[IO.Par].commutative applicative.invariant identity
2924[info] - CommutativeApplicative[IO.Par].commutative applicative.map2/map2Eval consistency
2925[info] - CommutativeApplicative[IO.Par].commutative applicative.map2/product-map consistency
2926[info] - CommutativeApplicative[IO.Par].commutative applicative.monoidal left identity
2927[info] - CommutativeApplicative[IO.Par].commutative applicative.monoidal right identity
2928[info] - CommutativeApplicative[IO.Par].commutative applicative.productL consistent map2
2929[info] - CommutativeApplicative[IO.Par].commutative applicative.productR consistent map2
2930[info] - CommutativeApplicative[IO.Par].commutative applicative.semigroupal associativity
2931[info] - Parallel[Task, Task.Par].parallel.isomorphic functor
2932[info] - Parallel[Task, Task.Par].parallel.isomorphic pure
2933[info] - Parallel[Task, Task.Par].parallel.parallel round trip
2934[info] - Parallel[Task, Task.Par].parallel.sequential round trip
2935[info] - Monoid[IO[Throwable, Int]].monoid.associative
2936[info] - Monoid[IO[Throwable, Int]].monoid.collect0
2937[info] - Monoid[IO[Throwable, Int]].monoid.combine all
2938[info] - Monoid[IO[Throwable, Int]].monoid.combineAllOption
2939[info] - Monoid[IO[Throwable, Int]].monoid.intercalateCombineAllOption
2940[info] - Monoid[IO[Throwable, Int]].monoid.intercalateIntercalates
2941[info] - Monoid[IO[Throwable, Int]].monoid.intercalateRepeat1
2942[info] - Monoid[IO[Throwable, Int]].monoid.intercalateRepeat2
2943[info] - Monoid[IO[Throwable, Int]].monoid.is id
2944[info] - Monoid[IO[Throwable, Int]].monoid.left identity
2945[info] - Monoid[IO[Throwable, Int]].monoid.repeat0
2946[info] - Monoid[IO[Throwable, Int]].monoid.repeat1
2947[info] - Monoid[IO[Throwable, Int]].monoid.repeat2
2948[info] - Monoid[IO[Throwable, Int]].monoid.reverseCombineAllOption
2949[info] - Monoid[IO[Throwable, Int]].monoid.reverseRepeat1
2950[info] - Monoid[IO[Throwable, Int]].monoid.reverseRepeat2
2951[info] - Monoid[IO[Throwable, Int]].monoid.reverseReverses
2952[info] - Monoid[IO[Throwable, Int]].monoid.right identity
2953[info] - Bifunctor[IO[String, Int]].Bifunctor.Bifunctor Identity
2954[info] - Bifunctor[IO[String, Int]].Bifunctor.Bifunctor associativity
2955[info] - Bifunctor[IO[String, Int]].Bifunctor.Bifunctor leftMap Identity
2956[info] - Bifunctor[IO[String, Int]].Bifunctor.Bifunctor leftMap associativity
2957
2958************************
2959Build summary:
2960[{
2961 "module": "monix-bio",
2962 "compile": {"status": "ok", "tookMs": 18916, "warnings": 0, "errors": 0, "sourceVersion": "3.8"},
2963 "doc": {"status": "skipped", "tookMs": 0, "files": 0, "totalSizeKb": 0},
2964 "test-compile": {"status": "ok", "tookMs": 37752, "warnings": 0, "errors": 0, "sourceVersion": "3.8"},
2965 "test": {"status": "ok", "tookMs": 32963, "passed": 2607, "failed": 0, "ignored": 0, "skipped": 0, "total": 2607, "byFramework": [{"framework": "unknown", "stats": {"passed": 2607, "failed": 0, "ignored": 0, "skipped": 0, "total": 2607}}]},
2966 "publish": {"status": "skipped", "tookMs": 0},
2967 "metadata": {
2968 "crossScalaVersions": ["2.12.13", "2.13.5", "3.0.0"]
2969}
2970}]
2971************************
2972[success] Total time: 93 s (0:01:33.0), completed Jan 13, 2026, 3:24:34 PM
2973[0JChecking 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.