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