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  * Test suite for the TmfEventProvider class.
  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                 assertEquals("getProviders", 2, eventProviders.length);
  69
  70                 eventProviders = (ITmfDataProvider<TmfEvent>[]) TmfProviderManager.getProviders(TmfEvent.class, TmfTraceStub.class);
  71                 assertEquals("getProviders", 1, eventProviders.length);
  72
  73                 eventProviders = (ITmfDataProvider<TmfEvent>[]) TmfProviderManager.getProviders(TmfEvent.class, TmfEventProviderStub.class);
  74                 assertEquals("getProviders", 1, eventProviders.length);
  75
  76                 // There should be 1 TmfSyntheticEventStub provider
  77                 eventProviders = (ITmfDataProvider<TmfEvent>[]) TmfProviderManager.getProviders(TmfSyntheticEventStub.class);
  78                 assertEquals("getProviders", 1, eventProviders.length);
  79         }
  80
  81         // ------------------------------------------------------------------------
  82         // getSyntheticEvent
  83         // ------------------------------------------------------------------------
  84
  85         @SuppressWarnings("unchecked")
  86         public void testGetPlainEvents() {
  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         try {
 109                         request.waitForCompletion();
 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                 } catch (InterruptedException e) {
 120                         fail();
 121                 }
 122         }
 123
 124         @SuppressWarnings("unchecked")
 125         private void getSyntheticData(final TmfTimeRange range, final int nbEvents, final int blockSize) throws InterruptedException {
 126
 127         final Vector<TmfSyntheticEventStub> requestedEvents = new Vector<TmfSyntheticEventStub>();
 128
 129         // Get the event provider
 130                 ITmfDataProvider<TmfSyntheticEventStub>[] eventProviders = (ITmfDataProvider<TmfSyntheticEventStub>[]) TmfProviderManager.getProviders(TmfSyntheticEventStub.class);
 131                 ITmfDataProvider<TmfSyntheticEventStub> provider = eventProviders[0];
 132
 133         final TmfEventRequest<TmfSyntheticEventStub> request =
 134                 new TmfEventRequest<TmfSyntheticEventStub>(TmfSyntheticEventStub.class, range, nbEvents, blockSize) {
 135                 @Override
 136                 public void handleData() {
 137                         TmfSyntheticEventStub[] events = getData();
 138                         for (TmfSyntheticEventStub e : events) {
 139                                 requestedEvents.add(e);
 140                         }
 141                 }
 142                 };
 143         provider.sendRequest(request);
 144
 145         request.waitForCompletion();
 146             if (nbEvents != -1)
 147                 assertEquals("nbEvents", nbEvents, requestedEvents.size());
 148             assertTrue("isCompleted", request.isCompleted());
 149             assertFalse("isCancelled", request.isCancelled());
 150
 151             // For each base event, the stub will queue 2 identical synthetic events
 152             // Ensure that the events are queued properly.
 153             // Don't go overboard: we are not validating the stub!
 154             for (int i = 0; i < (nbEvents / 2); i++) {
 155                 assertEquals("Distinct events", i+1, requestedEvents.get(2 * i + 0).getTimestamp().getValue());
 156                 assertEquals("Distinct events", i+1, requestedEvents.get(2 * i + 1).getTimestamp().getValue());
 157             }
 158         }
 159
 160         // The following tests are the same but for the size of the requested blocks
 161         // with regards to the size of the TmfSyntheticEventProviderStub block
 162     public void testGetSyntheticEvents_EqualBlockSizes() {
 163         TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BigBang, TmfTimestamp.BigCrunch);
 164                 try {
 165                         getSyntheticData(range, 1000, TmfSyntheticEventProviderStub.BLOCK_SIZE);
 166                 } catch (InterruptedException e) {
 167                         fail();
 168                 }
 169         }
 170
 171         public void testGetSyntheticEvents_SmallerBlock() {
 172         TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BigBang, TmfTimestamp.BigCrunch);
 173                 try {
 174                         getSyntheticData(range, 1000, TmfSyntheticEventProviderStub.BLOCK_SIZE / 2);
 175                 } catch (InterruptedException e) {
 176                         fail();
 177                 }
 178         }
 179
 180         public void testGetSyntheticEvents_LargerBlock() {
 181         TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BigBang, TmfTimestamp.BigCrunch);
 182                 try {
 183                         getSyntheticData(range, 1000, TmfSyntheticEventProviderStub.BLOCK_SIZE * 2);
 184                 } catch (InterruptedException e) {
 185                         fail();
 186                 }
 187         }
 188
 189         public void testGetSyntheticEvents_TimeRange() {
 190                 TmfTimestamp start = new TmfTimestamp(   1, (byte) -3, 0);
 191                 TmfTimestamp end   = new TmfTimestamp(1000, (byte) -3, 0);
 192         TmfTimeRange range = new TmfTimeRange(start, end);
 193                 try {
 194                         getSyntheticData(range, -1, TmfSyntheticEventProviderStub.BLOCK_SIZE);
 195                 } catch (InterruptedException e) {
 196                         fail();
 197                 }
 198         }
 199
 200         public void testGetSyntheticEvents_WeirdTimeRange1() {
 201                 TmfTimestamp start = TmfTimestamp.BigBang;
 202                 TmfTimestamp end   = TmfTimestamp.Zero; // new TmfTimestamp(0, (byte) -3, 0);
 203         TmfTimeRange range = new TmfTimeRange(start, end);
 204                 try {
 205                         getSyntheticData(range, -1, TmfSyntheticEventProviderStub.BLOCK_SIZE);
 206 //                      System.out.println("aie");
 207                 } catch (InterruptedException e) {
 208                         fail();
 209                 }
 210         }
 211
 212         public void testGetSyntheticEvents_WeirdTimeRange2() {
 213                 TmfTimestamp start = TmfTimestamp.Zero; // new TmfTimestamp(0, (byte) -3, 0);
 214                 TmfTimestamp end   = TmfTimestamp.BigCrunch;
 215         TmfTimeRange range = new TmfTimeRange(start, end);
 216                 try {
 217                         getSyntheticData(range, -1, TmfSyntheticEventProviderStub.BLOCK_SIZE);
 218                 } catch (InterruptedException e) {
 219                         fail();
 220                 }
 221         }
 222
 223         // ------------------------------------------------------------------------
 224         // getProviders (more a sanity check than a test)
 225         // ------------------------------------------------------------------------
 226
 227         @SuppressWarnings("unchecked")
 228         public void testGetProviders2() {
 229
 230                 // There should be 2 TmfEvent providers: a TmfTraceStub and a TmfEventProviderStub
 231                 ITmfDataProvider<TmfEvent>[] eventProviders = (ITmfDataProvider<TmfEvent>[]) TmfProviderManager.getProviders(TmfEvent.class);
 232                 assertEquals("getProviders", 2, eventProviders.length);
 233
 234                 eventProviders = (ITmfDataProvider<TmfEvent>[]) TmfProviderManager.getProviders(TmfEvent.class, TmfTraceStub.class);
 235                 assertEquals("getProviders", 1, eventProviders.length);
 236
 237                 eventProviders = (ITmfDataProvider<TmfEvent>[]) TmfProviderManager.getProviders(TmfEvent.class, TmfEventProviderStub.class);
 238                 assertEquals("getProviders", 1, eventProviders.length);
 239
 240                 // There should be 1 TmfSyntheticEventStub provider
 241                 eventProviders = (ITmfDataProvider<TmfEvent>[]) TmfProviderManager.getProviders(TmfSyntheticEventStub.class);
 242                 assertEquals("getProviders", 1, eventProviders.length);
 243         }
 244
 245 }