/*
* 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.
*/
package tests.api.java.util;
import dalvik.annotation.TestTargetNew;
import dalvik.annotation.TestTargets;
import dalvik.annotation.TestLevel;
import dalvik.annotation.TestTargetClass;
import java.util.Timer;
import java.util.TimerTask;
@TestTargetClass(TimerTask.class)
public class TimerTaskTest extends junit.framework.TestCase {
Object sync = new Object(), start = new Object();
/**
* 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()
*/
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "",
method = "TimerTask",
args = {}
)
public void test_Constructor() {
// Ensure the constructor does not fail
new TimerTestTask();
}
/**
* @tests java.util.TimerTask#cancel()
*/
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "",
method = "cancel",
args = {}
)
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()
*/
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "",
method = "scheduledExecutionTime",
args = {}
)
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()
*/
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "",
method = "run",
args = {}
)
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();
}
}
}
|
