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 testEqualsConsistency() throws Exception {
 219         assertTrue("equals", fRequest1.equals(fRequest1));
 220         assertTrue("equals", fRequest1.equals(fRequest1));
 221
 222         assertTrue("equals", fRequest2.equals(fRequest2));
 223         assertTrue("equals", fRequest2.equals(fRequest2));
 224         }
 225
 226         public void testEqualsNull() throws Exception {
 227         assertFalse("equals", fRequest1.equals(null));
 228         assertFalse("equals", fRequest2.equals(null));
 229         }
 230
 231         // ------------------------------------------------------------------------
 232         // hashCode
 233         // ------------------------------------------------------------------------
 234
 235         public void testHashCode() throws Exception {
 236         assertTrue("hashCode", fRequest1.hashCode() == fRequest1.hashCode());
 237         assertTrue("hashCode", fRequest2.hashCode() == fRequest2.hashCode());
 238                 assertTrue("hashCode", fRequest1.hashCode() != fRequest2.hashCode());
 239         }
 240
 241         // ------------------------------------------------------------------------
 242         // toString
 243         // ------------------------------------------------------------------------
 244
 245         public void testToString() {
 246         String expected1 = "[TmfEventRequest(0,TmfEvent," + range1 + ",100,200)]";
 247         String expected2 = "[TmfEventRequest(1,TmfEvent," + range2 + ",100,200)]";
 248         String expected3 = "[TmfEventRequest(2,TmfEvent," + range2 + ",200,200)]";
 249         String expected4 = "[TmfEventRequest(3,TmfEvent," + range2 + ",200,300)]";
 250
 251         assertEquals("toString", expected1, fRequest1.toString());
 252         assertEquals("toString", expected2, fRequest2.toString());
 253         assertEquals("toString", expected3, fRequest3.toString());
 254         assertEquals("toString", expected4, fRequest4.toString());
 255         }
 256
 257         // ------------------------------------------------------------------------
 258         // setData/getData
 259         // ------------------------------------------------------------------------
 260
 261         public void testSetData() {
 262                 // Initialize the data
 263                 int nbEvents = 10;
 264                 TmfEvent[] events = new TmfEvent[nbEvents];
 265                 for (int i = 0; i < nbEvents; i++) {
 266                         events[i] = new TmfEvent(new TmfTimestamp(i), new TmfEventSource(),
 267                                         new TmfEventType(), new TmfEventReference());
 268                 }
 269
 270                 fRequest1.setData(events);
 271                 assertEquals("setData", nbEvents, fRequest1.getNbRead());
 272
 273                 TmfEvent[] eventsRead = fRequest1.getData();
 274                 assertEquals("getData", nbEvents, eventsRead.length);
 275
 276                 for (int i = 0; i < nbEvents; i++) {
 277                         assertEquals("getData", i, eventsRead[i].getTimestamp().getValue());
 278                 }
 279         }
 280
 281         // ------------------------------------------------------------------------
 282         // done
 283         // ------------------------------------------------------------------------
 284
 285         public void testDone() {
 286
 287                 final boolean[] flags = new boolean[4];
 288                 TmfEventRequest<TmfEvent> request = setupTestRequest(flags);
 289                 request.done();
 290
 291                 assertTrue ("isCompleted", request.isCompleted());
 292                 assertFalse("isFailed",    request.isFailed());
 293                 assertFalse("isCancelled", request.isCancelled());
 294
 295                 assertTrue ("handleCompleted", flags[0]);
 296                 assertTrue ("handleSuccess",   flags[1]);
 297                 assertFalse("handleFailure",   flags[2]);
 298                 assertFalse("handleCancel",    flags[3]);
 299         }
 300
 301         // ------------------------------------------------------------------------
 302         // fail
 303         // ------------------------------------------------------------------------
 304
 305         public void testFail() {
 306
 307                 final boolean[] flags = new boolean[4];
 308                 TmfEventRequest<TmfEvent> request = setupTestRequest(flags);
 309                 request.fail();
 310
 311                 assertTrue ("isCompleted", request.isCompleted());
 312                 assertTrue ("isFailed",    request.isFailed());
 313                 assertFalse("isCancelled", request.isCancelled());
 314
 315                 assertTrue ("handleCompleted", flags[0]);
 316                 assertFalse("handleSuccess",   flags[1]);
 317                 assertTrue ("handleFailure",   flags[2]);
 318                 assertFalse("handleCancel",    flags[3]);
 319         }
 320
 321         // ------------------------------------------------------------------------
 322         // cancel
 323         // ------------------------------------------------------------------------
 324
 325         public void testCancel() {
 326
 327                 final boolean[] flags = new boolean[4];
 328                 TmfEventRequest<TmfEvent> request = setupTestRequest(flags);
 329                 request.cancel();
 330
 331                 assertTrue ("isCompleted", request.isCompleted());
 332                 assertFalse("isFailed",    request.isFailed());
 333                 assertTrue ("isCancelled", request.isCancelled());
 334
 335                 assertTrue ("handleCompleted", flags[0]);
 336                 assertFalse("handleSuccess",   flags[1]);
 337                 assertFalse("handleFailure",   flags[2]);
 338                 assertTrue ("handleCancel",    flags[3]);
 339         }
 340
 341         // ------------------------------------------------------------------------
 342         // waitForCompletion
 343         // ------------------------------------------------------------------------
 344
 345 }