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