Java IncrementalTask类代码示例

import org.waveprotocol.wave.client.scheduler.Scheduler.IncrementalTask; //导入依赖的package包/类
/**
 * A task that is to be run at the specified time, and then repeatedly each
 * time the specified interval has passed.
 *
 * @param time earliest time when the task should run
 * @param task The task to run
 * @param interval delay before the next time the task is to be run. Must be
 *        {@literal >= 0}. If {@link IncrementalTask#execute()} returns
 *        false, the task is not rerun again; Clients of this class must make
 *        sure that this eventually happens for tasks with an interval 0, as
 *        otherwise {@link FakeTimerService#tick(int)} will repeat the task
 *        indefinitely and never return.
 * @throws IllegalArgumentException if time or interval < 0
 */
TimedTask(int time, IncrementalTask task, int interval) {
  this.task = task;
  this.time = time;
  this.interval = interval;
  if (task == null) {
    throw new NullPointerException("null task");
  }
  if (time < 0) {
    throw new IllegalArgumentException("Expected time >= 0, got " + time);
  }
  if (interval < 0) {
    throw new IllegalArgumentException("Expected interval >= 0, got " + interval);
  }
  this.instanceNumber = instanceCount++;
}
 

import org.waveprotocol.wave.client.scheduler.Scheduler.IncrementalTask; //导入依赖的package包/类
/** Tests that multiple processes can be run at the same time. */
public void testMultipleProcessesAtSameTime() {
  final int time = 100;
  final IncrementalTask anotherTask = mock(IncrementalTask.class, "anotherTask");
  timer.scheduleRepeating(repeating, 0, time);
  timer.scheduleRepeating(anotherTask, time, time);

  checking(new Expectations() {{
    one(repeating).execute();
    will(returnValue(true));
  }});
  timer.tick(0);

  checking(new Expectations() {{
    one(repeating).execute();
    will(returnValue(true));
    one(anotherTask).execute();
    will(returnValue(true));
  }});
  timer.tick(time);
}
 

import org.waveprotocol.wave.client.scheduler.Scheduler.IncrementalTask; //导入依赖的package包/类
public void testCancellingAnIncrementalTaskDuringExecutionIgnoresContinueValue() {
  IncrementalTask mock = new IncrementalTask() {
    boolean cancelled;
    @Override
    public boolean execute() {
      if (cancelled) {
        fail("Cancelled task was not removed from scheduler");
      }
      scheduler.cancel(this);
      cancelled = true;
      return true;
    }
  };

  scheduler.scheduleRepeating(Priority.LOW, mock, 0, 50);
  providedTimer.trigger();
  for (int i = 0; i < 50; i++) {
    providedTimer.trigger(1);
  }
  assertEmpty(true);
}
 

import org.waveprotocol.wave.client.scheduler.Scheduler.IncrementalTask; //导入依赖的package包/类
public void testRepeatingJobs() {

    final int[] intervals = new int[] { 30, 40, 70 };

    for (int i : intervals) {
      Scheduler.IncrementalTask p = new IntervalProcess(0, i);
      scheduler.scheduleRepeating(Priority.LOW, p, 0, i);
    }

    assertEmpty(false);

    for (int i = 0; i < 500; i++) {
      providedTimer.trigger();
      providedTimer.tick(1);
    }
  }
 

import org.waveprotocol.wave.client.scheduler.Scheduler.IncrementalTask; //导入依赖的package包/类
/**
 * Tests that when there are several tasks with interval 0 running at the same time,
 * all of them are executed once before the first one is executed again.
 */
public void testTasksRepeatedlyRunningAtSameTimeAreScheduledFairly() {
  int taskCount = 10;
  final IncrementalTask[] tasks = new IncrementalTask[taskCount];
  for (int i = 0; i < taskCount; i++) {
    tasks[i] = mock(IncrementalTask.class, "repeating_" + i);
    if (i==0) {
      when(tasks[i].execute()).thenReturn(true, false);
    } else {
      when(tasks[i].execute()).thenReturn(false);
    }
    timer.scheduleRepeating(tasks[i], 1, 0);
  }

  InOrder inOrder = inOrder((Object[]) tasks);

  timer.tick(1);

  for (int i = 0; i < taskCount; i++) {
    inOrder.verify(tasks[i]).execute();
  }
  inOrder.verify(tasks[0]).execute();

  verify(tasks[0], times(2)).execute();
}
 

import org.waveprotocol.wave.client.scheduler.Scheduler.IncrementalTask; //导入依赖的package包/类
public IdempotentScheduler build(IncrementalTask task) {
  Preconditions.checkNotNull(task, "task must not be null");

  // NOTE(user): this must be lazily created to avoid test dependency on SchedulerInstance.
  if (timer == null) {
    timer = SchedulerInstance.getLowPriorityTimer();
  }
  return new IdempotentScheduler(timer, task, recorder, interval);
}
 

import org.waveprotocol.wave.client.scheduler.Scheduler.IncrementalTask; //导入依赖的package包/类
private IdempotentScheduler(TimerService scheduler, IncrementalTask task,
    EfficiencyRecorder recorder, int interval) {
  this.scheduler = scheduler;
  this.task = task;
  this.recorder = recorder;
  this.interval = interval;
}
 

import org.waveprotocol.wave.client.scheduler.Scheduler.IncrementalTask; //导入依赖的package包/类
@Override
protected void setUp() {
  task = mock(IncrementalTask.class);
  timer = mock(TimerService.class);
  delay = 50;

  is = IdempotentScheduler.builder().with(timer).with(delay).build(task);
}
 

import org.waveprotocol.wave.client.scheduler.Scheduler.IncrementalTask; //导入依赖的package包/类
/**
 * Advances specified millis, running all tasks in between.
 *
 * @param millisToAdvance Number of milliseconds to advance the timer.
 */
public void tick(int millisToAdvance) {
  currentTime += millisToAdvance;
  while (!tasks.isEmpty() && tasks.peek().getTime() <= currentTime) {
    TimedTask timedTask = tasks.poll();
    IncrementalTask task = timedTask.getTask();
    boolean doReschedule = task.execute();
    if (doReschedule) {
      // Note: If the next execution is at or before currentTime, the task
      // will be re-executed before this tick() call returns.
      tasks.add(timedTask.nextExecution());
    }
  }
}
 

import org.waveprotocol.wave.client.scheduler.Scheduler.IncrementalTask; //导入依赖的package包/类
@Override
protected void setUp() throws Exception {
  super.setUp();

  oneoff = mock(Task.class, "oneoff");
  repeating = mock(IncrementalTask.class, "repeating");
  timer = new FakeTimerService();
}
 

import org.waveprotocol.wave.client.scheduler.Scheduler.IncrementalTask; //导入依赖的package包/类
public void testRepeatingJob() {
  Scheduler.IncrementalTask p = new IntervalProcess(0, 50);
  scheduler.scheduleRepeating(Priority.LOW, p, 0, 50);

  providedTimer.trigger();
  for (int i = 0; i < 200; i++) {
    providedTimer.trigger(1);
  }

  assertEmpty(false);

  scheduler.cancel(p);

  assertEmpty(true);
}
 

import org.waveprotocol.wave.client.scheduler.Scheduler.IncrementalTask; //导入依赖的package包/类
public void testCoincidingRepeatingJobs() {
  for (int i = 0; i < 10; i++) {
    Scheduler.IncrementalTask p = new IntervalProcess(0, 50);
    scheduler.scheduleRepeating(Priority.LOW, p, 0, 50);
  }

  providedTimer.trigger();
  while (providedTimer.getTime() < 200) {
    providedTimer.trigger(1);
  }

  assertEmpty(false);
}
 

import org.waveprotocol.wave.client.scheduler.Scheduler.IncrementalTask; //导入依赖的package包/类
@Override
protected void setUp() throws Exception {
  super.setUp();

  oneoff = mock(Task.class, "oneoff");
  repeating = mock(IncrementalTask.class, "repeating");
  when(repeating.execute()).thenReturn(true);
  timer = new FakeTimerService();
}
 

import org.waveprotocol.wave.client.scheduler.Scheduler.IncrementalTask; //导入依赖的package包/类
/** Tests that multiple processes can be run at the same time. */
public void testMultipleProcessesAtSameTime() {
  final int time = 100;
  final IncrementalTask anotherTask = mock(IncrementalTask.class, "anotherTask");
  timer.scheduleRepeating(repeating, 0, time);
  timer.scheduleRepeating(anotherTask, time, time);

  timer.tick(0);
  verify(repeating, times(1)).execute();

  timer.tick(time);
  verify(repeating, times(2)).execute();
  verify(anotherTask, times(1)).execute();
}
 

import org.waveprotocol.wave.client.scheduler.Scheduler.IncrementalTask; //导入依赖的package包/类
@Override
public void schedule(IncrementalTask process) {
  throw new AssertionError("Not implemented");
}