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

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