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

   1 /*******************************************************************************
   2  * Copyright (c) 2009, 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.assertSame;
  19 import static org.junit.Assert.assertTrue;
  20
  21 import org.eclipse.linuxtools.tmf.core.event.ITmfEvent;
  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("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         TmfEventRequest.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("getRange", TmfTimeRange.ETERNITY, request.getRange());
 112         assertSame("getRange", TmfTimeRange.ETERNITY, request.getRange());
 113
 114         assertEquals("getIndex", 0, request.getIndex());
 115         assertEquals("getNbRequestedEvents", TmfEventRequest.ALL_DATA, request.getNbRequested());
 116
 117         assertFalse("isCompleted", request.isCompleted());
 118         assertFalse("isFailed", request.isFailed());
 119         assertFalse("isCancelled", request.isCancelled());
 120
 121         assertEquals("getNbRead", 0, request.getNbRead());
 122     }
 123
 124     @Test
 125     public void testTmfEventRequestTimeRange() {
 126         TmfTimeRange range = new TmfTimeRange(new TmfTimestamp(), TmfTimestamp.BIG_CRUNCH);
 127         TmfEventRequest request = new TmfEventRequestStub(ITmfEvent.class, range);
 128
 129         assertEquals("getRequestId", fRequestCount++, request.getRequestId());
 130         assertEquals("getDataType",  ITmfEvent.class, request.getDataType());
 131
 132         assertEquals("StartTime", new TmfTimestamp(), request.getRange().getStartTime());
 133         assertEquals("EndTime", TmfTimestamp.BIG_CRUNCH, request.getRange().getEndTime());
 134
 135         assertEquals("getIndex", 0, request.getIndex());
 136         assertEquals("getNbRequestedEvents", TmfEventRequest.ALL_DATA, request.getNbRequested());
 137
 138         assertFalse("isCompleted", request.isCompleted());
 139         assertFalse("isFailed", request.isFailed());
 140         assertFalse("isCancelled", request.isCancelled());
 141
 142         assertEquals("getNbRead", 0, request.getNbRead());
 143     }
 144
 145     @Test
 146     public void testTmfEventRequestTimeRangeNbRequested() {
 147         TmfTimeRange range = new TmfTimeRange(new TmfTimestamp(), TmfTimestamp.BIG_CRUNCH);
 148         TmfEventRequest request = new TmfEventRequestStub(ITmfEvent.class, range, 100);
 149
 150         assertEquals("getRequestId", fRequestCount++, request.getRequestId());
 151         assertEquals("getDataType",  ITmfEvent.class, request.getDataType());
 152
 153         assertEquals("StartTime", new TmfTimestamp(), request.getRange().getStartTime());
 154         assertEquals("EndTime", TmfTimestamp.BIG_CRUNCH, request.getRange().getEndTime());
 155
 156         assertEquals("getIndex", 0, request.getIndex());
 157         assertEquals("getNbRequestedEvents", 100, request.getNbRequested());
 158
 159         assertFalse("isCompleted", request.isCompleted());
 160         assertFalse("isFailed", request.isFailed());
 161         assertFalse("isCancelled", request.isCancelled());
 162
 163         assertEquals("getNbRead", 0, request.getNbRead());
 164     }
 165
 166     @Test
 167     public void testTmfEventRequestTimeRangeNbRequestedBlocksize() {
 168         TmfTimeRange range = new TmfTimeRange(new TmfTimestamp(), TmfTimestamp.BIG_CRUNCH);
 169         TmfEventRequest request = new TmfEventRequestStub(ITmfEvent.class, range, 100, 200);
 170
 171         assertEquals("getRequestId", fRequestCount++, request.getRequestId());
 172         assertEquals("getDataType",  ITmfEvent.class, request.getDataType());
 173
 174         assertEquals("StartTime", new TmfTimestamp(), request.getRange().getStartTime());
 175         assertEquals("EndTime", TmfTimestamp.BIG_CRUNCH, request.getRange().getEndTime());
 176
 177         assertEquals("getIndex", 0, request.getIndex());
 178         assertEquals("getNbRequestedEvents", 100, request.getNbRequested());
 179
 180         assertFalse("isCompleted", request.isCompleted());
 181         assertFalse("isFailed", request.isFailed());
 182         assertFalse("isCancelled", request.isCancelled());
 183
 184         assertEquals("getNbRead", 0, request.getNbRead());
 185     }
 186
 187     // ------------------------------------------------------------------------
 188     // equals
 189     // ------------------------------------------------------------------------
 190
 191     @Test
 192     public void testEqualsReflexivity() {
 193         assertTrue("equals", fRequest1.equals(fRequest1));
 194         assertTrue("equals", fRequest2.equals(fRequest2));
 195
 196         assertFalse("equals", fRequest1.equals(fRequest2));
 197         assertFalse("equals", fRequest2.equals(fRequest1));
 198     }
 199
 200     @Test
 201     public void testEqualsSymmetry() {
 202         assertTrue("equals", fRequest1.equals(fRequest1b));
 203         assertTrue("equals", fRequest1b.equals(fRequest1));
 204
 205         assertFalse("equals", fRequest1.equals(fRequest3));
 206         assertFalse("equals", fRequest2.equals(fRequest3));
 207         assertFalse("equals", fRequest3.equals(fRequest1));
 208         assertFalse("equals", fRequest3.equals(fRequest2));
 209     }
 210
 211     @Test
 212     public void testEqualsTransivity() {
 213         assertTrue("equals", fRequest1.equals(fRequest1b));
 214         assertTrue("equals", fRequest1b.equals(fRequest1c));
 215         assertTrue("equals", fRequest1.equals(fRequest1c));
 216     }
 217
 218     @Test
 219     public void testEqualsNull() {
 220         assertFalse("equals", fRequest1.equals(null));
 221         assertFalse("equals", fRequest2.equals(null));
 222     }
 223
 224     // ------------------------------------------------------------------------
 225     // hashCode
 226     // ------------------------------------------------------------------------
 227
 228     @Test
 229     public void testHashCode() {
 230         assertTrue("hashCode", fRequest1.hashCode() == fRequest1.hashCode());
 231         assertTrue("hashCode", fRequest2.hashCode() == fRequest2.hashCode());
 232         assertTrue("hashCode", fRequest1.hashCode() != fRequest2.hashCode());
 233     }
 234
 235     // ------------------------------------------------------------------------
 236     // toString
 237     // ------------------------------------------------------------------------
 238
 239     @Test
 240     public void testToString() {
 241         String expected1 = "[TmfEventRequestStub(0,ITmfEvent,FOREGROUND," + range1 + ",0,100)]";
 242         String expected2 = "[TmfEventRequestStub(1,ITmfEvent,FOREGROUND," + range2 + ",0,100)]";
 243         String expected3 = "[TmfEventRequestStub(2,ITmfEvent,FOREGROUND," + range2 + ",0,200)]";
 244         String expected4 = "[TmfEventRequestStub(3,ITmfEvent,FOREGROUND," + range2 + ",0,200)]";
 245
 246         assertEquals("toString", expected1, fRequest1.toString());
 247         assertEquals("toString", expected2, fRequest2.toString());
 248         assertEquals("toString", expected3, fRequest3.toString());
 249         assertEquals("toString", expected4, fRequest4.toString());
 250     }
 251
 252     // ------------------------------------------------------------------------
 253     // done
 254     // ------------------------------------------------------------------------
 255
 256     @Test
 257     public void testDone() {
 258         final boolean[] flags = new boolean[4];
 259         TmfEventRequest request = setupTestRequest(flags);
 260         request.done();
 261
 262         assertTrue("isCompleted", request.isCompleted());
 263         assertFalse("isFailed", request.isFailed());
 264         assertFalse("isCancelled", request.isCancelled());
 265
 266         assertTrue("handleCompleted", flags[0]);
 267         assertTrue("handleSuccess", flags[1]);
 268         assertFalse("handleFailure", flags[2]);
 269         assertFalse("handleCancel", flags[3]);
 270     }
 271
 272     // ------------------------------------------------------------------------
 273     // fail
 274     // ------------------------------------------------------------------------
 275
 276     @Test
 277     public void testFail() {
 278         final boolean[] flags = new boolean[4];
 279         TmfEventRequest request = setupTestRequest(flags);
 280         request.fail();
 281
 282         assertTrue("isCompleted", request.isCompleted());
 283         assertTrue("isFailed", request.isFailed());
 284         assertFalse("isCancelled", request.isCancelled());
 285
 286         assertTrue("handleCompleted", flags[0]);
 287         assertFalse("handleSuccess", flags[1]);
 288         assertTrue("handleFailure", flags[2]);
 289         assertFalse("handleCancel", flags[3]);
 290     }
 291
 292     // ------------------------------------------------------------------------
 293     // cancel
 294     // ------------------------------------------------------------------------
 295
 296     @Test
 297     public void testCancel() {
 298         final boolean[] flags = new boolean[4];
 299         TmfEventRequest request = setupTestRequest(flags);
 300         request.cancel();
 301
 302         assertTrue("isCompleted", request.isCompleted());
 303         assertFalse("isFailed", request.isFailed());
 304         assertTrue("isCancelled", request.isCancelled());
 305
 306         assertTrue("handleCompleted", flags[0]);
 307         assertFalse("handleSuccess", flags[1]);
 308         assertFalse("handleFailure", flags[2]);
 309         assertTrue("handleCancel", flags[3]);
 310     }
 311
 312 }