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