Spring Framework example source code file (TimerTaskExecutorTests.java)

This example Spring Framework source code file (TimerTaskExecutorTests.java) is included in the DevDaily.com "Java Source Code Warehouse" project. The intent of this project is to help you "Learn Java by Example" ^TM.

Java - Spring Framework tags/keywords

cancelawaretimer, creationawaretimertaskexecutor, creationawaretimertaskexecutor, exception, exception, if, nooprunnable, object, runawarerunnable, runnable, timer, timer, timertaskexecutor, timertaskexecutor, util

The Spring Framework TimerTaskExecutorTests.java source code

/*
 * Copyright 2002-2006 the original author or authors.
 *
 * 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 org.springframework.scheduling.timer;

import junit.framework.TestCase;
import org.springframework.test.AssertThrows;

import java.util.Timer;

/**
 * Unit tests for the {@link TimerTaskExecutor} class.
 *
 * @author Rick Evans
 */
public final class TimerTaskExecutorTests extends TestCase {

    public void testExecuteChokesWithNullTimer() throws Exception {
        new AssertThrows(IllegalArgumentException.class) {
            public void test() throws Exception {
                TimerTaskExecutor executor = new TimerTaskExecutor();
                executor.execute(new NoOpRunnable());
            }
        }.runTest();
    }

    public void testExecuteChokesWithNullTask() throws Exception {
        new AssertThrows(IllegalArgumentException.class) {
            public void test() throws Exception {
                TimerTaskExecutor executor = new TimerTaskExecutor(new Timer());
                executor.execute(null);
            }
        }.runTest();
    }

    public void testExecuteChokesWithNegativeDelay() throws Exception {
        new AssertThrows(IllegalArgumentException.class) {
            public void test() throws Exception {
                TimerTaskExecutor executor = new TimerTaskExecutor(new Timer());
                executor.setDelay(-10);
                executor.execute(new NoOpRunnable());
            }
        }.runTest();
    }

    public void testExecuteReallyDoesScheduleTheSuppliedTask() throws Exception {
        final Object monitor = new Object();

        RunAwareRunnable task = new RunAwareRunnable(monitor);

        TimerTaskExecutor executor = new TimerTaskExecutor(new Timer());
        executor.execute(task);

        synchronized (monitor) {
            monitor.wait(5000);
        }

        assertTrue("Supplied task (a Runnable) is not being invoked.", task.isRunWasCalled());
    }

    public void testCtorWithNullTimer() throws Exception {
        new AssertThrows(IllegalArgumentException.class) {
            public void test() throws Exception {
                new TimerTaskExecutor(null);
            }
        }.runTest();
    }

    public void testCreateTimerMethodIsCalledIfNoTimerIsExplicitlySupplied() throws Exception {
        CreationAwareTimerTaskExecutor executor = new CreationAwareTimerTaskExecutor();
        executor.afterPropertiesSet();
        assertTrue("If no Timer is set explicitly, then the protected createTimer() " +
                "method must be called to create the Timer (it obviously isn't being called).",
                executor.isCreateTimerWasCalled());
    }

    public void testCreateTimerMethodIsNotCalledIfTimerIsExplicitlySupplied() throws Exception {
        CreationAwareTimerTaskExecutor executor = new CreationAwareTimerTaskExecutor();
        executor.setTimer(new Timer());
        executor.afterPropertiesSet();
        assertFalse("If a Timer is set explicitly, then the protected createTimer() " +
                "method must not be called to create the Timer (it obviously is being called, in error).",
                executor.isCreateTimerWasCalled());
    }

    public void testThatTheDestroyCallbackCancelsTheTimerIfNoTimerIsExplicitlySupplied() throws Exception {

        final CancelAwareTimer timer = new CancelAwareTimer();

        TimerTaskExecutor executor = new TimerTaskExecutor() {

            protected Timer createTimer() {
                return timer;
            }
        };
        executor.afterPropertiesSet();
        executor.destroy();
        assertTrue("When the Timer used is created by the TimerTaskExecutor because " +
                "no Timer was set explicitly, then the destroy() callback must cancel() said Timer (it obviously isn't doing this).",
                timer.isCancelWasCalled());
    }

    public void testThatTheDestroyCallbackDoesNotCancelTheTimerIfTheTimerWasSuppliedExplictly() throws Exception {
        TimerTaskExecutor executor = new TimerTaskExecutor();
        CancelAwareTimer timer = new CancelAwareTimer();
        executor.setTimer(timer);
        executor.afterPropertiesSet();
        executor.destroy();
        assertFalse("When the Timer used is not created by the TimerTaskExecutor because " +
                "it Timer was set explicitly, then the destroy() callback must NOT cancel() said Timer (it obviously is, in error).",
                timer.isCancelWasCalled());
    }


    private final static class CreationAwareTimerTaskExecutor extends TimerTaskExecutor {

        private boolean createTimerWasCalled = false;


        public boolean isCreateTimerWasCalled() {
            return this.createTimerWasCalled;
        }

        protected Timer createTimer() {
            this.createTimerWasCalled = true;
            return super.createTimer();
        }

    }

    private static class CancelAwareTimer extends Timer {

        private boolean cancelWasCalled;


        public boolean isCancelWasCalled() {
            return this.cancelWasCalled;
        }


        public void cancel() {
            this.cancelWasCalled = true;
            super.cancel();
        }
    }

    private static class RunAwareRunnable implements Runnable {
        private boolean runWasCalled;
        private final Object monitor;

        public RunAwareRunnable(Object monitor) {
            this.monitor = monitor;
        }


        public boolean isRunWasCalled() {
            return this.runWasCalled;
        }


        public void run() {
            this.runWasCalled = true;
            synchronized (monitor) {
                monitor.notifyAll();
            }
        }
    }

    private static final class NoOpRunnable implements Runnable {

        public void run() {
            // explicit no-op
        }
    }

}