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

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