/
SyncTests.scala
111 lines (102 loc) · 2.91 KB
/
SyncTests.scala
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
/*
* Copyright 2020-2024 Typelevel
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package cats.effect
package laws
import cats.Eq
import cats.effect.kernel.Sync
import cats.laws.discipline.SemigroupalTests.Isomorphisms
import org.scalacheck._
import org.scalacheck.Prop.forAll
trait SyncTests[F[_]]
extends MonadCancelTests[F, Throwable]
with ClockTests[F]
with UniqueTests[F] {
val laws: SyncLaws[F]
def sync[A: Arbitrary: Eq, B: Arbitrary: Eq, C: Arbitrary: Eq](
implicit ArbFA: Arbitrary[F[A]],
ArbFB: Arbitrary[F[B]],
ArbFC: Arbitrary[F[C]],
ArbFU: Arbitrary[F[Unit]],
ArbFAtoB: Arbitrary[F[A => B]],
ArbFBtoC: Arbitrary[F[B => C]],
ArbE: Arbitrary[Throwable],
ArbST: Arbitrary[Sync.Type],
CogenA: Cogen[A],
CogenB: Cogen[B],
CogenC: Cogen[C],
CogenE: Cogen[Throwable],
EqFA: Eq[F[A]],
EqFB: Eq[F[B]],
EqFC: Eq[F[C]],
EqFU: Eq[F[Unit]],
EqE: Eq[Throwable],
EqFEitherEU: Eq[F[Either[Throwable, Unit]]],
EqFEitherEA: Eq[F[Either[Throwable, A]]],
EqFABC: Eq[F[(A, B, C)]],
EqFInt: Eq[F[Int]],
exec: F[Boolean] => Prop,
iso: Isomorphisms[F]): RuleSet = {
new RuleSet {
val name = "sync"
val bases = Nil
val parents = Seq(
monadCancel[A, B, C](
implicitly[Arbitrary[A]],
implicitly[Eq[A]],
implicitly[Arbitrary[B]],
implicitly[Eq[B]],
implicitly[Arbitrary[C]],
implicitly[Eq[C]],
ArbFA,
ArbFB,
ArbFC,
ArbFU,
ArbFAtoB,
ArbFBtoC,
ArbE,
CogenA,
CogenB,
CogenC,
CogenE,
EqFA,
EqFB,
EqFC,
EqFU,
EqE,
EqFEitherEU,
EqFEitherEA,
EqFABC,
EqFInt,
iso
),
clock,
unique
)
val props = Seq(
"suspend value is pure" -> forAll(laws.suspendValueIsPure[A] _),
"suspend throw is raiseError" -> forAll(laws.suspendThrowIsRaiseError[A] _),
"unsequenced suspend is no-op" -> forAll(laws.unsequencedSuspendIsNoop[A] _),
"repeated suspend is not memoized" -> forAll(laws.repeatedSuspendNotMemoized[A] _)
)
}
}
}
object SyncTests {
def apply[F[_]](implicit F0: Sync[F]): SyncTests[F] =
new SyncTests[F] {
val laws = SyncLaws[F]
}
}