| /* |
| * 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 org.apache.ode.scheduler.simple; |
| |
| import java.util.ArrayList; |
| import java.util.List; |
| import java.util.concurrent.ExecutorService; |
| import java.util.concurrent.Executors; |
| import java.util.concurrent.atomic.AtomicInteger; |
| |
| import org.apache.ode.scheduler.simple.SchedulerThread; |
| import org.apache.ode.scheduler.simple.Task; |
| import org.apache.ode.scheduler.simple.TaskRunner; |
| |
| |
| import junit.framework.TestCase; |
| |
| /** |
| * Test of SchedulerThread. |
| * |
| * @author Maciej Szefler ( m s z e f l e r @ g m a i l . c o m ) |
| */ |
| public class SchedulerThreadTest extends TestCase implements TaskRunner { |
| |
| static final long SCHED_TOLERANCE = 100; |
| SchedulerThread _st; |
| |
| List<TR> _tasks = new ArrayList<TR>(100); |
| |
| public void setUp() throws Exception { |
| _st = new SchedulerThread(this); |
| } |
| |
| public void testSchedulingResolution() throws Exception { |
| _st.start(); |
| long schedtime = System.currentTimeMillis() + 300; |
| _st.enqueue(new Task(schedtime)); |
| Thread.sleep(1000); |
| assertEquals(1,_tasks.size()); |
| assertTrue(_tasks.get(0).time < schedtime + SCHED_TOLERANCE / 2); |
| assertTrue(_tasks.get(0).time > schedtime - SCHED_TOLERANCE / 2); |
| } |
| |
| public void testStartStop() throws Exception { |
| _st.start(); |
| long schedtime = System.currentTimeMillis() + 500; |
| _st.enqueue(new Task(schedtime)); |
| _st.stop(); |
| Thread.sleep(600); |
| assertEquals(0,_tasks.size()); |
| _st.start(); |
| Thread.sleep(SCHED_TOLERANCE); |
| assertEquals(1,_tasks.size()); |
| } |
| |
| public void testParallelEnqueue() throws Exception { |
| _st.start(); |
| final long startTime = System.currentTimeMillis() + 100; |
| final AtomicInteger ai = new AtomicInteger(300); |
| // enque in reverse order |
| Runnable run = new Runnable() { |
| public void run() { |
| Task tsk = new Task(startTime + ai.getAndDecrement() * 5); |
| _st.enqueue(tsk); |
| } |
| }; |
| |
| ExecutorService es = Executors.newFixedThreadPool(50); |
| for (int i = 0; i < 300; ++i) |
| es.execute(run); |
| |
| Thread.sleep(300 + 300 * 5); |
| assertEquals(300,_tasks.size()); |
| // Make sure they got scheduled in the right order |
| |
| for (int i = 0; i < 299; ++i) |
| assertTrue(_tasks.get(i).task.schedDate < _tasks.get(i+1).task.schedDate); |
| |
| // Check scheduling tolerance |
| for (TR tr : _tasks) { |
| assertTrue(tr.time < tr.task.schedDate + SCHED_TOLERANCE / 2); |
| assertTrue(tr.time > tr.task.schedDate - SCHED_TOLERANCE / 2); |
| } |
| } |
| |
| public void runTask(Task task) { |
| synchronized(_tasks) { |
| _tasks.add(new TR(System.currentTimeMillis(),task)); |
| } |
| } |
| |
| |
| class TR { |
| long time; |
| Task task; |
| TR(long time, Task task) { |
| this.time = time; |
| this.task = task; |
| } |
| } |
| } |