org.eclipse.linuxtools.tmf.tests/src/org/eclipse/linuxtools/tmf/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.tests.request;
  14
  15 import junit.framework.TestCase;
  16
  17 import org.eclipse.linuxtools.tmf.event.TmfEvent;
  18 import org.eclipse.linuxtools.tmf.event.TmfEventReference;
  19 import org.eclipse.linuxtools.tmf.event.TmfEventSource;
  20 import org.eclipse.linuxtools.tmf.event.TmfEventType;
  21 import org.eclipse.linuxtools.tmf.event.TmfTimeRange;
  22 import org.eclipse.linuxtools.tmf.event.TmfTimestamp;
  23 import org.eclipse.linuxtools.tmf.request.TmfDataRequest;
  24 import org.eclipse.linuxtools.tmf.request.TmfEventRequest;
  25 import org.eclipse.linuxtools.tmf.request.TmfEventRequestStub;
  26
  27 /**
  28  * <b><u>TmfEventRequestTest</u></b>
  29  * <p>
  30  * Test suite for the TmfEventRequest class.
  31  */
  32 public class TmfEventRequestTest extends TestCase {
  33
  34         // ------------------------------------------------------------------------
  35         // Variables
  36         // ------------------------------------------------------------------------
  37
  38         private static TmfTimeRange range1 = new TmfTimeRange(TmfTimeRange.Eternity);
  39         private static TmfTimeRange range2 = new TmfTimeRange(new TmfTimestamp(), TmfTimestamp.BigCrunch);
  40
  41         private static TmfEventRequest<TmfEvent> fRequest1;
  42         private static TmfEventRequest<TmfEvent> fRequest1b;
  43         private static TmfEventRequest<TmfEvent> fRequest1c;
  44         private static TmfEventRequest<TmfEvent> fRequest2;
  45         private static TmfEventRequest<TmfEvent> fRequest3;
  46         private static TmfEventRequest<TmfEvent> fRequest4;
  47
  48         private static int fRequestCount;
  49
  50         // ------------------------------------------------------------------------
  51         // Housekeeping
  52         // ------------------------------------------------------------------------
  53
  54         public TmfEventRequestTest(String name) {
  55                 super(name);
  56         }
  57
  58         @Override
  59         protected void setUp() throws Exception {
  60                 super.setUp();
  61                 TmfDataRequest.reset();
  62                 fRequest1  = new TmfEventRequestStub<TmfEvent>(TmfEvent.class, range1, 100, 200);
  63                 fRequest2  = new TmfEventRequestStub<TmfEvent>(TmfEvent.class, range2, 100, 200);
  64                 fRequest3  = new TmfEventRequestStub<TmfEvent>(TmfEvent.class, range2, 200, 200);
  65                 fRequest4  = new TmfEventRequestStub<TmfEvent>(TmfEvent.class, range2, 200, 300);
  66                 fRequest1b = new TmfEventRequestStub<TmfEvent>(TmfEvent.class, range1, 100, 200);
  67                 fRequest1c = new TmfEventRequestStub<TmfEvent>(TmfEvent.class, range1, 100, 200);
  68                 fRequestCount = fRequest1c.getRequestId() + 1;
  69         }
  70
  71         @Override
  72         protected void tearDown() throws Exception {
  73                 super.tearDown();
  74         }
  75
  76         private TmfEventRequest<TmfEvent> setupTestRequest(final boolean[] flags) {
  77
  78                 TmfEventRequest<TmfEvent> request = new TmfEventRequestStub<TmfEvent>(TmfEvent.class, new TmfTimeRange(TmfTimeRange.Eternity), 100, 200) {
  79                     @Override
  80                         public void handleCompleted() {
  81                         super.handleCompleted();
  82                         flags[0] = true;
  83                     }
  84                     @Override
  85                     public void handleSuccess() {
  86                         super.handleSuccess();
  87                         flags[1] = true;
  88                     }
  89                     @Override
  90                     public void handleFailure() {
  91                         super.handleFailure();
  92                         flags[2] = true;
  93                     }
  94                     @Override
  95                     public void handleCancel() {
  96                         super.handleCancel();
  97                         flags[3] = true;
  98                     }
  99                 };
 100                 return request;
 101         }
 102
 103         // ------------------------------------------------------------------------
 104         // Constructors
 105         // ------------------------------------------------------------------------
 106
 107         public void testTmfEventRequest() {
 108         TmfEventRequest<TmfEvent> request = new TmfEventRequestStub<TmfEvent>(TmfEvent.class);
 109
 110         assertEquals("getRequestId", fRequestCount++, request.getRequestId());
 111         assertEquals("getDataType",  TmfEvent.class, request.getDataType());
 112
 113         assertEquals("StartTime", TmfTimestamp.BigBang,   request.getRange().getStartTime());
 114         assertEquals("EndTime",   TmfTimestamp.BigCrunch, request.getRange().getEndTime());
 115
 116         assertEquals("getIndex", 0, request.getIndex());
 117         assertEquals("getNbRequestedEvents", TmfDataRequest.ALL_DATA, request.getNbRequested());
 118         assertEquals("getBlockize", TmfDataRequest.DEFAULT_BLOCK_SIZE, request.getBlockize());
 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.BigCrunch);
 129         TmfEventRequest<TmfEvent> request = new TmfEventRequestStub<TmfEvent>(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.BigCrunch, request.getRange().getEndTime());
 136
 137         assertEquals("getIndex", 0, request.getIndex());
 138         assertEquals("getNbRequestedEvents", TmfDataRequest.ALL_DATA, request.getNbRequested());
 139         assertEquals("getBlockize", TmfDataRequest.DEFAULT_BLOCK_SIZE, request.getBlockize());
 140
 141         assertFalse("isCompleted", request.isCompleted());
 142         assertFalse("isFailed", request.isFailed());
 143         assertFalse("isCancelled", request.isCancelled());
 144
 145         assertEquals("getNbRead", 0, request.getNbRead());
 146         }
 147
 148         public void testTmfEventRequestTimeRangeNbRequested() {
 149         TmfTimeRange range = new TmfTimeRange(new TmfTimestamp(), TmfTimestamp.BigCrunch);
 150         TmfEventRequest<TmfEvent> request = new TmfEventRequestStub<TmfEvent>(TmfEvent.class, range, 100);
 151
 152         assertEquals("getRequestId", fRequestCount++, request.getRequestId());
 153         assertEquals("getDataType",  TmfEvent.class, request.getDataType());
 154
 155         assertEquals("StartTime", new TmfTimestamp(), request.getRange().getStartTime());
 156         assertEquals("EndTime",   TmfTimestamp.BigCrunch, request.getRange().getEndTime());
 157
 158         assertEquals("getIndex", 0, request.getIndex());
 159         assertEquals("getNbRequestedEvents", 100, request.getNbRequested());
 160         assertEquals("getBlockize", TmfDataRequest.DEFAULT_BLOCK_SIZE, request.getBlockize());
 161
 162         assertFalse("isCompleted", request.isCompleted());
 163         assertFalse("isFailed", request.isFailed());
 164         assertFalse("isCancelled", request.isCancelled());
 165
 166         assertEquals("getNbRead", 0, request.getNbRead());
 167         }
 168
 169         public void testTmfEventRequestTimeRangeNbRequestedBlocksize() {
 170         TmfTimeRange range = new TmfTimeRange(new TmfTimestamp(), TmfTimestamp.BigCrunch);
 171         TmfEventRequest<TmfEvent> request = new TmfEventRequestStub<TmfEvent>(TmfEvent.class, range, 100, 200);
 172
 173         assertEquals("getRequestId", fRequestCount++, request.getRequestId());
 174         assertEquals("getDataType",  TmfEvent.class, request.getDataType());
 175
 176         assertEquals("StartTime", new TmfTimestamp(), request.getRange().getStartTime());
 177         assertEquals("EndTime",   TmfTimestamp.BigCrunch, request.getRange().getEndTime());
 178
 179         assertEquals("getIndex", 0, request.getIndex());
 180         assertEquals("getNbRequestedEvents", 100, request.getNbRequested());
 181         assertEquals("getBlockize", 200, request.getBlockize());
 182
 183         assertFalse("isCompleted", request.isCompleted());
 184         assertFalse("isFailed", request.isFailed());
 185         assertFalse("isCancelled", request.isCancelled());
 186
 187         assertEquals("getNbRead", 0, request.getNbRead());
 188         }
 189
 190         // ------------------------------------------------------------------------
 191         // equals
 192         // ------------------------------------------------------------------------
 193
 194         public void testEqualsReflexivity() throws Exception {
 195         assertTrue("equals", fRequest1.equals(fRequest1));
 196         assertTrue("equals", fRequest2.equals(fRequest2));
 197
 198         assertFalse("equals", fRequest1.equals(fRequest2));
 199         assertFalse("equals", fRequest2.equals(fRequest1));
 200         }
 201
 202         public void testEqualsSymmetry() throws Exception {
 203         assertTrue("equals", fRequest1.equals(fRequest1b));
 204         assertTrue("equals", fRequest1b.equals(fRequest1));
 205
 206         assertFalse("equals", fRequest1.equals(fRequest3));
 207         assertFalse("equals", fRequest2.equals(fRequest3));
 208         assertFalse("equals", fRequest3.equals(fRequest1));
 209         assertFalse("equals", fRequest3.equals(fRequest2));
 210         }
 211
 212         public void testEqualsTransivity() throws Exception {
 213         assertTrue("equals", fRequest1.equals(fRequest1b));
 214         assertTrue("equals", fRequest1b.equals(fRequest1c));
 215         assertTrue("equals", fRequest1.equals(fRequest1c));
 216         }
 217
 218         public void testEqualsNull() throws Exception {
 219         assertFalse("equals", fRequest1.equals(null));
 220         assertFalse("equals", fRequest2.equals(null));
 221         }
 222
 223         // ------------------------------------------------------------------------
 224         // hashCode
 225         // ------------------------------------------------------------------------
 226
 227         public void testHashCode() throws Exception {
 228         assertTrue("hashCode", fRequest1.hashCode() == fRequest1.hashCode());
 229         assertTrue("hashCode", fRequest2.hashCode() == fRequest2.hashCode());
 230                 assertTrue("hashCode", fRequest1.hashCode() != fRequest2.hashCode());
 231         }
 232
 233         // ------------------------------------------------------------------------
 234         // toString
 235         // ------------------------------------------------------------------------
 236
 237         public void testToString() {
 238         String expected1 = "[TmfEventRequest(0,TmfEvent," + range1 + ",100,200)]";
 239         String expected2 = "[TmfEventRequest(1,TmfEvent," + range2 + ",100,200)]";
 240         String expected3 = "[TmfEventRequest(2,TmfEvent," + range2 + ",200,200)]";
 241         String expected4 = "[TmfEventRequest(3,TmfEvent," + range2 + ",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         // setData/getData
 251         // ------------------------------------------------------------------------
 252
 253         public void testSetData() {
 254                 // Initialize the data
 255                 int nbEvents = 10;
 256                 TmfEvent[] events = new TmfEvent[nbEvents];
 257                 for (int i = 0; i < nbEvents; i++) {
 258                         events[i] = new TmfEvent(new TmfTimestamp(i), new TmfEventSource(),
 259                                         new TmfEventType(), new TmfEventReference());
 260                 }
 261
 262                 fRequest1.setData(events);
 263                 assertEquals("setData", nbEvents, fRequest1.getNbRead());
 264
 265                 TmfEvent[] eventsRead = fRequest1.getData();
 266                 assertEquals("getData", nbEvents, eventsRead.length);
 267
 268                 for (int i = 0; i < nbEvents; i++) {
 269                         assertEquals("getData", i, eventsRead[i].getTimestamp().getValue());
 270                 }
 271         }
 272
 273         // ------------------------------------------------------------------------
 274         // done
 275         // ------------------------------------------------------------------------
 276
 277         public void testDone() {
 278
 279                 final boolean[] flags = new boolean[4];
 280                 TmfEventRequest<TmfEvent> request = setupTestRequest(flags);
 281                 request.done();
 282
 283                 assertTrue ("isCompleted", request.isCompleted());
 284                 assertFalse("isFailed",    request.isFailed());
 285                 assertFalse("isCancelled", request.isCancelled());
 286
 287                 assertTrue ("handleCompleted", flags[0]);
 288                 assertTrue ("handleSuccess",   flags[1]);
 289                 assertFalse("handleFailure",   flags[2]);
 290                 assertFalse("handleCancel",    flags[3]);
 291         }
 292
 293         // ------------------------------------------------------------------------
 294         // fail
 295         // ------------------------------------------------------------------------
 296
 297         public void testFail() {
 298
 299                 final boolean[] flags = new boolean[4];
 300                 TmfEventRequest<TmfEvent> request = setupTestRequest(flags);
 301                 request.fail();
 302
 303                 assertTrue ("isCompleted", request.isCompleted());
 304                 assertTrue ("isFailed",    request.isFailed());
 305                 assertFalse("isCancelled", request.isCancelled());
 306
 307                 assertTrue ("handleCompleted", flags[0]);
 308                 assertFalse("handleSuccess",   flags[1]);
 309                 assertTrue ("handleFailure",   flags[2]);
 310                 assertFalse("handleCancel",    flags[3]);
 311         }
 312
 313         // ------------------------------------------------------------------------
 314         // cancel
 315         // ------------------------------------------------------------------------
 316
 317         public void testCancel() {
 318
 319                 final boolean[] flags = new boolean[4];
 320                 TmfEventRequest<TmfEvent> request = setupTestRequest(flags);
 321                 request.cancel();
 322
 323                 assertTrue ("isCompleted", request.isCompleted());
 324                 assertFalse("isFailed",    request.isFailed());
 325                 assertTrue ("isCancelled", request.isCancelled());
 326
 327                 assertTrue ("handleCompleted", flags[0]);
 328                 assertFalse("handleSuccess",   flags[1]);
 329                 assertFalse("handleFailure",   flags[2]);
 330                 assertTrue ("handleCancel",    flags[3]);
 331         }
 332
 333         // ------------------------------------------------------------------------
 334         // waitForCompletion
 335         // ------------------------------------------------------------------------
 336
 337 }