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