ctf: Introduce IPacketReader

[deliverable/tracecompass.git] / ctf / org.eclipse.tracecompass.tmf.ctf.core.tests / src / org / eclipse / tracecompass / tmf / ctf / core / tests / event / CtfTmfLostEventsTest.java

diff --git a/ctf/org.eclipse.tracecompass.tmf.ctf.core.tests/src/org/eclipse/tracecompass/tmf/ctf/core/tests/event/CtfTmfLostEventsTest.java b/ctf/org.eclipse.tracecompass.tmf.ctf.core.tests/src/org/eclipse/tracecompass/tmf/ctf/core/tests/event/CtfTmfLostEventsTest.java
index 2eed62ac3dd8f24186cdeb7900fd78dfb9164560..96a0295766379acb2df8c6db760febb21b4db952 100644 (file)
--- a/ctf/org.eclipse.tracecompass.tmf.ctf.core.tests/src/org/eclipse/tracecompass/tmf/ctf/core/tests/event/CtfTmfLostEventsTest.java
+++ b/ctf/org.eclipse.tracecompass.tmf.ctf.core.tests/src/org/eclipse/tracecompass/tmf/ctf/core/tests/event/CtfTmfLostEventsTest.java
@@ -15,19 +15,20 @@ package org.eclipse.tracecompass.tmf.ctf.core.tests.event;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertTrue;
-import static org.junit.Assume.assumeTrue;
 
 import org.eclipse.jdt.annotation.NonNull;
+import org.eclipse.tracecompass.testtraces.ctf.CtfTestTrace;
 import org.eclipse.tracecompass.tmf.core.event.ITmfEvent;
 import org.eclipse.tracecompass.tmf.core.event.ITmfLostEvent;
 import org.eclipse.tracecompass.tmf.core.request.ITmfEventRequest;
 import org.eclipse.tracecompass.tmf.core.request.TmfEventRequest;
+import org.eclipse.tracecompass.tmf.core.synchronization.TimestampTransformFactory;
 import org.eclipse.tracecompass.tmf.core.timestamp.ITmfTimestamp;
 import org.eclipse.tracecompass.tmf.core.timestamp.TmfNanoTimestamp;
 import org.eclipse.tracecompass.tmf.core.timestamp.TmfTimeRange;
-import org.eclipse.tracecompass.tmf.core.timestamp.TmfTimestamp;
+import org.eclipse.tracecompass.tmf.core.trace.ITmfContext;
 import org.eclipse.tracecompass.tmf.ctf.core.event.CtfTmfEvent;
-import org.eclipse.tracecompass.tmf.ctf.core.tests.shared.CtfTmfTestTrace;
+import org.eclipse.tracecompass.tmf.ctf.core.tests.shared.CtfTmfTestTraceUtils;
 import org.eclipse.tracecompass.tmf.ctf.core.trace.CtfTmfTrace;
 import org.junit.After;
 import org.junit.Before;
@@ -47,7 +48,7 @@ import org.junit.Test;
  */
 public class CtfTmfLostEventsTest {
 
-    private static final CtfTmfTestTrace testTrace = CtfTmfTestTrace.HELLO_LOST;
+    private static final @NonNull CtfTestTrace testTrace = CtfTestTrace.HELLO_LOST;
 
     private CtfTmfTrace fixture = null;
 
@@ -56,8 +57,7 @@ public class CtfTmfLostEventsTest {
      */
     @Before
     public void setUp() {
-        assumeTrue(testTrace.exists());
-        fixture = testTrace.getTrace();
+        fixture = CtfTmfTestTraceUtils.getTrace(testTrace);
         fixture.indexTrace(true);
     }
 
@@ -96,28 +96,46 @@ public class CtfTmfLostEventsTest {
         assertEquals(expectedLost, req.getLost());
     }
 
+    /**
+     * Test that the number of events is reported correctly (a range of lost
+     * events is counted as one event). Events could be wrongly counted as lost
+     * events in certain situations.
+     */
+    @Test
+    public void testNbEventsBug475007() {
+        final CtfTestTrace tmfTestTrace = CtfTestTrace.DYNSCOPE;
+        CtfTmfTrace trace = CtfTmfTestTraceUtils.getTrace(tmfTestTrace);
+        trace.indexTrace(true);
+
+        final long expectedReal = 100003;
+        final long expectedLost = 1;
+
+        EventCountRequest req = new EventCountRequest();
+        trace.sendRequest(req);
+        try {
+            req.waitForCompletion();
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+
+        assertEquals(expectedReal, req.getReal());
+        assertEquals(expectedLost, req.getLost());
+
+        trace.dispose();
+    }
+
     /**
      * Test getting the first lost event from the trace.
      */
     @Test
     public void testFirstLostEvent() {
-        final long rank = 153;
-        final ITmfTimestamp start = new TmfNanoTimestamp(1376592664828848222L);
-        final ITmfTimestamp end   = new TmfNanoTimestamp(1376592664828848540L);
+        final long rank = 152;
+        final long startTime = 1376592664828848222L;
+        final ITmfTimestamp start = new TmfNanoTimestamp(startTime);
+        final ITmfTimestamp end = new TmfNanoTimestamp(startTime + 554854L);
         final long nbLost = 859;
 
-        final CtfTmfEvent ev = getOneEventTime(start);
-        /* Make sure seeking by rank yields the same event */
-        final CtfTmfEvent ev2 = getOneEventRank(rank);
-        assertEquals(ev, ev2);
-
-        assertTrue(ev instanceof ITmfLostEvent);
-        ITmfLostEvent event = (ITmfLostEvent) ev;
-
-        assertEquals(start, event.getTimestamp());
-        assertEquals(start, event.getTimeRange().getStartTime());
-        assertEquals(end, event.getTimeRange().getEndTime());
-        assertEquals(nbLost, event.getNbLostEvents());
+        validateLostEvent(rank, start, end, nbLost);
     }
 
     /**
@@ -126,10 +144,15 @@ public class CtfTmfLostEventsTest {
     @Test
     public void testSecondLostEvent() {
         final long rank = 191;
-        final ITmfTimestamp start = new TmfNanoTimestamp(1376592664829402521L);
-        final ITmfTimestamp end   = new TmfNanoTimestamp(1376592664829403076L);
+        final long startTime = 1376592664829402521L;
+        final ITmfTimestamp start = new TmfNanoTimestamp(startTime);
+        final ITmfTimestamp end = new TmfNanoTimestamp(startTime + 421993L);
         final long nbLost = 488;
 
+        validateLostEvent(rank, start, end, nbLost);
+    }
+
+    private void validateLostEvent(final long rank, final @NonNull ITmfTimestamp start, final ITmfTimestamp end, final long nbLost) {
         final CtfTmfEvent ev = getOneEventTime(start);
         /* Make sure seeking by rank yields the same event */
         final CtfTmfEvent ev2 = getOneEventRank(rank);
@@ -150,8 +173,8 @@ public class CtfTmfLostEventsTest {
      */
     @Test
     public void testNormalEvent() {
-        final long rank = 200;
-        final ITmfTimestamp ts = new TmfNanoTimestamp(1376592664829423928L);
+        final long rank = 193;
+        final ITmfTimestamp ts = new TmfNanoTimestamp(1376592664829411423L);
 
         final CtfTmfEvent event = getOneEventTime(ts);
         /* Make sure seeking by rank yields the same event */
@@ -162,6 +185,37 @@ public class CtfTmfLostEventsTest {
         assertEquals(ts, event.getTimestamp());
     }
 
+    /**
+     * Test getting a lost event from a trace that has a timestamp transform.
+     */
+    @Test
+    public void testLostEventWithTransform() {
+        CtfTmfTrace trace = CtfTmfTestTraceUtils.getTrace(testTrace);
+        long offset = 1234567890L;
+        trace.setTimestampTransform(TimestampTransformFactory.createWithOffset(offset));
+        trace.indexTrace(true);
+
+        final long rank = 152;
+        final ITmfTimestamp start = new TmfNanoTimestamp(1376592664828848222L + offset);
+        final ITmfTimestamp end = new TmfNanoTimestamp(1376592664828848222L + 554854L + offset);
+        final long nbLost = 859;
+
+        ITmfContext context = trace.seekEvent(rank);
+        final CtfTmfEvent ev = trace.getNext(context);
+        context.dispose();
+
+        assertTrue(ev instanceof ITmfLostEvent);
+        ITmfLostEvent event = (ITmfLostEvent) ev;
+
+        assertEquals(start, event.getTimestamp());
+        assertEquals(start, event.getTimeRange().getStartTime());
+        assertEquals(end, event.getTimeRange().getEndTime());
+        assertEquals(nbLost, event.getNbLostEvents());
+
+        trace.setTimestampTransform(null);
+        trace.dispose();
+    }
+
     // ------------------------------------------------------------------------
     // Event requests
     // ------------------------------------------------------------------------
@@ -213,7 +267,7 @@ public class CtfTmfLostEventsTest {
 
         public OneEventRequestPerTs(@NonNull ITmfTimestamp ts) {
             super(CtfTmfEvent.class,
-                    new TmfTimeRange(ts, TmfTimestamp.BIG_CRUNCH),
+                    new TmfTimeRange(ts, ts),
                     0, 1, ExecutionType.FOREGROUND);
         }