/*******************************************************************************
- * Copyright (c) 2009, 2010, 2012 Ericsson
+ * Copyright (c) 2009, 2013 Ericsson
*
* All rights reserved. This program and the accompanying materials are
* made available under the terms of the Eclipse Public License v1.0 which
* Contributors:
* Francois Chouinard - Initial API and implementation
* Francois Chouinard - Adjusted for new Trace Model
+ * Alexandre Montplaisir - Port to JUnit4
+ * Patrick Tasse - Fix for concurrency
*******************************************************************************/
package org.eclipse.linuxtools.tmf.core.tests.trace;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
+
import java.io.File;
import java.io.IOException;
import java.net.URISyntaxException;
import java.net.URL;
import java.util.Vector;
-import junit.framework.TestCase;
-
import org.eclipse.core.runtime.FileLocator;
import org.eclipse.core.runtime.Path;
import org.eclipse.linuxtools.internal.tmf.core.trace.TmfExperimentContext;
import org.eclipse.linuxtools.tmf.core.event.ITmfEvent;
-import org.eclipse.linuxtools.tmf.core.event.TmfEvent;
-import org.eclipse.linuxtools.tmf.core.event.TmfTimeRange;
-import org.eclipse.linuxtools.tmf.core.event.TmfTimestamp;
import org.eclipse.linuxtools.tmf.core.exceptions.TmfTraceException;
-import org.eclipse.linuxtools.tmf.core.request.TmfDataRequest;
+import org.eclipse.linuxtools.tmf.core.request.ITmfEventRequest;
+import org.eclipse.linuxtools.tmf.core.request.ITmfEventRequest.ExecutionType;
import org.eclipse.linuxtools.tmf.core.request.TmfEventRequest;
import org.eclipse.linuxtools.tmf.core.tests.TmfCoreTestPlugin;
+import org.eclipse.linuxtools.tmf.core.tests.shared.TmfTestTrace;
+import org.eclipse.linuxtools.tmf.core.timestamp.ITmfTimestamp;
+import org.eclipse.linuxtools.tmf.core.timestamp.TmfTimeRange;
+import org.eclipse.linuxtools.tmf.core.timestamp.TmfTimestamp;
import org.eclipse.linuxtools.tmf.core.trace.ITmfContext;
-import org.eclipse.linuxtools.tmf.core.trace.ITmfLocation;
import org.eclipse.linuxtools.tmf.core.trace.ITmfTrace;
+import org.eclipse.linuxtools.tmf.core.trace.location.ITmfLocation;
import org.eclipse.linuxtools.tmf.tests.stubs.trace.TmfExperimentStub;
import org.eclipse.linuxtools.tmf.tests.stubs.trace.TmfTraceStub;
+import org.junit.AfterClass;
+import org.junit.BeforeClass;
+import org.junit.Test;
/**
* Test suite for the TmfExperiment class (multiple traces).
*/
-@SuppressWarnings({"nls","javadoc"})
-public class TmfMultiTraceExperimentTest extends TestCase {
+@SuppressWarnings("javadoc")
+public class TmfMultiTraceExperimentTest {
// ------------------------------------------------------------------------
// Attributes
// ------------------------------------------------------------------------
- private static final String DIRECTORY = "testfiles";
- private static final String TEST_STREAM1 = "O-Test-10K";
- private static final String TEST_STREAM2 = "E-Test-10K";
+ private static final long DEFAULT_INITIAL_OFFSET_VALUE = (1L * 100 * 1000 * 1000); // .1sec
private static final String EXPERIMENT = "MyExperiment";
private static int NB_EVENTS = 20000;
private static int BLOCK_SIZE = 1000;
- private static ITmfTrace<TmfEvent>[] fTraces;
- private static TmfExperimentStub<TmfEvent> fExperiment;
+ private static TmfExperimentStub fExperiment;
private static byte SCALE = (byte) -3;
// Housekeeping
// ------------------------------------------------------------------------
- @SuppressWarnings("unchecked")
- private synchronized static ITmfTrace<?>[] setupTrace(final String path1, final String path2) {
- if (fTraces == null) {
- fTraces = new ITmfTrace[2];
- try {
- URL location = FileLocator.find(TmfCoreTestPlugin.getDefault().getBundle(), new Path(path1), null);
- File test = new File(FileLocator.toFileURL(location).toURI());
- final TmfTraceStub trace1 = new TmfTraceStub(test.getPath(), 0, true);
- fTraces[0] = trace1;
- location = FileLocator.find(TmfCoreTestPlugin.getDefault().getBundle(), new Path(path2), null);
- test = new File(FileLocator.toFileURL(location).toURI());
- final TmfTraceStub trace2 = new TmfTraceStub(test.getPath(), 0, true);
- fTraces[1] = trace2;
- } catch (final TmfTraceException e) {
- e.printStackTrace();
- } catch (final URISyntaxException e) {
- e.printStackTrace();
- } catch (final IOException e) {
- e.printStackTrace();
- }
- }
- return fTraces;
+ @BeforeClass
+ public static void setUp() {
+ ITmfTrace[] traces = setupTraces();
+ fExperiment = new TmfExperimentStub(EXPERIMENT, traces, BLOCK_SIZE);
+ fExperiment.getIndexer().buildIndex(0, TmfTimeRange.ETERNITY, true);
}
- /**
- * @param name the test name
- */
- public TmfMultiTraceExperimentTest(final String name) {
- super(name);
+ @AfterClass
+ public static void tearDown() {
+ fExperiment.dispose();
}
- @Override
- protected synchronized void setUp() throws Exception {
- super.setUp();
- setupTrace(DIRECTORY + File.separator + TEST_STREAM1, DIRECTORY + File.separator + TEST_STREAM2);
- if (fExperiment == null) {
- fExperiment = new TmfExperimentStub<TmfEvent>(EXPERIMENT, fTraces, BLOCK_SIZE);
- fExperiment.getIndexer().buildIndex(0, TmfTimeRange.ETERNITY, true);
+ private static ITmfTrace[] setupTraces() {
+ try {
+ ITmfTrace[] traces = new ITmfTrace[2];
+
+ URL location = FileLocator.find(TmfCoreTestPlugin.getDefault().getBundle(), new Path(TmfTestTrace.O_TEST_10K.getFullPath()), null);
+ File test = new File(FileLocator.toFileURL(location).toURI());
+ final TmfTraceStub trace1 = new TmfTraceStub(test.getPath(), 0, true, null);
+ traces[0] = trace1;
+
+ location = FileLocator.find(TmfCoreTestPlugin.getDefault().getBundle(), new Path(TmfTestTrace.E_TEST_10K.getFullPath()), null);
+ test = new File(FileLocator.toFileURL(location).toURI());
+ final TmfTraceStub trace2 = new TmfTraceStub(test.getPath(), 0, true, null);
+ traces[1] = trace2;
+
+ return traces;
+ } catch (final TmfTraceException e) {
+ e.printStackTrace();
+ } catch (final URISyntaxException e) {
+ e.printStackTrace();
+ } catch (final IOException e) {
+ e.printStackTrace();
}
- }
-
- @Override
- protected void tearDown() throws Exception {
- super.tearDown();
+ return new ITmfTrace[0];
}
// ------------------------------------------------------------------------
// Constructor
// ------------------------------------------------------------------------
+ @Test
public void testBasicTmfExperimentConstructor() {
-
assertEquals("GetId", EXPERIMENT, fExperiment.getName());
assertEquals("GetNbEvents", NB_EVENTS, fExperiment.getNbEvents());
final TmfTimeRange timeRange = fExperiment.getTimeRange();
assertEquals("getStartTime", 1, timeRange.getStartTime().getValue());
assertEquals("getEndTime", NB_EVENTS, timeRange.getEndTime().getValue());
+
+ TmfTimestamp initRange = new TmfTimestamp(DEFAULT_INITIAL_OFFSET_VALUE, ITmfTimestamp.NANOSECOND_SCALE);
+ assertEquals("getInitialRangeOffset", initRange, fExperiment.getInitialRangeOffset());
}
// ------------------------------------------------------------------------
// seekEvent on rank
// ------------------------------------------------------------------------
+ @Test
public void testSeekRankOnCacheBoundary() {
-
long cacheSize = fExperiment.getCacheSize();
// On lower bound, returns the first event (TS = 1)
assertEquals("Context rank", 4 * cacheSize + 1, context.getRank());
}
+ @Test
public void testSeekRankNotOnCacheBoundary() {
-
long cacheSize = fExperiment.getCacheSize();
// Position trace at event rank 9
assertEquals("Context rank", 4501, context.getRank());
}
+ @Test
public void testSeekRankOutOfScope() {
-
// Position trace at beginning
ITmfContext context = fExperiment.seekEvent(-1);
assertEquals("Event rank", 0, context.getRank());
// seekEvent on timestamp
// ------------------------------------------------------------------------
+ @Test
public void testSeekTimestampOnCacheBoundary() {
-
long cacheSize = fExperiment.getCacheSize();
// Position trace at event rank 0
assertEquals("Context rank", 4 * cacheSize + 1, context.getRank());
}
+ @Test
public void testSeekTimestampNotOnCacheBoundary() {
-
// Position trace at event rank 1 (TS = 2)
ITmfContext context = fExperiment.seekEvent(new TmfTimestamp(2, SCALE, 0));
assertEquals("Context rank", 1, context.getRank());
assertEquals("Context rank", 4501, context.getRank());
}
+ @Test
public void testSeekTimestampOutOfScope() {
-
// Position trace at beginning
ITmfContext context = fExperiment.seekEvent(new TmfTimestamp(-1, SCALE, 0));
assertEquals("Event rank", 0, context.getRank());
// seekEvent by location (context rank is undefined)
// ------------------------------------------------------------------------
+ @Test
public void testSeekLocationOnCacheBoundary() {
-
long cacheSize = fExperiment.getCacheSize();
// Position trace at event rank 0
assertEquals("Event timestamp", 4 * cacheSize + 2, event.getTimestamp().getValue());
}
+ @Test
public void testSeekLocationNotOnCacheBoundary() {
-
long cacheSize = fExperiment.getCacheSize();
// Position trace at event 'cacheSize' - 1
assertEquals("Event timestamp", 4502, event.getTimestamp().getValue());
}
+ @Test
public void testSeekLocationOutOfScope() {
-
// Position trace at beginning
- ITmfContext context = fExperiment.seekEvent((ITmfLocation<?>) null);
+ ITmfContext context = fExperiment.seekEvent((ITmfLocation) null);
ITmfEvent event = fExperiment.getNext(context);
assertEquals("Event timestamp", 1, event.getTimestamp().getValue());
assertTrue("Experiment context type", context instanceof TmfExperimentContext);
TmfExperimentContext ctx = (TmfExperimentContext) context;
- int nbTraces = ctx.getContexts().length;
+ int nbTraces = ctx.getNbTraces();
// expRank = sum(trace ranks) - nbTraces + 1 (if lastTraceRead != NO_TRACE)
long expRank = -nbTraces + ((ctx.getLastTrace() != TmfExperimentContext.NO_TRACE) ? 1 : 0);
for (int i = 0; i < nbTraces; i++) {
- long rank = ctx.getContexts()[i].getRank();
+ ITmfContext subContext = ctx.getContext(i);
+ assertNotNull(subContext);
+ long rank = subContext.getRank();
if (rank == -1) {
expRank = -1;
break;
assertEquals("Experiment context rank", expRank, ctx.getRank());
}
+ @Test
public void testGetNextAfteSeekingOnTS_1() {
-
final long INITIAL_TS = 1;
final int NB_READS = 20;
validateContextRanks(context);
}
+ @Test
public void testGetNextAfteSeekingOnTS_2() {
-
final long INITIAL_TS = 2;
final int NB_READS = 20;
validateContextRanks(context);
}
+ @Test
public void testGetNextAfteSeekingOnTS_3() {
-
final long INITIAL_TS = 500;
final int NB_READS = 20;
validateContextRanks(context);
}
+ @Test
public void testGetNextAfterSeekingOnRank_1() {
-
final long INITIAL_RANK = 0L;
final int NB_READS = 20;
validateContextRanks(context);
}
+ @Test
public void testGetNextAfterSeekingOnRank_2() {
-
final long INITIAL_RANK = 1L;
final int NB_READS = 20;
validateContextRanks(context);
}
+ @Test
public void testGetNextAfterSeekingOnRank_3() {
-
final long INITIAL_RANK = 500L;
final int NB_READS = 20;
validateContextRanks(context);
}
+ @Test
public void testGetNextAfterSeekingOnLocation_1() {
-
- final ITmfLocation<?> INITIAL_LOC = null;
+ final ITmfLocation INITIAL_LOC = null;
final long INITIAL_TS = 1;
final int NB_READS = 20;
validateContextRanks(context);
}
+ @Test
public void testGetNextAfterSeekingOnLocation_2() {
-
- final ITmfLocation<?> INITIAL_LOC = fExperiment.seekEvent(1L).getLocation();
+ final ITmfLocation INITIAL_LOC = fExperiment.seekEvent(1L).getLocation();
final long INITIAL_TS = 2;
final int NB_READS = 20;
validateContextRanks(context);
}
+ @Test
public void testGetNextAfterSeekingOnLocation_3() {
-
- final ITmfLocation<?> INITIAL_LOC = fExperiment.seekEvent(500L).getLocation();
+ final ITmfLocation INITIAL_LOC = fExperiment.seekEvent(500L).getLocation();
final long INITIAL_TS = 501;
final int NB_READS = 20;
validateContextRanks(context);
}
+ @Test
public void testGetNextLocation() {
ITmfContext context1 = fExperiment.seekEvent(0);
fExperiment.getNext(context1);
- ITmfLocation<?> location = context1.getLocation().clone();
+ ITmfLocation location = context1.getLocation();
ITmfEvent event1 = fExperiment.getNext(context1);
ITmfContext context2 = fExperiment.seekEvent(location);
ITmfEvent event2 = fExperiment.getNext(context2);
assertEquals("Event timestamp", event1.getTimestamp().getValue(), event2.getTimestamp().getValue());
}
+ @Test
public void testGetNextEndLocation() {
ITmfContext context1 = fExperiment.seekEvent(fExperiment.getNbEvents() - 1);
fExperiment.getNext(context1);
- ITmfLocation<?> location = context1.getLocation().clone();
+ ITmfLocation location = context1.getLocation();
ITmfContext context2 = fExperiment.seekEvent(location);
ITmfEvent event = fExperiment.getNext(context2);
assertNull("Event", event);
// processRequest
// ------------------------------------------------------------------------
+ @Test
public void testProcessRequestForNbEvents() throws InterruptedException {
-
- final int blockSize = 100;
final int nbEvents = 1000;
- final Vector<TmfEvent> requestedEvents = new Vector<TmfEvent>();
-
- final TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BIG_BANG, TmfTimestamp.BIG_CRUNCH);
- final TmfEventRequest<TmfEvent> request = new TmfEventRequest<TmfEvent>(TmfEvent.class, range, nbEvents, blockSize) {
- @Override
- public void handleData(final TmfEvent event) {
- super.handleData(event);
- requestedEvents.add(event);
- }
- };
- fExperiment.sendRequest(request);
- request.waitForCompletion();
-
- assertEquals("nbEvents", nbEvents, requestedEvents.size());
- assertTrue("isCompleted", request.isCompleted());
- assertFalse("isCancelled", request.isCancelled());
-
- // Ensure that we have distinct events.
- // Don't go overboard: we are not validating the stub!
- for (int i = 0; i < nbEvents; i++) {
- assertEquals("Distinct events", i+1, requestedEvents.get(i).getTimestamp().getValue());
- }
- }
-
- public void testProcessRequestForNbEvents2() throws InterruptedException {
-
- final int blockSize = 2 * NB_EVENTS;
- final int nbEvents = 1000;
- final Vector<TmfEvent> requestedEvents = new Vector<TmfEvent>();
+ final Vector<ITmfEvent> requestedEvents = new Vector<>();
final TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BIG_BANG, TmfTimestamp.BIG_CRUNCH);
- final TmfEventRequest<TmfEvent> request = new TmfEventRequest<TmfEvent>(TmfEvent.class, range, nbEvents, blockSize) {
+ final TmfEventRequest request = new TmfEventRequest(ITmfEvent.class,
+ range, 0, nbEvents, ExecutionType.FOREGROUND) {
@Override
- public void handleData(final TmfEvent event) {
+ public void handleData(final ITmfEvent event) {
super.handleData(event);
requestedEvents.add(event);
}
}
}
+ @Test
public void testProcessRequestForAllEvents() throws InterruptedException {
-
- final int nbEvents = TmfDataRequest.ALL_DATA;
- final int blockSize = 1;
- final Vector<TmfEvent> requestedEvents = new Vector<TmfEvent>();
+ final int nbEvents = ITmfEventRequest.ALL_DATA;
+ final Vector<ITmfEvent> requestedEvents = new Vector<>();
final long nbExpectedEvents = NB_EVENTS;
final TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BIG_BANG, TmfTimestamp.BIG_CRUNCH);
- final TmfEventRequest<TmfEvent> request = new TmfEventRequest<TmfEvent>(TmfEvent.class, range, nbEvents, blockSize) {
+ final TmfEventRequest request = new TmfEventRequest(ITmfEvent.class,
+ range, 0, nbEvents, ExecutionType.FOREGROUND) {
@Override
- public void handleData(final TmfEvent event) {
+ public void handleData(final ITmfEvent event) {
super.handleData(event);
requestedEvents.add(event);
}
// cancel
// ------------------------------------------------------------------------
+ @Test
public void testCancel() throws InterruptedException {
-
final int nbEvents = NB_EVENTS;
- final int blockSize = BLOCK_SIZE;
- final Vector<TmfEvent> requestedEvents = new Vector<TmfEvent>();
+ final int limit = BLOCK_SIZE;
+ final Vector<ITmfEvent> requestedEvents = new Vector<>();
final TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BIG_BANG, TmfTimestamp.BIG_CRUNCH);
- final TmfEventRequest<TmfEvent> request = new TmfEventRequest<TmfEvent>(TmfEvent.class, range, nbEvents, blockSize) {
+ final TmfEventRequest request = new TmfEventRequest(ITmfEvent.class,
+ range, 0, nbEvents, ExecutionType.FOREGROUND) {
int nbRead = 0;
+
@Override
- public void handleData(final TmfEvent event) {
+ public void handleData(final ITmfEvent event) {
super.handleData(event);
requestedEvents.add(event);
- if (++nbRead == blockSize) {
+ if (++nbRead == limit) {
cancel();
}
}
- @Override
- public void handleCancel() {
- if (requestedEvents.size() < blockSize) {
- System.out.println("aie");
- }
- }
};
fExperiment.sendRequest(request);
request.waitForCompletion();
- assertEquals("nbEvents", blockSize, requestedEvents.size());
+ assertEquals("nbEvents", limit, requestedEvents.size());
assertTrue("isCompleted", request.isCompleted());
assertTrue("isCancelled", request.isCancelled());
}
// getTimestamp
// ------------------------------------------------------------------------
+ @Test
public void testGetTimestamp() {
assertEquals("getTimestamp", new TmfTimestamp( 1, (byte) -3), fExperiment.getTimestamp( 0));
assertEquals("getTimestamp", new TmfTimestamp( 2, (byte) -3), fExperiment.getTimestamp( 1));
assertNull("getTimestamp", fExperiment.getTimestamp(20000));
}
+ // ------------------------------------------------------------------------
+ // getInitialRangeOffset, getCurrentRange, getCurrentTime
+ // ------------------------------------------------------------------------
+
+ @Test
+ public void testDefaultCurrentTimeValues() {
+ ITmfTrace[] traces = setupTraces();
+ TmfExperimentStub exp = new TmfExperimentStub(EXPERIMENT, traces, BLOCK_SIZE);
+
+ // verify initial values
+ TmfTimestamp initRange = new TmfTimestamp(DEFAULT_INITIAL_OFFSET_VALUE, ITmfTimestamp.NANOSECOND_SCALE);
+ assertEquals("getInitialRangeOffset", initRange, exp.getInitialRangeOffset());
+
+ exp.dispose();
+ }
+
+ @Test
+ public void testInitialRangeOffset() {
+ ITmfTrace[] traces = setupTraces();
+ ((TmfTraceStub) traces[0]).setInitialRangeOffset(new TmfTimestamp(5, ITmfTimestamp.MILLISECOND_SCALE));
+ ((TmfTraceStub) traces[1]).setInitialRangeOffset(new TmfTimestamp(2, ITmfTimestamp.MILLISECOND_SCALE));
+ TmfExperimentStub exp = new TmfExperimentStub(EXPERIMENT, traces, BLOCK_SIZE);
+
+ TmfTimestamp initRange = new TmfTimestamp(2, ITmfTimestamp.MILLISECOND_SCALE);
+ assertEquals("getInitialRangeOffset", initRange, exp.getInitialRangeOffset());
+
+ exp.dispose();
+ }
+
}
projects / deliverable / tracecompass.git / blobdiff