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.assertSame;
  19 import static org.junit.Assert.assertTrue;
  20
  21 import org.eclipse.tracecompass.tmf.core.event.ITmfEvent;
  22 import org.eclipse.tracecompass.tmf.core.request.ITmfEventRequest;
  23 import org.eclipse.tracecompass.tmf.core.request.ITmfEventRequest.ExecutionType;
  24 import org.eclipse.tracecompass.tmf.core.request.TmfEventRequest;
  25 import org.eclipse.tracecompass.tmf.core.timestamp.TmfTimeRange;
  26 import org.eclipse.tracecompass.tmf.core.timestamp.TmfTimestamp;
  27 import org.eclipse.tracecompass.tmf.tests.stubs.request.TmfEventRequestStub;
  28 import org.junit.Before;
  29 import org.junit.Test;
  30
  31 /**
  32  * Test suite for the TmfEventRequest class.
  33  */
  34 @SuppressWarnings("javadoc")
  35 public class TmfEventRequestTest {
  36
  37     // ------------------------------------------------------------------------
  38     // Variables
  39     // ------------------------------------------------------------------------
  40
  41     private static TmfTimeRange range1 = TmfTimeRange.ETERNITY;
  42     private static TmfTimeRange range2 = new TmfTimeRange(TmfTimestamp.fromSeconds(0), TmfTimestamp.BIG_CRUNCH);
  43
  44     private static TmfEventRequest fRequest1;
  45     private static TmfEventRequest fRequest2;
  46     private static TmfEventRequest fRequest3;
  47     private static TmfEventRequest fRequest4;
  48     private static TmfEventRequest fRequest5;
  49
  50     // ------------------------------------------------------------------------
  51     // Housekeeping
  52     // ------------------------------------------------------------------------
  53
  54     @Before
  55     public void setUp() {
  56         fRequest1 = new TmfEventRequestStub(ITmfEvent.class, range1, 100, 200);
  57         fRequest2 = new TmfEventRequestStub(ITmfEvent.class, range2, 100, 200);
  58         fRequest3 = new TmfEventRequestStub(ITmfEvent.class, range2, 200, 200);
  59         fRequest4 = new TmfEventRequestStub(ITmfEvent.class, range2, 200, 300);
  60         fRequest5 = new TmfEventRequestStub(ITmfEvent.class, range2, 200, 300, ExecutionType.FOREGROUND, 1);
  61     }
  62
  63     private static TmfEventRequest setupTestRequest(final boolean[] flags) {
  64
  65         TmfEventRequest request = new TmfEventRequestStub(ITmfEvent.class, TmfTimeRange.ETERNITY, 100, 200) {
  66             @Override
  67             public void handleCompleted() {
  68                 super.handleCompleted();
  69                 flags[0] = true;
  70             }
  71
  72             @Override
  73             public void handleSuccess() {
  74                 super.handleSuccess();
  75                 flags[1] = true;
  76             }
  77
  78             @Override
  79             public void handleFailure() {
  80                 super.handleFailure();
  81                 flags[2] = true;
  82             }
  83
  84             @Override
  85             public void handleCancel() {
  86                 super.handleCancel();
  87                 flags[3] = true;
  88             }
  89         };
  90         return request;
  91     }
  92
  93     // ------------------------------------------------------------------------
  94     // Constructors
  95     // ------------------------------------------------------------------------
  96
  97     @Test
  98     public void testTmfEventRequest() {
  99         TmfEventRequest request = new TmfEventRequestStub(ITmfEvent.class);
 100
 101         assertEquals("getDataType", ITmfEvent.class, request.getDataType());
 102
 103         assertEquals("StartTime", TmfTimestamp.BIG_BANG, request.getRange().getStartTime());
 104         assertEquals("EndTime", TmfTimestamp.BIG_CRUNCH, request.getRange().getEndTime());
 105
 106         assertEquals("getRange", TmfTimeRange.ETERNITY, request.getRange());
 107         assertSame("getRange", TmfTimeRange.ETERNITY, request.getRange());
 108
 109         assertEquals("getIndex", 0, request.getIndex());
 110         assertEquals("getNbRequestedEvents", ITmfEventRequest.ALL_DATA, request.getNbRequested());
 111
 112         assertFalse("isCompleted", request.isCompleted());
 113         assertFalse("isFailed", request.isFailed());
 114         assertFalse("isCancelled", request.isCancelled());
 115
 116         assertEquals("getNbRead", 0, request.getNbRead());
 117         assertEquals("getDependencyLevel", 0, request.getDependencyLevel());
 118     }
 119
 120     @Test
 121     public void testTmfEventRequestTimeRange() {
 122         TmfTimeRange range = new TmfTimeRange(TmfTimestamp.fromSeconds(0), TmfTimestamp.BIG_CRUNCH);
 123         TmfEventRequest request = new TmfEventRequestStub(ITmfEvent.class, range);
 124
 125         assertEquals("getDataType",  ITmfEvent.class, request.getDataType());
 126
 127         assertEquals("StartTime", TmfTimestamp.fromSeconds(0), request.getRange().getStartTime());
 128         assertEquals("EndTime", TmfTimestamp.BIG_CRUNCH, request.getRange().getEndTime());
 129
 130         assertEquals("getIndex", 0, request.getIndex());
 131         assertEquals("getNbRequestedEvents", ITmfEventRequest.ALL_DATA, request.getNbRequested());
 132
 133         assertFalse("isCompleted", request.isCompleted());
 134         assertFalse("isFailed", request.isFailed());
 135         assertFalse("isCancelled", request.isCancelled());
 136
 137         assertEquals("getNbRead", 0, request.getNbRead());
 138         assertEquals("getDependencyLevel", 0, request.getDependencyLevel());
 139     }
 140
 141     @Test
 142     public void testTmfEventRequestTimeRangeNbRequested() {
 143         TmfTimeRange range = new TmfTimeRange(TmfTimestamp.fromSeconds(0), TmfTimestamp.BIG_CRUNCH);
 144         TmfEventRequest request = new TmfEventRequestStub(ITmfEvent.class, range, 100);
 145
 146         assertEquals("getDataType",  ITmfEvent.class, request.getDataType());
 147
 148         assertEquals("StartTime", TmfTimestamp.fromSeconds(0), request.getRange().getStartTime());
 149         assertEquals("EndTime", TmfTimestamp.BIG_CRUNCH, request.getRange().getEndTime());
 150
 151         assertEquals("getIndex", 0, request.getIndex());
 152         assertEquals("getNbRequestedEvents", 100, request.getNbRequested());
 153
 154         assertFalse("isCompleted", request.isCompleted());
 155         assertFalse("isFailed", request.isFailed());
 156         assertFalse("isCancelled", request.isCancelled());
 157
 158         assertEquals("getNbRead", 0, request.getNbRead());
 159         assertEquals("getDependencyLevel", 0, request.getDependencyLevel());
 160     }
 161
 162     @Test
 163     public void testTmfEventRequestTimeRangeNbRequestedBlocksize() {
 164         TmfTimeRange range = new TmfTimeRange(TmfTimestamp.fromSeconds(0), TmfTimestamp.BIG_CRUNCH);
 165         TmfEventRequest request = new TmfEventRequestStub(ITmfEvent.class, range, 100, 200);
 166
 167         assertEquals("getDataType",  ITmfEvent.class, request.getDataType());
 168
 169         assertEquals("StartTime", TmfTimestamp.fromSeconds(0), request.getRange().getStartTime());
 170         assertEquals("EndTime", TmfTimestamp.BIG_CRUNCH, request.getRange().getEndTime());
 171
 172         assertEquals("getIndex", 0, request.getIndex());
 173         assertEquals("getNbRequestedEvents", 100, request.getNbRequested());
 174
 175         assertFalse("isCompleted", request.isCompleted());
 176         assertFalse("isFailed", request.isFailed());
 177         assertFalse("isCancelled", request.isCancelled());
 178
 179         assertEquals("getNbRead", 0, request.getNbRead());
 180         assertEquals("getDependencyLevel", 0, request.getDependencyLevel());
 181     }
 182
 183     @Test
 184     public void testTmfEventRequestWithDependencyLevel() {
 185         TmfTimeRange range = new TmfTimeRange(TmfTimestamp.fromSeconds(0), TmfTimestamp.BIG_CRUNCH);
 186         TmfEventRequest request = new TmfEventRequestStub(ITmfEvent.class, range, 100, 200, ExecutionType.FOREGROUND, 1);
 187
 188         assertEquals("getDataType",  ITmfEvent.class, request.getDataType());
 189
 190         assertEquals("StartTime", TmfTimestamp.fromSeconds(0), request.getRange().getStartTime());
 191         assertEquals("EndTime", TmfTimestamp.BIG_CRUNCH, request.getRange().getEndTime());
 192
 193         assertEquals("getIndex", 0, request.getIndex());
 194         assertEquals("getNbRequestedEvents", 100, request.getNbRequested());
 195
 196         assertFalse("isCompleted", request.isCompleted());
 197         assertFalse("isFailed", request.isFailed());
 198         assertFalse("isCancelled", request.isCancelled());
 199
 200         assertEquals("getNbRead", 0, request.getNbRead());
 201         assertEquals("getDependencyLevel", 1, request.getDependencyLevel());
 202     }
 203
 204     // ------------------------------------------------------------------------
 205     // equals
 206     // ------------------------------------------------------------------------
 207
 208     @Test
 209     public void testEquals() {
 210         /*
 211          * No two different requests should be "equal", even if they used the
 212          * same constructor parameters.
 213          */
 214         assertTrue(fRequest1.equals(fRequest1));
 215         assertFalse(fRequest1.equals(fRequest2));
 216         assertFalse(fRequest1.equals(fRequest3));
 217         assertFalse(fRequest1.equals(fRequest4));
 218
 219         /* Request with different dependency level, but otherwise identical, are not equal */
 220         assertFalse(fRequest4.equals(fRequest5));
 221     }
 222
 223     // ------------------------------------------------------------------------
 224     // toString
 225     // ------------------------------------------------------------------------
 226
 227     @Test
 228     public void testToString() {
 229         String expected1 = "[TmfEventRequestStub(" + fRequest1.getRequestId() + ",ITmfEvent,FOREGROUND," + range1 + ",0,100,0)]";
 230         String expected2 = "[TmfEventRequestStub(" + fRequest2.getRequestId() + ",ITmfEvent,FOREGROUND," + range2 + ",0,100,0)]";
 231         String expected3 = "[TmfEventRequestStub(" + fRequest3.getRequestId() + ",ITmfEvent,FOREGROUND," + range2 + ",0,200,0)]";
 232         String expected4 = "[TmfEventRequestStub(" + fRequest4.getRequestId() + ",ITmfEvent,FOREGROUND," + range2 + ",0,200,0)]";
 233         String expected5 = "[TmfEventRequestStub(" + fRequest5.getRequestId() + ",ITmfEvent,FOREGROUND," + range2 + ",0,200,1)]";
 234
 235         assertEquals("toString", expected1, fRequest1.toString());
 236         assertEquals("toString", expected2, fRequest2.toString());
 237         assertEquals("toString", expected3, fRequest3.toString());
 238         assertEquals("toString", expected4, fRequest4.toString());
 239         assertEquals("toString", expected5, fRequest5.toString());
 240     }
 241
 242     // ------------------------------------------------------------------------
 243     // done
 244     // ------------------------------------------------------------------------
 245
 246     @Test
 247     public void testDone() {
 248         final boolean[] flags = new boolean[4];
 249         TmfEventRequest request = setupTestRequest(flags);
 250         request.done();
 251
 252         assertTrue("isCompleted", request.isCompleted());
 253         assertFalse("isFailed", request.isFailed());
 254         assertFalse("isCancelled", request.isCancelled());
 255
 256         assertTrue("handleCompleted", flags[0]);
 257         assertTrue("handleSuccess", flags[1]);
 258         assertFalse("handleFailure", flags[2]);
 259         assertFalse("handleCancel", flags[3]);
 260     }
 261
 262     // ------------------------------------------------------------------------
 263     // fail
 264     // ------------------------------------------------------------------------
 265
 266     @Test
 267     public void testFail() {
 268         final boolean[] flags = new boolean[4];
 269         TmfEventRequest request = setupTestRequest(flags);
 270         request.fail();
 271
 272         assertTrue("isCompleted", request.isCompleted());
 273         assertTrue("isFailed", request.isFailed());
 274         assertFalse("isCancelled", request.isCancelled());
 275
 276         assertTrue("handleCompleted", flags[0]);
 277         assertFalse("handleSuccess", flags[1]);
 278         assertTrue("handleFailure", flags[2]);
 279         assertFalse("handleCancel", flags[3]);
 280     }
 281
 282     // ------------------------------------------------------------------------
 283     // cancel
 284     // ------------------------------------------------------------------------
 285
 286     @Test
 287     public void testCancel() {
 288         final boolean[] flags = new boolean[4];
 289         TmfEventRequest request = setupTestRequest(flags);
 290         request.cancel();
 291
 292         assertTrue("isCompleted", request.isCompleted());
 293         assertFalse("isFailed", request.isFailed());
 294         assertTrue("isCancelled", request.isCancelled());
 295
 296         assertTrue("handleCompleted", flags[0]);
 297         assertFalse("handleSuccess", flags[1]);
 298         assertFalse("handleFailure", flags[2]);
 299         assertTrue("handleCancel", flags[3]);
 300     }
 301
 302 }