org.eclipse.linuxtools.tmf.tests/src/org/eclipse/linuxtools/tmf/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.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.component.ITmfDataProvider;
  21 import org.eclipse.linuxtools.tmf.component.TmfEventProviderStub;
  22 import org.eclipse.linuxtools.tmf.component.TmfProviderManager;
  23 import org.eclipse.linuxtools.tmf.component.TmfSyntheticEventProviderStub;
  24 import org.eclipse.linuxtools.tmf.event.TmfEvent;
  25 import org.eclipse.linuxtools.tmf.event.TmfSyntheticEventStub;
  26 import org.eclipse.linuxtools.tmf.event.TmfTimeRange;
  27 import org.eclipse.linuxtools.tmf.event.TmfTimestamp;
  28 import org.eclipse.linuxtools.tmf.request.TmfEventRequest;
  29 import org.eclipse.linuxtools.tmf.trace.TmfTraceStub;
  30
  31 /**
  32  * <b><u>TmfClientTest</u></b>
  33  * <p>
  34  * TODO: Implement me. Please.
  35  */
  36 public class TmfEventProviderTest extends TestCase {
  37
  38         TmfEventProviderStub fEventProvider;
  39         TmfSyntheticEventProviderStub fSyntheticEventProvider;
  40
  41         public TmfEventProviderTest(String name) throws IOException {
  42                 super(name);
  43         }
  44
  45         @Override
  46         protected void setUp() throws Exception {
  47                 super.setUp();
  48                 fEventProvider = new TmfEventProviderStub();
  49                 fSyntheticEventProvider = new TmfSyntheticEventProviderStub();
  50         }
  51
  52         @Override
  53         protected void tearDown() throws Exception {
  54                 super.tearDown();
  55                 fEventProvider.dispose();
  56                 fSyntheticEventProvider.dispose();
  57         }
  58
  59         // ------------------------------------------------------------------------
  60         // getProviders (more a sanity check than a test)
  61         // ------------------------------------------------------------------------
  62
  63         @SuppressWarnings("unchecked")
  64         public void testGetProviders() {
  65
  66                 // There should be 2 TmfEvent providers: a TmfTraceStub and a TmfEventProviderStub
  67                 ITmfDataProvider<TmfEvent>[] eventProviders = (ITmfDataProvider<TmfEvent>[]) TmfProviderManager.getProviders(TmfEvent.class);
  68                 assertTrue(eventProviders.length == 2);
  69
  70                 eventProviders = (ITmfDataProvider<TmfEvent>[]) TmfProviderManager.getProviders(TmfEvent.class, TmfTraceStub.class);
  71                 assertTrue(eventProviders.length == 1);
  72
  73                 eventProviders = (ITmfDataProvider<TmfEvent>[]) TmfProviderManager.getProviders(TmfEvent.class, TmfEventProviderStub.class);
  74                 assertTrue(eventProviders.length == 1);
  75
  76                 // There should be 1 TmfSyntheticEventStub provider
  77                 eventProviders = (ITmfDataProvider<TmfEvent>[]) TmfProviderManager.getProviders(TmfSyntheticEventStub.class);
  78                 assertTrue(eventProviders.length == 1);
  79         }
  80
  81         // ------------------------------------------------------------------------
  82         // getSyntheticEvent
  83         // ------------------------------------------------------------------------
  84
  85         @SuppressWarnings("unchecked")
  86         public void testGetPlainEvents() throws InterruptedException {
  87
  88         final int BLOCK_SIZE = 100;
  89         final int NB_EVENTS  = 1000;
  90         final Vector<TmfEvent> requestedEvents = new Vector<TmfEvent>();
  91
  92         // Get the TmfSyntheticEventStub provider
  93                 ITmfDataProvider<TmfEvent>[] eventProviders = (ITmfDataProvider<TmfEvent>[]) TmfProviderManager.getProviders(TmfEvent.class, TmfEventProviderStub.class);
  94                 ITmfDataProvider<TmfEvent> provider = eventProviders[0];
  95
  96         TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BigBang, TmfTimestamp.BigCrunch);
  97         final TmfEventRequest<TmfEvent> request =
  98                 new TmfEventRequest<TmfEvent>(TmfEvent.class, range, NB_EVENTS, BLOCK_SIZE) {
  99                 @Override
 100                 public void handleData() {
 101                         TmfEvent[] events = getData();
 102                         for (TmfEvent e : events) {
 103                                 requestedEvents.add(e);
 104                         }
 105                 }
 106                 };
 107         provider.sendRequest(request);
 108         request.waitForCompletion();
 109
 110         assertEquals("nbEvents", NB_EVENTS, requestedEvents.size());
 111         assertTrue("isCompleted",  request.isCompleted());
 112         assertFalse("isCancelled", request.isCancelled());
 113
 114         // Make that we have distinct events.
 115         // Don't go overboard: we are not validating the stub!
 116         for (int i = 0; i < NB_EVENTS; i++) {
 117             assertEquals("Distinct events", i+1, requestedEvents.get(i).getTimestamp().getValue());
 118         }
 119         }
 120
 121         @SuppressWarnings("unchecked")
 122         private void getSyntheticData(final TmfTimeRange range, final int nbEvents, final int blockSize) throws InterruptedException {
 123
 124         final Vector<TmfSyntheticEventStub> requestedEvents = new Vector<TmfSyntheticEventStub>();
 125
 126         // Get the event provider
 127                 ITmfDataProvider<TmfSyntheticEventStub>[] eventProviders = (ITmfDataProvider<TmfSyntheticEventStub>[]) TmfProviderManager.getProviders(TmfSyntheticEventStub.class);
 128                 ITmfDataProvider<TmfSyntheticEventStub> provider = eventProviders[0];
 129
 130         final TmfEventRequest<TmfSyntheticEventStub> request =
 131                 new TmfEventRequest<TmfSyntheticEventStub>(TmfSyntheticEventStub.class, range, nbEvents, blockSize) {
 132                 @Override
 133                 public void handleData() {
 134                         TmfSyntheticEventStub[] events = getData();
 135                         for (TmfSyntheticEventStub e : events) {
 136                                 requestedEvents.add(e);
 137                         }
 138                 }
 139                 };
 140         provider.sendRequest(request);
 141         request.waitForCompletion();
 142
 143         if (nbEvents != -1)
 144                 assertEquals("nbEvents", nbEvents, requestedEvents.size());
 145         assertTrue("isCompleted", request.isCompleted());
 146         assertFalse("isCancelled", request.isCancelled());
 147
 148         // For each base event, the stub will queue 2 identical synthetic events
 149         // Ensure that the events are queued properly.
 150         // Don't go overboard: we are not validating the stub!
 151         for (int i = 0; i < (nbEvents / 2); i++) {
 152             assertEquals("Distinct events", i+1, requestedEvents.get(2 * i + 0).getTimestamp().getValue());
 153             assertEquals("Distinct events", i+1, requestedEvents.get(2 * i + 1).getTimestamp().getValue());
 154         }
 155         }
 156
 157         // The following tests are the same but for the size of the requested blocks
 158         // with regards to the size of the TmfSyntheticEventProviderStub block
 159     public void testGetSyntheticEvents_EqualBlockSizes() throws InterruptedException {
 160         TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BigBang, TmfTimestamp.BigCrunch);
 161                 getSyntheticData(range, 1000, TmfSyntheticEventProviderStub.BLOCK_SIZE);
 162         }
 163
 164         public void testGetSyntheticEvents_SmallerBlock() throws InterruptedException {
 165         TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BigBang, TmfTimestamp.BigCrunch);
 166                 getSyntheticData(range, 1000, TmfSyntheticEventProviderStub.BLOCK_SIZE / 2);
 167         }
 168
 169         public void testGetSyntheticEvents_LargerBlock() throws InterruptedException {
 170         TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BigBang, TmfTimestamp.BigCrunch);
 171                 getSyntheticData(range, 1000, TmfSyntheticEventProviderStub.BLOCK_SIZE * 2);
 172         }
 173
 174         public void testGetSyntheticEvents_TimeRange() throws InterruptedException {
 175                 TmfTimestamp start = new TmfTimestamp(   1, (byte) -3, 0);
 176                 TmfTimestamp end   = new TmfTimestamp(1000, (byte) -3, 0);
 177         TmfTimeRange range = new TmfTimeRange(start, end);
 178                 getSyntheticData(range, -1, TmfSyntheticEventProviderStub.BLOCK_SIZE);
 179         }
 180
 181         public void testGetSyntheticEvents_WeirdTimeRange1() throws InterruptedException {
 182                 TmfTimestamp start = TmfTimestamp.BigBang;
 183                 TmfTimestamp end   = new TmfTimestamp(0, (byte) -3, 0);
 184         TmfTimeRange range = new TmfTimeRange(start, end);
 185                 getSyntheticData(range, -1, TmfSyntheticEventProviderStub.BLOCK_SIZE);
 186         }
 187
 188         public void testGetSyntheticEvents_WeirdTimeRange2() throws InterruptedException {
 189                 TmfTimestamp start = new TmfTimestamp(0, (byte) -3, 0);
 190                 TmfTimestamp end   = TmfTimestamp.BigCrunch;
 191         TmfTimeRange range = new TmfTimeRange(start, end);
 192                 getSyntheticData(range, -1, TmfSyntheticEventProviderStub.BLOCK_SIZE);
 193         }
 194
 195         // ------------------------------------------------------------------------
 196         // getProviders (more a sanity check than a test)
 197         // ------------------------------------------------------------------------
 198
 199         @SuppressWarnings("unchecked")
 200         public void testGetProviders2() {
 201
 202                 // There should be 2 TmfEvent providers: a TmfTraceStub and a TmfEventProviderStub
 203                 ITmfDataProvider<TmfEvent>[] eventProviders = (ITmfDataProvider<TmfEvent>[]) TmfProviderManager.getProviders(TmfEvent.class);
 204                 assertTrue(eventProviders.length == 2);
 205
 206                 eventProviders = (ITmfDataProvider<TmfEvent>[]) TmfProviderManager.getProviders(TmfEvent.class, TmfTraceStub.class);
 207                 assertTrue(eventProviders.length == 1);
 208
 209                 eventProviders = (ITmfDataProvider<TmfEvent>[]) TmfProviderManager.getProviders(TmfEvent.class, TmfEventProviderStub.class);
 210                 assertTrue(eventProviders.length == 1);
 211
 212                 // There should be 1 TmfSyntheticEventStub provider
 213                 eventProviders = (ITmfDataProvider<TmfEvent>[]) TmfProviderManager.getProviders(TmfSyntheticEventStub.class);
 214                 assertTrue(eventProviders.length == 1);
 215         }
 216
 217 }