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

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