Fixes in serialization tests for LoggerTakingImplicit

Author: paweliwanow

src/main/scala/com/typesafe/scalalogging/Logger.scala

@@ -32,8 +32,8 @@ object Logger {
     new Logger(underlying)
 
   /**
-    * Create a [[LoggerTakingImplicit]] wrapping the given underlying `org.slf4j.Logger`.
-    */
+   * Create a [[LoggerTakingImplicit]] wrapping the given underlying `org.slf4j.Logger`.
+   */
   def takingImplicit[A](underlying: Underlying)(implicit ev: CanLog[A]): LoggerTakingImplicit[A] =
     new LoggerTakingImplicit[A](underlying)
 
@@ -48,12 +48,12 @@ object Logger {
     new Logger(LoggerFactory.getLogger(name))
 
   /**
-    * Create a [[LoggerTakingImplicit]] for the given name.
-    * Example:
-    * {{{
-    *   val logger = Logger.takingImplicit[CorrelationId]("application")
-    * }}}
-    */
+   * Create a [[LoggerTakingImplicit]] for the given name.
+   * Example:
+   * {{{
+   *   val logger = Logger.takingImplicit[CorrelationId]("application")
+   * }}}
+   */
   def takingImplicit[A](name: String)(implicit ev: CanLog[A]): LoggerTakingImplicit[A] =
     new LoggerTakingImplicit[A](LoggerFactory.getLogger(name))
 
@@ -64,8 +64,8 @@ object Logger {
     new Logger(LoggerFactory.getLogger(clazz.getName))
 
   /**
-    * Create a [[LoggerTakingImplicit]] wrapping the created underlying `org.slf4j.Logger`.
-    */
+   * Create a [[LoggerTakingImplicit]] wrapping the created underlying `org.slf4j.Logger`.
+   */
   def takingImplicit[A](clazz: Class[_])(implicit ev: CanLog[A]): LoggerTakingImplicit[A] =
     new LoggerTakingImplicit[A](LoggerFactory.getLogger(clazz.getName))
 
@@ -81,13 +81,13 @@ object Logger {
     new Logger(LoggerFactory.getLogger(ct.runtimeClass.getName.stripSuffix("$")))
 
   /**
-    * Create a [[LoggerTakingImplicit]] for the runtime class wrapped by the implicit class
-    * tag parameter.
-    * Example:
-    * {{{
-    *   val logger = Logger.takingImplicit[MyClass]
-    * }}}
-    */
+   * Create a [[LoggerTakingImplicit]] for the runtime class wrapped by the implicit class
+   * tag parameter.
+   * Example:
+   * {{{
+   *   val logger = Logger.takingImplicit[MyClass, CorrelationId]
+   * }}}
+   */
   def takingImplicit[T, A](implicit ct: ClassTag[T], ev: CanLog[A]): LoggerTakingImplicit[A] =
     new LoggerTakingImplicit[A](LoggerFactory.getLogger(ct.runtimeClass.getName.stripSuffix("$")))
 }

src/main/scala/com/typesafe/scalalogging/LoggerTakingImplicit.scala

@@ -8,8 +8,7 @@ trait CanLog[A] { this: Serializable =>
 }
 
 @SerialVersionUID(957385465L)
-final class LoggerTakingImplicit[A] private[scalalogging] (val underlying: Underlying)
-    (implicit val canLogEv: CanLog[A]) extends Serializable {
+final class LoggerTakingImplicit[A] private[scalalogging] (val underlying: Underlying)(implicit val canLogEv: CanLog[A]) extends Serializable {
 
   // Error
 

src/test/scala/com/typesafe/scalalogging/LoggerSpec.scala

@@ -374,6 +374,74 @@ class LoggerSpec extends WordSpec with Matchers with MockitoSugar {
     }
   }
 
+  "Serializing LoggerTakingImplicit" should {
+    case class CorrelationId(value: String)
+    implicit val correlationId = CorrelationId(value = "correlationId")
+
+    implicit case object canLogCorrelationId extends CanLog[CorrelationId] {
+      override def logMessage(originalMsg: String, a: CorrelationId): String = s"${a.value} msg"
+    }
+
+    def serialize[A](logger: LoggerTakingImplicit[A]): Array[Byte] = {
+      val byteArrayStream = new ByteArrayOutputStream
+      val out = new ObjectOutputStream(byteArrayStream)
+
+      out.writeObject(logger)
+      out.close()
+      byteArrayStream.close()
+
+      byteArrayStream.toByteArray
+    }
+
+    def deserialize[A](array: Array[Byte]): LoggerTakingImplicit[A] = {
+      val byteArrayStream = new ByteArrayInputStream(array)
+      val in = new ObjectInputStream(byteArrayStream)
+
+      val logger = in.readObject.asInstanceOf[LoggerTakingImplicit[A]]
+      in.close()
+      byteArrayStream.close()
+
+      logger
+    }
+
+    "be usable after deserialization" in {
+      val logger =
+        deserialize[CorrelationId](
+          serialize[CorrelationId](
+            Logger.takingImplicit[CorrelationId](
+              org.slf4j.LoggerFactory.getLogger("test")
+            )
+          )
+        )
+
+      logger.trace("Back from deserialization")
+    }
+
+    "constructed by explicit class and be usable after deserialization" in {
+      val logger =
+        deserialize[CorrelationId](
+          serialize[CorrelationId](
+            Logger.takingImplicit[CorrelationId](
+              classOf[LoggerSpec]
+            )
+          )
+        )
+
+      logger.trace("Back from deserialization")
+    }
+
+    "constructed by implicit class tag and be usable after deserialization" in {
+      val logger =
+        deserialize[CorrelationId](
+          serialize[CorrelationId](
+            Logger.takingImplicit[LoggerSpec, CorrelationId]
+          )
+        )
+
+      logger.trace("Back from deserialization")
+    }
+  }
+
   def fixture(p: Underlying => Boolean, isEnabled: Boolean) =
     new {
       val msg = "msg"

src/test/scala/com/typesafe/scalalogging/LoggerTakingImplicitSpec.scala

@@ -1,12 +1,10 @@
 package com.typesafe.scalalogging
 
-import java.io.{ByteArrayInputStream, ByteArrayOutputStream, ObjectInputStream, ObjectOutputStream}
-
 import org.mockito.Matchers._
 import org.mockito.Mockito._
 import org.scalatest.mockito.MockitoSugar
-import org.scalatest.{Matchers, WordSpec}
-import org.slf4j.{Logger => Underlying}
+import org.scalatest.{ Matchers, WordSpec }
+import org.slf4j.{ Logger => Underlying }
 
 class LoggerTakingImplicitSpec extends WordSpec with Matchers with MockitoSugar {
 
@@ -377,69 +375,10 @@ class LoggerTakingImplicitSpec extends WordSpec with Matchers with MockitoSugar
     }
   }
 
-  "Serializing Logger" should {
-    implicit val correlationId = CorrelationId(value = "correlationId")
-
-    implicit case object canLogCorrelationId extends CanLog[CorrelationId] {
-      override def logMessage(originalMsg: String, a: CorrelationId): String = s"${a.value} msg"
-    }
-
-    def serialize[A](logger: LoggerTakingImplicit[A]): Array[Byte] = {
-      val byteArrayStream = new ByteArrayOutputStream
-      val out = new ObjectOutputStream(byteArrayStream)
-
-      out.writeObject(logger)
-      out.close()
-      byteArrayStream.close()
-
-      byteArrayStream.toByteArray
-    }
-
-    def deserialize[A](array: Array[Byte]): LoggerTakingImplicit[A] = {
-      val byteArrayStream = new ByteArrayInputStream(array)
-      val in = new ObjectInputStream(byteArrayStream)
-
-      val logger = in.readObject.asInstanceOf[LoggerTakingImplicit[A]]
-      in.close()
-      byteArrayStream.close()
-
-      logger
-    }
-
-    "be usable after deserialization" in {
-      val logger =
-        deserialize[CorrelationId](
-          serialize[CorrelationId](
-            Logger.takingImplicit[CorrelationId](
-              org.slf4j.LoggerFactory.getLogger("test"))))
-
-      logger.trace("Back from deserialization")
-    }
-
-    "constructed by explicit class and be usable after deserialization" in {
-      val logger =
-        deserialize[CorrelationId](
-          serialize[CorrelationId](
-            Logger.takingImplicit[CorrelationId](
-              classOf[LoggerSpec])))
-
-      logger.trace("Back from deserialization")
-    }
-
-    "constructed by implicit class tag and be usable after deserialization" in {
-      val logger =
-        deserialize[CorrelationId](
-          serialize[CorrelationId](
-            Logger.takingImplicit[LoggerSpec, CorrelationId]))
-
-      logger.trace("Back from deserialization")
-    }
-  }
-
   def fixture(p: Underlying => Boolean, isEnabled: Boolean) =
     new {
       implicit val correlationId = CorrelationId("corrId")
-      implicit val canLogCorrelationId =  mock[CanLog[CorrelationId]]
+      implicit val canLogCorrelationId = mock[CanLog[CorrelationId]]
       val msg = "msg"
       val cause = new RuntimeException("cause")
       val arg1 = "arg1"