org.eclipse.linuxtools.tmf.tests/src/org/eclipse/linuxtools/tmf/tests/component/TmfEventProviderTest.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.tests.component;
  14
  15 import java.io.IOException;
  16 import java.util.Vector;
  17
  18 import junit.framework.TestCase;
  19
  20 import org.eclipse.linuxtools.tmf.component.ITmfDataProvider;
  21 import org.eclipse.linuxtools.tmf.component.TmfEventProviderStub;
  22 import org.eclipse.linuxtools.tmf.component.TmfProviderManager;
  23 import org.eclipse.linuxtools.tmf.component.TmfSyntheticEventProviderStub;
  24 import org.eclipse.linuxtools.tmf.event.TmfEvent;
  25 import org.eclipse.linuxtools.tmf.event.TmfSyntheticEventStub;
  26 import org.eclipse.linuxtools.tmf.event.TmfTimeRange;
  27 import org.eclipse.linuxtools.tmf.event.TmfTimestamp;
  28 import org.eclipse.linuxtools.tmf.request.TmfEventRequest;
  29 import org.eclipse.linuxtools.tmf.signal.TmfEndSynchSignal;
  30 import org.eclipse.linuxtools.tmf.signal.TmfStartSynchSignal;
  31 import org.eclipse.linuxtools.tmf.trace.TmfTraceStub;
  32
  33 /**
  34  * <b><u>TmfClientTest</u></b>
  35  * <p>
  36  * Test suite for the TmfEventProvider class.
  37  */
  38 public class TmfEventProviderTest extends TestCase {
  39
  40         TmfEventProviderStub fEventProvider;
  41         TmfSyntheticEventProviderStub fSyntheticEventProvider;
  42
  43         public TmfEventProviderTest(String name) throws IOException {
  44                 super(name);
  45         }
  46
  47         @Override
  48         protected void setUp() throws Exception {
  49                 super.setUp();
  50                 fEventProvider = new TmfEventProviderStub();
  51                 fSyntheticEventProvider = new TmfSyntheticEventProviderStub();
  52         }
  53
  54         @Override
  55         protected void tearDown() throws Exception {
  56                 super.tearDown();
  57                 fEventProvider.dispose();
  58                 fSyntheticEventProvider.dispose();
  59         }
  60
  61         // ------------------------------------------------------------------------
  62         // getProviders (more a sanity check than a test)
  63         // ------------------------------------------------------------------------
  64
  65         @SuppressWarnings("unchecked")
  66         public void testGetProviders() {
  67
  68                 // There should be 2 TmfEvent providers: a TmfTraceStub and a TmfEventProviderStub
  69                 ITmfDataProvider<TmfEvent>[] eventProviders = (ITmfDataProvider<TmfEvent>[]) TmfProviderManager.getProviders(TmfEvent.class);
  70                 assertEquals("getProviders", 2, eventProviders.length);
  71
  72                 eventProviders = (ITmfDataProvider<TmfEvent>[]) TmfProviderManager.getProviders(TmfEvent.class, TmfTraceStub.class);
  73                 assertEquals("getProviders", 1, eventProviders.length);
  74
  75                 eventProviders = (ITmfDataProvider<TmfEvent>[]) TmfProviderManager.getProviders(TmfEvent.class, TmfEventProviderStub.class);
  76                 assertEquals("getProviders", 1, eventProviders.length);
  77
  78                 // There should be 1 TmfSyntheticEventStub provider
  79                 eventProviders = (ITmfDataProvider<TmfEvent>[]) TmfProviderManager.getProviders(TmfSyntheticEventStub.class);
  80                 assertEquals("getProviders", 1, eventProviders.length);
  81         }
  82
  83         // ------------------------------------------------------------------------
  84         // getSyntheticEvent
  85         // ------------------------------------------------------------------------
  86
  87         @SuppressWarnings("unchecked")
  88         public void testGetPlainEvents() {
  89
  90         final int BLOCK_SIZE = 100;
  91         final int NB_EVENTS  = 1000;
  92         final Vector<TmfEvent> requestedEvents = new Vector<TmfEvent>();
  93
  94         // Get the TmfSyntheticEventStub provider
  95                 ITmfDataProvider<TmfEvent>[] eventProviders = (ITmfDataProvider<TmfEvent>[]) TmfProviderManager.getProviders(TmfEvent.class, TmfEventProviderStub.class);
  96                 ITmfDataProvider<TmfEvent> provider = eventProviders[0];
  97
  98         TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BigBang, TmfTimestamp.BigCrunch);
  99         final TmfEventRequest<TmfEvent> request =
 100                 new TmfEventRequest<TmfEvent>(TmfEvent.class, range, NB_EVENTS, BLOCK_SIZE) {
 101                 @Override
 102                 public void handleData(TmfEvent event) {
 103                 super.handleData(event);
 104                         requestedEvents.add(event);
 105                 }
 106         };
 107
 108         provider.sendRequest(request);
 109         try {
 110                         request.waitForCompletion();
 111                 assertEquals("nbEvents", NB_EVENTS, requestedEvents.size());
 112                 assertTrue("isCompleted",  request.isCompleted());
 113                 assertFalse("isCancelled", request.isCancelled());
 114
 115                 // Make that we have distinct events.
 116                 // Don't go overboard: we are not validating the stub!
 117                 for (int i = 0; i < NB_EVENTS; i++) {
 118                     assertEquals("Distinct events", i+1, requestedEvents.get(i).getTimestamp().getValue());
 119                 }
 120                 } catch (InterruptedException e) {
 121                         fail();
 122                 }
 123         }
 124
 125         @SuppressWarnings("unchecked")
 126         public void testCancelRequests() {
 127
 128             final int BLOCK_SIZE = 100;
 129             final int NB_EVENTS  = 1000;
 130             final int NUMBER_EVENTS_BEFORE_CANCEL_REQ1 = 10;
 131             final int NUMBER_EVENTS_BEFORE_CANCEL_REQ2 = 800;
 132
 133             final Vector<TmfEvent> requestedEventsReq1 = new Vector<TmfEvent>();
 134             final Vector<TmfEvent> requestedEventsReq2 = new Vector<TmfEvent>();
 135
 136             // Get the TmfSyntheticEventStub provider
 137             ITmfDataProvider<TmfEvent>[] eventProviders = (ITmfDataProvider<TmfEvent>[]) TmfProviderManager.getProviders(TmfEvent.class, TmfEventProviderStub.class);
 138             ITmfDataProvider<TmfEvent> provider = eventProviders[0];
 139
 140             TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BigBang, TmfTimestamp.BigCrunch);
 141
 142             // Create first request
 143             final TmfEventRequest<TmfEvent> request1 =
 144                 new TmfEventRequest<TmfEvent>(TmfEvent.class, range, NB_EVENTS, BLOCK_SIZE) {
 145                 @Override
 146                 public void handleData(TmfEvent event) {
 147                     super.handleData(event);
 148                     requestedEventsReq1.add(event);
 149
 150                     // cancel sub request
 151                     if (getNbRead() == NUMBER_EVENTS_BEFORE_CANCEL_REQ1) {
 152                         cancel();
 153                     }
 154                 }
 155             };
 156
 157             // Synchronize requests
 158             ((TmfEventProviderStub) provider).startSynch(new TmfStartSynchSignal(0));
 159
 160             // Additionally, notify provider for up-coming requests
 161             provider.notifyPendingRequest(true);
 162
 163             // Call sendRequest, which will create a coalescing request, but it doesn't send request1 yet
 164             provider.sendRequest(request1);
 165
 166             // Check if request1 is not running yet.
 167             assertFalse("isRunning", request1.isRunning());
 168
 169             // Create second request
 170             final TmfEventRequest<TmfEvent> request2 =
 171                 new TmfEventRequest<TmfEvent>(TmfEvent.class, range, NB_EVENTS, BLOCK_SIZE) {
 172                 @Override
 173                 public void handleData(TmfEvent event) {
 174                     super.handleData(event);
 175                 requestedEventsReq2.add(event);
 176
 177                 // cancel sub request which will cancel also main request
 178                     if (getNbRead() == NUMBER_EVENTS_BEFORE_CANCEL_REQ2) {
 179                         cancel();
 180                     }
 181                 }
 182             };
 183
 184             // Call sendRequest, which will create a coalescing request, but it doesn't send request2 yet
 185         provider.sendRequest(request2);
 186
 187         // Check if request1/2 is not running yet.
 188         assertFalse("isRunning",  request1.isRunning());
 189         assertFalse("isRunning",  request2.isRunning());
 190
 191         // Send end synch signal, however requests won't be sent
 192         ((TmfEventProviderStub) provider).endSynch(new TmfEndSynchSignal(0));
 193
 194         // Check if request1/2 is not running yet.
 195         assertFalse("isRunning",  request1.isRunning());
 196         assertFalse("isRunning",  request2.isRunning());
 197
 198         // Finally, trigger sending of requests
 199         provider.notifyPendingRequest(false);
 200
 201             try {
 202
 203                 // Wait till requests start
 204                 request1.waitForStart();
 205                 request2.waitForStart();
 206
 207                 // Check if request1/2 are running.
 208                 assertTrue("isRunning",  request1.isRunning());
 209                 assertTrue("isRunning",  request2.isRunning());
 210
 211                 request1.waitForCompletion();
 212
 213                 // Check if request2 is still running
 214             assertTrue("isRunning",  request2.isRunning());
 215
 216                 // Verify result (request1)
 217             assertEquals("nbEvents", NUMBER_EVENTS_BEFORE_CANCEL_REQ1, requestedEventsReq1.size());
 218                 assertTrue("isCompleted",  request1.isCompleted());
 219                 assertTrue("isCancelled",  request1.isCancelled());
 220
 221                 request2.waitForCompletion();
 222
 223                 // Verify result (request2)
 224                 assertEquals("nbEvents", NUMBER_EVENTS_BEFORE_CANCEL_REQ2, requestedEventsReq2.size());
 225                 assertTrue("isCompleted",  request2.isCompleted());
 226                 assertTrue("isCancelled",  request2.isCancelled());
 227
 228             } catch (InterruptedException e) {
 229                 fail();
 230             }
 231         }
 232
 233         @SuppressWarnings("unchecked")
 234         private void getSyntheticData(final TmfTimeRange range, final int nbEvents, final int blockSize) throws InterruptedException {
 235
 236         final Vector<TmfSyntheticEventStub> requestedEvents = new Vector<TmfSyntheticEventStub>();
 237
 238         // Get the event provider
 239                 ITmfDataProvider<TmfSyntheticEventStub>[] eventProviders = (ITmfDataProvider<TmfSyntheticEventStub>[]) TmfProviderManager.getProviders(TmfSyntheticEventStub.class);
 240                 ITmfDataProvider<TmfSyntheticEventStub> provider = eventProviders[0];
 241
 242         final TmfEventRequest<TmfSyntheticEventStub> request =
 243                 new TmfEventRequest<TmfSyntheticEventStub>(TmfSyntheticEventStub.class, range, nbEvents, blockSize) {
 244                         @Override
 245                         public void handleData(TmfSyntheticEventStub event) {
 246                         super.handleData(event);
 247                                 requestedEvents.add(event);
 248                         }
 249                 };
 250         provider.sendRequest(request);
 251
 252         request.waitForCompletion();
 253             if (nbEvents != -1)
 254                 assertEquals("nbEvents", nbEvents, requestedEvents.size());
 255             assertTrue("isCompleted", request.isCompleted());
 256             assertFalse("isCancelled", request.isCancelled());
 257
 258             // For each base event, the stub will queue 2 identical synthetic events
 259             // Ensure that the events are queued properly.
 260             // Don't go overboard: we are not validating the stub!
 261             for (int i = 0; i < (nbEvents / 2); i++) {
 262                 assertEquals("Distinct events", i+1, requestedEvents.get(2 * i + 0).getTimestamp().getValue());
 263                 assertEquals("Distinct events", i+1, requestedEvents.get(2 * i + 1).getTimestamp().getValue());
 264             }
 265         }
 266
 267         // The following tests are the same but for the size of the requested blocks
 268         // with regards to the size of the TmfSyntheticEventProviderStub block
 269     public void testGetSyntheticEvents_EqualBlockSizes() {
 270         TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BigBang, TmfTimestamp.BigCrunch);
 271                 try {
 272                         getSyntheticData(range, 1000, TmfSyntheticEventProviderStub.BLOCK_SIZE);
 273                 } catch (InterruptedException e) {
 274                         fail();
 275                 }
 276         }
 277
 278         public void testGetSyntheticEvents_SmallerBlock() {
 279         TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BigBang, TmfTimestamp.BigCrunch);
 280                 try {
 281                         getSyntheticData(range, 1000, TmfSyntheticEventProviderStub.BLOCK_SIZE / 2);
 282                 } catch (InterruptedException e) {
 283                         fail();
 284                 }
 285         }
 286
 287         public void testGetSyntheticEvents_LargerBlock() {
 288         TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BigBang, TmfTimestamp.BigCrunch);
 289                 try {
 290                         getSyntheticData(range, 1000, TmfSyntheticEventProviderStub.BLOCK_SIZE * 2);
 291                 } catch (InterruptedException e) {
 292                         fail();
 293                 }
 294         }
 295
 296         public void testGetSyntheticEvents_TimeRange() {
 297                 TmfTimestamp start = new TmfTimestamp(   1, (byte) -3, 0);
 298                 TmfTimestamp end   = new TmfTimestamp(1000, (byte) -3, 0);
 299         TmfTimeRange range = new TmfTimeRange(start, end);
 300                 try {
 301                         getSyntheticData(range, -1, TmfSyntheticEventProviderStub.BLOCK_SIZE);
 302                 } catch (InterruptedException e) {
 303                         fail();
 304                 }
 305         }
 306
 307         public void testGetSyntheticEvents_WeirdTimeRange1() {
 308                 TmfTimestamp start = TmfTimestamp.BigBang;
 309                 TmfTimestamp end   = TmfTimestamp.Zero; // new TmfTimestamp(0, (byte) -3, 0);
 310         TmfTimeRange range = new TmfTimeRange(start, end);
 311                 try {
 312                         getSyntheticData(range, -1, TmfSyntheticEventProviderStub.BLOCK_SIZE);
 313                 } catch (InterruptedException e) {
 314                         fail();
 315                 }
 316         }
 317
 318         public void testGetSyntheticEvents_WeirdTimeRange2() {
 319                 TmfTimestamp start = TmfTimestamp.Zero; // new TmfTimestamp(0, (byte) -3, 0);
 320                 TmfTimestamp end   = TmfTimestamp.BigCrunch;
 321         TmfTimeRange range = new TmfTimeRange(start, end);
 322                 try {
 323                         getSyntheticData(range, -1, TmfSyntheticEventProviderStub.BLOCK_SIZE);
 324                 } catch (InterruptedException e) {
 325                         fail();
 326                 }
 327         }
 328
 329         // ------------------------------------------------------------------------
 330         // getProviders (more a sanity check than a test)
 331         // ------------------------------------------------------------------------
 332
 333         @SuppressWarnings("unchecked")
 334         public void testGetProviders2() {
 335
 336                 // There should be 2 TmfEvent providers: a TmfTraceStub and a TmfEventProviderStub
 337                 ITmfDataProvider<TmfEvent>[] eventProviders = (ITmfDataProvider<TmfEvent>[]) TmfProviderManager.getProviders(TmfEvent.class);
 338                 assertEquals("getProviders", 2, eventProviders.length);
 339
 340                 eventProviders = (ITmfDataProvider<TmfEvent>[]) TmfProviderManager.getProviders(TmfEvent.class, TmfTraceStub.class);
 341                 assertEquals("getProviders", 1, eventProviders.length);
 342
 343                 eventProviders = (ITmfDataProvider<TmfEvent>[]) TmfProviderManager.getProviders(TmfEvent.class, TmfEventProviderStub.class);
 344                 assertEquals("getProviders", 1, eventProviders.length);
 345
 346                 // There should be 1 TmfSyntheticEventStub provider
 347                 eventProviders = (ITmfDataProvider<TmfEvent>[]) TmfProviderManager.getProviders(TmfSyntheticEventStub.class);
 348                 assertEquals("getProviders", 1, eventProviders.length);
 349         }
 350
 351 }