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