119 lines
No EOL
3 KiB
Scala
119 lines
No EOL
3 KiB
Scala
package se.scalablesolutions.akka.patterns
|
|
|
|
import java.util.concurrent.atomic.AtomicInteger
|
|
import se.scalablesolutions.akka.config.ScalaConfig._
|
|
import se.scalablesolutions.akka.actor.Actor
|
|
import se.scalablesolutions.akka.actor.Actor._
|
|
import se.scalablesolutions.akka.util.Logging
|
|
|
|
import org.scalatest.Suite
|
|
import org.junit.runner.RunWith
|
|
import org.scalatest.junit.JUnitRunner
|
|
import org.scalatest.matchers.MustMatchers
|
|
import org.junit.{Before, After, Test}
|
|
import scala.collection.mutable.HashSet
|
|
import java.util.concurrent.{ CountDownLatch, TimeUnit }
|
|
|
|
@RunWith(classOf[JUnitRunner])
|
|
class ActorPatternsTest extends junit.framework.TestCase with Suite with MustMatchers with Logging {
|
|
import Patterns._
|
|
@Test def testDispatcher = {
|
|
val (testMsg1,testMsg2,testMsg3,testMsg4) = ("test1","test2","test3","test4")
|
|
val latch = new CountDownLatch(1)
|
|
var targetOk = 0
|
|
val t1 = actor {
|
|
case `testMsg1` => targetOk += 2
|
|
case `testMsg2` => targetOk += 4
|
|
}
|
|
|
|
val t2 = actor {
|
|
case `testMsg3` =>
|
|
targetOk += 8
|
|
latch.countDown
|
|
}
|
|
|
|
val d = dispatcherActor {
|
|
case `testMsg1`|`testMsg2` => t1
|
|
case `testMsg3` => t2
|
|
}.start
|
|
|
|
d ! testMsg1
|
|
d ! testMsg2
|
|
d ! testMsg3
|
|
val done = latch.await(5,TimeUnit.SECONDS)
|
|
done must be (true)
|
|
targetOk must be(14)
|
|
t1.stop
|
|
t2.stop
|
|
d.stop
|
|
}
|
|
|
|
@Test def testLogger = {
|
|
val msgs = new HashSet[Any]
|
|
val t1 = actor {
|
|
case _ =>
|
|
}
|
|
val l = loggerActor(t1,(x) => msgs += x).start
|
|
val foo : Any = "foo"
|
|
val bar : Any = "bar"
|
|
l ! foo
|
|
l ! bar
|
|
msgs must ( have size (2) and contain (foo) and contain (bar) )
|
|
t1.stop
|
|
l.stop
|
|
}
|
|
|
|
@Test def testSmallestMailboxFirstDispatcher = {
|
|
val t1ProcessedCount = new AtomicInteger(0)
|
|
val t1 = actor {
|
|
case x =>
|
|
Thread.sleep(50) // slow actor
|
|
t1ProcessedCount.incrementAndGet
|
|
}
|
|
|
|
val t2ProcessedCount = new AtomicInteger(0)
|
|
val t2 = actor {
|
|
case x => t2ProcessedCount.incrementAndGet
|
|
}
|
|
val d = loadBalancerActor(new SmallestMailboxFirstIterator(t1 :: t2 :: Nil))
|
|
for (i <- 1 to 500) d ! i
|
|
Thread.sleep(6000)
|
|
t1ProcessedCount.get must be < (t2ProcessedCount.get) // because t1 is much slower and thus has a bigger mailbox all the time
|
|
t1.stop
|
|
t2.stop
|
|
d.stop
|
|
}
|
|
|
|
@Test def testListener = {
|
|
val latch = new CountDownLatch(2)
|
|
val num = new AtomicInteger(0)
|
|
val i = actorOf(new Actor with Listeners {
|
|
def receive = listenerManagement orElse {
|
|
case "foo" => gossip("bar")
|
|
}
|
|
})
|
|
i.start
|
|
|
|
def newListener = actor {
|
|
case "bar" =>
|
|
num.incrementAndGet
|
|
latch.countDown
|
|
}
|
|
|
|
val a1 = newListener
|
|
val a2 = newListener
|
|
val a3 = newListener
|
|
|
|
i ! Listen(a1)
|
|
i ! Listen(a2)
|
|
i ! Listen(a3)
|
|
i ! Deafen(a3)
|
|
|
|
i ! "foo"
|
|
|
|
val done = latch.await(5,TimeUnit.SECONDS)
|
|
done must be (true)
|
|
num.get must be (2)
|
|
i.stop
|
|
}
|
|
} |