ctf/org.eclipse.tracecompass.tmf.ctf.core.tests/src/org/eclipse/tracecompass/tmf/ctf/core/tests/event/CtfTmfLostEventsTest.java

   1 /*******************************************************************************
   2  * Copyright (c) 2013, 2015 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  *   Alexandre Montplaisir - Initial API and implementation
  11  *******************************************************************************/
  12
  13 package org.eclipse.tracecompass.tmf.ctf.core.tests.event;
  14
  15 import static org.junit.Assert.assertEquals;
  16 import static org.junit.Assert.assertFalse;
  17 import static org.junit.Assert.assertTrue;
  18 import static org.junit.Assume.assumeTrue;
  19
  20 import org.eclipse.jdt.annotation.NonNull;
  21 import org.eclipse.tracecompass.tmf.core.event.ITmfEvent;
  22 import org.eclipse.tracecompass.tmf.core.event.ITmfLostEvent;
  23 import org.eclipse.tracecompass.tmf.core.request.ITmfEventRequest;
  24 import org.eclipse.tracecompass.tmf.core.request.TmfEventRequest;
  25 import org.eclipse.tracecompass.tmf.core.timestamp.ITmfTimestamp;
  26 import org.eclipse.tracecompass.tmf.core.timestamp.TmfNanoTimestamp;
  27 import org.eclipse.tracecompass.tmf.core.timestamp.TmfTimeRange;
  28 import org.eclipse.tracecompass.tmf.core.timestamp.TmfTimestamp;
  29 import org.eclipse.tracecompass.tmf.ctf.core.event.CtfTmfEvent;
  30 import org.eclipse.tracecompass.tmf.ctf.core.tests.shared.CtfTmfTestTrace;
  31 import org.eclipse.tracecompass.tmf.ctf.core.trace.CtfTmfTrace;
  32 import org.junit.After;
  33 import org.junit.Before;
  34 import org.junit.Test;
  35
  36 /**
  37  * Tests to verify that lost events are handled correctly.
  38  *
  39  * Be wary if you are using Babeltrace to cross-check those values. There could
  40  * be a bug in Babeltrace with regards to lost events. See
  41  * http://bugs.lttng.org/issues/589
  42  *
  43  * It's not 100% sure at this point which implementation is correct, so for now
  44  * these tests assume the Java implementation is the right one.
  45  *
  46  * @author Alexandre Montplaisir
  47  */
  48 public class CtfTmfLostEventsTest {
  49
  50     private static final CtfTmfTestTrace testTrace = CtfTmfTestTrace.HELLO_LOST;
  51
  52     private CtfTmfTrace fixture = null;
  53
  54     /**
  55      * Class setup
  56      */
  57     @Before
  58     public void setUp() {
  59         assumeTrue(testTrace.exists());
  60         fixture = testTrace.getTrace();
  61         fixture.indexTrace(true);
  62     }
  63
  64     /**
  65      * Clean-up
  66      */
  67     @After
  68     public void tearDown() {
  69         if (fixture != null) {
  70             fixture.dispose();
  71         }
  72     }
  73
  74     // ------------------------------------------------------------------------
  75     // Test methods
  76     // ------------------------------------------------------------------------
  77
  78     /**
  79      * Test that the number of events is reported correctly (a range of lost
  80      * events is counted as one event).
  81      */
  82     @Test
  83     public void testNbEvents() {
  84         final long expectedReal = 32300;
  85         final long expectedLost = 562;
  86
  87         EventCountRequest req = new EventCountRequest();
  88         fixture.sendRequest(req);
  89         try {
  90             req.waitForCompletion();
  91         } catch (InterruptedException e) {
  92             e.printStackTrace();
  93         }
  94
  95         assertEquals(expectedReal, req.getReal());
  96         assertEquals(expectedLost, req.getLost());
  97     }
  98
  99     /**
 100      * Test getting the first lost event from the trace.
 101      */
 102     @Test
 103     public void testFirstLostEvent() {
 104         final long rank = 153;
 105         final ITmfTimestamp start = new TmfNanoTimestamp(1376592664828848222L);
 106         final ITmfTimestamp end   = new TmfNanoTimestamp(1376592664828848540L);
 107         final long nbLost = 859;
 108
 109         final CtfTmfEvent ev = getOneEventTime(start);
 110         /* Make sure seeking by rank yields the same event */
 111         final CtfTmfEvent ev2 = getOneEventRank(rank);
 112         assertEquals(ev, ev2);
 113
 114         assertTrue(ev instanceof ITmfLostEvent);
 115         ITmfLostEvent event = (ITmfLostEvent) ev;
 116
 117         assertEquals(start, event.getTimestamp());
 118         assertEquals(start, event.getTimeRange().getStartTime());
 119         assertEquals(end, event.getTimeRange().getEndTime());
 120         assertEquals(nbLost, event.getNbLostEvents());
 121     }
 122
 123     /**
 124      * Test getting the second lost event from the trace.
 125      */
 126     @Test
 127     public void testSecondLostEvent() {
 128         final long rank = 191;
 129         final ITmfTimestamp start = new TmfNanoTimestamp(1376592664829402521L);
 130         final ITmfTimestamp end   = new TmfNanoTimestamp(1376592664829403076L);
 131         final long nbLost = 488;
 132
 133         final CtfTmfEvent ev = getOneEventTime(start);
 134         /* Make sure seeking by rank yields the same event */
 135         final CtfTmfEvent ev2 = getOneEventRank(rank);
 136         assertEquals(ev, ev2);
 137
 138         assertTrue(ev instanceof ITmfLostEvent);
 139         ITmfLostEvent event = (ITmfLostEvent) ev;
 140
 141         assertEquals(start, event.getTimestamp());
 142         assertEquals(start, event.getTimeRange().getStartTime());
 143         assertEquals(end, event.getTimeRange().getEndTime());
 144         assertEquals(nbLost, event.getNbLostEvents());
 145     }
 146
 147     /**
 148      * Test getting one normal event from the trace (lost events should not
 149      * interfere).
 150      */
 151     @Test
 152     public void testNormalEvent() {
 153         final long rank = 200;
 154         final ITmfTimestamp ts = new TmfNanoTimestamp(1376592664829423928L);
 155
 156         final CtfTmfEvent event = getOneEventTime(ts);
 157         /* Make sure seeking by rank yields the same event */
 158         final CtfTmfEvent event2 = getOneEventRank(rank);
 159         assertEquals(event, event2);
 160
 161         assertFalse(event instanceof ITmfLostEvent);
 162         assertEquals(ts, event.getTimestamp());
 163     }
 164
 165     // ------------------------------------------------------------------------
 166     // Event requests
 167     // ------------------------------------------------------------------------
 168
 169     private CtfTmfEvent getOneEventRank(long rank) {
 170         OneEventRequestPerRank req = new OneEventRequestPerRank(rank);
 171         fixture.sendRequest(req);
 172         try {
 173             req.waitForCompletion();
 174         } catch (InterruptedException e) {
 175             e.printStackTrace();
 176         }
 177         return req.getEvent();
 178     }
 179
 180     private CtfTmfEvent getOneEventTime(@NonNull ITmfTimestamp ts) {
 181         OneEventRequestPerTs req = new OneEventRequestPerTs(ts);
 182         fixture.sendRequest(req);
 183         try {
 184             req.waitForCompletion();
 185         } catch (InterruptedException e) {
 186             e.printStackTrace();
 187         }
 188         return req.getEvent();
 189     }
 190
 191     private class OneEventRequestPerRank extends TmfEventRequest {
 192
 193         private CtfTmfEvent event = null;
 194
 195         public OneEventRequestPerRank(long rank) {
 196             super(CtfTmfEvent.class, TmfTimeRange.ETERNITY, rank, 1, ExecutionType.FOREGROUND);
 197         }
 198
 199         @Override
 200         public void handleData(ITmfEvent ev) {
 201             /* Type is checked by the request, cast should be safe */
 202             event = (CtfTmfEvent) ev;
 203         }
 204
 205         public CtfTmfEvent getEvent() {
 206             return event;
 207         }
 208     }
 209
 210     private class OneEventRequestPerTs extends TmfEventRequest {
 211
 212         private CtfTmfEvent event = null;
 213
 214         public OneEventRequestPerTs(@NonNull ITmfTimestamp ts) {
 215             super(CtfTmfEvent.class,
 216                     new TmfTimeRange(ts, TmfTimestamp.BIG_CRUNCH),
 217                     0, 1, ExecutionType.FOREGROUND);
 218         }
 219
 220         @Override
 221         public void handleData(ITmfEvent ev) {
 222             event = (CtfTmfEvent) ev;
 223         }
 224
 225         public CtfTmfEvent getEvent() {
 226             return event;
 227         }
 228     }
 229
 230     private class EventCountRequest extends TmfEventRequest {
 231
 232         private long nbReal = 0;
 233         private long nbLost = 0;
 234
 235         public EventCountRequest() {
 236             super(CtfTmfEvent.class, TmfTimeRange.ETERNITY, 0,
 237                     ITmfEventRequest.ALL_DATA, ExecutionType.FOREGROUND);
 238         }
 239
 240         @Override
 241         public void handleData(ITmfEvent event) {
 242             if (event instanceof ITmfLostEvent) {
 243                 nbLost++;
 244             } else {
 245                 nbReal++;
 246             }
 247         }
 248
 249         public long getReal() {
 250             return nbReal;
 251         }
 252
 253         public long getLost() {
 254             return nbLost;
 255         }
 256     }
 257 }