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