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