Harmonize naming of discipline test classes in cats-kernel-laws.

docs/src/main/tut/typeclasses/lawtesting.md

@@ -133,10 +133,10 @@ Then we can again test the instance inside our class extending `CatsSuite`:
 
 ```tut:book
 import cats.laws.discipline.FunctorTests
-import cats.kernel.laws.discipline.SemigroupLawTests
+import cats.kernel.laws.discipline.SemigroupTests
 
 class TreeLawTests extends CatsSuite {
-  checkAll("Tree[Int].SemigroupLaws", SemigroupLawTests[Tree[Int]].semigroup)
+  checkAll("Tree[Int].SemigroupLaws", SemigroupTests[Tree[Int]].semigroup)
   checkAll("Tree.FunctorLaws", FunctorTests[Tree].functor[Int, Int, String])
 }
 ```

js/src/test/scala/cats/tests/FutureTests.scala

@@ -2,7 +2,7 @@ package cats
 package js
 package tests
 
-import cats.kernel.laws.discipline.{MonoidLawTests, SemigroupLawTests}
+import cats.kernel.laws.discipline.{MonoidTests => MonoidLawTests, SemigroupTests => SemigroupLawTests}
 import cats.laws.discipline._
 import cats.js.instances.Await
 import cats.js.instances.future.futureComonad

jvm/src/test/scala/cats/tests/FutureTests.scala

@@ -2,7 +2,7 @@ package cats
 package jvm
 package tests
 
-import cats.kernel.laws.discipline.{MonoidLawTests, SemigroupLawTests}
+import cats.kernel.laws.discipline.{MonoidTests => MonoidLawTests, SemigroupTests => SemigroupLawTests}
 import cats.laws.discipline._
 import cats.laws.discipline.arbitrary._
 import cats.tests.{CatsSuite, ListWrapper}

kernel-laws/src/main/scala/cats/kernel/laws/discipline/BandTests.scala

@@ -6,7 +6,7 @@ package discipline
 import org.scalacheck.Arbitrary
 import org.scalacheck.Prop.forAll
 
-trait BandTests[A] extends SemigroupLawTests[A] {
+trait BandTests[A] extends SemigroupTests[A] {
 
   def laws: BandLaws[A]
 

kernel-laws/src/main/scala/cats/kernel/laws/discipline/CommutativeGroupTests.scala

@@ -5,7 +5,7 @@ package discipline
 
 import org.scalacheck.{Arbitrary, Prop}
 
-trait CommutativeGroupTests[A] extends CommutativeMonoidTests[A] with GroupLawTests[A] {
+trait CommutativeGroupTests[A] extends CommutativeMonoidTests[A] with GroupTests[A] {
   def laws: CommutativeGroupLaws[A]
 
   def commutativeGroup(implicit arbA: Arbitrary[A], eqA: Eq[A]): RuleSet =

kernel-laws/src/main/scala/cats/kernel/laws/discipline/CommutativeMonoidTests.scala

@@ -5,7 +5,7 @@ package discipline
 
 import org.scalacheck.{Arbitrary, Prop}
 
-trait CommutativeMonoidTests[A] extends CommutativeSemigroupTests[A] with MonoidLawTests[A] {
+trait CommutativeMonoidTests[A] extends CommutativeSemigroupTests[A] with MonoidTests[A] {
   def laws: CommutativeMonoidLaws[A]
 
   def commutativeMonoid(implicit arbA: Arbitrary[A], eqA: Eq[A]): RuleSet =

kernel-laws/src/main/scala/cats/kernel/laws/discipline/CommutativeSemigroupTests.scala

@@ -6,7 +6,7 @@ package discipline
 import org.scalacheck.Arbitrary
 import org.scalacheck.Prop.forAll
 
-trait CommutativeSemigroupTests[A] extends SemigroupLawTests[A] {
+trait CommutativeSemigroupTests[A] extends SemigroupTests[A] {
 
   def laws: CommutativeSemigroupLaws[A]
 

kernel-laws/src/main/scala/cats/kernel/laws/discipline/EqLawTests.scala → kernel-laws/src/main/scala/cats/kernel/laws/discipline/EqTests.scala

@@ -8,7 +8,7 @@ import org.scalacheck.Arbitrary
 import org.scalacheck.Prop.forAll
 import org.typelevel.discipline.Laws
 
-trait EqLawTests[A] extends Laws {
+trait EqTests[A] extends Laws {
   def laws: EqLaws[A]
 
   def eqv(implicit arbA: Arbitrary[A], arbF: Arbitrary[A => A], eqA: Eq[A]): RuleSet =
@@ -21,8 +21,8 @@ trait EqLawTests[A] extends Laws {
       "eq transitivity" -> forAll(laws.transitivityEq _))
 }
 
-object EqLawTests {
-  def apply[A: Eq]: EqLawTests[A] =
-    new EqLawTests[A] { def laws: EqLaws[A] = EqLaws[A] }
+object EqTests {
+  def apply[A: Eq]: EqTests[A] =
+    new EqTests[A] { def laws: EqLaws[A] = EqLaws[A] }
 }
 

kernel-laws/src/main/scala/cats/kernel/laws/discipline/GroupLawTests.scala → kernel-laws/src/main/scala/cats/kernel/laws/discipline/GroupTests.scala

@@ -6,7 +6,7 @@ package discipline
 import org.scalacheck.Arbitrary
 import org.scalacheck.Prop.forAll
 
-trait GroupLawTests[A] extends MonoidLawTests[A] {
+trait GroupTests[A] extends MonoidTests[A] {
 
   def laws: GroupLaws[A]
 
@@ -20,7 +20,7 @@ trait GroupLawTests[A] extends MonoidLawTests[A] {
 
 }
 
-object GroupLawTests {
-  def apply[A: Group]: GroupLawTests[A] =
-    new GroupLawTests[A] { def laws: GroupLaws[A] = GroupLaws[A] }
+object GroupTests {
+  def apply[A: Group]: GroupTests[A] =
+    new GroupTests[A] { def laws: GroupLaws[A] = GroupLaws[A] }
 }

kernel-laws/src/main/scala/cats/kernel/laws/discipline/HashTests.scala

@@ -9,7 +9,7 @@ import org.scalacheck.Prop.forAll
 
 import scala.util.hashing.Hashing
 
-trait HashTests[A] extends EqLawTests[A] {
+trait HashTests[A] extends EqTests[A] {
 
   def laws: HashLaws[A]
 

kernel-laws/src/main/scala/cats/kernel/laws/discipline/MonoidLawTests.scala → kernel-laws/src/main/scala/cats/kernel/laws/discipline/MonoidTests.scala

@@ -7,7 +7,7 @@ import cats.kernel.instances.boolean._
 import org.scalacheck.Arbitrary
 import org.scalacheck.Prop.forAll
 
-trait MonoidLawTests[A] extends SemigroupLawTests[A] {
+trait MonoidTests[A] extends SemigroupTests[A] {
 
   def laws: MonoidLaws[A]
 
@@ -24,7 +24,7 @@ trait MonoidLawTests[A] extends SemigroupLawTests[A] {
 
 }
 
-object MonoidLawTests {
-  def apply[A: Monoid]: MonoidLawTests[A] =
-    new MonoidLawTests[A] { def laws: MonoidLaws[A] = MonoidLaws[A] }
+object MonoidTests {
+  def apply[A: Monoid]: MonoidTests[A] =
+    new MonoidTests[A] { def laws: MonoidLaws[A] = MonoidLaws[A] }
 }

kernel-laws/src/main/scala/cats/kernel/laws/discipline/OrderLawTests.scala → kernel-laws/src/main/scala/cats/kernel/laws/discipline/OrderTests.scala

@@ -7,7 +7,7 @@ import cats.kernel.instances.boolean._
 import org.scalacheck.Arbitrary
 import org.scalacheck.Prop.forAll
 
-trait OrderLawTests[A] extends PartialOrderLawTests[A] {
+trait OrderTests[A] extends PartialOrderTests[A] {
 
   def laws: OrderLaws[A]
 
@@ -23,7 +23,7 @@ trait OrderLawTests[A] extends PartialOrderLawTests[A] {
 
 }
 
-object OrderLawTests {
-  def apply[A: Order]: OrderLawTests[A] =
-    new OrderLawTests[A] { def laws: OrderLaws[A] = OrderLaws[A] }
+object OrderTests {
+  def apply[A: Order]: OrderTests[A] =
+    new OrderTests[A] { def laws: OrderLaws[A] = OrderLaws[A] }
 }

kernel-laws/src/main/scala/cats/kernel/laws/discipline/PartialOrderLawTests.scala → kernel-laws/src/main/scala/cats/kernel/laws/discipline/PartialOrderTests.scala

@@ -7,7 +7,7 @@ import cats.kernel.instances.boolean._
 import org.scalacheck.Arbitrary
 import org.scalacheck.Prop.forAll
 
-trait PartialOrderLawTests[A] extends EqLawTests[A] {
+trait PartialOrderTests[A] extends EqTests[A] {
 
   def laws: PartialOrderLaws[A]
 
@@ -29,7 +29,7 @@ trait PartialOrderLawTests[A] extends EqLawTests[A] {
 
 }
 
-object PartialOrderLawTests {
-  def apply[A: PartialOrder]: PartialOrderLawTests[A] =
-    new PartialOrderLawTests[A] { def laws: PartialOrderLaws[A] = PartialOrderLaws[A] }
+object PartialOrderTests {
+  def apply[A: PartialOrder]: PartialOrderTests[A] =
+    new PartialOrderTests[A] { def laws: PartialOrderLaws[A] = PartialOrderLaws[A] }
 }

kernel-laws/src/main/scala/cats/kernel/laws/discipline/SemigroupLawTests.scala → kernel-laws/src/main/scala/cats/kernel/laws/discipline/SemigroupTests.scala

@@ -8,7 +8,7 @@ import org.scalacheck.Arbitrary
 import org.scalacheck.Prop.forAll
 import org.typelevel.discipline.Laws
 
-trait SemigroupLawTests[A] extends Laws {
+trait SemigroupTests[A] extends Laws {
   def laws: SemigroupLaws[A]
 
   def semigroup(implicit arbA: Arbitrary[A], eqA: Eq[A]): RuleSet =
@@ -21,7 +21,7 @@ trait SemigroupLawTests[A] extends Laws {
       "semigroup combineAllOption" -> forAll(laws.combineAllOption _))
 }
 
-object SemigroupLawTests {
-  def apply[A: Semigroup]: SemigroupLawTests[A] =
-    new SemigroupLawTests[A] { def laws: SemigroupLaws[A] = SemigroupLaws[A] }
+object SemigroupTests {
+  def apply[A: Semigroup]: SemigroupTests[A] =
+    new SemigroupTests[A] { def laws: SemigroupLaws[A] = SemigroupLaws[A] }
 }

kernel-laws/src/test/scala/cats/kernel/laws/LawTests.scala

@@ -80,7 +80,7 @@ object KernelCheck {
     }
 }
 
-class LawTests extends FunSuite with Discipline {
+class Tests extends FunSuite with Discipline {
 
   import KernelCheck._
 
@@ -95,67 +95,67 @@ class LawTests extends FunSuite with Discipline {
   {
     // needed for Cogen[Map[...]]
     implicit val ohe: Ordering[HasEq[Int]] = Ordering[Int].on(_.a)
-    checkAll("Eq[Map[String, HasEq[Int]]]", EqLawTests[Map[String, HasEq[Int]]].eqv)
+    checkAll("Eq[Map[String, HasEq[Int]]]", EqTests[Map[String, HasEq[Int]]].eqv)
   }
 
 
-  checkAll("Eq[List[HasEq[Int]]]", EqLawTests[List[HasEq[Int]]].eqv)
-  checkAll("Eq[Option[HasEq[Int]]]", EqLawTests[Option[HasEq[Int]]].eqv)
-  checkAll("Eq[Vector[HasEq[Int]]]", EqLawTests[Vector[HasEq[Int]]].eqv)
-  checkAll("Eq[Stream[HasEq[Int]]]", EqLawTests[Stream[HasEq[Int]]].eqv)
-  checkAll("Eq[Queue[HasEq[Int]]]", EqLawTests[Queue[HasEq[Int]]].eqv)
-
-  checkAll("PartialOrder[Set[Int]]", PartialOrderLawTests[Set[Int]].partialOrder)
-  checkAll("PartialOrder[Set[Int]].reverse", PartialOrderLawTests(PartialOrder[Set[Int]].reverse).partialOrder)
-  checkAll("PartialOrder[Set[Int]].reverse.reverse", PartialOrderLawTests(PartialOrder[Set[Int]].reverse.reverse).partialOrder)
-  checkAll("PartialOrder[Option[HasPartialOrder[Int]]]", PartialOrderLawTests[Option[HasPartialOrder[Int]]].partialOrder)
-  checkAll("PartialOrder[List[HasPartialOrder[Int]]]", PartialOrderLawTests[List[HasPartialOrder[Int]]].partialOrder)
-  checkAll("PartialOrder[Vector[HasPartialOrder[Int]]]", PartialOrderLawTests[Vector[HasPartialOrder[Int]]].partialOrder)
-  checkAll("PartialOrder[Stream[HasPartialOrder[Int]]]", PartialOrderLawTests[Stream[HasPartialOrder[Int]]].partialOrder)
-  checkAll("PartialOrder[Queue[HasPartialOrder[Int]]]", PartialOrderLawTests[Queue[HasPartialOrder[Int]]].partialOrder)
-  checkAll("Semilattice.asMeetPartialOrder[Set[Int]]", PartialOrderLawTests(Semilattice.asMeetPartialOrder[Set[Int]]).partialOrder)
-  checkAll("Semilattice.asJoinPartialOrder[Set[Int]]", PartialOrderLawTests(Semilattice.asJoinPartialOrder[Set[Int]]).partialOrder)
-
-  checkAll("Order[Unit]", OrderLawTests[Unit].order)
-  checkAll("Order[Boolean]", OrderLawTests[Boolean].order)
-  checkAll("Order[String]", OrderLawTests[String].order)
-  checkAll("Order[Symbol]", OrderLawTests[Symbol].order)
-  checkAll("Order[Byte]", OrderLawTests[Byte].order)
-  checkAll("Order[Short]", OrderLawTests[Short].order)
-  checkAll("Order[Char]", OrderLawTests[Char].order)
-  checkAll("Order[Int]", OrderLawTests[Int].order)
-  checkAll("Order[Long]", OrderLawTests[Long].order)
-  checkAll("PartialOrder[BitSet]", PartialOrderLawTests[BitSet].partialOrder)
-  checkAll("Order[BigInt]", OrderLawTests[BigInt].order)
-  checkAll("Order[Duration]", OrderLawTests[Duration].order)
-  checkAll("Order[UUID]", OrderLawTests[UUID].order)
-  checkAll("Order[List[Int]]", OrderLawTests[List[Int]]  .order)
-  checkAll("Order[Option[String]]", OrderLawTests[Option[String]].order)
-  checkAll("Order[List[String]", OrderLawTests[List[String]].order)
-  checkAll("Order[Vector[Int]]", OrderLawTests[Vector[Int]].order)
-  checkAll("Order[Stream[Int]]", OrderLawTests[Stream[Int]].order)
-  checkAll("Order[Queue[Int]]", OrderLawTests[Queue[Int]].order)
-  checkAll("fromOrdering[Int]", OrderLawTests(Order.fromOrdering[Int]).order)
-  checkAll("Order[Int].reverse", OrderLawTests(Order[Int].reverse).order)
-  checkAll("Order[Int].reverse.reverse", OrderLawTests(Order[Int].reverse.reverse).order)
-
-  checkAll("Monoid[String]", MonoidLawTests[String].monoid)
+  checkAll("Eq[List[HasEq[Int]]]", EqTests[List[HasEq[Int]]].eqv)
+  checkAll("Eq[Option[HasEq[Int]]]", EqTests[Option[HasEq[Int]]].eqv)
+  checkAll("Eq[Vector[HasEq[Int]]]", EqTests[Vector[HasEq[Int]]].eqv)
+  checkAll("Eq[Stream[HasEq[Int]]]", EqTests[Stream[HasEq[Int]]].eqv)
+  checkAll("Eq[Queue[HasEq[Int]]]", EqTests[Queue[HasEq[Int]]].eqv)
+
+  checkAll("PartialOrder[Set[Int]]", PartialOrderTests[Set[Int]].partialOrder)
+  checkAll("PartialOrder[Set[Int]].reverse", PartialOrderTests(PartialOrder[Set[Int]].reverse).partialOrder)
+  checkAll("PartialOrder[Set[Int]].reverse.reverse", PartialOrderTests(PartialOrder[Set[Int]].reverse.reverse).partialOrder)
+  checkAll("PartialOrder[Option[HasPartialOrder[Int]]]", PartialOrderTests[Option[HasPartialOrder[Int]]].partialOrder)
+  checkAll("PartialOrder[List[HasPartialOrder[Int]]]", PartialOrderTests[List[HasPartialOrder[Int]]].partialOrder)
+  checkAll("PartialOrder[Vector[HasPartialOrder[Int]]]", PartialOrderTests[Vector[HasPartialOrder[Int]]].partialOrder)
+  checkAll("PartialOrder[Stream[HasPartialOrder[Int]]]", PartialOrderTests[Stream[HasPartialOrder[Int]]].partialOrder)
+  checkAll("PartialOrder[Queue[HasPartialOrder[Int]]]", PartialOrderTests[Queue[HasPartialOrder[Int]]].partialOrder)
+  checkAll("Semilattice.asMeetPartialOrder[Set[Int]]", PartialOrderTests(Semilattice.asMeetPartialOrder[Set[Int]]).partialOrder)
+  checkAll("Semilattice.asJoinPartialOrder[Set[Int]]", PartialOrderTests(Semilattice.asJoinPartialOrder[Set[Int]]).partialOrder)
+
+  checkAll("Order[Unit]", OrderTests[Unit].order)
+  checkAll("Order[Boolean]", OrderTests[Boolean].order)
+  checkAll("Order[String]", OrderTests[String].order)
+  checkAll("Order[Symbol]", OrderTests[Symbol].order)
+  checkAll("Order[Byte]", OrderTests[Byte].order)
+  checkAll("Order[Short]", OrderTests[Short].order)
+  checkAll("Order[Char]", OrderTests[Char].order)
+  checkAll("Order[Int]", OrderTests[Int].order)
+  checkAll("Order[Long]", OrderTests[Long].order)
+  checkAll("PartialOrder[BitSet]", PartialOrderTests[BitSet].partialOrder)
+  checkAll("Order[BigInt]", OrderTests[BigInt].order)
+  checkAll("Order[Duration]", OrderTests[Duration].order)
+  checkAll("Order[UUID]", OrderTests[UUID].order)
+  checkAll("Order[List[Int]]", OrderTests[List[Int]]  .order)
+  checkAll("Order[Option[String]]", OrderTests[Option[String]].order)
+  checkAll("Order[List[String]", OrderTests[List[String]].order)
+  checkAll("Order[Vector[Int]]", OrderTests[Vector[Int]].order)
+  checkAll("Order[Stream[Int]]", OrderTests[Stream[Int]].order)
+  checkAll("Order[Queue[Int]]", OrderTests[Queue[Int]].order)
+  checkAll("fromOrdering[Int]", OrderTests(Order.fromOrdering[Int]).order)
+  checkAll("Order[Int].reverse", OrderTests(Order[Int].reverse).order)
+  checkAll("Order[Int].reverse.reverse", OrderTests(Order[Int].reverse.reverse).order)
+
+  checkAll("Monoid[String]", MonoidTests[String].monoid)
   checkAll("Monoid[String]", SerializableTests.serializable(Monoid[String]))
-  checkAll("Monoid[Option[Int]]", MonoidLawTests[Option[Int]].monoid)
+  checkAll("Monoid[Option[Int]]", MonoidTests[Option[Int]].monoid)
   checkAll("Monoid[Option[Int]]", SerializableTests.serializable(Monoid[String]))
-  checkAll("Monoid[Option[String]]", MonoidLawTests[Option[String]].monoid)
+  checkAll("Monoid[Option[String]]", MonoidTests[Option[String]].monoid)
   checkAll("Monoid[Option[String]]", SerializableTests.serializable(Monoid[String]))
-  checkAll("Monoid[List[Int]]", MonoidLawTests[List[Int]].monoid)
+  checkAll("Monoid[List[Int]]", MonoidTests[List[Int]].monoid)
   checkAll("Monoid[List[Int]]", SerializableTests.serializable(Monoid[List[Int]]))
-  checkAll("Monoid[Vector[Int]]", MonoidLawTests[Vector[Int]].monoid)
+  checkAll("Monoid[Vector[Int]]", MonoidTests[Vector[Int]].monoid)
   checkAll("Monoid[Vector[Int]]", SerializableTests.serializable(Monoid[Vector[Int]]))
-  checkAll("Monoid[Stream[Int]]", MonoidLawTests[Stream[Int]].monoid)
+  checkAll("Monoid[Stream[Int]]", MonoidTests[Stream[Int]].monoid)
   checkAll("Monoid[Stream[Int]]", SerializableTests.serializable(Monoid[Stream[Int]]))
-  checkAll("Monoid[List[String]]", MonoidLawTests[List[String]].monoid)
+  checkAll("Monoid[List[String]]", MonoidTests[List[String]].monoid)
   checkAll("Monoid[List[String]]", SerializableTests.serializable(Monoid[List[String]]))
-  checkAll("Monoid[Map[String, Int]]", MonoidLawTests[Map[String, Int]].monoid)
+  checkAll("Monoid[Map[String, Int]]", MonoidTests[Map[String, Int]].monoid)
   checkAll("Monoid[Map[String, Int]]", SerializableTests.serializable(Monoid[Map[String, Int]]))
-  checkAll("Monoid[Queue[Int]]", MonoidLawTests[Queue[Int]].monoid)
+  checkAll("Monoid[Queue[Int]]", MonoidTests[Queue[Int]].monoid)
   checkAll("Monoid[Queue[Int]]", SerializableTests.serializable(Monoid[Queue[Int]]))
 
   checkAll("BoundedSemilattice[BitSet]", BoundedSemilatticeTests[BitSet].boundedSemilattice)
@@ -216,7 +216,7 @@ class LawTests extends FunSuite with Discipline {
     // default Arbitrary[BigDecimal] is a bit too intense :/
     implicit val arbBigDecimal: Arbitrary[BigDecimal] =
       Arbitrary(arbitrary[Double].map(n => BigDecimal(n.toString)))
-    checkAll("Order[BigDecimal]", OrderLawTests[BigDecimal].order)
+    checkAll("Order[BigDecimal]", OrderTests[BigDecimal].order)
     checkAll("CommutativeGroup[BigDecimal]", CommutativeGroupTests[BigDecimal].commutativeGroup)
     checkAll("CommutativeGroup[BigDecimal]", SerializableTests.serializable(CommutativeGroup[BigDecimal]))
   }
@@ -238,15 +238,15 @@ class LawTests extends FunSuite with Discipline {
       else Double.NaN
   }
 
-  checkAll("subsetPartialOrder[Int]", PartialOrderLawTests(subsetPartialOrder[Int]).partialOrder)
+  checkAll("subsetPartialOrder[Int]", PartialOrderTests(subsetPartialOrder[Int]).partialOrder)
 
   implicit val arbitraryComparison: Arbitrary[Comparison] =
     Arbitrary(Gen.oneOf(Comparison.GreaterThan, Comparison.EqualTo, Comparison.LessThan))
 
   implicit val cogenComparison: Cogen[Comparison] =
     Cogen[Int].contramap(_.toInt)
 
-  checkAll("Eq[Comparison]", EqLawTests[Comparison].eqv)
+  checkAll("Eq[Comparison]", EqTests[Comparison].eqv)
 
   test("comparison") {
     val order = Order[Int]
@@ -326,7 +326,7 @@ class LawTests extends FunSuite with Discipline {
     }
 
     implicit val monoidOrderN = Order.whenEqualMonoid[N]
-    checkAll("Monoid[Order[N]]", MonoidLawTests[Order[N]].monoid)
+    checkAll("Monoid[Order[N]]", MonoidTests[Order[N]].monoid)
     checkAll("Band[Order[N]]", BandTests[Order[N]].band)
 
     {

tests/src/test/scala/cats/tests/CategoryTests.scala

@@ -1,7 +1,7 @@
 package cats
 package tests
 
-import cats.kernel.laws.discipline.{MonoidLawTests}
+import cats.kernel.laws.discipline.{MonoidTests => MonoidLawTests}
 
 import cats.arrow.Category
 import cats.laws.discipline.{MonoidKTests, SerializableTests}

tests/src/test/scala/cats/tests/ComposeTest.scala

@@ -1,7 +1,7 @@
 package cats
 package tests
 
-import cats.kernel.laws.discipline.{SemigroupLawTests}
+import cats.kernel.laws.discipline.{SemigroupTests => SemigroupLawTests}
 
 import cats.arrow.Compose
 import cats.laws.discipline.{SemigroupKTests, SerializableTests}

tests/src/test/scala/cats/tests/ConstTests.scala

@@ -3,11 +3,11 @@ package tests
 
 
 import cats.kernel.laws.discipline.{
-  MonoidLawTests,
-  SemigroupLawTests,
-  OrderLawTests,
-  PartialOrderLawTests,
-  EqLawTests
+  MonoidTests => MonoidLawTests,
+  SemigroupTests => SemigroupLawTests,
+  OrderTests => OrderLawTests,
+  PartialOrderTests => PartialOrderLawTests,
+  EqTests => EqLawTests
 }
 import cats.Contravariant
 import cats.data.{Const, NonEmptyList}