org.eclipse.linuxtools.tmf.tests/src/org/eclipse/linuxtools/tmf/tests/request/TmfCoalescedDataRequestTest.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
  16 import junit.framework.TestCase;
  17
  18 import org.eclipse.linuxtools.tmf.event.TmfEvent;
  19 import org.eclipse.linuxtools.tmf.request.TmfCoalescedDataRequest;
  20 import org.eclipse.linuxtools.tmf.request.TmfDataRequest;
  21 import org.eclipse.linuxtools.tmf.request.TmfDataRequestStub;
  22
  23 /**
  24  * <b><u>TmfCoalescedDataRequestTest</u></b>
  25  * <p>
  26  * Test suite for the TmfCoalescedDataRequest class.
  27  */
  28 public class TmfCoalescedDataRequestTest extends TestCase {
  29
  30         // ------------------------------------------------------------------------
  31         // Variables
  32         // ------------------------------------------------------------------------
  33
  34         private static TmfCoalescedDataRequest<TmfEvent> fRequest1;
  35         private static TmfCoalescedDataRequest<TmfEvent> fRequest2;
  36         private static TmfCoalescedDataRequest<TmfEvent> fRequest3;
  37         private static TmfCoalescedDataRequest<TmfEvent> fRequest4;
  38
  39         private static TmfCoalescedDataRequest<TmfEvent> fRequest1b;
  40         private static TmfCoalescedDataRequest<TmfEvent> fRequest1c;
  41
  42         private static int fRequestCount;
  43
  44         // ------------------------------------------------------------------------
  45         // Housekeeping
  46         // ------------------------------------------------------------------------
  47
  48         public TmfCoalescedDataRequestTest(String name) {
  49                 super(name);
  50         }
  51
  52         @Override
  53         public void setUp() throws Exception {
  54                 super.setUp();
  55                 TmfDataRequest.reset();
  56                 fRequest1  = new TmfCoalescedDataRequest<TmfEvent>(TmfEvent.class, 10, 100, 200);
  57                 fRequest2  = new TmfCoalescedDataRequest<TmfEvent>(TmfEvent.class, 20, 100, 200);
  58                 fRequest3  = new TmfCoalescedDataRequest<TmfEvent>(TmfEvent.class, 20, 200, 200);
  59                 fRequest4  = new TmfCoalescedDataRequest<TmfEvent>(TmfEvent.class, 20, 200, 300);
  60
  61                 fRequest1b = new TmfCoalescedDataRequest<TmfEvent>(TmfEvent.class, 10, 100, 200);
  62                 fRequest1c = new TmfCoalescedDataRequest<TmfEvent>(TmfEvent.class, 10, 100, 200);
  63
  64                 fRequestCount = fRequest1c.getRequestId() + 1;
  65         }
  66
  67         @Override
  68         public void tearDown() throws Exception {
  69                 super.tearDown();
  70         }
  71
  72         private TmfCoalescedDataRequest<TmfEvent> setupTestRequest(final boolean[] flags) {
  73
  74                 TmfCoalescedDataRequest<TmfEvent> request = new TmfCoalescedDataRequest<TmfEvent>(TmfEvent.class, 10, 100, 200) {
  75                     @Override
  76                         public void handleCompleted() {
  77                         super.handleCompleted();
  78                         flags[0] = true;
  79                     }
  80                     @Override
  81                     public void handleSuccess() {
  82                         super.handleSuccess();
  83                         flags[1] = true;
  84                     }
  85                     @Override
  86                     public void handleFailure() {
  87                         super.handleFailure();
  88                         flags[2] = true;
  89                     }
  90                     @Override
  91                     public void handleCancel() {
  92                         super.handleCancel();
  93                         flags[3] = true;
  94                     }
  95                 };
  96                 return request;
  97         }
  98
  99         // ------------------------------------------------------------------------
 100         // Constructors
 101         // ------------------------------------------------------------------------
 102
 103         public void testTmfCoalescedDataRequest() {
 104                 TmfCoalescedDataRequest<TmfEvent> request = new TmfCoalescedDataRequest<TmfEvent>(TmfEvent.class);
 105
 106         assertEquals("getRequestId", fRequestCount++, request.getRequestId());
 107         assertEquals("getDataType",  TmfEvent.class, request.getDataType());
 108
 109         assertEquals("getIndex", 0, request.getIndex());
 110         assertEquals("getNbRequestedEvents", TmfDataRequest.ALL_DATA, request.getNbRequested());
 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 testTmfCoalescedDataRequestIndex() {
 120                 TmfCoalescedDataRequest<TmfEvent> request = new TmfCoalescedDataRequest<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
 128         assertFalse("isCompleted", request.isCompleted());
 129         assertFalse("isFailed", request.isFailed());
 130         assertFalse("isCancelled", request.isCancelled());
 131
 132         assertEquals("getNbRead", 0, request.getNbRead());
 133         }
 134
 135         public void testTmfCoalescedDataRequestIndexNbRequested() {
 136                 TmfCoalescedDataRequest<TmfEvent> request = new TmfCoalescedDataRequest<TmfEvent>(TmfEvent.class, 10, 100);
 137
 138         assertEquals("getRequestId", fRequestCount++, request.getRequestId());
 139         assertEquals("getDataType",  TmfEvent.class, request.getDataType());
 140
 141         assertEquals("getIndex", 10, request.getIndex());
 142         assertEquals("getNbRequestedEvents", 100, request.getNbRequested());
 143
 144         assertFalse("isCompleted", request.isCompleted());
 145         assertFalse("isFailed", request.isFailed());
 146         assertFalse("isCancelled", request.isCancelled());
 147
 148         assertEquals("getNbRead", 0, request.getNbRead());
 149         }
 150
 151         public void testTmfCoalescedDataRequestIndexNbEventsBlocksize() {
 152                 TmfCoalescedDataRequest<TmfEvent> request = new TmfCoalescedDataRequest<TmfEvent>(TmfEvent.class, 10, 100, 200);
 153
 154         assertEquals("getRequestId", fRequestCount++, request.getRequestId());
 155         assertEquals("getDataType",  TmfEvent.class, request.getDataType());
 156
 157         assertEquals("getIndex", 10, request.getIndex());
 158         assertEquals("getNbRequestedEvents", 100, request.getNbRequested());
 159
 160         assertFalse("isCompleted", request.isCompleted());
 161         assertFalse("isFailed", request.isFailed());
 162         assertFalse("isCancelled", request.isCancelled());
 163
 164         assertEquals("getNbRead", 0, request.getNbRead());
 165         }
 166
 167         // ------------------------------------------------------------------------
 168         // equals
 169         // ------------------------------------------------------------------------
 170
 171         public void testEqualsReflexivity() throws Exception {
 172         assertTrue("equals", fRequest1.equals(fRequest1));
 173         assertTrue("equals", fRequest2.equals(fRequest2));
 174
 175         assertFalse("equals", fRequest1.equals(fRequest2));
 176         assertFalse("equals", fRequest2.equals(fRequest1));
 177         }
 178
 179         public void testEqualsSymmetry() throws Exception {
 180         assertTrue("equals", fRequest1.equals(fRequest1b));
 181         assertTrue("equals", fRequest1b.equals(fRequest1));
 182
 183         assertFalse("equals", fRequest1.equals(fRequest3));
 184         assertFalse("equals", fRequest2.equals(fRequest3));
 185         assertFalse("equals", fRequest3.equals(fRequest1));
 186         assertFalse("equals", fRequest3.equals(fRequest2));
 187         }
 188
 189         public void testEqualsTransivity() throws Exception {
 190         assertTrue("equals", fRequest1.equals(fRequest1b));
 191         assertTrue("equals", fRequest1b.equals(fRequest1c));
 192         assertTrue("equals", fRequest1.equals(fRequest1c));
 193         }
 194
 195         public void testEqualsNull() throws Exception {
 196         assertFalse("equals", fRequest1.equals(null));
 197         assertFalse("equals", fRequest2.equals(null));
 198         }
 199
 200         // ------------------------------------------------------------------------
 201         // hashCode
 202         // ------------------------------------------------------------------------
 203
 204         public void testHashCode() throws Exception {
 205         assertTrue("hashCode", fRequest1.hashCode() == fRequest1.hashCode());
 206         assertTrue("hashCode", fRequest2.hashCode() == fRequest2.hashCode());
 207                 assertTrue("hashCode", fRequest1.hashCode() != fRequest2.hashCode());
 208         }
 209
 210         // ------------------------------------------------------------------------
 211         // toString
 212         // ------------------------------------------------------------------------
 213
 214         public void testToString() {
 215         String expected1 = "[TmfCoalescedDataRequest(0,TmfEvent,10,100)]";
 216         String expected2 = "[TmfCoalescedDataRequest(1,TmfEvent,20,100)]";
 217         String expected3 = "[TmfCoalescedDataRequest(2,TmfEvent,20,200)]";
 218         String expected4 = "[TmfCoalescedDataRequest(3,TmfEvent,20,200)]";
 219
 220         assertEquals("toString", expected1, fRequest1.toString());
 221         assertEquals("toString", expected2, fRequest2.toString());
 222         assertEquals("toString", expected3, fRequest3.toString());
 223         assertEquals("toString", expected4, fRequest4.toString());
 224         }
 225
 226         // ------------------------------------------------------------------------
 227         // isCompatible
 228         // ------------------------------------------------------------------------
 229
 230         public void testIsCompatible() {
 231                 TmfCoalescedDataRequest<TmfEvent> coalescedRequest = new TmfCoalescedDataRequest<TmfEvent>(TmfEvent.class, 10, 100, 200);
 232                 TmfDataRequest<TmfEvent> request1 = new TmfDataRequestStub<TmfEvent>(TmfEvent.class, 10, 100, 200);
 233                 TmfDataRequest<TmfEvent> request2 = new TmfDataRequestStub<TmfEvent>(TmfEvent.class, 11, 100, 200);
 234                 TmfDataRequest<TmfEvent> request3 = new TmfDataRequestStub<TmfEvent>(TmfEvent.class, 10, 101, 200);
 235
 236         assertTrue ("isCompatible", coalescedRequest.isCompatible(request1));
 237         assertFalse("isCompatible", coalescedRequest.isCompatible(request2));
 238         assertFalse("isCompatible", coalescedRequest.isCompatible(request3));
 239         }
 240
 241         // ------------------------------------------------------------------------
 242         // done
 243         // ------------------------------------------------------------------------
 244
 245         public void testDone() {
 246
 247                 // Test request
 248                 final boolean[] crFlags = new boolean[4];
 249                 TmfCoalescedDataRequest<TmfEvent> request = setupTestRequest(crFlags);
 250                 TmfDataRequest<TmfEvent> subRequest1 = new TmfDataRequestStub<TmfEvent>(TmfEvent.class, 10, 100, 200);
 251                 TmfDataRequest<TmfEvent> subRequest2 = new TmfDataRequestStub<TmfEvent>(TmfEvent.class, 10, 100, 200);
 252                 request.addRequest(subRequest1);
 253                 request.addRequest(subRequest2);
 254
 255                 request.done();
 256
 257                 // Validate the coalescing request
 258                 assertTrue ("isCompleted", request.isCompleted());
 259                 assertFalse("isFailed",    request.isFailed());
 260                 assertFalse("isCancelled", request.isCancelled());
 261
 262                 assertTrue ("handleCompleted", crFlags[0]);
 263                 assertTrue ("handleSuccess",   crFlags[1]);
 264                 assertFalse("handleFailure",   crFlags[2]);
 265                 assertFalse("handleCancel",    crFlags[3]);
 266
 267                 // Validate the first coalesced request
 268                 assertTrue ("isCompleted", subRequest1.isCompleted());
 269                 assertFalse("isFailed",    subRequest1.isFailed());
 270                 assertFalse("isCancelled", subRequest1.isCancelled());
 271
 272                 // Validate the second coalesced request
 273                 assertTrue ("isCompleted", subRequest2.isCompleted());
 274                 assertFalse("isFailed",    subRequest2.isFailed());
 275                 assertFalse("isCancelled", subRequest2.isCancelled());
 276         }
 277
 278         // ------------------------------------------------------------------------
 279         // fail
 280         // ------------------------------------------------------------------------
 281
 282         public void testFail() {
 283
 284                 final boolean[] crFlags = new boolean[4];
 285                 TmfCoalescedDataRequest<TmfEvent> request = setupTestRequest(crFlags);
 286                 TmfDataRequest<TmfEvent> subRequest1 = new TmfDataRequestStub<TmfEvent>(TmfEvent.class, 10, 100, 200);
 287                 TmfDataRequest<TmfEvent> subRequest2 = new TmfDataRequestStub<TmfEvent>(TmfEvent.class, 10, 100, 200);
 288                 request.addRequest(subRequest1);
 289                 request.addRequest(subRequest2);
 290
 291                 request.fail();
 292
 293                 // Validate the coalescing request
 294                 assertTrue ("isCompleted", request.isCompleted());
 295                 assertTrue ("isFailed",    request.isFailed());
 296                 assertFalse("isCancelled", request.isCancelled());
 297
 298                 assertTrue ("handleCompleted", crFlags[0]);
 299                 assertFalse("handleSuccess",   crFlags[1]);
 300                 assertTrue ("handleFailure",   crFlags[2]);
 301                 assertFalse("handleCancel",    crFlags[3]);
 302
 303                 // Validate the first coalesced request
 304                 assertTrue ("isCompleted", subRequest1.isCompleted());
 305                 assertTrue ("isFailed",    subRequest1.isFailed());
 306                 assertFalse("isCancelled", subRequest1.isCancelled());
 307
 308                 // Validate the second coalesced request
 309                 assertTrue ("isCompleted", subRequest2.isCompleted());
 310                 assertTrue ("isFailed",    subRequest2.isFailed());
 311                 assertFalse("isCancelled", subRequest2.isCancelled());
 312         }
 313
 314         // ------------------------------------------------------------------------
 315         // cancel
 316         // ------------------------------------------------------------------------
 317
 318         public void testCancel() {
 319
 320                 final boolean[] crFlags = new boolean[4];
 321                 TmfCoalescedDataRequest<TmfEvent> request = setupTestRequest(crFlags);
 322                 TmfDataRequest<TmfEvent> subRequest1 = new TmfDataRequestStub<TmfEvent>(TmfEvent.class, 10, 100, 200);
 323                 TmfDataRequest<TmfEvent> subRequest2 = new TmfDataRequestStub<TmfEvent>(TmfEvent.class, 10, 100, 200);
 324                 request.addRequest(subRequest1);
 325                 request.addRequest(subRequest2);
 326
 327                 request.cancel();
 328
 329                 // Validate the coalescing request
 330                 assertTrue ("isCompleted", request.isCompleted());
 331                 assertFalse("isFailed",    request.isFailed());
 332                 assertTrue ("isCancelled", request.isCancelled());
 333
 334                 assertTrue ("handleCompleted", crFlags[0]);
 335                 assertFalse("handleSuccess",   crFlags[1]);
 336                 assertFalse("handleFailure",   crFlags[2]);
 337                 assertTrue ("handleCancel",    crFlags[3]);
 338
 339                 // Validate the first coalesced request
 340                 assertTrue ("isCompleted", subRequest1.isCompleted());
 341                 assertFalse("isFailed",    subRequest1.isFailed());
 342                 assertTrue ("isCancelled", subRequest1.isCancelled());
 343
 344                 // Validate the second coalesced request
 345                 assertTrue ("isCompleted", subRequest2.isCompleted());
 346                 assertFalse("isFailed",    subRequest2.isFailed());
 347                 assertTrue ("isCancelled", subRequest2.isCancelled());
 348         }
 349
 350         // ------------------------------------------------------------------------
 351         // waitForCompletion
 352         // ------------------------------------------------------------------------
 353
 354 }