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