Hook Eq up to scalactic/scalatest's equality

free/src/test/scala/cats/free/CoyonedaTests.scala

@@ -32,14 +32,12 @@ class CoyonedaTests extends CatsSuite {
   })
 
   test("transform and run is same as applying natural trans") {
-    assert {
       val nt =
         new NaturalTransformation[Option, List] {
           def apply[A](fa: Option[A]): List[A] = fa.toList
         }
       val o = Option("hello")
       val c = Coyoneda.lift(o)
-      c.transform(nt).run === nt(o)
-    }
+      c.transform(nt).run should === (nt(o))
   }
 }

state/src/test/scala/cats/state/StateTTests.scala

@@ -10,31 +10,31 @@ class StateTTests extends CatsSuite {
   import StateTTests._
 
   test("basic state usage"){
-    assert(add1.run(1).run == (2 -> 1))
+    add1.run(1).run should === (2 -> 1)
   }
 
   test("traversing state is stack-safe"){
     val ns = (0 to 100000).toList
     val x = ns.traverseU(_ => add1)
-    assert(x.runS(0).run == 100001)
+    x.runS(0).run should === (100001)
   }
 
   test("State.pure and StateT.pure are consistent")(check {
     forAll { (s: String, i: Int) =>
       val state: State[String, Int] = State.pure(i)
       val stateT: State[String, Int] = StateT.pure(i)
-      state.run(s).run == stateT.run(s).run
+      state.run(s).run === stateT.run(s).run
     }
   })
 
   test("Apply syntax is usable on State") {
     val x = add1 *> add1
-    assert(x.runS(0).run == 2)
+    x.runS(0).run should === (2)
   }
 
   test("Singleton and instance inspect are consistent")(check {
     forAll { (s: String, i: Int) =>
-      State.inspect[Int, String](_.toString).run(i).run ==
+      State.inspect[Int, String](_.toString).run(i).run ===
         State.pure[Int, Unit](()).inspect(_.toString).run(i).run
     }
   })

tests/src/test/scala/cats/tests/CatsEquality.scala

@@ -0,0 +1,29 @@
+package cats
+package tests
+
+import org.scalactic._
+import TripleEqualsSupport.AToBEquivalenceConstraint
+import TripleEqualsSupport.BToAEquivalenceConstraint
+
+// The code in this file was taken and only slightly modified from
+// https://github.com/bvenners/equality-integration-demo
+// Thanks for the great examples, Bill!
+
+final class CatsEquivalence[T](T: Eq[T]) extends Equivalence[T] {
+  def areEquivalent(a: T, b: T): Boolean = T.eqv(a, b)
+}
+
+trait LowPriorityStrictCatsConstraints extends TripleEquals {
+  implicit def lowPriorityCatsCanEqual[A, B](implicit B: Eq[B], ev: A <:< B): CanEqual[A, B] =
+    new AToBEquivalenceConstraint[A, B](new CatsEquivalence(B), ev)
+}
+
+trait StrictCatsEquality extends LowPriorityStrictCatsConstraints {
+  override def convertToEqualizer[T](left: T): Equalizer[T] = super.convertToEqualizer[T](left)
+  implicit override def convertToCheckingEqualizer[T](left: T): CheckingEqualizer[T] = new CheckingEqualizer(left)
+  override def unconstrainedEquality[A, B](implicit equalityOfA: Equality[A]): CanEqual[A, B] = super.unconstrainedEquality[A, B]
+  implicit def catsCanEqual[A, B](implicit A: Eq[A], ev: B <:< A): CanEqual[A, B] =
+    new BToAEquivalenceConstraint[A, B](new CatsEquivalence(A), ev)
+}
+
+object StrictCatsEquality extends StrictCatsEquality

tests/src/test/scala/cats/tests/CatsSuite.scala

@@ -4,7 +4,7 @@ package tests
 import bricks.Platform
 
 import cats.std.AllInstances
-import cats.syntax.AllSyntax
+import cats.syntax.{AllSyntax, EqOps}
 
 import org.scalactic.anyvals.{PosZDouble, PosInt}
 import org.scalatest.{FunSuite, PropSpec, Matchers}
@@ -32,12 +32,13 @@ trait TestSettings extends Configuration with Matchers {
  * An opinionated stack of traits to improve consistency and reduce
  * boilerplate in Cats tests.
  */
-trait CatsSuite extends FunSuite with Discipline with TestSettings with AllInstances with AllSyntax with TestInstances {
+trait CatsSuite extends FunSuite with Matchers with Discipline with TestSettings with AllInstances with AllSyntax with TestInstances with StrictCatsEquality {
   implicit override val generatorDrivenConfig: PropertyCheckConfiguration =
     checkConfiguration
 
-  // disable scalatest's ===
-  override def convertToEqualizer[T](left: T): Equalizer[T] = ???
+  // disable Eq syntax (by making `eqSyntax` not implicit), since it collides
+  // with scalactic's equality
+  override def eqSyntax[A: Eq](a: A): EqOps[A] = new EqOps[A](a)
 }
 
 trait CatsProps extends PropSpec with PropertyChecks with TestSettings with TestInstances {

tests/src/test/scala/cats/tests/EvalTests.scala

@@ -37,7 +37,7 @@ class EvalTests extends CatsSuite {
       val (spooky, lz) = init(value)
       (0 until n).foreach { _ =>
         val result = lz.value
-        assert(result === value)
+        result should === (value)
         spin ^= result.##
       }
       assert(spooky.counter == numEvals)

tests/src/test/scala/cats/tests/StreamingTTests.scala

@@ -50,6 +50,6 @@ class SpecificStreamingTTests extends CatsSuite {
 
     val x = fa.flatMap(f).flatMap(g)
     val y = fa.flatMap(a => f(a).flatMap(g))
-    assert(x === y)
+    x should === (y)
   }
 }

tests/src/test/scala/cats/tests/SyntaxTests.scala

@@ -1,6 +1,8 @@
 package cats
 package tests
 
+import cats.std.AllInstances
+import cats.syntax.AllSyntax
 import algebra.laws.GroupLaws
 import cats.functor.{Invariant, Contravariant}
 import cats.laws.discipline.SerializableTests
@@ -27,7 +29,7 @@ import scala.reflect.runtime.universe.TypeTag
  *
  * None of these tests should ever run, or do any runtime checks.
  */
-class SyntaxTests extends CatsSuite with PropertyChecks {
+class SyntaxTests extends AllInstances with AllSyntax {
 
   // pretend we have a value of type A
   def mock[A]: A = ???