org.eclipse.linuxtools.tmf.tests/src/org/eclipse/linuxtools/tmf/eventlog/TmfEventLogTest.java

   1 /*******************************************************************************
   2  * Copyright (c) 2009 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 (fchouinard@gmail.com) - Initial API and implementation
  11  *******************************************************************************/
  12
  13 package org.eclipse.linuxtools.tmf.eventlog;
  14
  15 import static org.junit.Assert.assertEquals;
  16 import static org.junit.Assert.assertFalse;
  17 import static org.junit.Assert.assertTrue;
  18
  19 import java.util.Vector;
  20
  21 import org.eclipse.linuxtools.tmf.event.TmfEvent;
  22 import org.eclipse.linuxtools.tmf.event.TmfTimeRange;
  23 import org.eclipse.linuxtools.tmf.event.TmfTimestamp;
  24 import org.junit.BeforeClass;
  25 import org.junit.Test;
  26
  27 /**
  28  * <b><u>TmfEventLogTest</u></b>
  29  * <p>
  30  * TODO: Implement me. Please.
  31  */
  32 public class TmfEventLogTest {
  33
  34     private static String filename = "Test-10K";
  35     private static int fTotalNbEvents = 10000;
  36     private static ITmfEventParser fParser;
  37     private static TmfEventStream  fStream;
  38
  39         @BeforeClass
  40         public static void setUpBeforeClass() throws Exception {
  41                 fParser = new TmfEventParserStub();
  42                 fStream = new TmfEventStreamStub(filename, fParser);
  43         }
  44
  45     // ========================================================================
  46     // Constructor
  47     // ========================================================================
  48
  49         @Test
  50         public void testBasicTmfEventLog() {
  51                 TmfTrace eventLog = new TmfTrace("MyEventLog", fStream);
  52
  53                 assertEquals("GetId", "MyEventLog", eventLog.getId());
  54         assertEquals("GetEpoch", TmfTimestamp.BigBang, eventLog.getEpoch());
  55         assertEquals("GetNbEvents", fTotalNbEvents, eventLog.getNbEvents());
  56
  57         TmfTimeRange timeRange = eventLog.getTimeRange();
  58         assertEquals("GetTimeRange", 0, timeRange.getStartTime().getValue());
  59         assertEquals("GetTimeRange", fTotalNbEvents - 1, timeRange.getEndTime().getValue());
  60         }
  61
  62         @Test
  63         public void testTmfEventLogWithEpoch() {
  64                 TmfTimestamp epoch = new TmfTimestamp(100, (byte) 0, 0);
  65                 TmfTrace eventLog = new TmfTrace("MyEventLog", fStream, epoch);
  66
  67                 assertEquals("GetId", "MyEventLog", eventLog.getId());
  68         assertEquals("GetEpoch", epoch, eventLog.getEpoch());
  69         assertEquals("GetNbEvents", fTotalNbEvents, eventLog.getNbEvents());
  70
  71         TmfTimeRange timeRange = eventLog.getTimeRange();
  72         assertEquals("GetTimeRange", 0, timeRange.getStartTime().getValue());
  73         assertEquals("GetTimeRange", fTotalNbEvents - 1, timeRange.getEndTime().getValue());
  74         }
  75
  76     // ========================================================================
  77     // Operators
  78     // ========================================================================
  79
  80     @Test
  81     public void testProcessRequestForNbEvents() throws Exception {
  82
  83         TmfTrace eventLog = new TmfTrace("MyEventLog", fStream);
  84
  85         final int NB_EVENTS  = 10 * 1000;
  86         final int BLOCK_SIZE = 100;
  87         final Vector<TmfEvent> requestedEvents = new Vector<TmfEvent>();
  88
  89         TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BigBang, TmfTimestamp.BigCrunch);
  90         final TmfEventRequest request = new TmfEventRequest(range, 0, NB_EVENTS, BLOCK_SIZE) {
  91             @Override
  92             public void newEvents(Vector<TmfEvent> events) {
  93                 for (TmfEvent e : events) {
  94                     requestedEvents.add(e);
  95                 }
  96             }
  97         };
  98         eventLog.process(request, true);
  99
 100         assertEquals("nbEvents", NB_EVENTS, requestedEvents.size());
 101         assertTrue("isCompleted",  request.isCompleted());
 102         assertFalse("isCancelled", request.isCancelled());
 103
 104         // Ensure that we have distinct events.
 105         // Don't go overboard: we are not validating the stub!
 106         for (int i = 0; i < NB_EVENTS; i++) {
 107             assertEquals("Distinct events", i, requestedEvents.get(i).getTimestamp().getValue());
 108         }
 109     }
 110
 111     @Test
 112     public void testProcessRequestForAllEvents() throws Exception {
 113
 114         TmfTrace eventLog = new TmfTrace("MyEventLog", fStream);
 115
 116         final int NB_EVENTS  = -1;
 117         final int BLOCK_SIZE =  1;
 118         final Vector<TmfEvent> requestedEvents = new Vector<TmfEvent>();
 119         int nbExpectedEvents = eventLog.getNbEvents();
 120
 121         TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BigBang, TmfTimestamp.BigCrunch);
 122         final TmfEventRequest request = new TmfEventRequest(range, 0, NB_EVENTS, BLOCK_SIZE) {
 123             @Override
 124             public void newEvents(Vector<TmfEvent> events) {
 125                 for (TmfEvent e : events) {
 126                     requestedEvents.add(e);
 127                 }
 128             }
 129         };
 130         eventLog.process(request, true);
 131
 132         assertEquals("nbEvents", nbExpectedEvents, requestedEvents.size());
 133         assertTrue("isCompleted",  request.isCompleted());
 134         assertFalse("isCancelled", request.isCancelled());
 135
 136         // Ensure that we have distinct events.
 137         // Don't go overboard: we are not validating the stub!
 138         for (int i = 0; i < nbExpectedEvents; i++) {
 139             assertEquals("Distinct events", i, requestedEvents.get(i).getTimestamp().getValue());
 140         }
 141     }
 142
 143     // @Test
 144     public void testProcessRequestWithOffset() throws Exception {
 145
 146         TmfTrace eventLog = new TmfTrace("MyEventLog", fStream);
 147
 148         final int NB_EVENTS  = -1;
 149         final int BLOCK_SIZE =  1;
 150         final int OFFSET = 5;
 151         final Vector<TmfEvent> requestedEvents = new Vector<TmfEvent>();
 152         int nbExpectedEvents = TmfRequestHandlerStub.MAX_GENERATED_EVENTS;
 153
 154         TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BigBang, TmfTimestamp.BigCrunch);
 155         final TmfEventRequest request = new TmfEventRequest(range, OFFSET, NB_EVENTS, BLOCK_SIZE) {
 156             @Override
 157             public void newEvents(Vector<TmfEvent> events) {
 158                 for (TmfEvent e : events) {
 159                     requestedEvents.add(e);
 160                 }
 161             }
 162         };
 163         eventLog.process(request, true);
 164
 165         assertEquals("nbEvents", nbExpectedEvents, requestedEvents.size());
 166         assertTrue("isCompleted",  request.isCompleted());
 167         assertFalse("isCancelled", request.isCancelled());
 168
 169         // Ensure that we have distinct events.
 170         // Don't go overboard: we are not validating the stub!
 171         for (int i = 0; i < nbExpectedEvents; i++) {
 172             assertEquals("Distinct events", i + OFFSET, requestedEvents.get(i).getTimestamp().getValue());
 173         }
 174     }
 175
 176     // l@Test
 177     public void testProcessRequestWithNegativeOffset() throws Exception {
 178
 179         TmfTrace eventLog = new TmfTrace("MyEventLog", fStream);
 180
 181         final int NB_EVENTS  = -1;
 182         final int BLOCK_SIZE =  1;
 183         final int OFFSET = -5;
 184         final Vector<TmfEvent> requestedEvents = new Vector<TmfEvent>();
 185         int nbExpectedEvents = TmfRequestHandlerStub.MAX_GENERATED_EVENTS;
 186
 187         TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BigBang, TmfTimestamp.BigCrunch);
 188         final TmfEventRequest request = new TmfEventRequest(range, OFFSET, NB_EVENTS, BLOCK_SIZE) {
 189             @Override
 190             public void newEvents(Vector<TmfEvent> events) {
 191                 for (TmfEvent e : events) {
 192                     requestedEvents.add(e);
 193                 }
 194             }
 195         };
 196         eventLog.process(request, true);
 197
 198         assertEquals("nbEvents", nbExpectedEvents, requestedEvents.size());
 199         assertTrue("isCompleted",  request.isCompleted());
 200         assertFalse("isCancelled", request.isCancelled());
 201
 202         // Ensure that we have distinct events.
 203         // Don't go overboard: we are not validating the stub!
 204         for (int i = 0; i < nbExpectedEvents; i++) {
 205             assertEquals("Distinct events", i + OFFSET, requestedEvents.get(i).getTimestamp().getValue());
 206         }
 207     }
 208
 209     // ========================================================================
 210     // cancel
 211     // ========================================================================
 212
 213     @Test
 214     public void testCancel() throws Exception {
 215
 216         TmfTrace eventLog = new TmfTrace("MyEventLog", fStream);
 217
 218         final int NB_EVENTS  = 10 * 1000;
 219         final int BLOCK_SIZE = 100;
 220         final Vector<TmfEvent> requestedEvents = new Vector<TmfEvent>();
 221
 222         TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BigBang, TmfTimestamp.BigCrunch);
 223         final TmfEventRequest request = new TmfEventRequest(range, 0, NB_EVENTS, BLOCK_SIZE) {
 224             @Override
 225             public void newEvents(Vector<TmfEvent> events) {
 226                 for (TmfEvent e : events) {
 227                     requestedEvents.add(e);
 228                 }
 229                 // Cancel request after the first chunk is received
 230                 cancel();
 231             }
 232         };
 233         eventLog.process(request, true);
 234
 235         assertEquals("nbEvents",  BLOCK_SIZE, requestedEvents.size());
 236         assertTrue("isCompleted", request.isCompleted());
 237         assertTrue("isCancelled", request.isCancelled());
 238     }
 239
 240 }