Package akka.testkit

Class ExplicitlyTriggeredScheduler

  • All Implemented Interfaces:
    Scheduler

    public class ExplicitlyTriggeredScheduler
    extends java.lang.Object
    implements Scheduler
    For testing: scheduler that does not look at the clock, but must be progressed manually by calling timePasses.

    This allows for faster and less timing-sensitive specs, as jobs will be executed on the test thread instead of using the original {ExecutionContext}. This means recreating specific scenario's becomes easier, but these tests might fail to catch race conditions that only happen when tasks are scheduled in parallel in 'real time'.

    • Method Summary

      All Methods Instance Methods Concrete Methods 
      Modifier and Type Method Description
      void executeTasks​(long runTo)  
      double maxFrequency()
      The maximum supported task frequency of this scheduler, i.e.
      Cancellable schedule​(scala.concurrent.duration.FiniteDuration initialDelay, scala.concurrent.duration.FiniteDuration interval, java.lang.Runnable runnable, scala.concurrent.ExecutionContext executor)
      Schedules a Runnable to be run repeatedly with an initial delay and a frequency.
      Cancellable scheduleOnce​(scala.concurrent.duration.FiniteDuration delay, java.lang.Runnable runnable, scala.concurrent.ExecutionContext executor)
      Schedules a Runnable to be run once with a delay, i.e.
      void timePasses​(scala.concurrent.duration.FiniteDuration amount)
      Advance the clock by the specified duration, executing all outstanding jobs on the calling thread before returning.
      • Methods inherited from class java.lang.Object

        clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
    • Constructor Detail

      • ExplicitlyTriggeredScheduler

        public ExplicitlyTriggeredScheduler​(com.typesafe.config.Config config,
                                            LoggingAdapter log,
                                            java.util.concurrent.ThreadFactory tf)
    • Method Detail

      • executeTasks

        public final void executeTasks​(long runTo)
      • maxFrequency

        public double maxFrequency()
        Description copied from interface: Scheduler
        The maximum supported task frequency of this scheduler, i.e. the inverse of the minimum time interval between executions of a recurring task, in Hz.
        Specified by:
        maxFrequency in interface Scheduler
        Returns:
        (undocumented)
      • schedule

        public Cancellable schedule​(scala.concurrent.duration.FiniteDuration initialDelay,
                                    scala.concurrent.duration.FiniteDuration interval,
                                    java.lang.Runnable runnable,
                                    scala.concurrent.ExecutionContext executor)
        Description copied from interface: Scheduler
        Schedules a Runnable to be run repeatedly with an initial delay and a frequency. E.g. if you would like the function to be run after 2 seconds and thereafter every 100ms you would set delay = Duration(2, TimeUnit.SECONDS) and interval = Duration(100, TimeUnit.MILLISECONDS). If the execution of the runnable takes longer than the interval, the subsequent execution will start immediately after the prior one completes (there will be no overlap of executions of the runnable). In such cases, the actual execution interval will differ from the interval passed to this method.

        If the Runnable throws an exception the repeated scheduling is aborted, i.e. the function will not be invoked any more.

        Specified by:
        schedule in interface Scheduler
        Parameters:
        initialDelay - (undocumented)
        interval - (undocumented)
        runnable - (undocumented)
        executor - (undocumented)
        Returns:
        (undocumented)
      • scheduleOnce

        public Cancellable scheduleOnce​(scala.concurrent.duration.FiniteDuration delay,
                                        java.lang.Runnable runnable,
                                        scala.concurrent.ExecutionContext executor)
        Description copied from interface: Scheduler
        Schedules a Runnable to be run once with a delay, i.e. a time period that has to pass before the runnable is executed.

        Specified by:
        scheduleOnce in interface Scheduler
        Parameters:
        delay - (undocumented)
        runnable - (undocumented)
        executor - (undocumented)
        Returns:
        (undocumented)
      • timePasses

        public void timePasses​(scala.concurrent.duration.FiniteDuration amount)
        Advance the clock by the specified duration, executing all outstanding jobs on the calling thread before returning.

        We will not add a dilation factor to this amount, since the scheduler API also does not apply dilation. If you want the amount of time passed to be dilated, apply the dilation before passing the delay to this method.

        Parameters:
        amount - (undocumented)