org.eclipse.linuxtools.tmf.core.tests/src/org/eclipse/linuxtools/tmf/core/tests/request/TmfCoalescedDataRequestTest.java

   1 /*******************************************************************************
   2  * Copyright (c) 2009, 2013 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  *   Francois Chouinard - Added tests to check offsets
  12  *   Alexandre Montplaisir - Port to JUnit4
  13  *******************************************************************************/
  14
  15 package org.eclipse.linuxtools.tmf.core.tests.request;
  16
  17 import static org.junit.Assert.assertEquals;
  18 import static org.junit.Assert.assertFalse;
  19 import static org.junit.Assert.assertTrue;
  20
  21 import org.eclipse.linuxtools.internal.tmf.core.request.TmfCoalescedDataRequest;
  22 import org.eclipse.linuxtools.tmf.core.event.ITmfEvent;
  23 import org.eclipse.linuxtools.tmf.core.request.TmfDataRequest;
  24 import org.eclipse.linuxtools.tmf.core.request.ITmfDataRequest.ExecutionType;
  25 import org.eclipse.linuxtools.tmf.tests.stubs.request.TmfDataRequestStub;
  26 import org.junit.Before;
  27 import org.junit.Test;
  28
  29 /**
  30  * Test suite for the TmfCoalescedDataRequest class.
  31  */
  32 @SuppressWarnings("javadoc")
  33 public class TmfCoalescedDataRequestTest {
  34
  35     // ------------------------------------------------------------------------
  36     // Variables
  37     // ------------------------------------------------------------------------
  38
  39     private TmfCoalescedDataRequest fRequest1;
  40     private TmfCoalescedDataRequest fRequest2;
  41     private TmfCoalescedDataRequest fRequest3;
  42     private TmfCoalescedDataRequest fRequest4;
  43
  44     private TmfCoalescedDataRequest fRequest1b;
  45     private TmfCoalescedDataRequest fRequest1c;
  46
  47     private int fRequestCount;
  48
  49     // ------------------------------------------------------------------------
  50     // Housekeeping
  51     // ------------------------------------------------------------------------
  52
  53     @Before
  54     public void setUp() {
  55         TmfDataRequest.reset();
  56         fRequest1 = new TmfCoalescedDataRequest(ITmfEvent.class, 10, 100, ExecutionType.FOREGROUND);
  57         fRequest2 = new TmfCoalescedDataRequest(ITmfEvent.class, 20, 100, ExecutionType.FOREGROUND);
  58         fRequest3 = new TmfCoalescedDataRequest(ITmfEvent.class, 20, 200, ExecutionType.FOREGROUND);
  59         fRequest4 = new TmfCoalescedDataRequest(ITmfEvent.class, 20, 200, ExecutionType.FOREGROUND);
  60
  61         fRequest1b = new TmfCoalescedDataRequest(ITmfEvent.class, 10, 100, ExecutionType.FOREGROUND);
  62         fRequest1c = new TmfCoalescedDataRequest(ITmfEvent.class, 10, 100, ExecutionType.FOREGROUND);
  63
  64         fRequestCount = fRequest1c.getRequestId() + 1;
  65     }
  66
  67     private static TmfCoalescedDataRequest setupTestRequest(final boolean[] flags) {
  68
  69         TmfCoalescedDataRequest request = new TmfCoalescedDataRequest(ITmfEvent.class, 10, 100, ExecutionType.FOREGROUND) {
  70             @Override
  71             public void handleCompleted() {
  72                 super.handleCompleted();
  73                 flags[0] = true;
  74             }
  75
  76             @Override
  77             public void handleSuccess() {
  78                 super.handleSuccess();
  79                 flags[1] = true;
  80             }
  81
  82             @Override
  83             public void handleFailure() {
  84                 super.handleFailure();
  85                 flags[2] = true;
  86             }
  87
  88             @Override
  89             public void handleCancel() {
  90                 super.handleCancel();
  91                 flags[3] = true;
  92             }
  93         };
  94         return request;
  95     }
  96
  97     // ------------------------------------------------------------------------
  98     // Constructor
  99     // ------------------------------------------------------------------------
 100
 101     @Test
 102     public void testTmfCoalescedDataRequestIndexNbEventsBlocksize() {
 103         TmfCoalescedDataRequest request = new TmfCoalescedDataRequest(ITmfEvent.class, 10, 100, ExecutionType.FOREGROUND);
 104
 105         assertEquals("getRequestId", fRequestCount++, request.getRequestId());
 106         assertEquals("getDataType", ITmfEvent.class, request.getDataType());
 107
 108         assertEquals("getIndex", 10, request.getIndex());
 109         assertEquals("getNbRequestedEvents", 100, request.getNbRequested());
 110
 111         assertFalse("isCompleted", request.isCompleted());
 112         assertFalse("isFailed", request.isFailed());
 113         assertFalse("isCancelled", request.isCancelled());
 114
 115         assertEquals("getNbRead", 0, request.getNbRead());
 116     }
 117
 118     // ------------------------------------------------------------------------
 119     // equals
 120     // ------------------------------------------------------------------------
 121
 122     @Test
 123     public void testEqualsReflexivity() {
 124         assertTrue("equals", fRequest1.equals(fRequest1));
 125         assertTrue("equals", fRequest2.equals(fRequest2));
 126
 127         assertFalse("equals", fRequest1.equals(fRequest2));
 128         assertFalse("equals", fRequest2.equals(fRequest1));
 129     }
 130
 131     @Test
 132     public void testEqualsSymmetry() {
 133         assertTrue("equals", fRequest1.equals(fRequest1b));
 134         assertTrue("equals", fRequest1b.equals(fRequest1));
 135
 136         assertFalse("equals", fRequest1.equals(fRequest3));
 137         assertFalse("equals", fRequest2.equals(fRequest3));
 138         assertFalse("equals", fRequest3.equals(fRequest1));
 139         assertFalse("equals", fRequest3.equals(fRequest2));
 140     }
 141
 142     @Test
 143     public void testEqualsTransivity() {
 144         assertTrue("equals", fRequest1.equals(fRequest1b));
 145         assertTrue("equals", fRequest1b.equals(fRequest1c));
 146         assertTrue("equals", fRequest1.equals(fRequest1c));
 147     }
 148
 149     @Test
 150     public void testEqualsNull() {
 151         assertFalse("equals", fRequest1.equals(null));
 152         assertFalse("equals", fRequest2.equals(null));
 153     }
 154
 155     // ------------------------------------------------------------------------
 156     // hashCode
 157     // ------------------------------------------------------------------------
 158
 159     @Test
 160     public void testHashCode() {
 161         assertTrue("hashCode", fRequest1.hashCode() == fRequest1.hashCode());
 162         assertTrue("hashCode", fRequest2.hashCode() == fRequest2.hashCode());
 163         assertTrue("hashCode", fRequest1.hashCode() != fRequest2.hashCode());
 164     }
 165
 166     // ------------------------------------------------------------------------
 167     // toString
 168     // ------------------------------------------------------------------------
 169
 170     @Test
 171     public void testToString() {
 172         String expected1 = "[TmfCoalescedDataRequest(0,ITmfEvent,FOREGROUND,10,100, [])]";
 173         String expected2 = "[TmfCoalescedDataRequest(1,ITmfEvent,FOREGROUND,20,100, [])]";
 174         String expected3 = "[TmfCoalescedDataRequest(2,ITmfEvent,FOREGROUND,20,200, [])]";
 175         String expected4 = "[TmfCoalescedDataRequest(3,ITmfEvent,FOREGROUND,20,200, [])]";
 176
 177         assertEquals("toString", expected1, fRequest1.toString());
 178         assertEquals("toString", expected2, fRequest2.toString());
 179         assertEquals("toString", expected3, fRequest3.toString());
 180         assertEquals("toString", expected4, fRequest4.toString());
 181     }
 182
 183     // ------------------------------------------------------------------------
 184     // isCompatible
 185     // ------------------------------------------------------------------------
 186
 187     @Test
 188     public void testIsCompatible() {
 189         TmfCoalescedDataRequest coalescedRequest = new TmfCoalescedDataRequest(ITmfEvent.class, 10, 100, ExecutionType.FOREGROUND);
 190         TmfDataRequest request1 = new TmfDataRequestStub(ITmfEvent.class, 10, 100);
 191         TmfDataRequest request2 = new TmfDataRequestStub(ITmfEvent.class, 5, 100);
 192         TmfDataRequest request3 = new TmfDataRequestStub(ITmfEvent.class, 5, 4);
 193         TmfDataRequest request4 = new TmfDataRequestStub(ITmfEvent.class, 5, 5);
 194         TmfDataRequest request5 = new TmfDataRequestStub(ITmfEvent.class, 15, 100);
 195         TmfDataRequest request6 = new TmfDataRequestStub(ITmfEvent.class, 100, 100);
 196         TmfDataRequest request7 = new TmfDataRequestStub(ITmfEvent.class, 110, 100);
 197         TmfDataRequest request8 = new TmfDataRequestStub(ITmfEvent.class, 111, 100);
 198
 199         assertTrue("isCompatible", coalescedRequest.isCompatible(request1));
 200         assertTrue("isCompatible", coalescedRequest.isCompatible(request2));
 201         assertTrue("isCompatible", coalescedRequest.isCompatible(request3));
 202         assertTrue("isCompatible", coalescedRequest.isCompatible(request4));
 203         assertTrue("isCompatible", coalescedRequest.isCompatible(request5));
 204         assertTrue("isCompatible", coalescedRequest.isCompatible(request6));
 205         assertTrue("isCompatible", coalescedRequest.isCompatible(request7));
 206         assertTrue("isCompatible", coalescedRequest.isCompatible(request8));
 207
 208         TmfDataRequest request9  = new TmfDataRequestStub(ITmfEvent.class,   5,   3);
 209         TmfDataRequest request10 = new TmfDataRequestStub(ITmfEvent.class, 112, 100);
 210
 211         assertFalse("isCompatible", coalescedRequest.isCompatible(request9));
 212         assertFalse("isCompatible", coalescedRequest.isCompatible(request10));
 213     }
 214
 215     // ------------------------------------------------------------------------
 216     // addRequest
 217     // ------------------------------------------------------------------------
 218
 219     @Test
 220     public void testAddRequest1() {
 221         TmfCoalescedDataRequest coalescedRequest = new TmfCoalescedDataRequest(ITmfEvent.class, 10, 100, ExecutionType.FOREGROUND);
 222         TmfDataRequest request = new TmfDataRequestStub(ITmfEvent.class, 10, 100);
 223
 224         assertTrue("isCompatible", coalescedRequest.isCompatible(request));
 225         coalescedRequest.addRequest(request);
 226         assertEquals("addRequest", 10, coalescedRequest.getIndex());
 227         assertEquals("addRequest", 100, coalescedRequest.getNbRequested());
 228     }
 229
 230     @Test
 231     public void testAddRequest2() {
 232         TmfCoalescedDataRequest coalescedRequest = new TmfCoalescedDataRequest(ITmfEvent.class, 10, 100, ExecutionType.FOREGROUND);
 233         TmfDataRequest request = new TmfDataRequestStub(ITmfEvent.class, 5, 100);
 234
 235         assertTrue("isCompatible", coalescedRequest.isCompatible(request));
 236         coalescedRequest.addRequest(request);
 237         assertEquals("addRequest", 5, coalescedRequest.getIndex());
 238         assertEquals("addRequest", 105, coalescedRequest.getNbRequested());
 239     }
 240
 241     @Test
 242     public void testAddRequest3() {
 243         TmfCoalescedDataRequest coalescedRequest = new TmfCoalescedDataRequest(ITmfEvent.class, 10, 100, ExecutionType.FOREGROUND);
 244         TmfDataRequest request = new TmfDataRequestStub(ITmfEvent.class, 5, 4);
 245
 246         assertTrue("isCompatible", coalescedRequest.isCompatible(request));
 247         coalescedRequest.addRequest(request);
 248         assertEquals("addRequest", 5, coalescedRequest.getIndex());
 249         assertEquals("addRequest", 105, coalescedRequest.getNbRequested());
 250     }
 251
 252     @Test
 253     public void testAddRequest4() {
 254         TmfCoalescedDataRequest coalescedRequest = new TmfCoalescedDataRequest(ITmfEvent.class, 10, 100, ExecutionType.FOREGROUND);
 255         TmfDataRequest request = new TmfDataRequestStub(ITmfEvent.class, 5, 5);
 256
 257         assertTrue("isCompatible", coalescedRequest.isCompatible(request));
 258         coalescedRequest.addRequest(request);
 259         assertEquals("addRequest", 5, coalescedRequest.getIndex());
 260         assertEquals("addRequest", 105, coalescedRequest.getNbRequested());
 261     }
 262
 263     @Test
 264     public void testAddRequest5() {
 265         TmfCoalescedDataRequest coalescedRequest = new TmfCoalescedDataRequest(ITmfEvent.class, 10, 100, ExecutionType.FOREGROUND);
 266         TmfDataRequest request = new TmfDataRequestStub(ITmfEvent.class,  15, 100);
 267
 268         assertTrue("isCompatible", coalescedRequest.isCompatible(request));
 269         coalescedRequest.addRequest(request);
 270         assertEquals("addRequest", 10, coalescedRequest.getIndex());
 271         assertEquals("addRequest", 105, coalescedRequest.getNbRequested());
 272     }
 273
 274     @Test
 275     public void testAddRequest6() {
 276         TmfCoalescedDataRequest coalescedRequest = new TmfCoalescedDataRequest(ITmfEvent.class, 10, 100, ExecutionType.FOREGROUND);
 277         TmfDataRequest request = new TmfDataRequestStub(ITmfEvent.class, 100, 100);
 278
 279         assertTrue("isCompatible", coalescedRequest.isCompatible(request));
 280         coalescedRequest.addRequest(request);
 281         assertEquals("addRequest", 10, coalescedRequest.getIndex());
 282         assertEquals("addRequest", 190, coalescedRequest.getNbRequested());
 283     }
 284
 285     @Test
 286     public void testAddRequest7() {
 287         TmfCoalescedDataRequest coalescedRequest = new TmfCoalescedDataRequest(ITmfEvent.class, 10, 100, ExecutionType.FOREGROUND);
 288         TmfDataRequest request = new TmfDataRequestStub(ITmfEvent.class, 110, 100);
 289
 290         assertTrue("isCompatible", coalescedRequest.isCompatible(request));
 291         coalescedRequest.addRequest(request);
 292         assertEquals("addRequest", 10, coalescedRequest.getIndex());
 293         assertEquals("addRequest", 200, coalescedRequest.getNbRequested());
 294     }
 295
 296     @Test
 297     public void testAddRequest8() {
 298         TmfCoalescedDataRequest coalescedRequest = new TmfCoalescedDataRequest(ITmfEvent.class, 10, 100, ExecutionType.FOREGROUND);
 299         TmfDataRequest request = new TmfDataRequestStub(ITmfEvent.class, 111, 100);
 300
 301         assertTrue("isCompatible", coalescedRequest.isCompatible(request));
 302         coalescedRequest.addRequest(request);
 303         assertEquals("addRequest", 10, coalescedRequest.getIndex());
 304         assertEquals("addRequest", 201, coalescedRequest.getNbRequested());
 305     }
 306
 307     // ------------------------------------------------------------------------
 308     // done
 309     // ------------------------------------------------------------------------
 310
 311     @Test
 312     public void testDone() {
 313         // Test request
 314         final boolean[] crFlags = new boolean[4];
 315         TmfCoalescedDataRequest request = setupTestRequest(crFlags);
 316         TmfDataRequest subRequest1 = new TmfDataRequestStub(ITmfEvent.class, 10, 100);
 317         TmfDataRequest subRequest2 = new TmfDataRequestStub(ITmfEvent.class, 10, 100);
 318         request.addRequest(subRequest1);
 319         request.addRequest(subRequest2);
 320
 321         request.done();
 322
 323         // Validate the coalescing request
 324         assertTrue("isCompleted", request.isCompleted());
 325         assertFalse("isFailed", request.isFailed());
 326         assertFalse("isCancelled", request.isCancelled());
 327
 328         assertTrue("handleCompleted", crFlags[0]);
 329         assertTrue("handleSuccess", crFlags[1]);
 330         assertFalse("handleFailure", crFlags[2]);
 331         assertFalse("handleCancel", crFlags[3]);
 332
 333         // Validate the first coalesced request
 334         assertTrue("isCompleted", subRequest1.isCompleted());
 335         assertFalse("isFailed", subRequest1.isFailed());
 336         assertFalse("isCancelled", subRequest1.isCancelled());
 337
 338         // Validate the second coalesced request
 339         assertTrue("isCompleted", subRequest2.isCompleted());
 340         assertFalse("isFailed", subRequest2.isFailed());
 341         assertFalse("isCancelled", subRequest2.isCancelled());
 342     }
 343
 344     // ------------------------------------------------------------------------
 345     // fail
 346     // ------------------------------------------------------------------------
 347
 348     @Test
 349     public void testFail() {
 350         final boolean[] crFlags = new boolean[4];
 351         TmfCoalescedDataRequest request = setupTestRequest(crFlags);
 352         TmfDataRequest subRequest1 = new TmfDataRequestStub(ITmfEvent.class, 10, 100);
 353         TmfDataRequest subRequest2 = new TmfDataRequestStub(ITmfEvent.class, 10, 100);
 354         request.addRequest(subRequest1);
 355         request.addRequest(subRequest2);
 356
 357         request.fail();
 358
 359         // Validate the coalescing request
 360         assertTrue("isCompleted", request.isCompleted());
 361         assertTrue("isFailed", request.isFailed());
 362         assertFalse("isCancelled", request.isCancelled());
 363
 364         assertTrue("handleCompleted", crFlags[0]);
 365         assertFalse("handleSuccess", crFlags[1]);
 366         assertTrue("handleFailure", crFlags[2]);
 367         assertFalse("handleCancel", crFlags[3]);
 368
 369         // Validate the first coalesced request
 370         assertTrue("isCompleted", subRequest1.isCompleted());
 371         assertTrue("isFailed", subRequest1.isFailed());
 372         assertFalse("isCancelled", subRequest1.isCancelled());
 373
 374         // Validate the second coalesced request
 375         assertTrue("isCompleted", subRequest2.isCompleted());
 376         assertTrue("isFailed", subRequest2.isFailed());
 377         assertFalse("isCancelled", subRequest2.isCancelled());
 378     }
 379
 380     // ------------------------------------------------------------------------
 381     // cancel
 382     // ------------------------------------------------------------------------
 383
 384     @Test
 385     public void testCancel() {
 386         final boolean[] crFlags = new boolean[4];
 387         TmfCoalescedDataRequest request = setupTestRequest(crFlags);
 388         TmfDataRequest subRequest1 = new TmfDataRequestStub(ITmfEvent.class, 10, 100);
 389         TmfDataRequest subRequest2 = new TmfDataRequestStub(ITmfEvent.class, 10, 100);
 390         request.addRequest(subRequest1);
 391         request.addRequest(subRequest2);
 392
 393         request.cancel();
 394
 395         // Validate the coalescing request
 396         assertTrue("isCompleted", request.isCompleted());
 397         assertFalse("isFailed", request.isFailed());
 398         assertTrue("isCancelled", request.isCancelled());
 399
 400         assertTrue("handleCompleted", crFlags[0]);
 401         assertFalse("handleSuccess", crFlags[1]);
 402         assertFalse("handleFailure", crFlags[2]);
 403         assertTrue("handleCancel", crFlags[3]);
 404
 405         // Validate the first coalesced request
 406         assertTrue("isCompleted", subRequest1.isCompleted());
 407         assertFalse("isFailed", subRequest1.isFailed());
 408         assertTrue("isCancelled", subRequest1.isCancelled());
 409
 410         // Validate the second coalesced request
 411         assertTrue("isCompleted", subRequest2.isCompleted());
 412         assertFalse("isFailed", subRequest2.isFailed());
 413         assertTrue("isCancelled", subRequest2.isCancelled());
 414     }
 415
 416     // ------------------------------------------------------------------------
 417     // cancel sub-requests
 418     // ------------------------------------------------------------------------
 419
 420     @Test
 421     public void testCancelSubRequests() {
 422         final boolean[] crFlags = new boolean[4];
 423         TmfCoalescedDataRequest request = setupTestRequest(crFlags);
 424         TmfDataRequest subRequest1 = new TmfDataRequestStub(ITmfEvent.class, 10, 100);
 425         TmfDataRequest subRequest2 = new TmfDataRequestStub(ITmfEvent.class, 10, 100);
 426         request.addRequest(subRequest1);
 427         request.addRequest(subRequest2);
 428
 429         subRequest1.cancel();
 430
 431         // Validate the first coalesced request
 432         assertTrue ("isCompleted", subRequest1.isCompleted());
 433         assertFalse("isFailed",    subRequest1.isFailed());
 434         assertTrue ("isCancelled", subRequest1.isCancelled());
 435
 436         // Validate the coalescing request
 437         assertFalse("isCompleted", request.isCompleted());
 438         assertFalse("isFailed",    request.isFailed());
 439         assertFalse("isCancelled", request.isCancelled());
 440
 441         // Cancel second sub-request
 442         subRequest2.cancel();
 443
 444         // Validate the second coalesced request
 445         assertTrue ("isCompleted", subRequest2.isCompleted());
 446         assertFalse("isFailed",    subRequest2.isFailed());
 447         assertTrue("isCancelled",  subRequest2.isCancelled());
 448
 449         // Validate the coalescing request
 450         assertTrue("isCompleted", request.isCompleted());
 451         assertFalse("isFailed",   request.isFailed());
 452         assertTrue("isCancelled", request.isCancelled());
 453
 454         // Finalize coalescing request -
 455         // Note: No need to check "request.isCancelled()" since it was verified
 456         // above
 457         request.cancel();
 458
 459         assertTrue("handleCompleted", crFlags[0]);
 460         assertFalse("handleSuccess", crFlags[1]);
 461         assertFalse("handleFailure", crFlags[2]);
 462         assertTrue("handleCancel", crFlags[3]);
 463     }
 464
 465 }