Changed test types for laws check

laserdisc-io · Dec 26, 2019 · 888034d · 888034d
1 parent 8d5f3b9
commit 888034d
Showing 1 changed file with 26 additions and 16 deletions.
diff --git a/core-laws/src/test/scala/laserdisc/protocol/ReadLawsCheck.scala b/core-laws/src/test/scala/laserdisc/protocol/ReadLawsCheck.scala
@@ -3,6 +3,7 @@ package protocol
 
 import cats.instances.int._
 import cats.instances.long._
+import cats.instances.string._
 import cats.laws.discipline.{ContravariantTests, MonadTests, SerializableTests}
 import cats.{Contravariant, Eq, Monad}
 import org.scalacheck.Gen.chooseNum
@@ -23,41 +24,50 @@ final class ReadLawsCheck
 
   import ReadInstances._
 
-  checkAll("Read[Num, *]", MonadTests[Read[Num, *]].stackUnsafeMonad[Long, Long, Long])
+  checkAll("Read[Num, *]", MonadTests[Read[Num, *]].stackUnsafeMonad[Long, String, Long])
   checkAll("Monad[Read[Num, *]]", SerializableTests.serializable(Monad[Read[Num, *]]))
 
-  checkAll("Read[*, Int]", ContravariantTests[Read[*, Long]].contravariant[Num, Num, Num])
+  checkAll("Read[*, Int]", ContravariantTests[Read[*, Long]].contravariant[Str, Num, Str])
   checkAll("Contravariant[Read[*, Int]]", SerializableTests.serializable(Contravariant[Read[*, Long]]))
 }
 
 private[protocol] sealed trait Implicits {
   implicit val genNum: Gen[Num] = chooseNum(0L, Long.MaxValue) map Num.apply
+  implicit val genStr: Gen[Str] = Gen.alphaNumStr map Str.apply
 
   implicit val genListOfNum: Gen[List[Num]] = Gen.listOfN(500, genNum) map (_.distinct)
+  implicit val genListOfStr: Gen[List[Str]] = Gen.listOfN(500, genStr) map (_.distinct)
 
   implicit def arbNum(implicit ev: Gen[Num]): Arbitrary[Num] = Arbitrary(ev)
+  implicit def arbStr(implicit ev: Gen[Str]): Arbitrary[Str] = Arbitrary(ev)
 
   implicit val cogenNum: Cogen[Num] = Cogen(_.value)
+  implicit val cogenStr: Cogen[Str] = Cogen(_.value.length.toLong)
 
-  implicit def arbPair(implicit ev: Arbitrary[Long]): Arbitrary[(Num, Long)] =
-    Arbitrary(ev.arbitrary map (l => Num(l) -> l))
+  implicit def arbReadNum(implicit ev: Arbitrary[Long]): Arbitrary[Read[Num, Long]] = Arbitrary(ev.arbitrary map Read.const)
+  implicit def arbReadStr(implicit ev: Arbitrary[Long]): Arbitrary[Read[Str, Long]] = Arbitrary(ev.arbitrary map Read.const)
 
-  implicit def arbPairFun(implicit ev: Arbitrary[Long]): Arbitrary[(Num, Long => Long)] =
-    Arbitrary(ev.arbitrary map (l => Num(l) -> (_ => l)))
+  implicit def arbReadNumString(implicit ev: Arbitrary[Num]): Arbitrary[Read[Num, String]] =
+    Arbitrary(ev.arbitrary map (n => Read.const(n.value.toString)))
 
-  implicit def arbRead(implicit ev: Arbitrary[Long]): Arbitrary[Read[Num, Long]] =
-    Arbitrary(ev.arbitrary map Read.const)
+  implicit def arbReadNumStringFun(implicit ev: Arbitrary[Num]): Arbitrary[Read[Num, Long => String]] =
+    Arbitrary(ev.arbitrary map (l => Read.const(_ => l.value.toString)))
 
-  implicit def arbReadFun(implicit ev: Arbitrary[Long]): Arbitrary[Read[Num, Long => Long]] =
-    Arbitrary(ev.arbitrary map (l => Read.const(_ => l)))
+  implicit def arbReadNumNumFun(implicit ev: Arbitrary[String]): Arbitrary[Read[Num, String => Long]] =
+    Arbitrary(ev.arbitrary map (s => Read.const(_ => s.length.toLong)))
 
-  implicit def eqTup[A, B](implicit eb: Eq[B]): Eq[(B, B, B)] =
-    new Eq[(B, B, B)] {
-      override def eqv(x: (B, B, B), y: (B, B, B)): Boolean =
-        (x, y) match {
-          case ((x1, x2, x3), (y1, y2, y3)) => eb.eqv(x1, y1) && eb.eqv(x2, y2) && eb.eqv(x3, y3)
-          case _                            => false
+  implicit def eqReadTup[A, B, C, D](implicit ga: Gen[List[A]], eb: Eq[B], ec: Eq[C], ed: Eq[D]): Eq[Read[A, (B, C, D)]] =
+    new Eq[Read[A, (B, C, D)]] {
+      override def eqv(x: ==>[A, (B, C, D)], y: ==>[A, (B, C, D)]): Boolean = {
+        val as = ga.sample.get
+        as.forall { a =>
+          (x.read(a), y.read(a)) match {
+            case (Right((b1, c1, d1)), Right((b2, c2, d2))) => eb.eqv(b1, b2) && ec.eqv(c1, c2) && ed.eqv(d1, d2)
+            case (Left(e1), Left(e2))                       => e1.message == e2.message
+            case _                                          => false
+          }
         }
+      }
     }
 
   implicit def eqRead[A, B](implicit ga: Gen[List[A]], eb: Eq[B]): Eq[Read[A, B]] =