format source with scalafmt, apache#1408

Author: Auto Format

actor-testkit-typed/src/main/scala/org/apache/pekko/actor/testkit/typed/CapturedLogEvent.scala

@@ -80,9 +80,8 @@ object CapturedLogEvent {
     case _                 => None
   }
 
-  def apply(level: Level, message: String): CapturedLogEvent = {
+  def apply(level: Level, message: String): CapturedLogEvent =
     CapturedLogEvent(level, message, None, None)
-  }
 
   /**
    * Auxiliary constructor that receives Pekko's internal [[OptionVal]] as parameters and converts them to Scala's [[Option]].
@@ -93,7 +92,6 @@ object CapturedLogEvent {
       level: Level,
       message: String,
       errorCause: OptionVal[Throwable],
-      logMarker: OptionVal[Marker]): CapturedLogEvent = {
+      logMarker: OptionVal[Marker]): CapturedLogEvent =
     new CapturedLogEvent(level, message, toOption(errorCause), toOption(logMarker))
-  }
 }

actor-testkit-typed/src/main/scala/org/apache/pekko/actor/testkit/typed/internal/ActorSystemStub.scala

@@ -117,9 +117,8 @@ import pekko.util.FutureConverters._
 
   override def printTree: String = "no tree for ActorSystemStub"
 
-  override def systemActorOf[U](behavior: Behavior[U], name: String, props: Props): ActorRef[U] = {
+  override def systemActorOf[U](behavior: Behavior[U], name: String, props: Props): ActorRef[U] =
     throw new UnsupportedOperationException("ActorSystemStub cannot create system actors")
-  }
 
   override def registerExtension[T <: Extension](ext: ExtensionId[T]): T =
     throw new UnsupportedOperationException("ActorSystemStub cannot register extensions")

actor-testkit-typed/src/main/scala/org/apache/pekko/actor/testkit/typed/internal/BehaviorTestKitImpl.scala

@@ -49,14 +49,12 @@ private[pekko] final class BehaviorTestKitImpl[T](
   private[pekko] def as[U]: BehaviorTestKitImpl[U] = this.asInstanceOf[BehaviorTestKitImpl[U]]
 
   private var currentUncanonical = _initialBehavior
-  private var current = {
+  private var current =
     try {
       context.setCurrentActorThread()
       Behavior.validateAsInitial(Behavior.start(_initialBehavior, context))
-    } finally {
+    } finally
       context.clearCurrentActorThread()
-    }
-  }
 
   // execute any future tasks scheduled in Actor's constructor
   runAllTasks()
@@ -92,24 +90,22 @@ private[pekko] final class BehaviorTestKitImpl[T](
 
   def getAllEffects(): util.List[Effect] = retrieveAllEffects().asJava
 
-  override def expectEffect(expectedEffect: Effect): Unit = {
+  override def expectEffect(expectedEffect: Effect): Unit =
     context.effectQueue.poll() match {
       case null   => assert(expectedEffect == NoEffects, s"expected: $expectedEffect but no effects were recorded")
       case effect => assert(expectedEffect == effect, s"expected: $expectedEffect but found $effect")
     }
-  }
 
-  def expectEffectClass[E <: Effect](effectClass: Class[E]): E = {
+  def expectEffectClass[E <: Effect](effectClass: Class[E]): E =
     context.effectQueue.poll() match {
       case null if effectClass.isAssignableFrom(NoEffects.getClass) => effectClass.cast(NoEffects)
       case null =>
         throw new AssertionError(s"expected: effect type ${effectClass.getName} but no effects were recorded")
       case effect if effectClass.isAssignableFrom(effect.getClass) => effect.asInstanceOf[E]
       case other                                                   => throw new AssertionError(s"expected: effect class ${effectClass.getName} but found $other")
     }
-  }
 
-  def expectEffectPF[R](f: PartialFunction[Effect, R]): R = {
+  def expectEffectPF[R](f: PartialFunction[Effect, R]): R =
     context.effectQueue.poll() match {
       case null if f.isDefinedAt(NoEffects) =>
         f.apply(NoEffects)
@@ -118,7 +114,6 @@ private[pekko] final class BehaviorTestKitImpl[T](
       case other =>
         throw new AssertionError(s"expected matching effect but got: $other")
     }
-  }
 
   def expectEffectType[E <: Effect](implicit classTag: ClassTag[E]): E =
     expectEffectClass(classTag.runtimeClass.asInstanceOf[Class[E]])
@@ -136,14 +131,13 @@ private[pekko] final class BehaviorTestKitImpl[T](
       throw e
   }
 
-  private def runAllTasks(): Unit = {
+  private def runAllTasks(): Unit =
     context.executionContext match {
       case controlled: ControlledExecutor => controlled.runAll()
       case _                              =>
     }
-  }
 
-  override def run(message: T): Unit = {
+  override def run(message: T): Unit =
     try {
       context.setCurrentActorThread()
       try {
@@ -153,25 +147,21 @@ private[pekko] final class BehaviorTestKitImpl[T](
         // notice we pass current and not intercepted, this way Behaviors.same will be resolved to current which will be intercepted again on the next message
         // otherwise we would have risked intercepting an already intercepted behavior (or would have had to explicitly check if the current behavior is already intercepted by us)
         current = Behavior.canonicalize(currentUncanonical, current, context)
-      } finally {
+      } finally
         context.clearCurrentActorThread()
-      }
       runAllTasks()
     } catch handleException
-  }
 
   override def runOne(): Unit = run(selfInbox().receiveMessage())
 
-  override def signal(signal: Signal): Unit = {
+  override def signal(signal: Signal): Unit =
     try {
       context.setCurrentActorThread()
       currentUncanonical = Behavior.interpretSignal(current, context, signal)
       current = Behavior.canonicalize(currentUncanonical, current, context)
     } catch handleException
-    finally {
+    finally
       context.clearCurrentActorThread()
-    }
-  }
 
   override def hasEffects(): Boolean = !context.effectQueue.isEmpty
 
@@ -191,7 +181,7 @@ private[pekko] object BehaviorTestKitImpl {
     override def aroundReceive(
         ctx: TypedActorContext[Any],
         msg: Any,
-        target: BehaviorInterceptor.ReceiveTarget[Any]): Behavior[Any] = {
+        target: BehaviorInterceptor.ReceiveTarget[Any]): Behavior[Any] =
       msg match {
         case AdaptWithRegisteredMessageAdapter(msgToAdapt) =>
           val fn = ctx
@@ -206,7 +196,6 @@ private[pekko] object BehaviorTestKitImpl {
           target.apply(ctx, adaptedMsg)
         case t => target.apply(ctx, t)
       }
-    }
 
     def inteceptBehaviour[T](behavior: Behavior[T], ctx: TypedActorContext[T]): Behavior[T] =
       Behavior

actor-testkit-typed/src/main/scala/org/apache/pekko/actor/testkit/typed/internal/CapturingAppender.scala

@@ -84,9 +84,8 @@ import pekko.annotation.InternalApi
     import pekko.util.ccompat.JavaConverters._
     val logbackLogger = getLogbackLogger(classOf[CapturingAppender].getName + "Delegate")
     val appenders = logbackLogger.iteratorForAppenders().asScala.filterNot(_ == this).toList
-    for (event <- buffer; appender <- appenders) {
+    for (event <- buffer; appender <- appenders)
       appender.doAppend(event)
-    }
     clear()
   }
 

actor-testkit-typed/src/main/scala/org/apache/pekko/actor/testkit/typed/internal/ControlledExecutor.scala

@@ -32,11 +32,9 @@ private[pekko] final class ControlledExecutor extends ExecutionContextExecutor {
 
   def runAll(): Unit = while (!tasks.isEmpty()) runOne()
 
-  def execute(task: Runnable): Unit = {
+  def execute(task: Runnable): Unit =
     tasks.add(task)
-  }
 
-  def reportFailure(cause: Throwable): Unit = {
+  def reportFailure(cause: Throwable): Unit =
     cause.printStackTrace()
-  }
 }

actor-testkit-typed/src/main/scala/org/apache/pekko/actor/testkit/typed/internal/EffectfulActorContext.scala

@@ -127,7 +127,7 @@ import scala.reflect.ClassTag
 
     override def cancelAll(): Unit = activeTimers.foreach(cancel)
 
-    private def sendAction(key: Any): () => Unit = () => {
+    private def sendAction(key: Any): () => Unit = () =>
       activeTimers.get(key).foreach {
         case Effect.TimerScheduled(_, msg, _, mode, _) =>
           mode match {
@@ -138,8 +138,6 @@ import scala.reflect.ClassTag
           self ! msg
       }
 
-    }
-
     def startTimer(key: Any, msg: T, delay: FiniteDuration, mode: Effect.TimerScheduled.TimerMode) = {
       val effect = Effect.TimerScheduled(key, msg, delay, mode, activeTimers.keySet(key))(sendAction(key))
       activeTimers += (key -> effect)

actor-testkit-typed/src/main/scala/org/apache/pekko/actor/testkit/typed/internal/LogbackUtil.scala

@@ -30,7 +30,7 @@ import scala.annotation.tailrec
     getLogbackLoggerInternal(loggerName, 50)
 
   @tailrec
-  private def getLogbackLoggerInternal(loggerName: String, count: Int): ch.qos.logback.classic.Logger = {
+  private def getLogbackLoggerInternal(loggerName: String, count: Int): ch.qos.logback.classic.Logger =
     LoggerFactory.getLogger(loggerNameOrRoot(loggerName)) match {
       case logger: ch.qos.logback.classic.Logger              => logger
       case _: org.slf4j.helpers.SubstituteLogger if count > 0 =>
@@ -43,9 +43,8 @@ import scala.annotation.tailrec
         throw new IllegalArgumentException(
           s"Requires Logback logger for [$loggerName], it was a [${other.getClass.getName}]")
     }
-  }
 
-  def convertLevel(level: ch.qos.logback.classic.Level): Level = {
+  def convertLevel(level: ch.qos.logback.classic.Level): Level =
     level.levelInt match {
       case ch.qos.logback.classic.Level.TRACE_INT => Level.TRACE
       case ch.qos.logback.classic.Level.DEBUG_INT => Level.DEBUG
@@ -55,5 +54,4 @@ import scala.annotation.tailrec
       case _ =>
         throw new IllegalArgumentException("Level " + level.levelStr + ", " + level.levelInt + " is unknown.")
     }
-  }
 }

actor-testkit-typed/src/main/scala/org/apache/pekko/actor/testkit/typed/internal/LoggingTestKitImpl.scala

@@ -58,42 +58,39 @@ import pekko.testkit.TestKit
   @volatile // JMM does not guarantee visibility for non-final fields
   private var todo = occurrences
 
-  def matches(event: LoggingEvent): Boolean = {
+  def matches(event: LoggingEvent): Boolean =
     logLevel.forall(_ == event.level) &&
-    source.forall(_ == sourceOrEmpty(event)) &&
-    messageContains.forall(messageOrEmpty(event).contains) &&
-    messageRegex.forall(_.findFirstIn(messageOrEmpty(event)).isDefined) &&
-    cause.forall(c => event.throwable.isDefined && c.isInstance(event.throwable.get)) &&
-    mdc.forall { case (key, value) => event.mdc.contains(key) && event.mdc(key) == value } &&
-    custom.forall(f => f(event))
+      source.forall(_ == sourceOrEmpty(event)) &&
+      messageContains.forall(messageOrEmpty(event).contains) &&
+      messageRegex.forall(_.findFirstIn(messageOrEmpty(event)).isDefined) &&
+      cause.forall(c => event.throwable.isDefined && c.isInstance(event.throwable.get)) &&
+      mdc.forall { case (key, value) => event.mdc.contains(key) && event.mdc(key) == value } &&
+      custom.forall(f => f(event))
 
     // loggerName is handled when installing the filter, in `expect`
-  }
 
   private def messageOrEmpty(event: LoggingEvent): String =
     if (event.message == null) "" else event.message
 
   private def sourceOrEmpty(event: LoggingEvent): String =
     event.mdc.getOrElse("pekkoSource", "")
 
-  def apply(event: LoggingEvent): Boolean = {
+  def apply(event: LoggingEvent): Boolean =
     if (matches(event)) {
       if (todo != Int.MaxValue) todo -= 1
       true
     } else false
-  }
 
   private def awaitDone(max: Duration): Boolean = {
     if (todo != Int.MaxValue && todo > 0) TestKit.awaitCond(todo <= 0, max, noThrow = true)
     todo == Int.MaxValue || todo == 0
   }
 
-  private def awaitNoExcess(max: Duration): Boolean = {
+  private def awaitNoExcess(max: Duration): Boolean =
     if (todo == 0)
       !TestKit.awaitCond(todo < 0, max, noThrow = true)
     else
       todo > 0
-  }
 
   override def expect[T](code: => T)(implicit system: ActorSystem[_]): T = {
     val effectiveLoggerName = loggerName.getOrElse("")
@@ -127,11 +124,10 @@ import pekko.testkit.TestKit
   override def intercept[T](code: => T)(implicit system: ActorSystem[_]): T =
     expect(code)(system)
 
-  private def checkLogback(system: ActorSystem[_]): Unit = {
+  private def checkLogback(system: ActorSystem[_]): Unit =
     if (!system.dynamicAccess.classIsOnClasspath("ch.qos.logback.classic.spi.ILoggingEvent")) {
       throw new IllegalStateException("LoggingEventFilter requires logback-classic dependency in classpath.")
     }
-  }
 
   override def withOccurrences(newOccurrences: Int): LoggingTestKitImpl =
     copy(occurrences = newOccurrences)

actor-testkit-typed/src/main/scala/org/apache/pekko/actor/testkit/typed/internal/StubbedActorContext.scala

@@ -74,13 +74,11 @@ private[pekko] final class FunctionRef[-T](override val path: ActorPath, send: (
     currentBehaviorProvider: () => Behavior[T])
     extends ActorContextImpl[T] {
 
-  def this(system: ActorSystemStub, name: String, currentBehaviorProvider: () => Behavior[T]) = {
+  def this(system: ActorSystemStub, name: String, currentBehaviorProvider: () => Behavior[T]) =
     this(system, (system.path / name).withUid(rnd().nextInt()), currentBehaviorProvider)
-  }
 
-  def this(name: String, currentBehaviorProvider: () => Behavior[T]) = {
+  def this(name: String, currentBehaviorProvider: () => Behavior[T]) =
     this(new ActorSystemStub("StubbedActorContext"), name, currentBehaviorProvider)
-  }
 
   /**
    * INTERNAL API
@@ -141,21 +139,16 @@ private[pekko] final class FunctionRef[-T](override val path: ActorPath, send: (
       _children -= child.path.name
     }
   }
-  override def watch[U](other: ActorRef[U]): Unit = {
+  override def watch[U](other: ActorRef[U]): Unit =
     checkCurrentActorThread()
-  }
-  override def watchWith[U](other: ActorRef[U], message: T): Unit = {
+  override def watchWith[U](other: ActorRef[U], message: T): Unit =
     checkCurrentActorThread()
-  }
-  override def unwatch[U](other: ActorRef[U]): Unit = {
+  override def unwatch[U](other: ActorRef[U]): Unit =
     checkCurrentActorThread()
-  }
-  override def setReceiveTimeout(d: FiniteDuration, message: T): Unit = {
+  override def setReceiveTimeout(d: FiniteDuration, message: T): Unit =
     checkCurrentActorThread()
-  }
-  override def cancelReceiveTimeout(): Unit = {
+  override def cancelReceiveTimeout(): Unit =
     checkCurrentActorThread()
-  }
 
   override def scheduleOnce[U](delay: FiniteDuration, target: ActorRef[U], message: U): classic.Cancellable =
     new classic.Cancellable {
@@ -223,15 +216,13 @@ private[pekko] final class FunctionRef[-T](override val path: ActorPath, send: (
     logger
   }
 
-  override def setLoggerName(name: String): Unit = {
+  override def setLoggerName(name: String): Unit =
     // nop as we don't track logger
     checkCurrentActorThread()
-  }
 
-  override def setLoggerName(clazz: Class[_]): Unit = {
+  override def setLoggerName(clazz: Class[_]): Unit =
     // nop as we don't track logger
     checkCurrentActorThread()
-  }
 
   /**
    * The log entries logged through context.log.{debug, info, warn, error} are captured and can be inspected through
@@ -243,15 +234,13 @@ private[pekko] final class FunctionRef[-T](override val path: ActorPath, send: (
       .iterator()
       .asScala
       .map { evt =>
-        {
-          val marker: Option[Marker] = Option(evt.getMarkers).flatMap(_.asScala.headOption)
-          CapturedLogEvent(
-            level = evt.getLevel,
-            message = MessageFormatter.arrayFormat(evt.getMessage, evt.getArgumentArray).getMessage,
-            cause = Option(evt.getThrowable),
-            marker = marker)
+        val marker: Option[Marker] = Option(evt.getMarkers).flatMap(_.asScala.headOption)
+        CapturedLogEvent(
+          level = evt.getLevel,
+          message = MessageFormatter.arrayFormat(evt.getMessage, evt.getArgumentArray).getMessage,
+          cause = Option(evt.getThrowable),
+          marker = marker)
 
-        }
       }
       .toList
   }

actor-testkit-typed/src/main/scala/org/apache/pekko/actor/testkit/typed/internal/TestAppender.scala

@@ -103,14 +103,13 @@ import pekko.annotation.InternalApi
     filter(loggingEvent)
   }
 
-  private def filter(event: LoggingEvent): Boolean = {
+  private def filter(event: LoggingEvent): Boolean =
     filters.exists(f =>
-      try {
+      try
         f.apply(event)
-      } catch {
+      catch {
         case _: Exception => false
       })
-  }
 
   def addTestFilter(filter: LoggingTestKitImpl): Unit = synchronized {
     filters ::= filter