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