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

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