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