user/test/com/google/gwt/core/client/testing/StubSchedulerTest.java

/*
 * Copyright 2013 Google Inc.
 *
 * Licensed under the Apache License, Version 2.0 (the "License"); you may not
 * use this file except in compliance with the License. You may obtain a copy of
 * the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
 * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
 * License for the specific language governing permissions and limitations under
 * the License.
 */

package com.google.gwt.core.client.testing;

import com.google.gwt.core.client.GWT;
import com.google.gwt.core.client.Scheduler.RepeatingCommand;
import com.google.gwt.core.client.Scheduler.ScheduledCommand;

import junit.framework.TestCase;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

import javax.annotation.Nullable;

/**
 * Tests for {@link StubScheduler}.
 */
public class StubSchedulerTest extends TestCase {

  private StubScheduler scheduler;
  private List<String> events;
  private List<String> thrownExceptionMessages;

  @Override
  protected void setUp() throws Exception {
    super.setUp();
    scheduler = new StubScheduler();
    events = new ArrayList<String>();
    thrownExceptionMessages = new ArrayList<String>();
    GWT.setUncaughtExceptionHandler(new GWT.UncaughtExceptionHandler() {
      @Override public void onUncaughtException(Throwable throwable) {
        if (throwable.getMessage().contains("Fake failure")) {
          thrownExceptionMessages.add(throwable.getMessage());
        } else {
          fail(throwable.getMessage());
        }
      }
    });
  }

  @Override
  protected void tearDown() throws Exception {
    GWT.setUncaughtExceptionHandler(null);
    checkEvents();
    checkThrownExceptionMessages();
    super.tearDown();
  }

  public void testMixedCommands() {
    scheduler.scheduleEntry(new FakeRepeatingCommand("repeating", 2, "repeating child"));
    scheduler.scheduleDeferred(new FakeScheduledCommand("scheduled", "scheduled child"));
    checkEvents();

    assertTrue(scheduler.executeCommands());
    checkEvents("repeating", "scheduled");

    assertTrue(scheduler.executeCommands());
    checkEvents("repeating child", "repeating", "scheduled child");

    assertTrue(scheduler.executeCommands());
    checkEvents("repeating child", "repeating child");

    assertFalse(scheduler.executeCommands());
    checkEvents("repeating child");

    checkCommands(scheduler.getRepeatingCommands());
    checkCommands(scheduler.getScheduledCommands());
  }

  public void testExceptions() {
    scheduler.scheduleEntry(new FakeRepeatingCommand("repeating ok", 1, null));
    scheduler.scheduleEntry(new FakeRepeatingCommand("repeating failing", 2, null));
    scheduler.scheduleDeferred(new FakeScheduledCommand("scheduled failing", null));
    scheduler.scheduleDeferred(new FakeScheduledCommand("scheduled ok", null));

    assertFalse(scheduler.executeCommands());

    checkEvents("repeating ok", "repeating failing", "scheduled failing", "scheduled ok");
    checkThrownExceptionMessages(
        "Fake failure: repeating failing",
        "Fake failure: scheduled failing");
  }

  public void testRepeatingCommands() {
    scheduler.scheduleEntry(new FakeRepeatingCommand("entry1", 1, null));
    scheduler.scheduleFinally(new FakeRepeatingCommand("finally1", 2, null));
    scheduler.scheduleFixedDelay(new FakeRepeatingCommand("delay1", 1, null), 42);
    scheduler.scheduleFixedPeriod(new FakeRepeatingCommand("period1", 2, "period1 child"), 42);
    scheduler.scheduleIncremental(new FakeRepeatingCommand("incremental1", 1, null));

    scheduler.scheduleEntry(new FakeRepeatingCommand("entry2", 2, null));
    scheduler.scheduleFinally(new FakeRepeatingCommand("finally2", 1, "finally2 child"));
    scheduler.scheduleFixedDelay(new FakeRepeatingCommand("delay2", 2, null), 42);
    scheduler.scheduleFixedPeriod(new FakeRepeatingCommand("period2", 1, null), 42);
    scheduler.scheduleIncremental(new FakeRepeatingCommand("incremental2", 2, null));

    scheduler.scheduleDeferred(new FakeScheduledCommand("scheduled", null)); // ignored
    checkEvents();

    checkCommands(scheduler.getRepeatingCommands(),
        "entry1", "finally1", "delay1", "period1", "incremental1",
        "entry2", "finally2", "delay2", "period2", "incremental2");
    assertTrue(scheduler.executeRepeatingCommands());
    checkEvents(
        "entry1", "finally1", "delay1", "period1", "incremental1",
        "entry2", "finally2", "delay2", "period2", "incremental2");

    checkCommands(scheduler.getRepeatingCommands(),
        "finally1", "period1 child", "period1",
        "entry2", "finally2 child", "delay2", "incremental2");
    assertTrue(scheduler.executeRepeatingCommands());
    checkEvents(
        "finally1", "period1 child", "period1",
        "entry2", "finally2 child", "delay2", "incremental2");

    checkCommands(scheduler.getRepeatingCommands(),
        "period1 child", "period1 child");
    assertTrue(scheduler.executeRepeatingCommands());
    checkEvents("period1 child", "period1 child");

    checkCommands(scheduler.getRepeatingCommands(),
        "period1 child");
    assertFalse(scheduler.executeRepeatingCommands());
    checkEvents("period1 child");

    checkCommands(scheduler.getRepeatingCommands());
  }

  public void testScheduledCommands() {
    scheduler.scheduleDeferred(new FakeScheduledCommand("deferred1", "deferred1 child"));
    scheduler.scheduleEntry(new FakeScheduledCommand("entry1", null));
    scheduler.scheduleFinally(new FakeScheduledCommand("finally1", null));

    scheduler.scheduleFinally(new FakeScheduledCommand("finally2", null));
    scheduler.scheduleEntry(new FakeScheduledCommand("entry2", "entry2 child"));
    scheduler.scheduleDeferred(new FakeScheduledCommand("deferred2", null));

    scheduler.scheduleEntry(new FakeRepeatingCommand("repeating", 1, null));  // ignored
    checkEvents();

    checkCommands(scheduler.getScheduledCommands(),
        "deferred1", "entry1", "finally1", "finally2", "entry2", "deferred2");
    assertTrue(scheduler.executeScheduledCommands());
    checkEvents("deferred1", "entry1", "finally1", "finally2", "entry2", "deferred2");

    checkCommands(scheduler.getScheduledCommands(), "deferred1 child", "entry2 child");
    assertFalse(scheduler.executeScheduledCommands());
    checkEvents("deferred1 child", "entry2 child");

    checkCommands(scheduler.getScheduledCommands());
  }

  private void checkEvents(String... expected) {
    assertEquals(Arrays.asList(expected), events);
    events.clear();
  }

  private void checkThrownExceptionMessages(String... expected) {
    assertEquals(Arrays.asList(expected), thrownExceptionMessages);
    thrownExceptionMessages.clear();
  }

  private void checkCommands(List<?> actual, String... expected) {
    List<String> actualStrings = new ArrayList<String>();
    for (Object command : actual) {
      actualStrings.add(command.toString());
    }
    assertEquals(Arrays.asList(expected), actualStrings);
  }

  private abstract class FakeCommand {

    protected final String id;
    @Nullable protected final String scheduledEntryId;
    protected int executionCount;

    public FakeCommand(String id, @Nullable String scheduledEntryId) {
      this.id = id;
      this.scheduledEntryId = scheduledEntryId;
    }

    protected void prepareExecute() {
      executionCount++;
      events.add(id);

      if (id.contains("failing")) {
        throw new RuntimeException("Fake failure: " + id);
      }
    }
  }

  private class FakeRepeatingCommand extends FakeCommand implements RepeatingCommand {

    private final int repeatCount;

    public FakeRepeatingCommand(String id, int repeatCount, @Nullable String scheduledEntryId) {
      super(id, scheduledEntryId);
      this.repeatCount = repeatCount;
    }

    @Override
    public boolean execute() {
      prepareExecute();
      assertTrue(executionCount <= repeatCount);

      if (scheduledEntryId != null) {
        scheduler.scheduleEntry(new FakeRepeatingCommand(scheduledEntryId, repeatCount, null));
      }

      return executionCount < repeatCount;
    }

    @Override
    public String toString() {
      return id;
    }
  }

  private class FakeScheduledCommand extends FakeCommand implements ScheduledCommand {

    public FakeScheduledCommand(String id, @Nullable String scheduledEntryId) {
      super(id, scheduledEntryId);
    }

    @Override
    public void execute() {
      prepareExecute();
      assertEquals(1, executionCount);

      if (scheduledEntryId != null) {
        scheduler.scheduleEntry(new FakeScheduledCommand(scheduledEntryId, null));
      }
    }

    @Override
    public String toString() {
      return id;
    }
  }
}