javacommons/jvms/cldc_1.1.1/tsrc/javasrc/com/nokia/mj/test/java/util/TimerTaskTest.java
/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You 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.
*/
/**
* TimerTask tests adapted to Java ME from Apache Harmony (Open Source Java SE)
* Main changes:
* - junit to j2meunit related changes
*/
package com.nokia.mj.test.java.util;
import java.util.Timer;
import java.util.TimerTask;
import j2meunit.framework.Test;
import j2meunit.framework.TestCase;
import j2meunit.framework.TestSuite;
import j2meunit.framework.TestMethod;
public class TimerTaskTest extends TestCase
{
Object sync = new Object(), start = new Object();
public TimerTaskTest()
{
}
public TimerTaskTest(String sTestName, TestMethod rTestMethod)
{
super(sTestName, rTestMethod);
}
public Test suite()
{
TestSuite aSuite = new TestSuite();
aSuite.addTest(new TimerTaskTest("test_Constructor", new TestMethod()
{
public void run(TestCase tc)
{
((TimerTaskTest) tc).test_Constructor();
}
}));
aSuite.addTest(new TimerTaskTest("test_cancel", new TestMethod()
{
public void run(TestCase tc)
{
((TimerTaskTest) tc).test_cancel();
}
}));
aSuite.addTest(new TimerTaskTest("test_scheduledExecutionTime", new TestMethod()
{
public void run(TestCase tc)
{
((TimerTaskTest) tc).test_scheduledExecutionTime();
}
}));
aSuite.addTest(new TimerTaskTest("test_run", new TestMethod()
{
public void run(TestCase tc)
{
((TimerTaskTest) tc).test_run();
}
}));
aSuite.addTest(new TimerTaskTest("test_runThrows", new TestMethod()
{
public void run(TestCase tc)
{
((TimerTaskTest) tc).test_runThrows();
}
}));
return aSuite;
}
/**
* Warning: These tests have the possibility to leave a VM hanging if the
* Timer is not cancelled.
*/
class TimerTestTask extends TimerTask
{
private int wasRun = 0;
// Set this to true to see normal tests fail (or hang possibly)
// The default is false and needs to be set by some tests
private boolean sleepInRun = false;
public void run()
{
synchronized (this)
{
wasRun++;
}
synchronized (start)
{
start.notify();
}
if (sleepInRun)
{
try
{
Thread.sleep(200);
}
catch (InterruptedException e)
{
}
}
synchronized (sync)
{
sync.notify();
}
}
public synchronized int wasRun()
{
return wasRun;
}
public void sleepInRun(boolean value)
{
sleepInRun = value;
}
}
/**
* @tests java.util.TimerTask#TimerTask()
*/
public void test_Constructor()
{
// Ensure the constructor does not fail
new TimerTestTask();
}
/**
* @tests java.util.TimerTask#cancel()
*/
public void test_cancel()
{
Timer t = null;
try
{
// Ensure cancel returns false if never scheduled
TimerTestTask testTask = new TimerTestTask();
assertTrue("Unsheduled tasks should return false for cancel()",
!testTask.cancel());
// Ensure cancelled task never runs
t = new Timer();
testTask = new TimerTestTask();
t.schedule(testTask, 500);
assertTrue("TimerTask should not have run yet", testTask.cancel());
t.cancel();
// Ensure cancelling a task which has already run returns true
t = new Timer();
testTask = new TimerTestTask();
t.schedule(testTask, 50);
while (testTask.wasRun() == 0)
{
try
{
Thread.sleep(150);
}
catch (InterruptedException e)
{
}
}
assertFalse(
"TimerTask.cancel() should return false if task has run",
testTask.cancel());
assertFalse(
"TimerTask.cancel() should return false if called a second time",
testTask.cancel());
t.cancel();
// Ensure cancelling a repeated execution task which has never run
// returns true
t = new Timer();
testTask = new TimerTestTask();
t.schedule(testTask, 500, 500); // should never run
assertTrue(
"TimerTask.cancel() should return true if sheduled for repeated execution even if not run",
testTask.cancel());
t.cancel();
// Ensure cancelling a repeated execution task which HAS run returns
// true
t = new Timer();
testTask = new TimerTestTask();
t.schedule(testTask, 50, 50);
while (testTask.wasRun() == 0)
{
try
{
Thread.sleep(100);
}
catch (InterruptedException e)
{
}
}
assertTrue(
"TimerTask.cancel() should return true if sheduled for repeated execution and run",
testTask.cancel());
t.cancel();
// Ensure calling cancel a second returns false
t = new Timer();
testTask = new TimerTestTask();
t.schedule(testTask, 5000); // Should never run
assertTrue(
"TimerTask.cancel() should return true if task has never run",
testTask.cancel());
assertFalse(
"TimerTask.cancel() should return false if called a second time",
testTask.cancel());
t.cancel();
// Ensure cancelling a task won't cause deadlock
t = new Timer();
testTask = new TimerTestTask();
testTask.sleepInRun(true);
synchronized (start)
{
t.schedule(testTask, 0);
try
{
start.wait();
Thread.sleep(50);
}
catch (InterruptedException e)
{
}
}
assertFalse("TimerTask should have been cancelled", testTask
.cancel());
t.cancel();
}
finally
{
if (t != null)
t.cancel();
}
}
/**
* @tests java.util.TimerTask#scheduledExecutionTime()
*/
public void test_scheduledExecutionTime()
{
Timer t = null;
try
{
// Ensure scheduledExecutionTime is roughly right
t = new Timer();
TimerTestTask testTask = new TimerTestTask();
t.schedule(testTask, 100);
long time = System.currentTimeMillis() + 100;
synchronized (sync)
{
try
{
sync.wait(500);
}
catch (InterruptedException e)
{
}
}
long scheduledExecutionTime = testTask.scheduledExecutionTime();
assertTrue(scheduledExecutionTime <= time);
t.cancel();
// Ensure scheduledExecutionTime is the last scheduled time
t = new Timer();
testTask = new TimerTestTask();
t.schedule(testTask, 100, 500);
long estNow = System.currentTimeMillis() + 100;
// Will wake in 100, and every 500 run again
// We want to try to get it after it's run at least once but not
// twice
synchronized (sync)
{
try
{
sync.wait(500);
}
catch (InterruptedException e)
{
}
}
scheduledExecutionTime = testTask.scheduledExecutionTime();
assertTrue(scheduledExecutionTime <= estNow);
t.cancel();
}
finally
{
if (t != null)
t.cancel();
}
}
/**
* @tests java.util.TimerTask#run()
*/
public void test_run()
{
Timer t = null;
try
{
// Ensure a new task is never run
TimerTestTask testTask = new TimerTestTask();
try
{
Thread.sleep(200);
}
catch (InterruptedException e)
{
}
assertEquals("TimerTask.run() method should not have been called",
0, testTask.wasRun());
// Ensure a task is run
t = new Timer();
testTask = new TimerTestTask();
t.schedule(testTask, 200);
while (testTask.wasRun() < 1)
{
try
{
Thread.sleep(400);
}
catch (InterruptedException e)
{
}
}
assertFalse(testTask.cancel());
t.cancel();
}
finally
{
if (t != null)
t.cancel();
}
}
private void assertFalse(String aStr, boolean aBool)
{
assertTrue(aStr, !aBool);
}
private void assertFalse(boolean aBool)
{
assertTrue(!aBool);
}
/**
* @tests java.util.TimerTask#run() throws exception
*/
public void test_runThrows()
{
Timer t = null;
class TestTask extends TimerTestTask
{
public void run()
{
super.run();
// throws exception
byte[] array = null;
array[1] = 0;
}
}
try
{
// Ensure a task is run only once if exception is thrown in run()
t = new Timer();
TestTask testTask = new TestTask();
t.schedule(testTask, 50, 50);
try
{
Thread.sleep(300);
}
catch (InterruptedException e)
{
}
t.cancel();
assertEquals(testTask.wasRun(), 1);
}
finally
{
if (t != null)
t.cancel();
}
}
}