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