tmf/org.eclipse.tracecompass.tmf.core.tests/src/org/eclipse/tracecompass/tmf/core/tests/request/TmfCoalescedEventRequestTest.java

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