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