com.guit.junit.SchedulerMock.java Source code

Introduction

Here is the source code for com.guit.junit.SchedulerMock.java

Source

/*
 * Copyright 2010 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.guit.junit;

import com.google.gwt.core.client.impl.SchedulerImpl;
import com.google.gwt.user.client.Timer;

import java.util.ArrayList;

/**
 * Mock for SchedulerImpl.
 * 
 * SchedulerImpl's scheduling functions are implemented with the timer, which
 * fakes time
 */
public class SchedulerMock extends SchedulerImpl {
    // These functions are implemented using the timer class so controlling time
    // with JavaTimer.advanceTime* may also trigger these scheduled commands.
    @Override
    public void scheduleFixedDelay(final RepeatingCommand cmd, final int delayMs) {
        new Timer() {
            @Override
            public void run() {
                boolean repeat = cmd.execute();
                if (repeat) {
                    this.schedule(delayMs);
                }
            }
        }.schedule(delayMs);
    }

    @Override
    public void scheduleFixedPeriod(final RepeatingCommand cmd, int delayMs) {
        new Timer() {
            @Override
            public void run() {
                boolean repeat = cmd.execute();
                if (!repeat) {
                    cancel();
                }
            }
        }.scheduleRepeating(delayMs);
    }

    ArrayList<ScheduledCommand> deferredCmds = new ArrayList<ScheduledCommand>();
    ArrayList<ScheduledCommand> finallyCmds = new ArrayList<ScheduledCommand>();

    @Override
    public void scheduleDeferred(ScheduledCommand cmd) {
        deferredCmds.add(cmd);
    }

    @Override
    public void scheduleFinally(ScheduledCommand cmd) {
        finallyCmds.add(cmd);
    }

    @Override
    public void scheduleIncremental(RepeatingCommand cmd) {
        throw new AssertionError("Not implemented");
    }

    public void runDeferredCmds() {
        ArrayList<ScheduledCommand> oldCommands = deferredCmds;
        deferredCmds = new ArrayList<ScheduledCommand>();

        for (ScheduledCommand c : oldCommands) {
            c.execute();
        }
    }

    public void runFinallyCmds() {
        // All the commands should be run regardless of any exceptions thrown.
        // We will throw the first one.
        RuntimeException exception = null;
        ArrayList<ScheduledCommand> oldFinally = finallyCmds;
        finallyCmds = new ArrayList<ScheduledCommand>();

        for (ScheduledCommand c : oldFinally) {
            try {
                c.execute();
            } catch (RuntimeException e) {
                if (exception == null) {
                    exception = e;
                } else {
                    System.err.println(
                            "Multiple exceptions detected in runFinallyCmds." + " Subsequent exceptions ignored.");
                }
            }
        }

        if (exception != null) {
            throw exception;
        }
    }

    /**
     * Run the specified command in a try/catch block. Deferred commands are run
     * after the command if the command does not throw an exception and finally
     * commands are run afterwards regardless.
     * 
     * @param cmd
     */
    public void runAndFlushScheduler(ScheduledCommand cmd) {
        try {
            cmd.execute();
            runDeferredCmds();
        } catch (RuntimeException e) {
            throw e;
        } finally {
            runFinallyCmds();
        }
    }
}