diff --git a/akka-actor-tests/src/test/scala/akka/actor/SchedulerSpec.scala b/akka-actor-tests/src/test/scala/akka/actor/SchedulerSpec.scala
index f01f0ecd1b..e3d4af7b14 100644
--- a/akka-actor-tests/src/test/scala/akka/actor/SchedulerSpec.scala
+++ b/akka-actor-tests/src/test/scala/akka/actor/SchedulerSpec.scala
@@ -105,12 +105,12 @@ trait SchedulerSpec extends BeforeAndAfterEach with DefaultTimeout with Implicit
 
       // should not be run immediately
       assert(countDownLatch.await(100, TimeUnit.MILLISECONDS) == false)
-      countDownLatch.getCount should ===(3)
+      countDownLatch.getCount should ===(3L)
 
       // after 1 second the wait should fail
       assert(countDownLatch.await(2, TimeUnit.SECONDS) == false)
       // should still be 1 left
-      countDownLatch.getCount should ===(1)
+      countDownLatch.getCount should ===(1L)
     }
 
     /**
diff --git a/akka-actor-tests/src/test/scala/akka/actor/dispatch/DispatcherActorSpec.scala b/akka-actor-tests/src/test/scala/akka/actor/dispatch/DispatcherActorSpec.scala
index 3ca9d9ba81..2ed0e173bd 100644
--- a/akka-actor-tests/src/test/scala/akka/actor/dispatch/DispatcherActorSpec.scala
+++ b/akka-actor-tests/src/test/scala/akka/actor/dispatch/DispatcherActorSpec.scala
@@ -98,7 +98,7 @@ class DispatcherActorSpec extends AkkaSpec(DispatcherActorSpec.config) with Defa
       latch.await(10, TimeUnit.SECONDS)
       system.stop(fastOne)
       system.stop(slowOne)
-      assert(latch.getCount() === 0)
+      assert(latch.getCount() === 0L)
     }
 
     "respect throughput deadline" in {
diff --git a/akka-actor-tests/src/test/scala/akka/actor/dispatch/DispatcherActorsSpec.scala b/akka-actor-tests/src/test/scala/akka/actor/dispatch/DispatcherActorsSpec.scala
index a9a86e3c24..c316cc6094 100644
--- a/akka-actor-tests/src/test/scala/akka/actor/dispatch/DispatcherActorsSpec.scala
+++ b/akka-actor-tests/src/test/scala/akka/actor/dispatch/DispatcherActorsSpec.scala
@@ -51,7 +51,7 @@ class DispatcherActorsSpec extends AkkaSpec {
       fFinished.await
       assert(sFinished.getCount > 0)
       sFinished.await
-      assert(sFinished.getCount === 0)
+      assert(sFinished.getCount === 0L)
       system.stop(f)
       system.stop(s)
     }
diff --git a/akka-actor-tests/src/test/scala/akka/config/ConfigSpec.scala b/akka-actor-tests/src/test/scala/akka/config/ConfigSpec.scala
index ea862b22aa..e9afc98626 100644
--- a/akka-actor-tests/src/test/scala/akka/config/ConfigSpec.scala
+++ b/akka-actor-tests/src/test/scala/akka/config/ConfigSpec.scala
@@ -37,7 +37,7 @@ class ConfigSpec extends AkkaSpec(ConfigFactory.defaultReference(ActorSystem.fin
         settings.SerializeAllMessages should ===(true)
 
         getInt("akka.scheduler.ticks-per-wheel") should ===(512)
-        getDuration("akka.scheduler.tick-duration", TimeUnit.MILLISECONDS) should ===(10)
+        getDuration("akka.scheduler.tick-duration", TimeUnit.MILLISECONDS) should ===(10L)
         getString("akka.scheduler.implementation") should ===("akka.actor.LightArrayRevolverScheduler")
 
         getBoolean("akka.daemonic") should ===(false)
@@ -77,9 +77,9 @@ class ConfigSpec extends AkkaSpec(ConfigFactory.defaultReference(ActorSystem.fin
         {
           c.getString("type") should ===("Dispatcher")
           c.getString("executor") should ===("default-executor")
-          c.getDuration("shutdown-timeout", TimeUnit.MILLISECONDS) should ===(1 * 1000)
+          c.getDuration("shutdown-timeout", TimeUnit.MILLISECONDS) should ===(1 * 1000L)
           c.getInt("throughput") should ===(5)
-          c.getDuration("throughput-deadline-time", TimeUnit.MILLISECONDS) should ===(0)
+          c.getDuration("throughput-deadline-time", TimeUnit.MILLISECONDS) should ===(0L)
           c.getBoolean("attempt-teamwork") should ===(true)
         }
 
@@ -104,7 +104,7 @@ class ConfigSpec extends AkkaSpec(ConfigFactory.defaultReference(ActorSystem.fin
         {
           val pool = c.getConfig("thread-pool-executor")
           import pool._
-          getDuration("keep-alive-time", TimeUnit.MILLISECONDS) should ===(60 * 1000)
+          getDuration("keep-alive-time", TimeUnit.MILLISECONDS) should ===(60 * 1000L)
           getDouble("core-pool-size-factor") should ===(3.0)
           getDouble("max-pool-size-factor") should ===(3.0)
           getInt("task-queue-size") should ===(-1)
@@ -148,7 +148,7 @@ class ConfigSpec extends AkkaSpec(ConfigFactory.defaultReference(ActorSystem.fin
 
         {
           c.getInt("mailbox-capacity") should ===(1000)
-          c.getDuration("mailbox-push-timeout-time", TimeUnit.MILLISECONDS) should ===(10 * 1000)
+          c.getDuration("mailbox-push-timeout-time", TimeUnit.MILLISECONDS) should ===(10 * 1000L)
           c.getString("mailbox-type") should ===("akka.dispatch.UnboundedMailbox")
         }
       }
diff --git a/akka-actor-tests/src/test/scala/akka/util/DurationSpec.scala b/akka-actor-tests/src/test/scala/akka/util/DurationSpec.scala
index b7c7f72de7..6ee47d5a04 100644
--- a/akka-actor-tests/src/test/scala/akka/util/DurationSpec.scala
+++ b/akka-actor-tests/src/test/scala/akka/util/DurationSpec.scala
@@ -23,7 +23,7 @@ class DurationSpec extends AkkaSpec {
       (2 * one) should ===(two)
       (three - two) should ===(one)
       (three / 3) should ===(one)
-      (two / one) should ===(2)
+      (two / one) should ===(2D)
       (one + zero) should ===(one)
       (one / 1000000) should ===(1.micro)
     }
diff --git a/akka-actor-tests/src/test/scala/akka/util/TokenBucketSpec.scala b/akka-actor-tests/src/test/scala/akka/util/TokenBucketSpec.scala
index ad2cd54b23..91b60ba13a 100644
--- a/akka-actor-tests/src/test/scala/akka/util/TokenBucketSpec.scala
+++ b/akka-actor-tests/src/test/scala/akka/util/TokenBucketSpec.scala
@@ -20,54 +20,54 @@ class TokenBucketSpec extends AkkaSpec {
       val bucket = new TestBucket(10, 1)
       bucket.init()
 
-      bucket.offer(1) should ===(0)
-      bucket.offer(1) should ===(0)
-      bucket.offer(1) should ===(0)
-      bucket.offer(7) should ===(0)
+      bucket.offer(1) should ===(0L)
+      bucket.offer(1) should ===(0L)
+      bucket.offer(1) should ===(0L)
+      bucket.offer(7) should ===(0L)
 
-      bucket.offer(3) should ===(3)
+      bucket.offer(3) should ===(3L)
     }
 
     "calculate correctly with different rates and capacities" in {
       val bucketRate2 = new TestBucket(10, 2)
       bucketRate2.init()
 
-      bucketRate2.offer(5) should ===(0)
-      bucketRate2.offer(5) should ===(0)
-      bucketRate2.offer(5) should ===(10)
+      bucketRate2.offer(5) should ===(0L)
+      bucketRate2.offer(5) should ===(0L)
+      bucketRate2.offer(5) should ===(10L)
 
       val bucketRate3 = new TestBucket(8, 3)
       bucketRate3.init()
-      bucketRate3.offer(5) should ===(0)
-      bucketRate3.offer(5) should ===(6)
+      bucketRate3.offer(5) should ===(0L)
+      bucketRate3.offer(5) should ===(6L)
 
       bucketRate3.currentTime = 6
-      bucketRate3.offer(3) should ===(9)
+      bucketRate3.offer(3) should ===(9L)
     }
 
     "allow sending elements larger than capacity" in {
       val bucket = new TestBucket(10, 2)
       bucket.init()
 
-      bucket.offer(5) should ===(0)
-      bucket.offer(20) should ===(30)
+      bucket.offer(5) should ===(0L)
+      bucket.offer(20) should ===(30L)
 
       bucket.currentTime = 30
-      bucket.offer(1) should ===(2)
+      bucket.offer(1) should ===(2L)
 
       bucket.currentTime = 34
-      bucket.offer(1) should ===(0)
-      bucket.offer(1) should ===(2)
+      bucket.offer(1) should ===(0L)
+      bucket.offer(1) should ===(2L)
     }
 
     "work with zero capacity" in {
       val bucket = new TestBucket(0, 2)
       bucket.init()
 
-      bucket.offer(10) should ===(20)
+      bucket.offer(10) should ===(20L)
 
       bucket.currentTime = 40
-      bucket.offer(10) should ===(20)
+      bucket.offer(10) should ===(20L)
     }
 
     "not delay if rate is higher than production" in {
@@ -76,7 +76,7 @@ class TokenBucketSpec extends AkkaSpec {
 
       for (time ← 0 to 100 by 10) {
         bucket.currentTime = time
-        bucket.offer(1) should ===(0)
+        bucket.offer(1) should ===(0L)
       }
 
     }
@@ -84,10 +84,10 @@ class TokenBucketSpec extends AkkaSpec {
     "maintain maximum capacity" in {
       val bucket = new TestBucket(10, 1)
       bucket.init()
-      bucket.offer(10) should ===(0)
+      bucket.offer(10) should ===(0L)
 
       bucket.currentTime = 100000
-      bucket.offer(20) should ===(10)
+      bucket.offer(20) should ===(10L)
     }
 
     "work if currentTime is negative" in {
@@ -95,12 +95,12 @@ class TokenBucketSpec extends AkkaSpec {
       bucket.currentTime = -100 // Must be set before init()!
       bucket.init()
 
-      bucket.offer(5) should ===(0)
-      bucket.offer(10) should ===(5)
+      bucket.offer(5) should ===(0L)
+      bucket.offer(10) should ===(5L)
 
       bucket.currentTime += 10
 
-      bucket.offer(5) should ===(0)
+      bucket.offer(5) should ===(0L)
     }
 
     "work if currentTime wraps over" in {
@@ -108,19 +108,19 @@ class TokenBucketSpec extends AkkaSpec {
       bucket.currentTime = Long.MaxValue - 5 // Must be set before init()!
       bucket.init()
 
-      bucket.offer(5) should ===(0)
-      bucket.offer(10) should ===(5)
+      bucket.offer(5) should ===(0L)
+      bucket.offer(10) should ===(5L)
 
       bucket.currentTime += 10
 
-      bucket.offer(5) should ===(0)
+      bucket.offer(5) should ===(0L)
     }
 
     "(attempt to) maintain equal time between token renewal intervals" in {
       val bucket = new TestBucket(5, 3)
       bucket.init()
 
-      bucket.offer(10) should ===(15)
+      bucket.offer(10) should ===(15L)
 
       bucket.currentTime = 16
       // At this point there is no token in the bucket (we consumed it at T15) but the next token will arrive at T18!
@@ -133,7 +133,7 @@ class TokenBucketSpec extends AkkaSpec {
       //  emitted here --+ +---- currently here (T16)
       //
 
-      bucket.offer(1) should ===(2)
+      bucket.offer(1) should ===(2L)
 
       bucket.currentTime = 19
       // At 18 bucket is empty, and so is at 19. For a cost of 2 we need to wait until T24 which is 5 units.
@@ -143,19 +143,19 @@ class TokenBucketSpec extends AkkaSpec {
       //                     ^ ^
       //      emptied here --+ +---- currently here (T19)
       //
-      bucket.offer(2) should ===(5)
+      bucket.offer(2) should ===(5L)
 
       // Another case
       val bucket2 = new TestBucket(10, 3)
       bucket2.init()
 
       bucket2.currentTime = 4
-      bucket2.offer(6) should ===(0)
+      bucket2.offer(6) should ===(0L)
 
       // 4 tokens remain and new tokens arrive at T6 and T9 so here we have 6 tokens remaining.
       // We need 1 more, which will arrive at T12
       bucket2.currentTime = 10
-      bucket2.offer(7) should ===(2)
+      bucket2.offer(7) should ===(2L)
     }
 
     "work with cost of zero" in {
@@ -167,7 +167,7 @@ class TokenBucketSpec extends AkkaSpec {
       bucket.offer(0)
       bucket.offer(0)
 
-      bucket.offer(10) should ===(0)
+      bucket.offer(10) should ===(0L)
 
       // Bucket is empty now
       // Still can be called any number of times
@@ -187,7 +187,7 @@ class TokenBucketSpec extends AkkaSpec {
       // Collect 5 tokens
       bucket.currentTime += 5 * T
 
-      bucket.offer(4) should ===(0)
+      bucket.offer(4) should ===(0L)
       bucket.offer(2) should ===(T)
     }
 
@@ -222,7 +222,7 @@ class TokenBucketSpec extends AkkaSpec {
 
           if (delaying && idealBucket == 0) {
             // Actual emit time should equal to what the optimized token bucket calculates
-            time should ===(nextEmit)
+            time.toLong should ===(nextEmit)
             untilNextElement = time + Random.nextInt(arrivalPeriod)
             if (Debug) println(s"  EMITTING")
             delaying = false
diff --git a/akka-actor-tests/src/test/scala/akka/util/TypedMultiMapSpec.scala b/akka-actor-tests/src/test/scala/akka/util/TypedMultiMapSpec.scala
index 28297cd0b5..414847a3c4 100644
--- a/akka-actor-tests/src/test/scala/akka/util/TypedMultiMapSpec.scala
+++ b/akka-actor-tests/src/test/scala/akka/util/TypedMultiMapSpec.scala
@@ -6,7 +6,7 @@ package akka.util
 
 import org.scalatest.WordSpec
 import org.scalatest.Matchers
-import org.scalactic.ConversionCheckedTripleEquals
+import org.scalactic.TypeCheckedTripleEquals
 
 object TypedMultiMapSpec {
   trait AbstractKey { type Type }
@@ -16,7 +16,7 @@ object TypedMultiMapSpec {
   type KV[K <: AbstractKey] = MyValue[K#Type]
 }
 
-class TypedMultiMapSpec extends WordSpec with Matchers with ConversionCheckedTripleEquals {
+class TypedMultiMapSpec extends WordSpec with Matchers with TypeCheckedTripleEquals {
   import TypedMultiMapSpec._
 
   "A TypedMultiMap" must {
diff --git a/akka-docs/src/test/scala/docs/stream/BidiFlowDocSpec.scala b/akka-docs/src/test/scala/docs/stream/BidiFlowDocSpec.scala
index f6fca69e8b..005e3e096d 100644
--- a/akka-docs/src/test/scala/docs/stream/BidiFlowDocSpec.scala
+++ b/akka-docs/src/test/scala/docs/stream/BidiFlowDocSpec.scala
@@ -10,10 +10,8 @@ import akka.stream._
 import akka.util.ByteString
 import java.nio.ByteOrder
 import akka.stream.stage._
-import scala.annotation.tailrec
 import scala.concurrent.duration._
 import scala.concurrent.Await
-import org.scalactic.ConversionCheckedTripleEquals
 
 object BidiFlowDocSpec {
   //#codec
diff --git a/akka-docs/src/test/scala/tutorial_3/DeviceSpec.scala b/akka-docs/src/test/scala/tutorial_3/DeviceSpec.scala
index 4be331e2a8..053593d7dc 100644
--- a/akka-docs/src/test/scala/tutorial_3/DeviceSpec.scala
+++ b/akka-docs/src/test/scala/tutorial_3/DeviceSpec.scala
@@ -19,7 +19,7 @@ class DeviceSpec extends AkkaSpec {
 
       deviceActor.tell(Device.ReadTemperature(requestId = 42), probe.ref)
       val response = probe.expectMsgType[Device.RespondTemperature]
-      response.requestId should ===(42)
+      response.requestId should ===(42L)
       response.value should ===(None)
     }
     //#device-read-test
@@ -34,7 +34,7 @@ class DeviceSpec extends AkkaSpec {
 
       deviceActor.tell(Device.ReadTemperature(requestId = 2), probe.ref)
       val response1 = probe.expectMsgType[Device.RespondTemperature]
-      response1.requestId should ===(2)
+      response1.requestId should ===(2L)
       response1.value should ===(Some(24.0))
 
       deviceActor.tell(Device.RecordTemperature(requestId = 3, 55.0), probe.ref)
@@ -42,7 +42,7 @@ class DeviceSpec extends AkkaSpec {
 
       deviceActor.tell(Device.ReadTemperature(requestId = 4), probe.ref)
       val response2 = probe.expectMsgType[Device.RespondTemperature]
-      response2.requestId should ===(4)
+      response2.requestId should ===(4L)
       response2.value should ===(Some(55.0))
     }
     //#device-write-read-test
diff --git a/akka-docs/src/test/scala/tutorial_4/DeviceSpec.scala b/akka-docs/src/test/scala/tutorial_4/DeviceSpec.scala
index 6a5429ceee..9895bede6b 100644
--- a/akka-docs/src/test/scala/tutorial_4/DeviceSpec.scala
+++ b/akka-docs/src/test/scala/tutorial_4/DeviceSpec.scala
@@ -40,7 +40,7 @@ class DeviceSpec extends AkkaSpec {
 
       deviceActor.tell(Device.ReadTemperature(requestId = 42), probe.ref)
       val response = probe.expectMsgType[Device.RespondTemperature]
-      response.requestId should ===(42)
+      response.requestId should ===(42L)
       response.value should ===(None)
     }
 
@@ -53,7 +53,7 @@ class DeviceSpec extends AkkaSpec {
 
       deviceActor.tell(Device.ReadTemperature(requestId = 2), probe.ref)
       val response1 = probe.expectMsgType[Device.RespondTemperature]
-      response1.requestId should ===(2)
+      response1.requestId should ===(2L)
       response1.value should ===(Some(24.0))
 
       deviceActor.tell(Device.RecordTemperature(requestId = 3, 55.0), probe.ref)
@@ -61,7 +61,7 @@ class DeviceSpec extends AkkaSpec {
 
       deviceActor.tell(Device.ReadTemperature(requestId = 4), probe.ref)
       val response2 = probe.expectMsgType[Device.RespondTemperature]
-      response2.requestId should ===(4)
+      response2.requestId should ===(4L)
       response2.value should ===(Some(55.0))
     }
 
diff --git a/akka-remote/src/test/scala/akka/remote/artery/EnvelopeBufferSpec.scala b/akka-remote/src/test/scala/akka/remote/artery/EnvelopeBufferSpec.scala
index 30f425ad9f..6c66d79475 100644
--- a/akka-remote/src/test/scala/akka/remote/artery/EnvelopeBufferSpec.scala
+++ b/akka-remote/src/test/scala/akka/remote/artery/EnvelopeBufferSpec.scala
@@ -82,7 +82,7 @@ class EnvelopeBufferSpec extends AkkaSpec {
       envelope.parseHeader(headerOut)
 
       headerOut.version should ===(version)
-      headerOut.uid should ===(42)
+      headerOut.uid should ===(42L)
       headerOut.inboundActorRefCompressionTableVersion should ===(28.toByte)
       headerOut.inboundClassManifestCompressionTableVersion should ===(35.toByte)
       headerOut.serializer should ===(4)
@@ -117,7 +117,7 @@ class EnvelopeBufferSpec extends AkkaSpec {
       envelope.parseHeader(headerOut)
 
       headerOut.version should ===(version)
-      headerOut.uid should ===(42)
+      headerOut.uid should ===(42L)
       headerOut.serializer should ===(4)
       headerOut.senderActorRefPath should ===(OptionVal.Some("akka://EnvelopeBufferSpec/uncompressable0"))
       headerOut.senderActorRef(originUid) should ===(OptionVal.None)
@@ -145,7 +145,7 @@ class EnvelopeBufferSpec extends AkkaSpec {
       envelope.parseHeader(headerOut)
 
       headerOut.version should ===(version)
-      headerOut.uid should ===(42)
+      headerOut.uid should ===(42L)
       headerOut.serializer should ===(4)
       headerOut.senderActorRef(originUid).get.path.toSerializationFormat should ===("akka://EnvelopeBufferSpec/reallylongcompressablestring")
       headerOut.senderActorRefPath should ===(OptionVal.None)
@@ -198,7 +198,7 @@ class EnvelopeBufferSpec extends AkkaSpec {
       envelope.parseHeader(headerOut)
 
       headerOut.version should ===(version)
-      headerOut.uid should ===(42)
+      headerOut.uid should ===(42L)
       headerOut.serializer should ===(4)
       headerOut.senderActorRef(originUid).get.path.toSerializationFormat should ===("akka://EnvelopeBufferSpec/reallylongcompressablestring")
       headerOut.senderActorRefPath should ===(OptionVal.None)
diff --git a/akka-remote/src/test/scala/akka/remote/artery/FlightRecorderSpec.scala b/akka-remote/src/test/scala/akka/remote/artery/FlightRecorderSpec.scala
index 425e0fc1d3..5b491bfe36 100644
--- a/akka-remote/src/test/scala/akka/remote/artery/FlightRecorderSpec.scala
+++ b/akka-remote/src/test/scala/akka/remote/artery/FlightRecorderSpec.scala
@@ -37,19 +37,19 @@ class FlightRecorderSpec extends AkkaSpec {
 
       def checkLogInitialized(log: reader.RollingLog): Unit = {
         log.logs(0).state should ===(Live)
-        log.logs(0).head should ===(0)
+        log.logs(0).head should ===(0L)
         log.logs(0).richEntries.toSeq should ===(Nil)
 
         log.logs(1).state should ===(Empty)
-        log.logs(1).head should ===(0)
+        log.logs(1).head should ===(0L)
         log.logs(1).richEntries.toSeq should ===(Nil)
 
         log.logs(2).state should ===(Empty)
-        log.logs(2).head should ===(0)
+        log.logs(2).head should ===(0L)
         log.logs(2).richEntries.toSeq should ===(Nil)
 
         log.logs(3).state should ===(Empty)
-        log.logs(3).head should ===(0)
+        log.logs(3).head should ===(0L)
         log.logs(3).richEntries.toSeq should ===(Nil)
       }
 
diff --git a/akka-remote/src/test/scala/akka/remote/artery/compress/CompressionTableSpec.scala b/akka-remote/src/test/scala/akka/remote/artery/compress/CompressionTableSpec.scala
index 2933447874..36950188fc 100644
--- a/akka-remote/src/test/scala/akka/remote/artery/compress/CompressionTableSpec.scala
+++ b/akka-remote/src/test/scala/akka/remote/artery/compress/CompressionTableSpec.scala
@@ -13,7 +13,7 @@ class CompressionTableSpec extends AkkaSpec {
       val decomp = CompressionTable(17L, 1, Map("0" → 0, "1" → 1, "2" → 2, "3" → 3)).invert
       decomp.table should ===(Array("0", "1", "2", "3"))
       decomp.originUid should ===(17L)
-      decomp.version should ===(1)
+      decomp.version should ===(1.toByte)
     }
 
     "enforce to start allocating from 0th index" in {
diff --git a/akka-stream-testkit/src/test/scala/akka/stream/testkit/TestPublisherSubscriberSpec.scala b/akka-stream-testkit/src/test/scala/akka/stream/testkit/TestPublisherSubscriberSpec.scala
index f283fd8f70..dd413d4def 100644
--- a/akka-stream-testkit/src/test/scala/akka/stream/testkit/TestPublisherSubscriberSpec.scala
+++ b/akka-stream-testkit/src/test/scala/akka/stream/testkit/TestPublisherSubscriberSpec.scala
@@ -31,7 +31,7 @@ class TestPublisherSubscriberSpec extends AkkaSpec {
 
       upstreamSubscription.sendNext(1)
       downstreamSubscription.request(1)
-      upstream.expectEventPF { case RequestMore(_, e) ⇒ e } should ===(1)
+      upstream.expectEventPF { case RequestMore(_, e) ⇒ e } should ===(1L)
       downstream.expectEventPF { case OnNext(e) ⇒ e } should ===(1)
 
       upstreamSubscription.sendNext(1)
@@ -70,7 +70,7 @@ class TestPublisherSubscriberSpec extends AkkaSpec {
         .expectSubscription()
         .request(10)
 
-      upstream.expectRequest() should ===(10)
+      upstream.expectRequest() should ===(10L)
       upstream.sendNext(1)
       downstream.expectNext(1)
     }
diff --git a/akka-stream-tests/src/test/scala/akka/stream/io/FileSinkSpec.scala b/akka-stream-tests/src/test/scala/akka/stream/io/FileSinkSpec.scala
index ac503dd28e..00bd21962d 100644
--- a/akka-stream-tests/src/test/scala/akka/stream/io/FileSinkSpec.scala
+++ b/akka-stream-tests/src/test/scala/akka/stream/io/FileSinkSpec.scala
@@ -82,7 +82,7 @@ class FileSinkSpec extends StreamSpec(UnboundedMailboxConfig) {
         val completion2 = write(lastWrite)
         val result = Await.result(completion2, 3.seconds)
 
-        result.count should ===(lastWrite.flatten.length)
+        result.count should ===(lastWrite.flatten.length.toLong)
         checkFileContents(f, lastWrite.mkString("") + TestLines.mkString("").drop(100))
       }
     }
@@ -101,7 +101,7 @@ class FileSinkSpec extends StreamSpec(UnboundedMailboxConfig) {
         val completion2 = write(lastWrite)
         val result = Await.result(completion2, 3.seconds)
 
-        result.count should ===(lastWrite.flatten.length)
+        result.count should ===(lastWrite.flatten.length.toLong)
         checkFileContents(f, lastWrite.mkString(""))
       }
     }
diff --git a/akka-stream-tests/src/test/scala/akka/stream/scaladsl/BidiFlowSpec.scala b/akka-stream-tests/src/test/scala/akka/stream/scaladsl/BidiFlowSpec.scala
index a3480838bd..b7f99f1961 100644
--- a/akka-stream-tests/src/test/scala/akka/stream/scaladsl/BidiFlowSpec.scala
+++ b/akka-stream-tests/src/test/scala/akka/stream/scaladsl/BidiFlowSpec.scala
@@ -50,7 +50,7 @@ class BidiFlowSpec extends StreamSpec {
         ClosedShape
       }).run()
 
-      Await.result(top, 1.second) should ===(3)
+      Await.result(top, 1.second) should ===(3L)
       Await.result(bottom, 1.second) should ===(str)
     }
 
diff --git a/akka-stream-tests/src/test/scala/akka/stream/scaladsl/SinkAsJavaStreamSpec.scala b/akka-stream-tests/src/test/scala/akka/stream/scaladsl/SinkAsJavaStreamSpec.scala
index 331072d1ca..9adbe08140 100644
--- a/akka-stream-tests/src/test/scala/akka/stream/scaladsl/SinkAsJavaStreamSpec.scala
+++ b/akka-stream-tests/src/test/scala/akka/stream/scaladsl/SinkAsJavaStreamSpec.scala
@@ -24,7 +24,7 @@ class SinkAsJavaStreamSpec extends StreamSpec(UnboundedMailboxConfig) {
 
     "work in happy case" in {
       val javaSource = Source(1 to 100).runWith(StreamConverters.asJavaStream())
-      javaSource.count() should ===(100)
+      javaSource.count() should ===(100L)
     }
 
     "fail if parent stream is failed" in {
@@ -41,12 +41,12 @@ class SinkAsJavaStreamSpec extends StreamSpec(UnboundedMailboxConfig) {
 
     "work with empty stream" in {
       val javaSource = Source.empty.runWith(StreamConverters.asJavaStream())
-      javaSource.count() should ===(0)
+      javaSource.count() should ===(0L)
     }
 
     "work with endless stream" in assertAllStagesStopped {
       val javaSource = Source.repeat(1).runWith(StreamConverters.asJavaStream())
-      javaSource.limit(10).count() should ===(10)
+      javaSource.limit(10).count() should ===(10L)
       javaSource.close()
     }
 
diff --git a/akka-stream-tests/src/test/scala/akka/stream/scaladsl/SinkSpec.scala b/akka-stream-tests/src/test/scala/akka/stream/scaladsl/SinkSpec.scala
index cd73998839..bb03827558 100644
--- a/akka-stream-tests/src/test/scala/akka/stream/scaladsl/SinkSpec.scala
+++ b/akka-stream-tests/src/test/scala/akka/stream/scaladsl/SinkSpec.scala
@@ -228,22 +228,22 @@ class SinkSpec extends StreamSpec with DefaultTimeout with ScalaFutures {
       Source(1 to 100).runWith(StreamConverters
         .javaCollectorParallelUnordered(4)(
           () ⇒ Collectors.summingInt[Int](intIdentity)))
-        .futureValue should ===(5050)
+        .futureValue.toInt should ===(5050)
     }
 
     "be reusable" in {
       val sink = StreamConverters.javaCollector[Int, Integer](() ⇒ Collectors.summingInt[Int](intIdentity))
-      Source(1 to 4).runWith(sink).futureValue should ===(10)
+      Source(1 to 4).runWith(sink).futureValue.toInt should ===(10)
 
       // Collector has state so it preserves all previous elements that went though
-      Source(4 to 6).runWith(sink).futureValue should ===(15)
+      Source(4 to 6).runWith(sink).futureValue.toInt should ===(15)
     }
 
     "be reusable with parallel version" in {
       val sink = StreamConverters.javaCollectorParallelUnordered(4)(() ⇒ Collectors.summingInt[Int](intIdentity))
 
-      Source(1 to 4).runWith(sink).futureValue should ===(10)
-      Source(4 to 6).runWith(sink).futureValue should ===(15)
+      Source(1 to 4).runWith(sink).futureValue.toInt should ===(10)
+      Source(4 to 6).runWith(sink).futureValue.toInt should ===(15)
     }
 
     "fail if getting the supplier fails" in {
diff --git a/akka-testkit/src/test/scala/akka/testkit/AkkaSpec.scala b/akka-testkit/src/test/scala/akka/testkit/AkkaSpec.scala
index 25e3b58aad..fa9e4e5e90 100644
--- a/akka-testkit/src/test/scala/akka/testkit/AkkaSpec.scala
+++ b/akka-testkit/src/test/scala/akka/testkit/AkkaSpec.scala
@@ -4,7 +4,7 @@
 
 package akka.testkit
 
-import org.scalactic.Constraint
+import org.scalactic.{ CanEqual, TypeCheckedTripleEquals }
 
 import language.postfixOps
 import org.scalatest.{ BeforeAndAfterAll, WordSpecLike }
@@ -17,7 +17,6 @@ import scala.concurrent.Future
 import com.typesafe.config.{ Config, ConfigFactory }
 import akka.dispatch.Dispatchers
 import akka.testkit.TestEvent._
-import org.scalactic.ConversionCheckedTripleEquals
 import org.scalatest.concurrent.ScalaFutures
 import org.scalatest.time.Span
 
@@ -59,7 +58,7 @@ object AkkaSpec {
 
 abstract class AkkaSpec(_system: ActorSystem)
   extends TestKit(_system) with WordSpecLike with Matchers with BeforeAndAfterAll with WatchedByCoroner
-  with ConversionCheckedTripleEquals with ScalaFutures {
+  with TypeCheckedTripleEquals with ScalaFutures {
 
   implicit val patience = PatienceConfig(testKitSettings.DefaultTimeout.duration, Span(100, org.scalatest.time.Millis))
 
@@ -109,13 +108,13 @@ abstract class AkkaSpec(_system: ActorSystem)
     }
 
   // for ScalaTest === compare of Class objects
-  implicit def classEqualityConstraint[A, B]: Constraint[Class[A], Class[B]] =
-    new Constraint[Class[A], Class[B]] {
+  implicit def classEqualityConstraint[A, B]: CanEqual[Class[A], Class[B]] =
+    new CanEqual[Class[A], Class[B]] {
       def areEqual(a: Class[A], b: Class[B]) = a == b
     }
 
-  implicit def setEqualityConstraint[A, T <: Set[_ <: A]]: Constraint[Set[A], T] =
-    new Constraint[Set[A], T] {
+  implicit def setEqualityConstraint[A, T <: Set[_ <: A]]: CanEqual[Set[A], T] =
+    new CanEqual[Set[A], T] {
       def areEqual(a: Set[A], b: T) = a == b
     }
 }
diff --git a/akka-testkit/src/test/scala/akka/testkit/TestTimeSpec.scala b/akka-testkit/src/test/scala/akka/testkit/TestTimeSpec.scala
index 8a1b142263..84b212af38 100644
--- a/akka-testkit/src/test/scala/akka/testkit/TestTimeSpec.scala
+++ b/akka-testkit/src/test/scala/akka/testkit/TestTimeSpec.scala
@@ -12,7 +12,7 @@ class TestTimeSpec extends AkkaSpec(Map("akka.test.timefactor" → 2.0)) {
   "A TestKit" must {
 
     "correctly dilate times" taggedAs TimingTest in {
-      1.second.dilated.toNanos should ===(1000000000L * testKitSettings.TestTimeFactor)
+      1.second.dilated.toNanos should ===(1000000000L * testKitSettings.TestTimeFactor.toLong)
 
       val probe = TestProbe()
       val now = System.nanoTime