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