/*******************************************************************************
- * 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 - Adapted for TMF Trace Model 1.0
+ * Alexandre Montplaisir - Port to JUnit4
*******************************************************************************/
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.assertNull;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
import java.io.File;
import java.io.IOException;
import java.net.URISyntaxException;
import java.net.URL;
-import java.util.Collection;
+import java.util.Map;
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.component.TmfProviderManager;
import org.eclipse.linuxtools.tmf.core.component.ITmfDataProvider;
import org.eclipse.linuxtools.tmf.core.event.ITmfEvent;
-import org.eclipse.linuxtools.tmf.core.event.ITmfTimestamp;
-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.TmfEventRequest;
import org.eclipse.linuxtools.tmf.core.statesystem.ITmfStateSystem;
import org.eclipse.linuxtools.tmf.core.statistics.ITmfStatistics;
import org.eclipse.linuxtools.tmf.core.tests.TmfCoreTestPlugin;
+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.TmfCheckpointIndexer;
import org.eclipse.linuxtools.tmf.core.trace.TmfContext;
import org.eclipse.linuxtools.tmf.tests.stubs.trace.TmfTraceStub;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
/**
* Test suite for the TmfTrace class.
*/
-@SuppressWarnings({"nls","javadoc"})
-public class TmfTraceTest extends TestCase {
+@SuppressWarnings("javadoc")
+public class TmfTraceTest {
// ------------------------------------------------------------------------
// Variables
// ------------------------------------------------------------------------
+
private static final long DEFAULT_INITIAL_OFFSET_VALUE = (1L * 100 * 1000 * 1000); // .1sec
private static final String DIRECTORY = "testfiles";
private static final String TEST_STREAM = "A-Test-10K";
// Housekeeping
// ------------------------------------------------------------------------
- /**
- * @param name the test name
- */
- public TmfTraceTest(final String name) {
- super(name);
- }
-
- @Override
- protected void setUp() throws Exception {
- super.setUp();
+ @Before
+ public void setUp() {
fTrace = setupTrace(DIRECTORY + File.separator + TEST_STREAM);
}
- @Override
- protected void tearDown() throws Exception {
- super.tearDown();
+ @After
+ public void tearDown() {
fTrace.dispose();
fTrace = null;
}
// Constructors
// ------------------------------------------------------------------------
+ @Test
@SuppressWarnings("null")
public void testStandardConstructor() throws TmfTraceException {
TmfTraceStub trace = null;
}
assertFalse ("Open trace", trace == null);
- assertEquals("getType", TmfEvent.class, trace.getType());
+ assertEquals("getType", ITmfEvent.class, trace.getType());
assertNull ("getResource", trace.getResource());
assertEquals("getPath", testfile.toURI().getPath(), trace.getPath());
assertEquals("getCacheSize", ITmfTrace.DEFAULT_TRACE_CACHE_SIZE, trace.getCacheSize());
assertEquals("getEndTime", NB_EVENTS, trace.getEndTime().getValue());
}
+ @Test
@SuppressWarnings("null")
public void testStandardConstructorCacheSize() throws TmfTraceException {
TmfTraceStub trace = null;
}
assertFalse ("Open trace", trace == null);
- assertEquals("getType", TmfEvent.class, trace.getType());
+ assertEquals("getType", ITmfEvent.class, trace.getType());
assertNull ("getResource", trace.getResource());
assertEquals("getPath", testfile.toURI().getPath(), trace.getPath());
assertEquals("getCacheSize", ITmfTrace.DEFAULT_TRACE_CACHE_SIZE, trace.getCacheSize());
fail("IOException");
}
- assertEquals("getType", TmfEvent.class, trace.getType());
+ assertEquals("getType", ITmfEvent.class, trace.getType());
assertNull ("getResource", trace.getResource());
assertEquals("getPath", testfile.toURI().getPath(), trace.getPath());
assertEquals("getCacheSize", BLOCK_SIZE, trace.getCacheSize());
assertEquals("getEndTime", NB_EVENTS, trace.getEndTime().getValue());
}
+ @Test
@SuppressWarnings("null")
public void testFullConstructor() throws TmfTraceException {
TmfTraceStub trace = null;
}
assertFalse ("Open trace", trace == null);
- assertEquals("getType", TmfEvent.class, trace.getType());
+ assertEquals("getType", ITmfEvent.class, trace.getType());
assertNull ("getResource", trace.getResource());
assertEquals("getPath", testfile.toURI().getPath(), trace.getPath());
assertEquals("getCacheSize", BLOCK_SIZE, trace.getCacheSize());
assertEquals("getEndTime", NB_EVENTS, trace.getEndTime().getValue());
}
+ @Test
@SuppressWarnings("null")
public void testLiveTraceConstructor() throws TmfTraceException {
TmfTraceStub trace = null;
}
assertFalse ("Open trace", trace == null);
- assertEquals("getType", TmfEvent.class, trace.getType());
+ assertEquals("getType", ITmfEvent.class, trace.getType());
assertNull ("getResource", trace.getResource());
assertEquals("getPath", testfile.toURI().getPath(), trace.getPath());
assertEquals("getCacheSize", BLOCK_SIZE, trace.getCacheSize());
assertEquals("getEndTime", NB_EVENTS, trace.getEndTime().getValue());
}
+ @Test
@SuppressWarnings("null")
public void testCopyConstructor() throws TmfTraceException {
TmfTraceStub original = null;
}
assertFalse ("Open trace", trace == null);
- assertEquals("getType", TmfEvent.class, trace.getType());
+ assertEquals("getType", ITmfEvent.class, trace.getType());
assertNull ("getResource", trace.getResource());
assertEquals("getPath", testfile.toURI().getPath(), trace.getPath());
assertEquals("getCacheSize", BLOCK_SIZE, trace.getCacheSize());
// Trace initialization
// ------------------------------------------------------------------------
+ @Test
public void testInitializeNullPath() {
-
// Instantiate an "empty" trace
final TmfTraceStub trace = new TmfTraceStub();
try {
- trace.initialize(null, null, TmfEvent.class);
+ trace.initialize(null, null, ITmfEvent.class);
fail("TmfTrace.initialize() - no exception thrown");
} catch (TmfTraceException e) {
// Success
}
}
+ @Test
public void testInitializeSimplePath() {
-
// Instantiate an "empty" trace
final TmfTraceStub trace = new TmfTraceStub();
// Path == trace name
String path = "TraceName";
try {
- trace.initialize(null, path, TmfEvent.class);
+ trace.initialize(null, path, ITmfEvent.class);
} catch (Exception e) {
fail("TmfTrace.initialize() - Exception thrown");
}
- assertEquals("getType", TmfEvent.class, trace.getType());
+ assertEquals("getType", ITmfEvent.class, trace.getType());
assertNull ("getResource", trace.getResource());
assertEquals("getPath", path, trace.getPath());
assertEquals("getCacheSize", ITmfTrace.DEFAULT_TRACE_CACHE_SIZE, trace.getCacheSize());
assertEquals("getEndTime", Long.MIN_VALUE, trace.getEndTime().getValue());
}
+ @Test
public void testInitializeNormalPath() {
-
// Instantiate an "empty" trace
final TmfTraceStub trace = new TmfTraceStub();
String name = "TraceName";
String path = "/my/trace/path/" + name;
try {
- trace.initialize(null, path, TmfEvent.class);
+ trace.initialize(null, path, ITmfEvent.class);
} catch (Exception e) {
fail("TmfTrace.initialize() - Exception thrown");
}
- assertEquals("getType", TmfEvent.class, trace.getType());
+ assertEquals("getType", ITmfEvent.class, trace.getType());
assertNull ("getResource", trace.getResource());
assertEquals("getPath", path, trace.getPath());
assertEquals("getCacheSize", ITmfTrace.DEFAULT_TRACE_CACHE_SIZE, trace.getCacheSize());
assertEquals("getEndTime", Long.MIN_VALUE, trace.getEndTime().getValue());
}
+ @Test
public void testInitTrace() throws URISyntaxException, IOException, TmfTraceException, InterruptedException {
-
// Instantiate an "empty" trace
final TmfTraceStub trace = new TmfTraceStub();
// Validate
final URL location = FileLocator.find(TmfCoreTestPlugin.getDefault().getBundle(), new Path(DIRECTORY + File.separator + TEST_STREAM), null);
final File testfile = new File(FileLocator.toFileURL(location).toURI());
- assertTrue("validate", trace.validate(null, testfile.getPath()));
+ assertTrue("validate", trace.validate(null, testfile.getPath()).isOK());
// InitTrace and wait for indexing completion...
- trace.initTrace(null, testfile.toURI().getPath(), TmfEvent.class);
+ trace.initTrace(null, testfile.toURI().getPath(), ITmfEvent.class);
trace.indexTrace();
int nbSecs = 0;
while (trace.getNbEvents() < NB_EVENTS && nbSecs < 10) {
fail("indexing");
}
- assertEquals("getType", TmfEvent.class, trace.getType());
+ assertEquals("getType", ITmfEvent.class, trace.getType());
assertNull ("getResource", trace.getResource());
assertEquals("getCacheSize", ITmfTrace.DEFAULT_TRACE_CACHE_SIZE, trace.getCacheSize());
assertEquals("getStreamingInterval", 0, trace.getStreamingInterval());
// Set/Get streaming interval
// ------------------------------------------------------------------------
+ @Test
public void testSetStreamingInterval() throws TmfTraceException {
final TmfTraceStub trace = new TmfTraceStub(fTrace);
// Set/Get time range
// ------------------------------------------------------------------------
+ @Test
public void testSetTimeRange() throws TmfTraceException {
final TmfTraceStub trace = new TmfTraceStub(fTrace);
trace.indexTrace();
trace.dispose();
}
+ @Test
public void testSetStartTime() throws TmfTraceException {
final TmfTraceStub trace = new TmfTraceStub(fTrace);
trace.indexTrace();
trace.dispose();
}
+ @Test
public void testSetEndTime() throws TmfTraceException {
final TmfTraceStub trace = new TmfTraceStub(fTrace);
trace.indexTrace();
trace.dispose();
}
+ @Test
public void testSetNbEvents() throws TmfTraceException {
final TmfTraceStub trace = new TmfTraceStub(fTrace);
trace.indexTrace();
// State system and statistics methods
// ------------------------------------------------------------------------
+ @Test
public void testGetStatistics() {
/* Should be null in unit tests */
ITmfStatistics stats = fTrace.getStatistics();
assertNull(stats);
}
+ @Test
public void testGetStateSystem() {
/* There should be no state system registered so far */
- ITmfStateSystem ss = fTrace.getStateSystem("something");
+ ITmfStateSystem ss = fTrace.getStateSystems().get("something");
assertNull(ss);
}
- public void testListStateSystem() {
- Collection<String> sss = fTrace.listStateSystems();
- assertNotNull(sss);
- assertEquals(0, sss.size());
+ /**
+ * Make sure the returned map is unmodifiable.
+ */
+ @Test(expected=UnsupportedOperationException.class)
+ public void testGetStateSystem_readOnly() {
+ Map<String, ITmfStateSystem> sss = fTrace.getStateSystems();
+ sss.put("something", null);
}
// ------------------------------------------------------------------------
// seekEvent on location (note: does not reliably set the rank)
// ------------------------------------------------------------------------
+ @Test
public void testSeekEventOnCacheBoundary() {
-
// Position trace at event rank 0
ITmfContext context = fTrace.seekEvent(0);
ITmfEvent event = fTrace.parseEvent(context);
assertEquals("Event rank", ITmfContext.UNKNOWN_RANK, context.getRank());
}
+ @Test
public void testSeekEventNotOnCacheBoundary() {
-
// Position trace at event rank 9
ITmfContext tmpContext = fTrace.seekEvent(new TmfTimestamp(10, SCALE, 0));
TmfContext context = fTrace.seekEvent(tmpContext.getLocation());
assertEquals("Event rank", ITmfContext.UNKNOWN_RANK, context.getRank());
}
+ @Test
public void testSeekEventOutOfScope() {
-
// Position trace at beginning
ITmfContext tmpContext = fTrace.seekEvent(0);
ITmfContext context = fTrace.seekEvent(tmpContext.getLocation());
// seekEvent on timestamp (note: does not reliably set the rank)
// ------------------------------------------------------------------------
+ @Test
public void testSeekEventOnNullTimestamp() {
-
// Position trace at event rank 0
ITmfContext context = fTrace.seekEvent((ITmfTimestamp) null);
assertEquals("Event rank", 0, context.getRank());
assertEquals("Event rank", 0, context.getRank());
}
+ @Test
public void testSeekEventOnTimestampOnCacheBoundary() {
-
// Position trace at event rank 0
ITmfContext context = fTrace.seekEvent(new TmfTimestamp(1, SCALE, 0));
assertEquals("Event rank", 0, context.getRank());
assertEquals("Event rank", 4001, context.getRank());
}
+ @Test
public void testSeekEventOnTimestampNotOnCacheBoundary() {
-
// Position trace at event rank 1
ITmfContext context = fTrace.seekEvent(new TmfTimestamp(2, SCALE, 0));
assertEquals("Event rank", 1, context.getRank());
assertEquals("Event rank", 4501, context.getRank());
}
+ @Test
public void testSeekEventOnTimestampOutOfScope() {
-
// Position trace at beginning
ITmfContext context = fTrace.seekEvent(new TmfTimestamp(-1, SCALE, 0));
assertEquals("Event rank", 0, context.getRank());
// seekEvent on rank
// ------------------------------------------------------------------------
+ @Test
public void testSeekEventOnNegativeRank() {
-
// Position trace at event rank 0
ITmfContext context = fTrace.seekEvent(-1);
assertEquals("Event rank", 0, context.getRank());
assertEquals("Event rank", 0, context.getRank());
}
+ @Test
public void testSeekOnRankOnCacheBoundary() {
-
// On lower bound, returns the first event (ts = 1)
ITmfContext context = fTrace.seekEvent(0);
assertEquals("Event rank", 0, context.getRank());
assertEquals("Event rank", 4001, context.getRank());
}
+ @Test
public void testSeekOnRankNotOnCacheBoundary() {
-
// Position trace at event rank 9
ITmfContext context = fTrace.seekEvent(9);
assertEquals("Event rank", 9, context.getRank());
assertEquals("Event rank", 4501, context.getRank());
}
+ @Test
public void testSeekEventOnRankOutOfScope() {
-
// Position trace at beginning
ITmfContext context = fTrace.seekEvent(-1);
assertEquals("Event rank", 0, context.getRank());
// parseEvent - make sure parseEvent doesn't update the context
// ------------------------------------------------------------------------
+ @Test
public void testParseEvent() {
-
final int NB_READS = 20;
// On lower bound, returns the first event (ts = 0)
// getNext - updates the context
// ------------------------------------------------------------------------
+ @Test
public void testGetNextAfteSeekingOnTS_1() {
-
final long INITIAL_TS = 1;
final int NB_READS = 20;
assertEquals("Event rank", INITIAL_TS + NB_READS - 1, context.getRank());
}
+ @Test
public void testGetNextAfteSeekingOnTS_2() {
-
final long INITIAL_TS = 2;
final int NB_READS = 20;
assertEquals("Event rank", INITIAL_TS + NB_READS - 1, context.getRank());
}
+ @Test
public void testGetNextAfteSeekingOnTS_3() {
-
final long INITIAL_TS = 500;
final int NB_READS = 20;
assertEquals("Event rank", INITIAL_TS + NB_READS - 1, context.getRank());
}
+ @Test
public void testGetNextAfterSeekingOnRank_1() {
-
final long INITIAL_RANK = 0L;
final int NB_READS = 20;
assertEquals("Event rank", INITIAL_RANK + NB_READS, context.getRank());
}
+ @Test
public void testGetNextAfterSeekingOnRank_2() {
-
final long INITIAL_RANK = 1L;
final int NB_READS = 20;
assertEquals("Event rank", INITIAL_RANK + NB_READS, context.getRank());
}
+ @Test
public void testGetNextAfterSeekingOnRank_3() {
-
final long INITIAL_RANK = 500L;
final int NB_READS = 20;
assertEquals("Event rank", INITIAL_RANK + NB_READS, context.getRank());
}
+ @Test
public void testGetNextAfterSeekingOnLocation_1() {
-
final ITmfLocation INITIAL_LOC = null;
final long INITIAL_TS = 1;
final int NB_READS = 20;
assertEquals("Event rank", INITIAL_TS + NB_READS - 1, context.getRank());
}
+ @Test
public void testGetNextAfterSeekingOnLocation_2() {
-
final ITmfLocation INITIAL_LOC = fTrace.seekEvent(1L).getLocation();
final long INITIAL_TS = 2;
final int NB_READS = 20;
assertEquals("Event timestamp", INITIAL_TS + NB_READS, event.getTimestamp().getValue());
}
+ @Test
public void testGetNextAfterSeekingOnLocation_3() {
-
final ITmfLocation INITIAL_LOC = fTrace.seekEvent(500L).getLocation();
final long INITIAL_TS = 501;
final int NB_READS = 20;
assertEquals("Event timestamp", INITIAL_TS + NB_READS, event.getTimestamp().getValue());
}
+ @Test
public void testGetNextLocation() {
ITmfContext context1 = fTrace.seekEvent(0);
fTrace.getNext(context1);
assertEquals("Event timestamp", event1.getTimestamp().getValue(), event2.getTimestamp().getValue());
}
+ @Test
public void testGetNextEndLocation() {
ITmfContext context1 = fTrace.seekEvent(fTrace.getNbEvents() - 1);
fTrace.getNext(context1);
// processRequest
// ------------------------------------------------------------------------
- @SuppressWarnings("hiding")
+ @Test
public void testProcessEventRequestForAllEvents() throws InterruptedException {
- final int BLOCK_SIZE = 1;
+ final int blockSize = 1;
final Vector<ITmfEvent> requestedEvents = new Vector<ITmfEvent>();
final TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BIG_BANG, TmfTimestamp.BIG_CRUNCH);
- final TmfEventRequest request = new TmfEventRequest(TmfEvent.class, range, NB_EVENTS, BLOCK_SIZE) {
+ final TmfEventRequest request = new TmfEventRequest(ITmfEvent.class, range, NB_EVENTS, blockSize) {
@Override
public void handleData(final ITmfEvent event) {
super.handleData(event);
requestedEvents.add(event);
}
};
- final ITmfDataProvider[] providers = TmfProviderManager.getProviders(TmfEvent.class, TmfTraceStub.class);
+ final ITmfDataProvider[] providers = TmfProviderManager.getProviders(ITmfEvent.class, TmfTraceStub.class);
providers[0].sendRequest(request);
request.waitForCompletion();
}
}
- @SuppressWarnings("hiding")
+ @Test
public void testProcessEventRequestForNbEvents() throws InterruptedException {
- final int BLOCK_SIZE = 100;
- final int NB_EVENTS = 1000;
+ final int blockSize = 100;
+ final int nbEvents = 1000;
final Vector<ITmfEvent> requestedEvents = new Vector<ITmfEvent>();
final TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BIG_BANG, TmfTimestamp.BIG_CRUNCH);
- final TmfEventRequest request = new TmfEventRequest(TmfEvent.class, range, NB_EVENTS, BLOCK_SIZE) {
+ final TmfEventRequest request = new TmfEventRequest(ITmfEvent.class, range, nbEvents, blockSize) {
@Override
public void handleData(final ITmfEvent event) {
super.handleData(event);
requestedEvents.add(event);
}
};
- final ITmfDataProvider[] providers = TmfProviderManager.getProviders(TmfEvent.class, TmfTraceStub.class);
+ final ITmfDataProvider[] providers = TmfProviderManager.getProviders(ITmfEvent.class, TmfTraceStub.class);
providers[0].sendRequest(request);
request.waitForCompletion();
- assertEquals("nbEvents", NB_EVENTS, requestedEvents.size());
+ 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 < NB_EVENTS; i++) {
+ for (int i = 0; i < nbEvents; i++) {
assertEquals("Distinct events", i + 1, requestedEvents.get(i).getTimestamp().getValue());
}
}
- @SuppressWarnings("hiding")
+ @Test
public void testProcessEventRequestForSomeEvents() throws InterruptedException {
- final int BLOCK_SIZE = 1;
+ final int blockSize = 1;
final long startTime = 100;
- final int NB_EVENTS = 1000;
+ final int nbEvents = 1000;
final Vector<ITmfEvent> requestedEvents = new Vector<ITmfEvent>();
final TmfTimeRange range = new TmfTimeRange(new TmfTimestamp(startTime, SCALE), TmfTimestamp.BIG_CRUNCH);
- final TmfEventRequest request = new TmfEventRequest(TmfEvent.class, range, NB_EVENTS, BLOCK_SIZE) {
+ final TmfEventRequest request = new TmfEventRequest(ITmfEvent.class, range, nbEvents, blockSize) {
@Override
public void handleData(final ITmfEvent event) {
super.handleData(event);
requestedEvents.add(event);
}
};
- final ITmfDataProvider[] providers = TmfProviderManager.getProviders(TmfEvent.class, TmfTraceStub.class);
+ final ITmfDataProvider[] providers = TmfProviderManager.getProviders(ITmfEvent.class, TmfTraceStub.class);
providers[0].sendRequest(request);
request.waitForCompletion();
- assertEquals("nbEvents", NB_EVENTS, requestedEvents.size());
+ 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 < NB_EVENTS; i++) {
+ for (int i = 0; i < nbEvents; i++) {
assertEquals("Distinct events", startTime + i, requestedEvents.get(i).getTimestamp().getValue());
}
}
- @SuppressWarnings("hiding")
+ @Test
public void testProcessEventRequestForOtherEvents() throws InterruptedException {
- final int BLOCK_SIZE = 1;
+ final int blockSize = 1;
final int startIndex = 99;
final long startTime = 100;
- final int NB_EVENTS = 1000;
+ final int nbEvents = 1000;
final Vector<ITmfEvent> requestedEvents = new Vector<ITmfEvent>();
final TmfTimeRange range = new TmfTimeRange(new TmfTimestamp(startTime, SCALE), TmfTimestamp.BIG_CRUNCH);
- final TmfEventRequest request = new TmfEventRequest(TmfEvent.class, range, startIndex, NB_EVENTS, BLOCK_SIZE) {
+ final TmfEventRequest request = new TmfEventRequest(ITmfEvent.class, range, startIndex, nbEvents, blockSize) {
@Override
public void handleData(final ITmfEvent event) {
super.handleData(event);
requestedEvents.add(event);
}
};
- final ITmfDataProvider[] providers = TmfProviderManager.getProviders(TmfEvent.class, TmfTraceStub.class);
+ final ITmfDataProvider[] providers = TmfProviderManager.getProviders(ITmfEvent.class, TmfTraceStub.class);
providers[0].sendRequest(request);
request.waitForCompletion();
- assertEquals("nbEvents", NB_EVENTS, requestedEvents.size());
+ 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 < NB_EVENTS; i++) {
+ for (int i = 0; i < nbEvents; i++) {
assertEquals("Distinct events", startTime + i, requestedEvents.get(i).getTimestamp().getValue());
}
}
- @SuppressWarnings("hiding")
+ @Test
public void testProcessDataRequestForSomeEvents() throws InterruptedException {
final int startIndex = 100;
- final int NB_EVENTS = 1000;
+ final int nbEvents = 1000;
final Vector<ITmfEvent> requestedEvents = new Vector<ITmfEvent>();
- final TmfDataRequest request = new TmfDataRequest(TmfEvent.class, startIndex, NB_EVENTS) {
+ final TmfDataRequest request = new TmfDataRequest(ITmfEvent.class, startIndex, nbEvents) {
@Override
public void handleData(final ITmfEvent event) {
super.handleData(event);
requestedEvents.add(event);
}
};
- final ITmfDataProvider[] providers = TmfProviderManager.getProviders(TmfEvent.class, TmfTraceStub.class);
+ final ITmfDataProvider[] providers = TmfProviderManager.getProviders(ITmfEvent.class, TmfTraceStub.class);
providers[0].sendRequest(request);
request.waitForCompletion();
- assertEquals("nbEvents", NB_EVENTS, requestedEvents.size());
+ 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 < NB_EVENTS; i++) {
+ for (int i = 0; i < nbEvents; i++) {
assertEquals("Distinct events", startIndex + 1 + i, requestedEvents.get(i).getTimestamp().getValue());
}
}
// cancel
// ------------------------------------------------------------------------
+ @Test
public void testCancel() throws InterruptedException {
final Vector<ITmfEvent> requestedEvents = new Vector<ITmfEvent>();
final TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BIG_BANG, TmfTimestamp.BIG_CRUNCH);
- final TmfEventRequest request = new TmfEventRequest(TmfEvent.class, range, NB_EVENTS, BLOCK_SIZE) {
+ final TmfEventRequest request = new TmfEventRequest(ITmfEvent.class, range, NB_EVENTS, BLOCK_SIZE) {
int nbRead = 0;
@Override
public void handleData(final ITmfEvent event) {
}
}
};
- final ITmfDataProvider[] providers = TmfProviderManager.getProviders(TmfEvent.class, TmfTraceStub.class);
+ final ITmfDataProvider[] providers = TmfProviderManager.getProviders(ITmfEvent.class, TmfTraceStub.class);
providers[0].sendRequest(request);
request.waitForCompletion();
// toString
// ------------------------------------------------------------------------
+ @Test
public void testDefaultTmfTraceStub() {
assertFalse ("Open trace", fTrace == null);
- assertEquals("getType", TmfEvent.class, fTrace.getType());
+ assertEquals("getType", ITmfEvent.class, fTrace.getType());
assertNull ("getResource", fTrace.getResource());
assertEquals("getCacheSize", BLOCK_SIZE, fTrace.getCacheSize());
assertEquals("getStreamingInterval", 0, fTrace.getStreamingInterval());
// ------------------------------------------------------------------------
// getInitialRangeOffset, getCurrentRange, getCurrentTime
// ------------------------------------------------------------------------
- @SuppressWarnings("null")
+
+ @Test
public void testCurrentTimeValues() throws TmfTraceException {
TmfTraceStub trace = null;
projects / deliverable / tracecompass.git / blobdiff