org.eclipse.linuxtools.tmf.core.tests/src/org/eclipse/linuxtools/tmf/core/tests/request/TmfCoalescedEventRequestTest.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  *   Alexandre Montplaisir - Port to JUnit4
  12  *******************************************************************************/
  13
  14 package org.eclipse.linuxtools.tmf.core.tests.request;
  15
  16 import static org.junit.Assert.assertEquals;
  17 import static org.junit.Assert.assertFalse;
  18 import static org.junit.Assert.assertTrue;
  19
  20 import java.io.File;
  21 import java.io.IOException;
  22 import java.net.URISyntaxException;
  23 import java.net.URL;
  24 import java.util.Vector;
  25
  26 import org.eclipse.core.runtime.FileLocator;
  27 import org.eclipse.core.runtime.Path;
  28 import org.eclipse.linuxtools.internal.tmf.core.component.TmfProviderManager;
  29 import org.eclipse.linuxtools.internal.tmf.core.request.TmfCoalescedDataRequest;
  30 import org.eclipse.linuxtools.internal.tmf.core.request.TmfCoalescedEventRequest;
  31 import org.eclipse.linuxtools.tmf.core.component.ITmfDataProvider;
  32 import org.eclipse.linuxtools.tmf.core.event.ITmfEvent;
  33 import org.eclipse.linuxtools.tmf.core.exceptions.TmfTraceException;
  34 import org.eclipse.linuxtools.tmf.core.request.ITmfDataRequest.ExecutionType;
  35 import org.eclipse.linuxtools.tmf.core.request.TmfDataRequest;
  36 import org.eclipse.linuxtools.tmf.core.request.TmfEventRequest;
  37 import org.eclipse.linuxtools.tmf.core.signal.TmfSignal;
  38 import org.eclipse.linuxtools.tmf.core.signal.TmfSignalHandler;
  39 import org.eclipse.linuxtools.tmf.core.signal.TmfSignalManager;
  40 import org.eclipse.linuxtools.tmf.core.tests.TmfCoreTestPlugin;
  41 import org.eclipse.linuxtools.tmf.core.timestamp.TmfTimeRange;
  42 import org.eclipse.linuxtools.tmf.core.timestamp.TmfTimestamp;
  43 import org.eclipse.linuxtools.tmf.tests.stubs.request.TmfEventRequestStub;
  44 import org.eclipse.linuxtools.tmf.tests.stubs.trace.TmfTraceStub;
  45 import org.junit.Before;
  46 import org.junit.Test;
  47
  48 /**
  49  * Test suite for the TmfCoalescedEventRequest class.
  50  */
  51 @SuppressWarnings("javadoc")
  52 public class TmfCoalescedEventRequestTest {
  53
  54     // ------------------------------------------------------------------------
  55     // Variables
  56     // ------------------------------------------------------------------------
  57
  58     private final TmfTimeRange range1 = new TmfTimeRange(TmfTimeRange.ETERNITY);
  59     private final TmfTimeRange range2 = new TmfTimeRange(new TmfTimestamp(), TmfTimestamp.BIG_CRUNCH);
  60
  61     private TmfCoalescedEventRequest fRequest1;
  62     private TmfCoalescedEventRequest fRequest2;
  63     private TmfCoalescedEventRequest fRequest3;
  64     private TmfCoalescedEventRequest fRequest4;
  65
  66     private TmfCoalescedEventRequest fRequest1b;
  67     private TmfCoalescedEventRequest fRequest1c;
  68
  69     private int fRequestCount;
  70
  71     // ------------------------------------------------------------------------
  72     // Housekeeping
  73     // ------------------------------------------------------------------------
  74
  75     @Before
  76     public void setUp() {
  77         TmfDataRequest.reset();
  78         fRequest1 = new TmfCoalescedEventRequest(ITmfEvent.class, range1, 0, 100, 200, ExecutionType.FOREGROUND);
  79         fRequest2 = new TmfCoalescedEventRequest(ITmfEvent.class, range2, 0, 100, 200, ExecutionType.FOREGROUND);
  80         fRequest3 = new TmfCoalescedEventRequest(ITmfEvent.class, range2, 0, 200, 200, ExecutionType.FOREGROUND);
  81         fRequest4 = new TmfCoalescedEventRequest(ITmfEvent.class, range2, 0, 200, 300, ExecutionType.FOREGROUND);
  82
  83         fRequest1b = new TmfCoalescedEventRequest(ITmfEvent.class, range1, 0, 100, 200, ExecutionType.FOREGROUND);
  84         fRequest1c = new TmfCoalescedEventRequest(ITmfEvent.class, range1, 0, 100, 200, ExecutionType.FOREGROUND);
  85
  86         fRequestCount = fRequest1c.getRequestId() + 1;
  87     }
  88
  89     private TmfCoalescedEventRequest setupTestRequest(final boolean[] flags) {
  90
  91         TmfCoalescedEventRequest request = new TmfCoalescedEventRequest(ITmfEvent.class, range1, 0, 100, 200, ExecutionType.FOREGROUND) {
  92             @Override
  93             public void handleCompleted() {
  94                 super.handleCompleted();
  95                 flags[0] = true;
  96             }
  97
  98             @Override
  99             public void handleSuccess() {
 100                 super.handleSuccess();
 101                 flags[1] = true;
 102             }
 103
 104             @Override
 105             public void handleFailure() {
 106                 super.handleFailure();
 107                 flags[2] = true;
 108             }
 109
 110             @Override
 111             public void handleCancel() {
 112                 super.handleCancel();
 113                 flags[3] = true;
 114             }
 115         };
 116         return request;
 117     }
 118
 119     // ------------------------------------------------------------------------
 120     // Constructor
 121     // ------------------------------------------------------------------------
 122
 123     @Test
 124     public void testTmfCoalescedEventRequestIndexNbEventsBlocksize() {
 125         TmfCoalescedEventRequest request = new TmfCoalescedEventRequest(ITmfEvent.class, range1, 0, 100, 200, ExecutionType.FOREGROUND);
 126
 127         assertEquals("getRequestId", fRequestCount++, request.getRequestId());
 128         assertEquals("getDataType", ITmfEvent.class, request.getDataType());
 129
 130         assertEquals("getRange", range1, request.getRange());
 131         assertEquals("getNbRequestedEvents", 100, request.getNbRequested());
 132
 133         assertFalse("isCompleted", request.isCompleted());
 134         assertFalse("isFailed", request.isFailed());
 135         assertFalse("isCancelled", request.isCancelled());
 136
 137         assertEquals("getNbRead", 0, request.getNbRead());
 138     }
 139
 140     // ------------------------------------------------------------------------
 141     // equals
 142     // ------------------------------------------------------------------------
 143
 144     @Test
 145     public void testEqualsReflexivity() {
 146         assertTrue("equals", fRequest1.equals(fRequest1));
 147         assertTrue("equals", fRequest2.equals(fRequest2));
 148
 149         assertFalse("equals", fRequest1.equals(fRequest2));
 150         assertFalse("equals", fRequest2.equals(fRequest1));
 151     }
 152
 153     @Test
 154     public void testEqualsSymmetry() {
 155         assertTrue("equals", fRequest1.equals(fRequest1b));
 156         assertTrue("equals", fRequest1b.equals(fRequest1));
 157
 158         assertFalse("equals", fRequest1.equals(fRequest3));
 159         assertFalse("equals", fRequest2.equals(fRequest3));
 160         assertFalse("equals", fRequest3.equals(fRequest1));
 161         assertFalse("equals", fRequest3.equals(fRequest2));
 162     }
 163
 164     @Test
 165     public void testEqualsTransivity() {
 166         assertTrue("equals", fRequest1.equals(fRequest1b));
 167         assertTrue("equals", fRequest1b.equals(fRequest1c));
 168         assertTrue("equals", fRequest1.equals(fRequest1c));
 169     }
 170
 171     @Test
 172     public void testEqualsNull() {
 173         assertFalse("equals", fRequest1.equals(null));
 174         assertFalse("equals", fRequest2.equals(null));
 175     }
 176
 177     @Test
 178     public void testEqualsSuper() {
 179         TmfCoalescedDataRequest dataRequest1 = new TmfCoalescedDataRequest(
 180                 fRequest1.getDataType(),
 181                 fRequest1.getIndex(),
 182                 fRequest1.getNbRequested(),
 183                 TmfDataRequest.DEFAULT_BLOCK_SIZE,
 184                 ExecutionType.FOREGROUND);
 185         TmfCoalescedDataRequest dataRequest2 = new TmfCoalescedDataRequest(
 186                 fRequest1.getDataType(),
 187                 fRequest1.getIndex(),
 188                 fRequest1.getNbRequested(),
 189                 TmfDataRequest.DEFAULT_BLOCK_SIZE,
 190                 ExecutionType.FOREGROUND);
 191         TmfCoalescedDataRequest dataRequest3 = new TmfCoalescedDataRequest(
 192                 fRequest3.getDataType(),
 193                 fRequest3.getIndex(),
 194                 fRequest3.getNbRequested(),
 195                 TmfDataRequest.DEFAULT_BLOCK_SIZE,
 196                 ExecutionType.FOREGROUND);
 197
 198         assertTrue("equals", fRequest1.equals(dataRequest2));
 199         assertTrue("equals", fRequest2.equals(dataRequest1));
 200         assertFalse("equals", fRequest1.equals(dataRequest3));
 201         assertFalse("equals", fRequest3.equals(dataRequest1));
 202     }
 203
 204     // ------------------------------------------------------------------------
 205     // hashCode
 206     // ------------------------------------------------------------------------
 207
 208     @Test
 209     public void testHashCode() {
 210         assertTrue("hashCode", fRequest1.hashCode() == fRequest1.hashCode());
 211         assertTrue("hashCode", fRequest2.hashCode() == fRequest2.hashCode());
 212         assertTrue("hashCode", fRequest1.hashCode() != fRequest2.hashCode());
 213     }
 214
 215     // ------------------------------------------------------------------------
 216     // toString
 217     // ------------------------------------------------------------------------
 218
 219     @Test
 220     public void testToString() {
 221         String expected1 = "[TmfCoalescedEventRequest(0,ITmfEvent," + range1 + ",0,100,200)]";
 222         String expected2 = "[TmfCoalescedEventRequest(1,ITmfEvent," + range2 + ",0,100,200)]";
 223         String expected3 = "[TmfCoalescedEventRequest(2,ITmfEvent," + range2 + ",0,200,200)]";
 224         String expected4 = "[TmfCoalescedEventRequest(3,ITmfEvent," + range2 + ",0,200,300)]";
 225
 226         assertEquals("toString", expected1, fRequest1.toString());
 227         assertEquals("toString", expected2, fRequest2.toString());
 228         assertEquals("toString", expected3, fRequest3.toString());
 229         assertEquals("toString", expected4, fRequest4.toString());
 230     }
 231
 232     // ------------------------------------------------------------------------
 233     // isCompatible
 234     // ------------------------------------------------------------------------
 235
 236     @Test
 237     public void testIsCompatible() {
 238         TmfCoalescedEventRequest coalescedRequest = new TmfCoalescedEventRequest(ITmfEvent.class, range1, 0, 100, 200, ExecutionType.FOREGROUND);
 239         TmfEventRequest req1 = new TmfEventRequestStub(ITmfEvent.class, range1, 100, 200);
 240         TmfEventRequest req2 = new TmfEventRequestStub(ITmfEvent.class, range2, 100, 200);
 241         TmfEventRequest req3 = new TmfEventRequestStub(ITmfEvent.class, range1, 101, 200);
 242
 243         assertTrue("isCompatible", coalescedRequest.isCompatible(req1));
 244         assertTrue("isCompatible", coalescedRequest.isCompatible(req2));
 245         assertTrue("isCompatible", coalescedRequest.isCompatible(req3));
 246     }
 247
 248     // ------------------------------------------------------------------------
 249     // addEvent
 250     // ------------------------------------------------------------------------
 251
 252     @Test
 253     public void testAddEvent1() {
 254         TmfCoalescedEventRequest coalescedRequest = new TmfCoalescedEventRequest(ITmfEvent.class, range1, 0, 2147483647, 200, ExecutionType.FOREGROUND);
 255         TmfEventRequest req1 = new TmfEventRequestStub(ITmfEvent.class, range1, 0, 2147483647, 200);
 256         TmfEventRequest req2 = new TmfEventRequestStub(ITmfEvent.class, range1, 1, 2147483647, 200);
 257
 258         assertTrue("isCompatible", coalescedRequest.isCompatible(req1));
 259         assertTrue("isCompatible", coalescedRequest.isCompatible(req2));
 260
 261         coalescedRequest.addRequest(req1);
 262         coalescedRequest.addRequest(req2);
 263
 264         assertEquals("addRequest", 0, coalescedRequest.getIndex());
 265         assertEquals("addRequest", 2147483647, coalescedRequest.getNbRequested());
 266         assertEquals("addRequest", 200, coalescedRequest.getBlockSize());
 267
 268     }
 269
 270     @Test
 271     public void testAddEvent2() {
 272         TmfCoalescedEventRequest coalescedRequest = new TmfCoalescedEventRequest(ITmfEvent.class, range1, 1, 2147483647, 200, ExecutionType.FOREGROUND);
 273         TmfEventRequest req1 = new TmfEventRequestStub(ITmfEvent.class, range1, 1, 2147483647, 200);
 274         TmfEventRequest req2 = new TmfEventRequestStub(ITmfEvent.class, range1, 0, 2147483647, 200);
 275
 276         assertTrue("isCompatible", coalescedRequest.isCompatible(req1));
 277         assertTrue("isCompatible", coalescedRequest.isCompatible(req2));
 278
 279         coalescedRequest.addRequest(req1);
 280         coalescedRequest.addRequest(req2);
 281
 282         assertEquals("addRequest", 0, coalescedRequest.getIndex());
 283         assertEquals("addRequest", 2147483647, coalescedRequest.getNbRequested());
 284         assertEquals("addRequest", 200, coalescedRequest.getBlockSize());
 285
 286     }
 287
 288     // ------------------------------------------------------------------------
 289     // done
 290     // ------------------------------------------------------------------------
 291
 292     @Test
 293     public void testDone() {
 294         // Test request
 295         final boolean[] crFlags = new boolean[4];
 296         TmfCoalescedEventRequest request = setupTestRequest(crFlags);
 297         TmfEventRequest subRequest1 = new TmfEventRequestStub(ITmfEvent.class, range1, 100, 200);
 298         TmfEventRequest subRequest2 = new TmfEventRequestStub(ITmfEvent.class, range1, 100, 200);
 299         request.addRequest(subRequest1);
 300         request.addRequest(subRequest2);
 301
 302         request.done();
 303
 304         // Validate the coalescing request
 305         assertTrue("isCompleted", request.isCompleted());
 306         assertFalse("isFailed", request.isFailed());
 307         assertFalse("isCancelled", request.isCancelled());
 308
 309         assertTrue("handleCompleted", crFlags[0]);
 310         assertTrue("handleSuccess", crFlags[1]);
 311         assertFalse("handleFailure", crFlags[2]);
 312         assertFalse("handleCancel", crFlags[3]);
 313
 314         // Validate the first coalesced request
 315         assertTrue("isCompleted", subRequest1.isCompleted());
 316         assertFalse("isFailed", subRequest1.isFailed());
 317         assertFalse("isCancelled", subRequest1.isCancelled());
 318
 319         // Validate the second coalesced request
 320         assertTrue("isCompleted", subRequest2.isCompleted());
 321         assertFalse("isFailed", subRequest2.isFailed());
 322         assertFalse("isCancelled", subRequest2.isCancelled());
 323     }
 324
 325     // ------------------------------------------------------------------------
 326     // fail
 327     // ------------------------------------------------------------------------
 328
 329     @Test
 330     public void testFail() {
 331         final boolean[] crFlags = new boolean[4];
 332         TmfCoalescedEventRequest request = setupTestRequest(crFlags);
 333         TmfEventRequest subRequest1 = new TmfEventRequestStub(ITmfEvent.class, range1, 100, 200);
 334         TmfEventRequest subRequest2 = new TmfEventRequestStub(ITmfEvent.class, range1, 100, 200);
 335         request.addRequest(subRequest1);
 336         request.addRequest(subRequest2);
 337
 338         request.fail();
 339
 340         // Validate the coalescing request
 341         assertTrue("isCompleted", request.isCompleted());
 342         assertTrue("isFailed", request.isFailed());
 343         assertFalse("isCancelled", request.isCancelled());
 344
 345         assertTrue("handleCompleted", crFlags[0]);
 346         assertFalse("handleSuccess", crFlags[1]);
 347         assertTrue("handleFailure", crFlags[2]);
 348         assertFalse("handleCancel", crFlags[3]);
 349
 350         // Validate the first coalesced request
 351         assertTrue("isCompleted", subRequest1.isCompleted());
 352         assertTrue("isFailed", subRequest1.isFailed());
 353         assertFalse("isCancelled", subRequest1.isCancelled());
 354
 355         // Validate the second coalesced request
 356         assertTrue("isCompleted", subRequest2.isCompleted());
 357         assertTrue("isFailed", subRequest2.isFailed());
 358         assertFalse("isCancelled", subRequest2.isCancelled());
 359     }
 360
 361     // ------------------------------------------------------------------------
 362     // cancel
 363     // ------------------------------------------------------------------------
 364
 365     @Test
 366     public void testCancel() {
 367         final boolean[] crFlags = new boolean[4];
 368         TmfCoalescedEventRequest request = setupTestRequest(crFlags);
 369         TmfEventRequest subRequest1 = new TmfEventRequestStub(ITmfEvent.class, range1, 100, 200);
 370         TmfEventRequest subRequest2 = new TmfEventRequestStub(ITmfEvent.class, range1, 100, 200);
 371         request.addRequest(subRequest1);
 372         request.addRequest(subRequest2);
 373
 374         request.cancel();
 375
 376         // Validate the coalescing request
 377         assertTrue("isCompleted", request.isCompleted());
 378         assertFalse("isFailed", request.isFailed());
 379         assertTrue("isCancelled", request.isCancelled());
 380
 381         assertTrue("handleCompleted", crFlags[0]);
 382         assertFalse("handleSuccess", crFlags[1]);
 383         assertFalse("handleFailure", crFlags[2]);
 384         assertTrue("handleCancel", crFlags[3]);
 385
 386         // Validate the first coalesced request
 387         assertTrue("isCompleted", subRequest1.isCompleted());
 388         assertFalse("isFailed", subRequest1.isFailed());
 389         assertTrue("isCancelled", subRequest1.isCancelled());
 390
 391         // Validate the second coalesced request
 392         assertTrue("isCompleted", subRequest2.isCompleted());
 393         assertFalse("isFailed", subRequest2.isFailed());
 394         assertTrue("isCancelled", subRequest2.isCancelled());
 395     }
 396
 397     // ------------------------------------------------------------------------
 398     // Coalescing
 399     // ------------------------------------------------------------------------
 400
 401     private static final String DIRECTORY = "testfiles";
 402     private static final String TEST_STREAM = "A-Test-10K";
 403     private static final int NB_EVENTS = 5000;
 404     private static final int BLOCK_SIZE = 100;
 405
 406     // Initialize the test trace
 407     private TmfTraceStub fTrace = null;
 408
 409     private synchronized TmfTraceStub setupTrace(String path) {
 410         if (fTrace == null) {
 411             try {
 412                 URL location = FileLocator.find(TmfCoreTestPlugin.getDefault().getBundle(), new Path(path), null);
 413                 File test = new File(FileLocator.toFileURL(location).toURI());
 414                 fTrace = new TmfTraceStub(test.getPath(), 500);
 415             } catch (TmfTraceException e) {
 416                 e.printStackTrace();
 417             } catch (URISyntaxException e) {
 418                 e.printStackTrace();
 419             } catch (IOException e) {
 420                 e.printStackTrace();
 421             }
 422         }
 423         return fTrace;
 424     }
 425
 426     Vector<ITmfEvent> requestedEvents1;
 427     Vector<ITmfEvent> requestedEvents2;
 428     Vector<ITmfEvent> requestedEvents3;
 429
 430     TmfEventRequest request1;
 431     TmfEventRequest request2;
 432     TmfEventRequest request3;
 433
 434     ITmfDataProvider[] providers;
 435
 436     private static class TmfTestTriggerSignal extends TmfSignal {
 437         public final boolean forceCancel;
 438         public final long fIndex;
 439
 440         public TmfTestTriggerSignal(Object source, long index, boolean cancel) {
 441             super(source);
 442             forceCancel = cancel;
 443             fIndex = index;
 444         }
 445     }
 446
 447     @TmfSignalHandler
 448     public void trigger(final TmfTestTriggerSignal signal) {
 449
 450         TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BIG_BANG, TmfTimestamp.BIG_CRUNCH);
 451         final long REQUEST_OFFSET = 1000;
 452
 453         requestedEvents1 = new Vector<ITmfEvent>();
 454         request1 = new TmfEventRequest(ITmfEvent.class, range, signal.fIndex,
 455                 NB_EVENTS, BLOCK_SIZE, ExecutionType.FOREGROUND) {
 456             int nbRead = 0;
 457             @Override
 458             public void handleData(ITmfEvent event) {
 459                 super.handleData(event);
 460                 if (!isCompleted()) {
 461                     requestedEvents1.add(event);
 462                     if (++nbRead >= BLOCK_SIZE && signal.forceCancel) {
 463                         cancel();
 464                     }
 465                 }
 466             }
 467         };
 468
 469         requestedEvents2 = new Vector<ITmfEvent>();
 470         request2 = new TmfEventRequest(ITmfEvent.class, range,
 471                 signal.fIndex + REQUEST_OFFSET, NB_EVENTS, BLOCK_SIZE,
 472                 ExecutionType.FOREGROUND) {
 473             @Override
 474             public void handleData(ITmfEvent event) {
 475                 super.handleData(event);
 476                 if (!isCompleted()) {
 477                     requestedEvents2.add(event);
 478                 }
 479             }
 480         };
 481
 482         requestedEvents3 = new Vector<ITmfEvent>();
 483         request3 = new TmfEventRequest(ITmfEvent.class, range,
 484                 signal.fIndex + 2 * REQUEST_OFFSET, NB_EVENTS, BLOCK_SIZE,
 485                 ExecutionType.FOREGROUND) {
 486             @Override
 487             public void handleData(ITmfEvent event) {
 488                 super.handleData(event);
 489                 if (!isCompleted()) {
 490                     requestedEvents3.add(event);
 491                 }
 492             }
 493         };
 494
 495         providers = TmfProviderManager.getProviders(ITmfEvent.class, TmfTraceStub.class);
 496         providers[0].sendRequest(request1);
 497         providers[0].sendRequest(request2);
 498         providers[0].sendRequest(request3);
 499     }
 500
 501     public void runCoalescedRequest(long startIndex) throws InterruptedException {
 502
 503         fTrace = setupTrace(DIRECTORY + File.separator + TEST_STREAM);
 504
 505         TmfSignalManager.register(this);
 506         TmfTestTriggerSignal signal = new TmfTestTriggerSignal(this, startIndex, false);
 507         TmfSignalManager.dispatchSignal(signal);
 508
 509         request1.waitForCompletion();
 510         request2.waitForCompletion();
 511         request3.waitForCompletion();
 512
 513         try {
 514             assertEquals("Request1: nbEvents", NB_EVENTS, requestedEvents1.size());
 515             assertTrue("Request1: isCompleted", request1.isCompleted());
 516             assertFalse("Request1: isCancelled", request1.isCancelled());
 517
 518             assertEquals("Request2: nbEvents", NB_EVENTS, requestedEvents2.size());
 519             assertTrue("Request2: isCompleted", request2.isCompleted());
 520             assertFalse("Request2: isCancelled", request2.isCancelled());
 521
 522             assertEquals("Request3: nbEvents", NB_EVENTS, requestedEvents3.size());
 523             assertTrue("Request3: isCompleted", request3.isCompleted());
 524             assertFalse("Request3: isCancelled", request3.isCancelled());
 525
 526             // Ensure that we have distinct events.
 527             // Don't go overboard: we are not validating the stub!
 528             for (int i = 0; i < NB_EVENTS; i++) {
 529                 assertEquals("Distinct events", i + 1 + request1.getIndex(), requestedEvents1.get(i).getTimestamp().getValue());
 530                 assertEquals("Distinct events", i + 1 + request2.getIndex(), requestedEvents2.get(i).getTimestamp().getValue());
 531                 assertEquals("Distinct events", i + 1 + request3.getIndex(), requestedEvents3.get(i).getTimestamp().getValue());
 532             }
 533         } finally {
 534             TmfSignalManager.deregister(this);
 535             fTrace.dispose();
 536             fTrace = null;
 537         }
 538     }
 539
 540     @Test
 541     public void testCoalescedRequest() throws InterruptedException {
 542         runCoalescedRequest(0);
 543         runCoalescedRequest(1);
 544         runCoalescedRequest(5);
 545     }
 546
 547     @Test
 548     public void testCancelCoalescedRequest() throws InterruptedException {
 549
 550         fTrace = setupTrace(DIRECTORY + File.separator + TEST_STREAM);
 551
 552         TmfSignalManager.register(this);
 553         TmfTestTriggerSignal signal = new TmfTestTriggerSignal(this, 0, true);
 554         TmfSignalManager.dispatchSignal(signal);
 555
 556         request1.waitForCompletion();
 557         request2.waitForCompletion();
 558         request3.waitForCompletion();
 559
 560         assertEquals("Request1: nbEvents", BLOCK_SIZE, requestedEvents1.size());
 561         assertTrue("Request1: isCompleted", request1.isCompleted());
 562         assertTrue("Request1: isCancelled", request1.isCancelled());
 563
 564         assertEquals("Request2: nbEvents", NB_EVENTS, requestedEvents2.size());
 565         assertTrue("Request2: isCompleted", request2.isCompleted());
 566         assertFalse("Request2: isCancelled", request2.isCancelled());
 567
 568         assertEquals("Request3: nbEvents", NB_EVENTS, requestedEvents3.size());
 569         assertTrue("Request3: isCompleted", request3.isCompleted());
 570         assertFalse("Request3: isCancelled", request3.isCancelled());
 571
 572         // Ensure that we have distinct events.
 573         // Don't go overboard: we are not validating the stub!
 574         for (int i = 0; i < BLOCK_SIZE; i++) {
 575             assertEquals("Distinct events", i + 1 + request1.getIndex(), requestedEvents1.get(i).getTimestamp().getValue());
 576         }
 577         for (int i = 0; i < NB_EVENTS; i++) {
 578             assertEquals("Distinct events", i + 1 + request2.getIndex(), requestedEvents2.get(i).getTimestamp().getValue());
 579             assertEquals("Distinct events", i + 1 + request3.getIndex(), requestedEvents3.get(i).getTimestamp().getValue());
 580         }
 581
 582         TmfSignalManager.deregister(this);
 583         fTrace.dispose();
 584         fTrace = null;
 585     }
 586
 587 }