tmf/org.eclipse.tracecompass.tmf.core.tests/src/org/eclipse/tracecompass/tmf/core/tests/request/TmfEventRequestTest.java

   1 /*******************************************************************************
   2  * Copyright (c) 2009, 2015 Ericsson
   3  *
   4  * All rights reserved. This program and the accompanying materials are
   5  * made available under the terms of the Eclipse Public License v1.0 which
   6  * accompanies this distribution, and is available at
   7  * http://www.eclipse.org/legal/epl-v10.html
   8  *
   9  * Contributors:
  10  *   Francois Chouinard - Initial API and implementation
  11  *   Alexandre Montplaisir - Port to JUnit4
  12  *******************************************************************************/
  13
  14 package org.eclipse.tracecompass.tmf.core.tests.request;
  15
  16 import static org.junit.Assert.assertEquals;
  17 import static org.junit.Assert.assertFalse;
  18 import static org.junit.Assert.assertNotNull;
  19 import static org.junit.Assert.assertSame;
  20 import static org.junit.Assert.assertTrue;
  21
  22 import java.util.concurrent.TimeUnit;
  23
  24 import org.eclipse.tracecompass.tmf.core.event.ITmfEvent;
  25 import org.eclipse.tracecompass.tmf.core.request.ITmfEventRequest;
  26 import org.eclipse.tracecompass.tmf.core.request.ITmfEventRequest.ExecutionType;
  27 import org.eclipse.tracecompass.tmf.core.request.TmfEventRequest;
  28 import org.eclipse.tracecompass.tmf.core.timestamp.TmfTimeRange;
  29 import org.eclipse.tracecompass.tmf.core.timestamp.TmfTimestamp;
  30 import org.eclipse.tracecompass.tmf.tests.stubs.request.TmfEventRequestStub;
  31 import org.junit.Before;
  32 import org.junit.Rule;
  33 import org.junit.Test;
  34 import org.junit.rules.TestRule;
  35 import org.junit.rules.Timeout;
  36
  37 /**
  38  * Test suite for the TmfEventRequest class.
  39  */
  40 @SuppressWarnings("javadoc")
  41 public class TmfEventRequestTest {
  42
  43     @Rule
  44     public TestRule globalTimeout = new Timeout(20, TimeUnit.SECONDS);
  45
  46     // ------------------------------------------------------------------------
  47     // Variables
  48     // ------------------------------------------------------------------------
  49
  50     private static TmfTimeRange range1 = TmfTimeRange.ETERNITY;
  51     private static TmfTimeRange range2 = new TmfTimeRange(TmfTimestamp.fromSeconds(0), TmfTimestamp.BIG_CRUNCH);
  52
  53     private static TmfEventRequest fRequest1;
  54     private static TmfEventRequest fRequest2;
  55     private static TmfEventRequest fRequest3;
  56     private static TmfEventRequest fRequest4;
  57     private static TmfEventRequest fRequest5;
  58
  59     // ------------------------------------------------------------------------
  60     // Housekeeping
  61     // ------------------------------------------------------------------------
  62
  63     @Before
  64     public void setUp() {
  65         fRequest1 = new TmfEventRequestStub(ITmfEvent.class, range1, 100, 200);
  66         fRequest2 = new TmfEventRequestStub(ITmfEvent.class, range2, 100, 200);
  67         fRequest3 = new TmfEventRequestStub(ITmfEvent.class, range2, 200, 200);
  68         fRequest4 = new TmfEventRequestStub(ITmfEvent.class, range2, 200, 300);
  69         fRequest5 = new TmfEventRequestStub(ITmfEvent.class, range2, 200, 300, ExecutionType.FOREGROUND, 1);
  70     }
  71
  72     private static TmfEventRequest setupTestRequest(final boolean[] flags) {
  73
  74         TmfEventRequest request = new TmfEventRequestStub(ITmfEvent.class, TmfTimeRange.ETERNITY, 100, 200) {
  75             @Override
  76             public void handleCompleted() {
  77                 super.handleCompleted();
  78                 flags[0] = true;
  79             }
  80
  81             @Override
  82             public void handleSuccess() {
  83                 super.handleSuccess();
  84                 flags[1] = true;
  85             }
  86
  87             @Override
  88             public void handleFailure() {
  89                 super.handleFailure();
  90                 flags[2] = true;
  91             }
  92
  93             @Override
  94             public void handleCancel() {
  95                 super.handleCancel();
  96                 flags[3] = true;
  97             }
  98         };
  99         return request;
 100     }
 101
 102     // ------------------------------------------------------------------------
 103     // Constructors
 104     // ------------------------------------------------------------------------
 105
 106     @Test
 107     public void testTmfEventRequest() {
 108         TmfEventRequest request = new TmfEventRequestStub(ITmfEvent.class);
 109
 110         assertEquals("getDataType", ITmfEvent.class, request.getDataType());
 111
 112         assertEquals("StartTime", TmfTimestamp.BIG_BANG, request.getRange().getStartTime());
 113         assertEquals("EndTime", TmfTimestamp.BIG_CRUNCH, request.getRange().getEndTime());
 114
 115         assertEquals("getRange", TmfTimeRange.ETERNITY, request.getRange());
 116         assertSame("getRange", TmfTimeRange.ETERNITY, request.getRange());
 117
 118         assertEquals("getIndex", 0, request.getIndex());
 119         assertEquals("getNbRequestedEvents", ITmfEventRequest.ALL_DATA, request.getNbRequested());
 120
 121         assertFalse("isCompleted", request.isCompleted());
 122         assertFalse("isFailed", request.isFailed());
 123         assertFalse("isCancelled", request.isCancelled());
 124
 125         assertEquals("getNbRead", 0, request.getNbRead());
 126         assertEquals("getDependencyLevel", 0, request.getDependencyLevel());
 127     }
 128
 129     @Test
 130     public void testTmfEventRequestTimeRange() {
 131         TmfTimeRange range = new TmfTimeRange(TmfTimestamp.fromSeconds(0), TmfTimestamp.BIG_CRUNCH);
 132         TmfEventRequest request = new TmfEventRequestStub(ITmfEvent.class, range);
 133
 134         assertEquals("getDataType", ITmfEvent.class, request.getDataType());
 135
 136         assertEquals("StartTime", TmfTimestamp.fromSeconds(0), request.getRange().getStartTime());
 137         assertEquals("EndTime", TmfTimestamp.BIG_CRUNCH, request.getRange().getEndTime());
 138
 139         assertEquals("getIndex", 0, request.getIndex());
 140         assertEquals("getNbRequestedEvents", ITmfEventRequest.ALL_DATA, request.getNbRequested());
 141
 142         assertFalse("isCompleted", request.isCompleted());
 143         assertFalse("isFailed", request.isFailed());
 144         assertFalse("isCancelled", request.isCancelled());
 145
 146         assertEquals("getNbRead", 0, request.getNbRead());
 147         assertEquals("getDependencyLevel", 0, request.getDependencyLevel());
 148     }
 149
 150     @Test
 151     public void testTmfEventRequestTimeRangeNbRequested() {
 152         TmfTimeRange range = new TmfTimeRange(TmfTimestamp.fromSeconds(0), TmfTimestamp.BIG_CRUNCH);
 153         TmfEventRequest request = new TmfEventRequestStub(ITmfEvent.class, range, 100);
 154
 155         assertEquals("getDataType", ITmfEvent.class, request.getDataType());
 156
 157         assertEquals("StartTime", TmfTimestamp.fromSeconds(0), request.getRange().getStartTime());
 158         assertEquals("EndTime", TmfTimestamp.BIG_CRUNCH, request.getRange().getEndTime());
 159
 160         assertEquals("getIndex", 0, request.getIndex());
 161         assertEquals("getNbRequestedEvents", 100, request.getNbRequested());
 162
 163         assertFalse("isCompleted", request.isCompleted());
 164         assertFalse("isFailed", request.isFailed());
 165         assertFalse("isCancelled", request.isCancelled());
 166
 167         assertEquals("getNbRead", 0, request.getNbRead());
 168         assertEquals("getDependencyLevel", 0, request.getDependencyLevel());
 169     }
 170
 171     @Test
 172     public void testTmfEventRequestTimeRangeNbRequestedBlocksize() {
 173         TmfTimeRange range = new TmfTimeRange(TmfTimestamp.fromSeconds(0), TmfTimestamp.BIG_CRUNCH);
 174         TmfEventRequest request = new TmfEventRequestStub(ITmfEvent.class, range, 100, 200);
 175
 176         assertEquals("getDataType", ITmfEvent.class, request.getDataType());
 177
 178         assertEquals("StartTime", TmfTimestamp.fromSeconds(0), request.getRange().getStartTime());
 179         assertEquals("EndTime", TmfTimestamp.BIG_CRUNCH, request.getRange().getEndTime());
 180
 181         assertEquals("getIndex", 0, request.getIndex());
 182         assertEquals("getNbRequestedEvents", 100, request.getNbRequested());
 183
 184         assertFalse("isCompleted", request.isCompleted());
 185         assertFalse("isFailed", request.isFailed());
 186         assertFalse("isCancelled", request.isCancelled());
 187
 188         assertEquals("getNbRead", 0, request.getNbRead());
 189         assertEquals("getDependencyLevel", 0, request.getDependencyLevel());
 190     }
 191
 192     @Test
 193     public void testTmfEventRequestWithDependencyLevel() {
 194         TmfTimeRange range = new TmfTimeRange(TmfTimestamp.fromSeconds(0), TmfTimestamp.BIG_CRUNCH);
 195         TmfEventRequest request = new TmfEventRequestStub(ITmfEvent.class, range, 100, 200, ExecutionType.FOREGROUND, 1);
 196
 197         assertEquals("getDataType", ITmfEvent.class, request.getDataType());
 198
 199         assertEquals("StartTime", TmfTimestamp.fromSeconds(0), request.getRange().getStartTime());
 200         assertEquals("EndTime", TmfTimestamp.BIG_CRUNCH, request.getRange().getEndTime());
 201
 202         assertEquals("getIndex", 0, request.getIndex());
 203         assertEquals("getNbRequestedEvents", 100, request.getNbRequested());
 204
 205         assertFalse("isCompleted", request.isCompleted());
 206         assertFalse("isFailed", request.isFailed());
 207         assertFalse("isCancelled", request.isCancelled());
 208
 209         assertEquals("getNbRead", 0, request.getNbRead());
 210         assertEquals("getDependencyLevel", 1, request.getDependencyLevel());
 211     }
 212
 213     // ------------------------------------------------------------------------
 214     // equals
 215     // ------------------------------------------------------------------------
 216
 217     @Test
 218     public void testEquals() {
 219         /*
 220          * No two different requests should be "equal", even if they used the
 221          * same constructor parameters.
 222          */
 223         assertTrue(fRequest1.equals(fRequest1));
 224         assertFalse(fRequest1.equals(fRequest2));
 225         assertFalse(fRequest1.equals(fRequest3));
 226         assertFalse(fRequest1.equals(fRequest4));
 227
 228         /*
 229          * Request with different dependency level, but otherwise identical, are
 230          * not equal
 231          */
 232         assertFalse(fRequest4.equals(fRequest5));
 233     }
 234
 235     // ------------------------------------------------------------------------
 236     // toString
 237     // ------------------------------------------------------------------------
 238
 239     @Test
 240     public void testToString() {
 241         String expected1 = "[TmfEventRequestStub(" + fRequest1.getRequestId() + ",ITmfEvent,FOREGROUND," + range1 + ",0,100,0)]";
 242         String expected2 = "[TmfEventRequestStub(" + fRequest2.getRequestId() + ",ITmfEvent,FOREGROUND," + range2 + ",0,100,0)]";
 243         String expected3 = "[TmfEventRequestStub(" + fRequest3.getRequestId() + ",ITmfEvent,FOREGROUND," + range2 + ",0,200,0)]";
 244         String expected4 = "[TmfEventRequestStub(" + fRequest4.getRequestId() + ",ITmfEvent,FOREGROUND," + range2 + ",0,200,0)]";
 245         String expected5 = "[TmfEventRequestStub(" + fRequest5.getRequestId() + ",ITmfEvent,FOREGROUND," + range2 + ",0,200,1)]";
 246
 247         assertEquals("toString", expected1, fRequest1.toString());
 248         assertEquals("toString", expected2, fRequest2.toString());
 249         assertEquals("toString", expected3, fRequest3.toString());
 250         assertEquals("toString", expected4, fRequest4.toString());
 251         assertEquals("toString", expected5, fRequest5.toString());
 252     }
 253
 254     // ------------------------------------------------------------------------
 255     // done
 256     // ------------------------------------------------------------------------
 257
 258     @Test
 259     public void testDone() {
 260         final boolean[] flags = new boolean[4];
 261         TmfEventRequest request = setupTestRequest(flags);
 262         request.done();
 263
 264         assertTrue("isCompleted", request.isCompleted());
 265         assertFalse("isFailed", request.isFailed());
 266         assertFalse("isCancelled", request.isCancelled());
 267
 268         assertTrue("handleCompleted", flags[0]);
 269         assertTrue("handleSuccess", flags[1]);
 270         assertFalse("handleFailure", flags[2]);
 271         assertFalse("handleCancel", flags[3]);
 272     }
 273
 274     // ------------------------------------------------------------------------
 275     // fail
 276     // ------------------------------------------------------------------------
 277
 278     @Test
 279     public void testFail() {
 280         final boolean[] flags = new boolean[4];
 281         TmfEventRequest request = setupTestRequest(flags);
 282         request.fail(new IllegalArgumentException("Bad argument"));
 283
 284         final Throwable failCause = request.getFailureCause();
 285         assertTrue("isCompleted", request.isCompleted());
 286         assertTrue("isFailed", request.isFailed());
 287         assertFalse("isCancelled", request.isCancelled());
 288         assertNotNull("Cause of failure", failCause);
 289         assertEquals("Cause of failure message", "Bad argument", failCause.getMessage());
 290
 291         assertTrue("handleCompleted", flags[0]);
 292         assertFalse("handleSuccess", flags[1]);
 293         assertTrue("handleFailure", flags[2]);
 294         assertFalse("handleCancel", flags[3]);
 295     }
 296
 297     // ------------------------------------------------------------------------
 298     // cancel
 299     // ------------------------------------------------------------------------
 300
 301     @Test
 302     public void testCancel() {
 303         final boolean[] flags = new boolean[4];
 304         TmfEventRequest request = setupTestRequest(flags);
 305         request.cancel();
 306
 307         assertTrue("isCompleted", request.isCompleted());
 308         assertFalse("isFailed", request.isFailed());
 309         assertTrue("isCancelled", request.isCancelled());
 310
 311         assertTrue("handleCompleted", flags[0]);
 312         assertFalse("handleSuccess", flags[1]);
 313         assertFalse("handleFailure", flags[2]);
 314         assertTrue("handleCancel", flags[3]);
 315     }
 316
 317     // ------------------------------------------------------------------------
 318     // waitForStart
 319     // ------------------------------------------------------------------------
 320
 321     /**
 322      * Test calling waitForStart() after the request has already been started.
 323      * It should not block.
 324      */
 325     @Test
 326     public void testWaitForStartAfterStart() throws InterruptedException {
 327         final boolean[] flags = new boolean[4];
 328         TmfEventRequest request = setupTestRequest(flags);
 329
 330         request.start();
 331         request.waitForStart();
 332         request.done();
 333
 334         assertTrue("isCompleted", request.isCompleted());
 335         assertFalse("isFailed", request.isFailed());
 336         assertFalse("isCancelled", request.isCancelled());
 337
 338         assertTrue("handleCompleted", flags[0]);
 339         assertTrue("handleSuccess", flags[1]);
 340         assertFalse("handleFailure", flags[2]);
 341         assertFalse("handleCancel", flags[3]);
 342     }
 343
 344     /**
 345      * Test calling waitForStart() after the request has ended. It should not
 346      * block.
 347      */
 348     @Test
 349     public void testWaitForStartAfterDone() throws InterruptedException {
 350         final boolean[] flags = new boolean[4];
 351         TmfEventRequest request = setupTestRequest(flags);
 352
 353         request.start();
 354         request.done();
 355         request.waitForStart();
 356
 357         assertTrue("isCompleted", request.isCompleted());
 358         assertFalse("isFailed", request.isFailed());
 359         assertFalse("isCancelled", request.isCancelled());
 360
 361         assertTrue("handleCompleted", flags[0]);
 362         assertTrue("handleSuccess", flags[1]);
 363         assertFalse("handleFailure", flags[2]);
 364         assertFalse("handleCancel", flags[3]);
 365     }
 366
 367     /**
 368      * Test calling waitForStart() after the request has beend cancelled. It
 369      * should not block.
 370      */
 371     @Test
 372     public void testWaitForStartAfterCancel() throws InterruptedException {
 373         final boolean[] flags = new boolean[4];
 374         TmfEventRequest request = setupTestRequest(flags);
 375
 376         request.start();
 377         request.cancel();
 378         request.waitForStart();
 379
 380         assertTrue("isCompleted", request.isCompleted());
 381         assertFalse("isFailed", request.isFailed());
 382         assertTrue("isCancelled", request.isCancelled());
 383
 384         assertTrue("handleCompleted", flags[0]);
 385         assertFalse("handleSuccess", flags[1]);
 386         assertFalse("handleFailure", flags[2]);
 387         assertTrue("handleCancel", flags[3]);
 388     }
 389
 390     /**
 391      * Test calling waitForStart() before the request is started. It should not
 392      * block.
 393      */
 394     @Test
 395     public void testWaitForStartBeforeStart() throws InterruptedException {
 396         final boolean[] flags = new boolean[4];
 397         TmfEventRequest request = setupTestRequest(flags);
 398         Thread t = new Thread() {
 399             @Override
 400             public void run() {
 401                 try {
 402                     request.waitForStart();
 403                 } catch (InterruptedException e) {
 404                     // nothing
 405                 }
 406             }
 407         };
 408         t.setPriority(Thread.MAX_PRIORITY);
 409         t.start();
 410         request.start();
 411         t.join();
 412         request.done();
 413
 414         assertTrue("isCompleted", request.isCompleted());
 415         assertFalse("isFailed", request.isFailed());
 416         assertFalse("isCancelled", request.isCancelled());
 417
 418         assertTrue("handleCompleted", flags[0]);
 419         assertTrue("handleSuccess", flags[1]);
 420         assertFalse("handleFailure", flags[2]);
 421         assertFalse("handleCancel", flags[3]);
 422     }
 423
 424 }