raboof/pekko
1
0
Fork 0
Code Issues Pull requests Projects Releases 6 Packages Wiki Activity Actions 10

fix warnings in akka-actor-tests

Browse source
This commit is contained in:
Roland Kuhn 2015-01-30 16:05:36 +01:00
parent 613f63b526
commit 15ebe8f082
9 changed files with 59 additions and 150 deletions
Download patch file Download diff file Expand all files Collapse all files

2
akka-actor-tests/src/test/scala/akka/TestUtils.scala
View file

@ -11,6 +11,8 @@ import java.nio.channels.{ DatagramChannel, ServerSocketChannel }
import akka.actor.{ ActorSystem, ActorRef }
import akka.testkit.TestProbe
import language.reflectiveCalls
object TestUtils {
// Structural type needed since DatagramSocket and ServerSocket has no common ancestor apart from Object

96
akka-actor-tests/src/test/scala/akka/actor/ActorFireForgetRequestReplySpec.scala
View file

@ -1,96 +0,0 @@
/**
* Copyright (C) 2009-2014 Typesafe Inc. <http://www.typesafe.com>
*/
package akka.actor
import akka.testkit._
import org.scalatest.BeforeAndAfterEach
import scala.concurrent.duration._
import scala.concurrent.Await
import akka.pattern.ask
object ActorFireForgetRequestReplySpec {
class ReplyActor extends Actor {
def receive = {
case "Send" ⇒
sender() ! "Reply"
case "SendImplicit" ⇒
sender() ! "ReplyImplicit"
}
}
class CrashingActor extends Actor {
import context.system
def receive = {
case "Die" ⇒
state.finished.await
throw new Exception("Expected exception")
}
}
class SenderActor(replyActor: ActorRef) extends Actor {
import context.system
def receive = {
case "Init" ⇒
replyActor ! "Send"
case "Reply" ⇒ {
state.s = "Reply"
state.finished.await
}
case "InitImplicit" ⇒ replyActor ! "SendImplicit"
case "ReplyImplicit" ⇒ {
state.s = "ReplyImplicit"
state.finished.await
}
}
}
object state {
var s = "NIL"
val finished = TestBarrier(2)
}
}
@org.junit.runner.RunWith(classOf[org.scalatest.junit.JUnitRunner])
class ActorFireForgetRequestReplySpec extends AkkaSpec with BeforeAndAfterEach with DefaultTimeout {
import ActorFireForgetRequestReplySpec._
override def beforeEach() = {
state.finished.reset
}
"An Actor" must {
"reply to bang message using reply" in {
val replyActor = system.actorOf(Props[ReplyActor])
val senderActor = system.actorOf(Props(new SenderActor(replyActor)))
senderActor ! "Init"
state.finished.await
state.s should be("Reply")
}
"reply to bang message using implicit sender" in {
val replyActor = system.actorOf(Props[ReplyActor])
val senderActor = system.actorOf(Props(new SenderActor(replyActor)))
senderActor ! "InitImplicit"
state.finished.await
state.s should be("ReplyImplicit")
}
"shutdown crashed temporary actor" in {
filterEvents(EventFilter[Exception]("Expected exception")) {
val supervisor = system.actorOf(Props(new Supervisor(
OneForOneStrategy(maxNrOfRetries = 0)(List(classOf[Exception])))))
val actor = Await.result((supervisor ? Props[CrashingActor]).mapTo[ActorRef], timeout.duration)
actor.isTerminated should be(false)
actor ! "Die"
state.finished.await
Thread.sleep(1.second.dilated.toMillis)
actor.isTerminated should be(true)
system.stop(supervisor)
}
}
}
}

8
akka-actor-tests/src/test/scala/akka/actor/ActorMailboxSpec.scala
View file

@ -15,7 +15,7 @@ import java.util.concurrent.TimeUnit
import akka.util.Helpers.ConfigOps
object ActorMailboxSpec {
val mailboxConf = ConfigFactory.parseString("""
val mailboxConf = ConfigFactory.parseString(s"""
unbounded-dispatcher {
mailbox-type = "akka.dispatch.UnboundedMailbox"
}
@ -46,7 +46,7 @@ object ActorMailboxSpec {
requiring-balancing-bounded-dispatcher {
type = "akka.dispatch.BalancingDispatcherConfigurator"
mailbox-requirement = "akka.actor.ActorMailboxSpec$MCBoundedMessageQueueSemantics"
mailbox-requirement = "akka.actor.ActorMailboxSpec$$MCBoundedMessageQueueSemantics"
}
unbounded-mailbox {
@ -68,7 +68,7 @@ object ActorMailboxSpec {
mc-bounded-mailbox {
mailbox-capacity = 1000
mailbox-push-timeout-time = 10s
mailbox-type = "akka.actor.ActorMailboxSpec$MCBoundedMailbox"
mailbox-type = "akka.actor.ActorMailboxSpec$$MCBoundedMailbox"
}
akka.actor.deployment {
@ -142,7 +142,7 @@ object ActorMailboxSpec {
}
akka.actor.mailbox.requirements {
"akka.actor.ActorMailboxSpec$MCBoundedMessageQueueSemantics" =
"akka.actor.ActorMailboxSpec$$MCBoundedMessageQueueSemantics" =
mc-bounded-mailbox
}
""")

8
akka-actor-tests/src/test/scala/akka/actor/UidClashTest.scala
View file

@ -16,12 +16,12 @@ object UidClashTest {
@volatile var oldActor: ActorRef = _
class EvilCollidingActorRef(override val provider: ActorRefProvider,
override val path: ActorPath,
val eventStream: EventStream) extends MinimalActorRef {
private[akka] class EvilCollidingActorRef(override val provider: ActorRefProvider,
override val path: ActorPath,
val eventStream: EventStream) extends MinimalActorRef {
//Ignore everything
override def isTerminated(): Boolean = true
override def isTerminated: Boolean = true
override def sendSystemMessage(message: SystemMessage): Unit = ()
override def !(message: Any)(implicit sender: ActorRef = Actor.noSender): Unit = ()
}

62
akka-actor-tests/src/test/scala/akka/dispatch/FutureSpec.scala
View file

@ -51,6 +51,27 @@ object FutureSpec {
final case class Req[T](req: T)
final case class Res[T](res: T)
sealed trait IntAction { def apply(that: Int): Int }
final case class IntAdd(n: Int) extends IntAction { def apply(that: Int) = that + n }
final case class IntSub(n: Int) extends IntAction { def apply(that: Int) = that - n }
final case class IntMul(n: Int) extends IntAction { def apply(that: Int) = that * n }
final case class IntDiv(n: Int) extends IntAction { def apply(that: Int) = that / n }
sealed trait FutureAction {
def /:(that: Try[Int]): Try[Int]
def /:(that: Future[Int]): Future[Int]
}
final case class MapAction(action: IntAction)(implicit ec: ExecutionContext) extends FutureAction {
def /:(that: Try[Int]): Try[Int] = that map action.apply
def /:(that: Future[Int]): Future[Int] = that map action.apply
}
final case class FlatMapAction(action: IntAction)(implicit ec: ExecutionContext) extends FutureAction {
def /:(that: Try[Int]): Try[Int] = that map action.apply
def /:(that: Future[Int]): Future[Int] = that flatMap (n ⇒ Future.successful(action(n)))
}
}
class JavaFutureSpec extends JavaFutureTests with JUnitSuiteLike
@ -628,7 +649,7 @@ class FutureSpec extends AkkaSpec with Checkers with BeforeAndAfterAll with Defa
"filter result" in {
f { (future, result) ⇒
Await.result((future filter (_ ⇒ true)), timeout.duration) should be(result)
evaluating { Await.result((future filter (_ ⇒ false)), timeout.duration) } should produce[java.util.NoSuchElementException]
intercept[java.util.NoSuchElementException] { Await.result((future filter (_ ⇒ false)), timeout.duration) }
}
}
"transform result with map" in { f((future, result) ⇒ Await.result((future map (_.toString.length)), timeout.duration) should be(result.toString.length)) }
@ -648,7 +669,7 @@ class FutureSpec extends AkkaSpec with Checkers with BeforeAndAfterAll with Defa
"zip properly" in {
f { (future, result) ⇒
Await.result(future zip Promise.successful("foo").future, timeout.duration) should be((result, "foo"))
(evaluating { Await.result(future zip Promise.failed(new RuntimeException("ohnoes")).future, timeout.duration) } should produce[RuntimeException]).getMessage should be("ohnoes")
(intercept[RuntimeException] { Await.result(future zip Promise.failed(new RuntimeException("ohnoes")).future, timeout.duration) }).getMessage should be("ohnoes")
}
}
"not recover from exception" in { f((future, result) ⇒ Await.result(future.recover({ case _ ⇒ "pigdog" }), timeout.duration) should be(result)) }
@ -659,7 +680,7 @@ class FutureSpec extends AkkaSpec with Checkers with BeforeAndAfterAll with Defa
Await.result(p.future, timeout.duration) should be(result)
}
}
"not project a failure" in { f((future, result) ⇒ (evaluating { Await.result(future.failed, timeout.duration) } should produce[NoSuchElementException]).getMessage should be("Future.failed not completed with a throwable.")) }
"not project a failure" in { f((future, result) ⇒ (intercept[NoSuchElementException] { Await.result(future.failed, timeout.duration) }).getMessage should be("Future.failed not completed with a throwable.")) }
"not perform action on exception" is pending
"cast using mapTo" in { f((future, result) ⇒ Await.result(future.mapTo[Boolean].recover({ case _: ClassCastException ⇒ false }), timeout.duration) should be(false)) }
}
@ -674,20 +695,20 @@ class FutureSpec extends AkkaSpec with Checkers with BeforeAndAfterAll with Defa
f.getMessage should be(message)
})
}
"throw exception with 'get'" in { f((future, message) ⇒ (evaluating { Await.result(future, timeout.duration) } should produce[java.lang.Exception]).getMessage should be(message)) }
"throw exception with 'Await.result'" in { f((future, message) ⇒ (evaluating { Await.result(future, timeout.duration) } should produce[java.lang.Exception]).getMessage should be(message)) }
"throw exception with 'get'" in { f((future, message) ⇒ (intercept[java.lang.Exception] { Await.result(future, timeout.duration) }).getMessage should be(message)) }
"throw exception with 'Await.result'" in { f((future, message) ⇒ (intercept[java.lang.Exception] { Await.result(future, timeout.duration) }).getMessage should be(message)) }
"retain exception with filter" in {
f { (future, message) ⇒
(evaluating { Await.result(future filter (_ ⇒ true), timeout.duration) } should produce[java.lang.Exception]).getMessage should be(message)
(evaluating { Await.result(future filter (_ ⇒ false), timeout.duration) } should produce[java.lang.Exception]).getMessage should be(message)
(intercept[java.lang.Exception] { Await.result(future filter (_ ⇒ true), timeout.duration) }).getMessage should be(message)
(intercept[java.lang.Exception] { Await.result(future filter (_ ⇒ false), timeout.duration) }).getMessage should be(message)
}
}
"retain exception with map" in { f((future, message) ⇒ (evaluating { Await.result(future map (_.toString.length), timeout.duration) } should produce[java.lang.Exception]).getMessage should be(message)) }
"retain exception with flatMap" in { f((future, message) ⇒ (evaluating { Await.result(future flatMap (_ ⇒ Promise.successful[Any]("foo").future), timeout.duration) } should produce[java.lang.Exception]).getMessage should be(message)) }
"retain exception with map" in { f((future, message) ⇒ (intercept[java.lang.Exception] { Await.result(future map (_.toString.length), timeout.duration) }).getMessage should be(message)) }
"retain exception with flatMap" in { f((future, message) ⇒ (intercept[java.lang.Exception] { Await.result(future flatMap (_ ⇒ Promise.successful[Any]("foo").future), timeout.duration) }).getMessage should be(message)) }
"not perform action with foreach" is pending
"zip properly" in {
f { (future, message) ⇒ (evaluating { Await.result(future zip Promise.successful("foo").future, timeout.duration) } should produce[java.lang.Exception]).getMessage should be(message) }
f { (future, message) ⇒ (intercept[java.lang.Exception] { Await.result(future zip Promise.successful("foo").future, timeout.duration) }).getMessage should be(message) }
}
"recover from exception" in { f((future, message) ⇒ Await.result(future.recover({ case e if e.getMessage == message ⇒ "pigdog" }), timeout.duration) should be("pigdog")) }
"not perform action on result" is pending
@ -702,27 +723,6 @@ class FutureSpec extends AkkaSpec with Checkers with BeforeAndAfterAll with Defa
"always cast successfully using mapTo" in { f((future, message) ⇒ (evaluating { Await.result(future.mapTo[java.lang.Thread], timeout.duration) } should produce[java.lang.Exception]).getMessage should be(message)) }
}
sealed trait IntAction { def apply(that: Int): Int }
final case class IntAdd(n: Int) extends IntAction { def apply(that: Int) = that + n }
final case class IntSub(n: Int) extends IntAction { def apply(that: Int) = that - n }
final case class IntMul(n: Int) extends IntAction { def apply(that: Int) = that * n }
final case class IntDiv(n: Int) extends IntAction { def apply(that: Int) = that / n }
sealed trait FutureAction {
def /:(that: Try[Int]): Try[Int]
def /:(that: Future[Int]): Future[Int]
}
final case class MapAction(action: IntAction) extends FutureAction {
def /:(that: Try[Int]): Try[Int] = that map action.apply
def /:(that: Future[Int]): Future[Int] = that map action.apply
}
final case class FlatMapAction(action: IntAction) extends FutureAction {
def /:(that: Try[Int]): Try[Int] = that map action.apply
def /:(that: Future[Int]): Future[Int] = that flatMap (n ⇒ Future.successful(action(n)))
}
implicit def arbFuture: Arbitrary[Future[Int]] = Arbitrary(for (n ← arbitrary[Int]) yield Future(n))
implicit def arbFutureAction: Arbitrary[FutureAction] = Arbitrary {

12
akka-actor-tests/src/test/scala/akka/event/EventStreamSpec.scala
View file

@ -56,9 +56,9 @@ object EventStreamSpec {
// class hierarchy for subchannel test
class A
class B1 extends A
class B2 extends A
class C extends B1
class B3 extends A
class C extends B2
trait T
trait AT extends T
@ -137,12 +137,12 @@ class EventStreamSpec extends AkkaSpec(EventStreamSpec.config) {
"manage sub-channels using classes" in {
val a = new A
val b1 = new B1
val b2 = new B2
val b1 = new B2
val b2 = new B3
val c = new C
val bus = new EventStream(system, false)
within(2 seconds) {
bus.subscribe(testActor, classOf[B2]) should be(true)
bus.subscribe(testActor, classOf[B3]) should be(true)
bus.publish(c)
bus.publish(b2)
expectMsg(b2)
@ -151,7 +151,7 @@ class EventStreamSpec extends AkkaSpec(EventStreamSpec.config) {
expectMsg(c)
bus.publish(b1)
expectMsg(b1)
bus.unsubscribe(testActor, classOf[B1]) should be(true)
bus.unsubscribe(testActor, classOf[B2]) should be(true)
bus.publish(c)
bus.publish(b2)
bus.publish(a)

5
akka-actor-tests/src/test/scala/akka/event/LoggerSpec.scala
View file

@ -97,9 +97,10 @@ object LoggerSpec {
override def mdc(currentMessage: Any): MDC = {
reqId += 1
val always = Map("requestId" -> reqId)
val cmim = "Current Message in MDC"
val perMessage = currentMessage match {
case cm @ "Current Message in MDC" ⇒ Map("currentMsg" -> cm, "currentMsgLength" -> cm.length)
case _ ⇒ Map()
case `cmim` ⇒ Map[String, Any]("currentMsg" -> cmim, "currentMsgLength" -> cmim.length)
case _ ⇒ Map()
}
always ++ perMessage
}

14
akka-actor-tests/src/test/scala/akka/serialization/SerializeSpec.scala
View file

@ -20,7 +20,7 @@ import org.apache.commons.codec.binary.Hex.encodeHex
object SerializationTests {
val serializeConf = """
val serializeConf = s"""
akka {
actor {
serialize-messages = off
@ -29,13 +29,13 @@ object SerializationTests {
}
serialization-bindings {
"akka.serialization.SerializationTests$Person" = java
"akka.serialization.SerializationTests$Address" = java
"akka.serialization.SerializationTests$$Person" = java
"akka.serialization.SerializationTests$$Address" = java
"akka.serialization.TestSerializable" = test
"akka.serialization.SerializationTests$PlainMessage" = test
"akka.serialization.SerializationTests$A" = java
"akka.serialization.SerializationTests$B" = test
"akka.serialization.SerializationTests$D" = test
"akka.serialization.SerializationTests$$PlainMessage" = test
"akka.serialization.SerializationTests$$A" = java
"akka.serialization.SerializationTests$$B" = test
"akka.serialization.SerializationTests$$D" = test
}
}
}

2
project/AkkaBuild.scala
View file

@ -294,6 +294,8 @@ object AkkaBuild extends Build {
// compile options
scalacOptions in Compile ++= Seq("-encoding", "UTF-8", "-target:jvm-1.6", "-feature", "-unchecked", "-Xlog-reflective-calls", "-Xlint"),
scalacOptions in Compile ++= (if (deprecation) Seq("-deprecation") else Nil),
scalacOptions in Test := (scalacOptions in Test).value.filterNot(_ == "-Xlog-reflective-calls"),
// -XDignore.symbol.file suppresses sun.misc.Unsafe warnings
javacOptions in compile ++= Seq("-encoding", "UTF-8", "-source", "1.6", "-target", "1.6", "-Xlint:unchecked", "-XDignore.symbol.file"),
javacOptions in compile ++= (if (deprecation) Seq("-Xlint:deprecation") else Nil),
javacOptions in doc ++= Seq("-encoding", "UTF-8", "-source", "1.6"),