org.eclipse.linuxtools.tmf.core.tests/src/org/eclipse/linuxtools/tmf/core/tests/component/TmfEventProviderTest.java

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