groupbasedpolicy/src/test/java/org/opendaylight/groupbasedpolicy/util/SingletonTaskTest.java

   1 /*
   2  * Copyright 2011, Big Switch Networks, Inc.
   3  *
   4  * This program and the accompanying materials are made available under the
   5  * terms of the Eclipse Public License v1.0 which accompanies this distribution,
   6  * and is available at http://www.eclipse.org/legal/epl-v10.html
   7  */
   8
   9 package org.opendaylight.groupbasedpolicy.util;
  10
  11 import static org.junit.Assert.assertEquals;
  12 import static org.junit.Assert.assertFalse;
  13 import static org.junit.Assert.assertTrue;
  14
  15 import java.util.concurrent.Executors;
  16 import java.util.concurrent.ScheduledExecutorService;
  17 import java.util.concurrent.TimeUnit;
  18
  19 import org.junit.Before;
  20 import org.junit.Test;
  21
  22 public class SingletonTaskTest {
  23
  24     public int ran = 0;
  25     public int finished = 0;
  26     public long time = 0;
  27
  28     @Before
  29     public void setUp() throws Exception {
  30         ran = 0;
  31         finished = 0;
  32         time = 0;
  33     }
  34
  35     @Test
  36     public void testBasic() throws InterruptedException {
  37         ScheduledExecutorService ses =
  38             Executors.newSingleThreadScheduledExecutor();
  39
  40         SingletonTask st1 = new SingletonTask(ses, new Runnable() {
  41             @Override
  42             public void run() {
  43                 ran += 1;
  44             }
  45         });
  46         st1.reschedule(0, null);
  47         ses.shutdown();
  48         ses.awaitTermination(5, TimeUnit.SECONDS);
  49
  50         assertEquals("Check that task ran", 1, ran);
  51     }
  52
  53     @Test
  54     public void testDelay() throws InterruptedException {
  55         ScheduledExecutorService ses =
  56             Executors.newSingleThreadScheduledExecutor();
  57
  58         SingletonTask st1 = new SingletonTask(ses, new Runnable() {
  59             @Override
  60             public void run() {
  61                 ran += 1;
  62                 time = System.nanoTime();
  63             }
  64         });
  65         long start = System.nanoTime();
  66         st1.reschedule(10, TimeUnit.MILLISECONDS);
  67         assertFalse("Check that task hasn't run yet", ran > 0);
  68
  69         ses.shutdown();
  70         ses.awaitTermination(5, TimeUnit.SECONDS);
  71
  72         assertEquals("Check that task ran", 1, ran);
  73         assertTrue("Check that time passed appropriately",
  74                    (time - start) >= TimeUnit.NANOSECONDS.convert(10, TimeUnit.MILLISECONDS));
  75     }
  76
  77     @Test
  78     public void testReschedule() throws InterruptedException {
  79         ScheduledExecutorService ses =
  80             Executors.newSingleThreadScheduledExecutor();
  81
  82         final Object tc = this;
  83         SingletonTask st1 = new SingletonTask(ses, new Runnable() {
  84             @Override
  85             public void run() {
  86                 synchronized (tc) {
  87                     ran += 1;
  88                 }
  89                 time = System.nanoTime();
  90             }
  91         });
  92         long start = System.nanoTime();
  93         st1.reschedule(20, TimeUnit.MILLISECONDS);
  94         Thread.sleep(5);
  95         assertFalse("Check that task hasn't run yet", ran > 0);
  96         st1.reschedule(20, TimeUnit.MILLISECONDS);
  97         Thread.sleep(5);
  98         assertFalse("Check that task hasn't run yet", ran > 0);
  99         st1.reschedule(20, TimeUnit.MILLISECONDS);
 100         Thread.sleep(5);
 101         assertFalse("Check that task hasn't run yet", ran > 0);
 102         st1.reschedule(20, TimeUnit.MILLISECONDS);
 103         Thread.sleep(5);
 104         assertFalse("Check that task hasn't run yet", ran > 0);
 105         st1.reschedule(20, TimeUnit.MILLISECONDS);
 106         Thread.sleep(5);
 107         assertFalse("Check that task hasn't run yet", ran > 0);
 108         st1.reschedule(20, TimeUnit.MILLISECONDS);
 109         Thread.sleep(5);
 110         assertFalse("Check that task hasn't run yet", ran > 0);
 111         st1.reschedule(20, TimeUnit.MILLISECONDS);
 112         Thread.sleep(5);
 113         assertFalse("Check that task hasn't run yet", ran > 0);
 114         st1.reschedule(20, TimeUnit.MILLISECONDS);
 115         Thread.sleep(5);
 116         assertFalse("Check that task hasn't run yet", ran > 0);
 117
 118         ses.shutdown();
 119         ses.awaitTermination(5, TimeUnit.SECONDS);
 120
 121         assertEquals("Check that task ran only once", 1, ran);
 122         assertTrue("Check that time passed appropriately: " + (time - start),
 123                 (time - start) >= TimeUnit.NANOSECONDS.convert(55, TimeUnit.MILLISECONDS));
 124     }
 125
 126     @Test
 127     public void testConcurrentAddDelay() throws InterruptedException {
 128         ScheduledExecutorService ses =
 129             Executors.newSingleThreadScheduledExecutor();
 130
 131         final Object tc = this;
 132         SingletonTask st1 = new SingletonTask(ses, new Runnable() {
 133             @Override
 134             public void run() {
 135                 synchronized (tc) {
 136                     ran += 1;
 137                 }
 138                 try {
 139                     Thread.sleep(50);
 140                 } catch (InterruptedException e) {
 141                     e.printStackTrace();
 142                 }
 143                 synchronized (tc) {
 144                     finished += 1;
 145                     time = System.nanoTime();
 146                 }
 147             }
 148         });
 149
 150         long start = System.nanoTime();
 151         st1.reschedule(5, TimeUnit.MILLISECONDS);
 152         Thread.sleep(20);
 153         assertEquals("Check that task started", 1, ran);
 154         assertEquals("Check that task not finished", 0, finished);
 155         st1.reschedule(75, TimeUnit.MILLISECONDS);
 156         assertTrue("Check task running state true", st1.context.taskRunning);
 157         assertTrue("Check task should run state true", st1.context.taskShouldRun);
 158         assertEquals("Check that task started", 1, ran);
 159         assertEquals("Check that task not finished", 0, finished);
 160
 161         Thread.sleep(150);
 162
 163         assertTrue("Check task running state false", !st1.context.taskRunning);
 164         assertTrue("Check task should run state false", !st1.context.taskShouldRun);
 165         assertEquals("Check that task ran exactly twice", 2, ran);
 166         assertEquals("Check that task finished exactly twice", 2, finished);
 167
 168         assertTrue("Check that time passed appropriately: " + (time - start),
 169                 (time - start) >= TimeUnit.NANOSECONDS.convert(130, TimeUnit.MILLISECONDS));
 170         assertTrue("Check that time passed appropriately: " + (time - start),
 171                 (time - start) <= TimeUnit.NANOSECONDS.convert(500, TimeUnit.MILLISECONDS));
 172
 173         ses.shutdown();
 174         ses.awaitTermination(15, TimeUnit.SECONDS);
 175     }
 176
 177     @Test
 178     public void testConcurrentAddDelay2() throws InterruptedException {
 179         ScheduledExecutorService ses =
 180             Executors.newSingleThreadScheduledExecutor();
 181
 182         final Object tc = this;
 183         SingletonTask st1 = new SingletonTask(ses, new Runnable() {
 184             @Override
 185             public void run() {
 186                 synchronized (tc) {
 187                     ran += 1;
 188                 }
 189                 try {
 190                     Thread.sleep(50);
 191                 } catch (InterruptedException e) {
 192                     e.printStackTrace();
 193                 }
 194                 synchronized (tc) {
 195                     finished += 1;
 196                     time = System.nanoTime();
 197                 }
 198             }
 199         });
 200
 201         long start = System.nanoTime();
 202         st1.reschedule(5, TimeUnit.MILLISECONDS);
 203         Thread.sleep(20);
 204         assertEquals("Check that task started", 1, ran);
 205         assertEquals("Check that task not finished", 0, finished);
 206         st1.reschedule(25, TimeUnit.MILLISECONDS);
 207         assertTrue("Check task running state true", st1.context.taskRunning);
 208         assertTrue("Check task should run state true", st1.context.taskShouldRun);
 209         assertEquals("Check that task started", 1, ran);
 210         assertEquals("Check that task not finished", 0, finished);
 211
 212         Thread.sleep(150);
 213
 214         assertTrue("Check task running state false", !st1.context.taskRunning);
 215         assertTrue("Check task should run state false", !st1.context.taskShouldRun);
 216         assertEquals("Check that task ran exactly twice", 2, ran);
 217         assertEquals("Check that task finished exactly twice", 2, finished);
 218
 219         assertTrue("Check that time passed appropriately: " + (time - start),
 220                 (time - start) >= TimeUnit.NANOSECONDS.convert(100, TimeUnit.MILLISECONDS));
 221         assertTrue("Check that time passed appropriately: " + (time - start),
 222                 (time - start) <= TimeUnit.NANOSECONDS.convert(500, TimeUnit.MILLISECONDS));
 223
 224         ses.shutdown();
 225         ses.awaitTermination(5, TimeUnit.SECONDS);
 226     }
 227
 228
 229     @Test
 230     public void testConcurrentAddNoDelay() throws InterruptedException {
 231         ScheduledExecutorService ses =
 232             Executors.newSingleThreadScheduledExecutor();
 233
 234         final Object tc = this;
 235         SingletonTask st1 = new SingletonTask(ses, new Runnable() {
 236             @Override
 237             public void run() {
 238                 synchronized (tc) {
 239                     ran += 1;
 240                 }
 241                 try {
 242                     Thread.sleep(50);
 243                 } catch (InterruptedException e) {
 244                     e.printStackTrace();
 245                 }
 246                 synchronized (tc) {
 247                     finished += 1;
 248                     time = System.nanoTime();
 249                 }
 250             }
 251         });
 252
 253         long start = System.nanoTime();
 254         st1.reschedule(0, null);
 255         Thread.sleep(20);
 256         assertEquals("Check that task started", 1, ran);
 257         assertEquals("Check that task not finished", 0, finished);
 258         st1.reschedule(0, null);
 259         assertTrue("Check task running state true", st1.context.taskRunning);
 260         assertTrue("Check task should run state true", st1.context.taskShouldRun);
 261         assertEquals("Check that task started", 1, ran);
 262         assertEquals("Check that task not finished", 0, finished);
 263
 264         Thread.sleep(150);
 265
 266         assertTrue("Check task running state false", !st1.context.taskRunning);
 267         assertTrue("Check task should run state false", !st1.context.taskShouldRun);
 268         assertEquals("Check that task ran exactly twice", 2, ran);
 269         assertEquals("Check that task finished exactly twice", 2, finished);
 270
 271         assertTrue("Check that time passed appropriately: " + (time - start),
 272                 (time - start) >= TimeUnit.NANOSECONDS.convert(90, TimeUnit.MILLISECONDS));
 273         assertTrue("Check that time passed appropriately: " + (time - start),
 274                 (time - start) <= TimeUnit.NANOSECONDS.convert(500, TimeUnit.MILLISECONDS));
 275
 276         ses.shutdown();
 277         ses.awaitTermination(5, TimeUnit.SECONDS);
 278     }
 279 }