org.eclipse.linuxtools.tmf.core.tests/src/org/eclipse/linuxtools/tmf/core/tests/component/TmfEventProviderTest.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.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.request.ITmfDataRequest.ExecutionType;
  26 import org.eclipse.linuxtools.tmf.core.signal.TmfEndSynchSignal;
  27 import org.eclipse.linuxtools.tmf.core.signal.TmfStartSynchSignal;
  28 import org.eclipse.linuxtools.tmf.core.timestamp.TmfTimeRange;
  29 import org.eclipse.linuxtools.tmf.core.timestamp.TmfTimestamp;
  30 import org.eclipse.linuxtools.tmf.tests.stubs.component.TmfEventProviderStub;
  31 import org.eclipse.linuxtools.tmf.tests.stubs.component.TmfSyntheticEventProviderStub;
  32 import org.eclipse.linuxtools.tmf.tests.stubs.event.TmfSyntheticEventStub;
  33 import org.eclipse.linuxtools.tmf.tests.stubs.trace.TmfTraceStub;
  34 import org.junit.After;
  35 import org.junit.Before;
  36 import org.junit.Test;
  37
  38 /**
  39  * Test suite for the TmfEventProvider class.
  40  */
  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 NB_EVENTS = 1000;
 103         final Vector<ITmfEvent> requestedEvents = new Vector<ITmfEvent>();
 104
 105         // Get the TmfSyntheticEventStub provider
 106         ITmfDataProvider[] eventProviders = TmfProviderManager.getProviders(ITmfEvent.class,
 107                 TmfEventProviderStub.class);
 108         ITmfDataProvider provider = eventProviders[0];
 109
 110         TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BIG_BANG, TmfTimestamp.BIG_CRUNCH);
 111         final TmfEventRequest request = new TmfEventRequest(ITmfEvent.class,
 112                 range, 0, NB_EVENTS, ExecutionType.FOREGROUND) {
 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         final int NB_EVENTS = 1000;
 143         final int NUMBER_EVENTS_BEFORE_CANCEL_REQ1 = 10;
 144         final int NUMBER_EVENTS_BEFORE_CANCEL_REQ2 = 800;
 145
 146         final Vector<ITmfEvent> requestedEventsReq1 = new Vector<ITmfEvent>();
 147         final Vector<ITmfEvent> requestedEventsReq2 = new Vector<ITmfEvent>();
 148
 149         // Get the TmfSyntheticEventStub provider
 150         ITmfDataProvider[] eventProviders = TmfProviderManager.getProviders(ITmfEvent.class,
 151                 TmfEventProviderStub.class);
 152         ITmfDataProvider provider = eventProviders[0];
 153
 154         TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BIG_BANG, TmfTimestamp.BIG_CRUNCH);
 155
 156         // Create first request
 157         final TmfEventRequest request1 = new TmfEventRequest(ITmfEvent.class,
 158                 range, 0, NB_EVENTS, ExecutionType.FOREGROUND) {
 159             @Override
 160             public void handleData(ITmfEvent event) {
 161                 super.handleData(event);
 162                 requestedEventsReq1.add(event);
 163
 164                 // cancel sub request
 165                 if (getNbRead() == NUMBER_EVENTS_BEFORE_CANCEL_REQ1) {
 166                     cancel();
 167                 }
 168             }
 169         };
 170
 171         // Synchronize requests
 172         ((TmfEventProviderStub) provider).startSynch(new TmfStartSynchSignal(0));
 173
 174         // Additionally, notify provider for up-coming requests
 175         provider.notifyPendingRequest(true);
 176
 177         // Call sendRequest, which will create a coalescing request, but it
 178         // doesn't send request1 yet
 179         provider.sendRequest(request1);
 180
 181         // Check if request1 is not running yet.
 182         assertFalse("isRunning", request1.isRunning());
 183
 184         // Create second request
 185         final TmfEventRequest request2 = new TmfEventRequest(ITmfEvent.class,
 186                 range, 0, NB_EVENTS, ExecutionType.FOREGROUND) {
 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) 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                 0, nbEvents, ExecutionType.FOREGROUND) {
 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);
 293         } catch (InterruptedException e) {
 294             fail();
 295         }
 296     }
 297
 298     /**
 299      * Test getSyntheticEvents
 300      */
 301     @Test
 302     public void testGetSyntheticEvents_TimeRange() {
 303         TmfTimestamp start = new TmfTimestamp(1, (byte) -3, 0);
 304         TmfTimestamp end = new TmfTimestamp(1000, (byte) -3, 0);
 305         TmfTimeRange range = new TmfTimeRange(start, end);
 306         try {
 307             getSyntheticData(range, -1);
 308         } catch (InterruptedException e) {
 309             fail();
 310         }
 311     }
 312
 313 //    public void testGetSyntheticEvents_WeirdTimeRange1() {
 314 //        TmfTimestamp start = TmfTimestamp.BigBang;
 315 //        TmfTimestamp end = TmfTimestamp.Zero; // new TmfTimestamp(0, (byte) -3,
 316 //                                              // 0);
 317 //        TmfTimeRange range = new TmfTimeRange(start, end);
 318 //        try {
 319 //            getSyntheticData(range, -1, TmfSyntheticEventProviderStub.BLOCK_SIZE);
 320 //        } catch (InterruptedException e) {
 321 //            fail();
 322 //        }
 323 //    }
 324
 325 //    public void testGetSyntheticEvents_WeirdTimeRange2() {
 326 //        TmfTimestamp start = TmfTimestamp.Zero; // new TmfTimestamp(0, (byte)
 327 //                                                // -3, 0);
 328 //        TmfTimestamp end = TmfTimestamp.BigCrunch;
 329 //        TmfTimeRange range = new TmfTimeRange(start, end);
 330 //        try {
 331 //            getSyntheticData(range, -1, TmfSyntheticEventProviderStub.BLOCK_SIZE);
 332 //        } catch (InterruptedException e) {
 333 //            fail();
 334 //        }
 335 //    }
 336
 337     /**
 338      * Test getProviders (more a sanity check than a test)
 339      */
 340     @Test
 341     public void testGetProviders2() {
 342
 343         // There should be 2 TmfEvent providers: a TmfTraceStub and a
 344         // TmfEventProviderStub
 345         ITmfDataProvider[] eventProviders = TmfProviderManager.getProviders(ITmfEvent.class);
 346         assertEquals("getProviders", 2, eventProviders.length);
 347
 348         eventProviders = TmfProviderManager.getProviders(ITmfEvent.class, TmfTraceStub.class);
 349         assertEquals("getProviders", 1, eventProviders.length);
 350
 351         eventProviders = TmfProviderManager.getProviders(ITmfEvent.class, TmfEventProviderStub.class);
 352         assertEquals("getProviders", 1, eventProviders.length);
 353
 354         // There should be 1 TmfSyntheticEventStub provider
 355         eventProviders = TmfProviderManager.getProviders(TmfSyntheticEventStub.class);
 356         assertEquals("getProviders", 1, eventProviders.length);
 357     }
 358
 359 }