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 static org.junit.Assert.fail;
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 org.eclipse.core.runtime.FileLocator;
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.request.ITmfDataRequest.ExecutionType;
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.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.TmfCheckpointIndexer;
import org.eclipse.linuxtools.tmf.core.trace.TmfContext;
+import org.eclipse.linuxtools.tmf.core.trace.indexer.checkpoint.TmfCheckpointIndexer;
+import org.eclipse.linuxtools.tmf.core.trace.location.ITmfLocation;
import org.eclipse.linuxtools.tmf.tests.stubs.trace.TmfTraceStub;
import org.junit.After;
import org.junit.Before;
// Variables
// ------------------------------------------------------------------------
+ private static final TmfTestTrace TEST_TRACE = TmfTestTrace.A_TEST_10K;
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";
- private static final int BLOCK_SIZE = 500;
private static final int NB_EVENTS = 10000;
private static TmfTraceStub fTrace = null;
@Before
public void setUp() {
- fTrace = setupTrace(DIRECTORY + File.separator + TEST_STREAM);
+ fTrace = setupTrace(TEST_TRACE.getFullPath());
}
@After
try {
final URL location = FileLocator.find(TmfCoreTestPlugin.getDefault().getBundle(), new Path(path), null);
final File test = new File(FileLocator.toFileURL(location).toURI());
- fTrace = new TmfTraceStub(test.toURI().getPath(), BLOCK_SIZE);
- fTrace.indexTrace();
+ fTrace = new TmfTraceStub(test.toURI().getPath(), ITmfTrace.DEFAULT_TRACE_CACHE_SIZE, false, null, null);
+ fTrace.indexTrace(true);
} catch (final TmfTraceException e) {
e.printStackTrace();
} catch (final URISyntaxException e) {
// ------------------------------------------------------------------------
@Test
- @SuppressWarnings("null")
- public void testStandardConstructor() throws TmfTraceException {
- TmfTraceStub trace = null;
- File testfile = null;
- try {
- final URL location = FileLocator.find(TmfCoreTestPlugin.getDefault().getBundle(), new Path(DIRECTORY + File.separator + TEST_STREAM), null);
- testfile = new File(FileLocator.toFileURL(location).toURI());
- trace = new TmfTraceStub(testfile.toURI().getPath());
- trace.indexTrace();
- } catch (final URISyntaxException e) {
- fail("URISyntaxException");
- } catch (final IOException e) {
- fail("IOException");
- }
-
- assertFalse ("Open trace", trace == null);
- 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("getStreamingInterval", 0, trace.getStreamingInterval());
- assertEquals("getName", TEST_STREAM, trace.getName());
-
- assertEquals("getNbEvents", NB_EVENTS, trace.getNbEvents());
- assertEquals("getRange-start", 1, trace.getTimeRange().getStartTime().getValue());
- assertEquals("getRange-end", NB_EVENTS, trace.getTimeRange().getEndTime().getValue());
- assertEquals("getStartTime", 1, trace.getStartTime().getValue());
- assertEquals("getEndTime", NB_EVENTS, trace.getEndTime().getValue());
- }
-
- @Test
- @SuppressWarnings("null")
- public void testStandardConstructorCacheSize() throws TmfTraceException {
- TmfTraceStub trace = null;
- File testfile = null;
- try {
- final URL location = FileLocator.find(TmfCoreTestPlugin.getDefault().getBundle(), new Path(DIRECTORY + File.separator + TEST_STREAM), null);
- testfile = new File(FileLocator.toFileURL(location).toURI());
- trace = new TmfTraceStub(testfile.toURI().getPath(), 0);
- trace.indexTrace();
- } catch (final URISyntaxException e) {
- fail("URISyntaxException");
- } catch (final IOException e) {
- fail("IOException");
- }
-
- assertFalse ("Open trace", trace == null);
- 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("getStreamingInterval", 0, trace.getStreamingInterval());
- assertEquals("getName", TEST_STREAM, trace.getName());
-
- assertEquals("getNbEvents", NB_EVENTS, trace.getNbEvents());
- assertEquals("getRange-start", 1, trace.getTimeRange().getStartTime().getValue());
- assertEquals("getRange-end", NB_EVENTS, trace.getTimeRange().getEndTime().getValue());
- assertEquals("getStartTime", 1, trace.getStartTime().getValue());
- assertEquals("getEndTime", NB_EVENTS, trace.getEndTime().getValue());
-
- try {
- final URL location = FileLocator.find(TmfCoreTestPlugin.getDefault().getBundle(), new Path(DIRECTORY + File.separator + TEST_STREAM), null);
- testfile = new File(FileLocator.toFileURL(location).toURI());
- trace = new TmfTraceStub(testfile.toURI().getPath(), BLOCK_SIZE);
- trace.indexTrace();
- } catch (final URISyntaxException e) {
- fail("URISyntaxException");
- } catch (final IOException e) {
- fail("IOException");
- }
-
- assertEquals("getType", ITmfEvent.class, trace.getType());
- assertNull ("getResource", trace.getResource());
- assertEquals("getPath", testfile.toURI().getPath(), trace.getPath());
- assertEquals("getCacheSize", BLOCK_SIZE, trace.getCacheSize());
- assertEquals("getStreamingInterval", 0, trace.getStreamingInterval());
- assertEquals("getName", TEST_STREAM, trace.getName());
-
- assertEquals("getNbEvents", NB_EVENTS, trace.getNbEvents());
- assertEquals("getRange-start", 1, trace.getTimeRange().getStartTime().getValue());
- assertEquals("getRange-end", NB_EVENTS, trace.getTimeRange().getEndTime().getValue());
- assertEquals("getStartTime", 1, trace.getStartTime().getValue());
- assertEquals("getEndTime", NB_EVENTS, trace.getEndTime().getValue());
- }
-
- @Test
- @SuppressWarnings("null")
public void testFullConstructor() throws TmfTraceException {
- TmfTraceStub trace = null;
- File testfile = null;
try {
- final URL location = FileLocator.find(TmfCoreTestPlugin.getDefault().getBundle(), new Path(DIRECTORY + File.separator + TEST_STREAM), null);
- testfile = new File(FileLocator.toFileURL(location).toURI());
- trace = new TmfTraceStub(testfile.toURI().getPath(), BLOCK_SIZE, null);
- trace.indexTrace();
+ final URL location = FileLocator.find(TmfCoreTestPlugin.getDefault().getBundle(), new Path(TEST_TRACE.getFullPath()), null);
+ File testfile = new File(FileLocator.toFileURL(location).toURI());
+ TmfTraceStub trace = new TmfTraceStub(testfile.toURI().getPath(), ITmfTrace.DEFAULT_TRACE_CACHE_SIZE, false, null, null);
+ trace.indexTrace(true);
+
+ 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("getStreamingInterval", 0, trace.getStreamingInterval());
+ assertEquals("getName", TEST_TRACE.getPath(), trace.getName());
+
+ assertEquals("getNbEvents", NB_EVENTS, trace.getNbEvents());
+ assertEquals("getRange-start", 1, trace.getTimeRange().getStartTime().getValue());
+ assertEquals("getRange-end", NB_EVENTS, trace.getTimeRange().getEndTime().getValue());
+ assertEquals("getStartTime", 1, trace.getStartTime().getValue());
+ assertEquals("getEndTime", NB_EVENTS, trace.getEndTime().getValue());
+
} catch (final URISyntaxException e) {
fail("URISyntaxException");
} catch (final IOException e) {
fail("IOException");
}
-
- assertFalse ("Open trace", trace == null);
- assertEquals("getType", ITmfEvent.class, trace.getType());
- assertNull ("getResource", trace.getResource());
- assertEquals("getPath", testfile.toURI().getPath(), trace.getPath());
- assertEquals("getCacheSize", BLOCK_SIZE, trace.getCacheSize());
- assertEquals("getStreamingInterval", 0, trace.getStreamingInterval());
- assertEquals("getName", TEST_STREAM, trace.getName());
-
- assertEquals("getNbEvents", NB_EVENTS, trace.getNbEvents());
- assertEquals("getRange-start", 1, trace.getTimeRange().getStartTime().getValue());
- assertEquals("getRange-end", NB_EVENTS, trace.getTimeRange().getEndTime().getValue());
- assertEquals("getStartTime", 1, trace.getStartTime().getValue());
- assertEquals("getEndTime", NB_EVENTS, trace.getEndTime().getValue());
}
@Test
- @SuppressWarnings("null")
public void testLiveTraceConstructor() throws TmfTraceException {
- TmfTraceStub trace = null;
- File testfile = null;
final long interval = 100;
try {
- final URL location = FileLocator.find(TmfCoreTestPlugin.getDefault().getBundle(), new Path(DIRECTORY + File.separator + TEST_STREAM), null);
- testfile = new File(FileLocator.toFileURL(location).toURI());
- trace = new TmfTraceStub(testfile.toURI().getPath(), BLOCK_SIZE, interval);
- trace.indexTrace();
+ final URL location = FileLocator.find(TmfCoreTestPlugin.getDefault().getBundle(), new Path(TEST_TRACE.getFullPath()), null);
+ File testfile = new File(FileLocator.toFileURL(location).toURI());
+ TmfTraceStub trace = new TmfTraceStub(testfile.toURI().getPath(), ITmfTrace.DEFAULT_TRACE_CACHE_SIZE, interval);
+ trace.indexTrace(true);
+
+ 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("getStreamingInterval", interval, trace.getStreamingInterval());
+ assertEquals("getName", TEST_TRACE.getPath(), trace.getName());
+
+ assertEquals("getNbEvents", NB_EVENTS, trace.getNbEvents());
+ assertEquals("getRange-start", 1, trace.getTimeRange().getStartTime().getValue());
+ assertEquals("getRange-end", NB_EVENTS, trace.getTimeRange().getEndTime().getValue());
+ assertEquals("getStartTime", 1, trace.getStartTime().getValue());
+ assertEquals("getEndTime", NB_EVENTS, trace.getEndTime().getValue());
+
} catch (final URISyntaxException e) {
fail("URISyntaxException");
} catch (final IOException e) {
fail("IOException");
}
-
- assertFalse ("Open trace", trace == null);
- assertEquals("getType", ITmfEvent.class, trace.getType());
- assertNull ("getResource", trace.getResource());
- assertEquals("getPath", testfile.toURI().getPath(), trace.getPath());
- assertEquals("getCacheSize", BLOCK_SIZE, trace.getCacheSize());
- assertEquals("getStreamingInterval", interval, trace.getStreamingInterval());
- assertEquals("getName", TEST_STREAM, trace.getName());
-
- assertEquals("getNbEvents", NB_EVENTS, trace.getNbEvents());
- assertEquals("getRange-start", 1, trace.getTimeRange().getStartTime().getValue());
- assertEquals("getRange-end", NB_EVENTS, trace.getTimeRange().getEndTime().getValue());
- assertEquals("getStartTime", 1, trace.getStartTime().getValue());
- assertEquals("getEndTime", NB_EVENTS, trace.getEndTime().getValue());
}
@Test
- @SuppressWarnings("null")
public void testCopyConstructor() throws TmfTraceException {
- TmfTraceStub original = null;
- TmfTraceStub trace = null;
- File testfile = null;
try {
- final URL location = FileLocator.find(TmfCoreTestPlugin.getDefault().getBundle(), new Path(DIRECTORY + File.separator + TEST_STREAM), null);
- testfile = new File(FileLocator.toFileURL(location).toURI());
- original = new TmfTraceStub(testfile.toURI().getPath(), BLOCK_SIZE, new TmfCheckpointIndexer(null));
- trace = new TmfTraceStub(original);
- trace.indexTrace();
+ final URL location = FileLocator.find(TmfCoreTestPlugin.getDefault().getBundle(), new Path(TEST_TRACE.getFullPath()), null);
+ File testfile = new File(FileLocator.toFileURL(location).toURI());
+ TmfTraceStub original = new TmfTraceStub(testfile.toURI().getPath(), ITmfTrace.DEFAULT_TRACE_CACHE_SIZE, false, new TmfCheckpointIndexer(null), null);
+ TmfTraceStub trace = new TmfTraceStub(original);
+ trace.indexTrace(true);
+
+ 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("getStreamingInterval", 0, trace.getStreamingInterval());
+ assertEquals("getName", TEST_TRACE.getPath(), trace.getName());
+
+ assertEquals("getNbEvents", NB_EVENTS, trace.getNbEvents());
+ assertEquals("getRange-start", 1, trace.getTimeRange().getStartTime().getValue());
+ assertEquals("getRange-end", NB_EVENTS, trace.getTimeRange().getEndTime().getValue());
+ assertEquals("getStartTime", 1, trace.getStartTime().getValue());
+ assertEquals("getEndTime", NB_EVENTS, trace.getEndTime().getValue());
+
} catch (final URISyntaxException e) {
fail("URISyntaxException");
} catch (final IOException e) {
fail("IOException");
}
- assertFalse ("Open trace", trace == null);
- assertEquals("getType", ITmfEvent.class, trace.getType());
- assertNull ("getResource", trace.getResource());
- assertEquals("getPath", testfile.toURI().getPath(), trace.getPath());
- assertEquals("getCacheSize", BLOCK_SIZE, trace.getCacheSize());
- assertEquals("getStreamingInterval", 0, trace.getStreamingInterval());
- assertEquals("getName", TEST_STREAM, trace.getName());
-
- assertEquals("getNbEvents", NB_EVENTS, trace.getNbEvents());
- assertEquals("getRange-start", 1, trace.getTimeRange().getStartTime().getValue());
- assertEquals("getRange-end", NB_EVENTS, trace.getTimeRange().getEndTime().getValue());
- assertEquals("getStartTime", 1, trace.getStartTime().getValue());
- assertEquals("getEndTime", NB_EVENTS, trace.getEndTime().getValue());
-
// Test the copy of a null trace
try {
new TmfTraceStub((TmfTraceStub) null);
assertEquals("getEndTime", Long.MIN_VALUE, trace.getEndTime().getValue());
// Validate
- final URL location = FileLocator.find(TmfCoreTestPlugin.getDefault().getBundle(), new Path(DIRECTORY + File.separator + TEST_STREAM), null);
+ final URL location = FileLocator.find(TmfCoreTestPlugin.getDefault().getBundle(), new Path(TEST_TRACE.getFullPath()), 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(), ITmfEvent.class);
- trace.indexTrace();
+ trace.indexTrace(true);
int nbSecs = 0;
while (trace.getNbEvents() < NB_EVENTS && nbSecs < 10) {
Thread.sleep(1000);
assertNull ("getResource", trace.getResource());
assertEquals("getCacheSize", ITmfTrace.DEFAULT_TRACE_CACHE_SIZE, trace.getCacheSize());
assertEquals("getStreamingInterval", 0, trace.getStreamingInterval());
- assertEquals("getName", TEST_STREAM, trace.getName());
+ assertEquals("getName", TEST_TRACE.getPath(), trace.getName());
assertEquals("getNbEvents", NB_EVENTS, trace.getNbEvents());
assertEquals("getRange-start", 1, trace.getTimeRange().getStartTime().getValue());
@Test
public void testSetTimeRange() throws TmfTraceException {
final TmfTraceStub trace = new TmfTraceStub(fTrace);
- trace.indexTrace();
+ trace.indexTrace(true);
assertEquals("getRange-start", 1, trace.getTimeRange().getStartTime().getValue());
assertEquals("getRange-end", NB_EVENTS, trace.getTimeRange().getEndTime().getValue());
@Test
public void testSetStartTime() throws TmfTraceException {
final TmfTraceStub trace = new TmfTraceStub(fTrace);
- trace.indexTrace();
+ trace.indexTrace(true);
assertEquals("getRange-start", 1, trace.getTimeRange().getStartTime().getValue());
assertEquals("getRange-end", NB_EVENTS, trace.getTimeRange().getEndTime().getValue());
@Test
public void testSetEndTime() throws TmfTraceException {
final TmfTraceStub trace = new TmfTraceStub(fTrace);
- trace.indexTrace();
+ trace.indexTrace(true);
assertEquals("getRange-start", 1, trace.getTimeRange().getStartTime().getValue());
assertEquals("getRange-end", NB_EVENTS, trace.getTimeRange().getEndTime().getValue());
@Test
public void testSetNbEvents() throws TmfTraceException {
final TmfTraceStub trace = new TmfTraceStub(fTrace);
- trace.indexTrace();
+ trace.indexTrace(true);
assertEquals("getNbEvents", NB_EVENTS, trace.getNbEvents());
@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);
}
- @Test
- 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);
}
// ------------------------------------------------------------------------
@Test
public void testProcessEventRequestForAllEvents() throws InterruptedException {
- 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(ITmfEvent.class, range, NB_EVENTS, blockSize) {
+ final TmfEventRequest request = new TmfEventRequest(ITmfEvent.class,
+ range, 0, NB_EVENTS, ExecutionType.FOREGROUND) {
@Override
public void handleData(final ITmfEvent event) {
super.handleData(event);
@Test
public void testProcessEventRequestForNbEvents() throws InterruptedException {
- 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(ITmfEvent.class, range, nbEvents, blockSize) {
+ final TmfEventRequest request = new TmfEventRequest(ITmfEvent.class,
+ range, 0, nbEvents, ExecutionType.FOREGROUND) {
@Override
public void handleData(final ITmfEvent event) {
super.handleData(event);
@Test
public void testProcessEventRequestForSomeEvents() throws InterruptedException {
- final int blockSize = 1;
final long startTime = 100;
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(ITmfEvent.class, range, nbEvents, blockSize) {
+ final TmfEventRequest request = new TmfEventRequest(ITmfEvent.class,
+ range, 0, nbEvents, ExecutionType.FOREGROUND) {
@Override
public void handleData(final ITmfEvent event) {
super.handleData(event);
@Test
public void testProcessEventRequestForOtherEvents() throws InterruptedException {
- final int blockSize = 1;
final int startIndex = 99;
final long startTime = 100;
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(ITmfEvent.class, range, startIndex, nbEvents, blockSize) {
+ final TmfEventRequest request = new TmfEventRequest(ITmfEvent.class,
+ range, startIndex, nbEvents, ExecutionType.FOREGROUND) {
@Override
public void handleData(final ITmfEvent event) {
super.handleData(event);
final int nbEvents = 1000;
final Vector<ITmfEvent> requestedEvents = new Vector<ITmfEvent>();
- final TmfDataRequest request = new TmfDataRequest(ITmfEvent.class, startIndex, nbEvents) {
+ final TmfDataRequest request = new TmfDataRequest(ITmfEvent.class,
+ startIndex,
+ nbEvents,
+ TmfDataRequest.ExecutionType.FOREGROUND) {
@Override
public void handleData(final ITmfEvent event) {
super.handleData(event);
@Test
public void testCancel() throws InterruptedException {
+ final int limit = 500;
final Vector<ITmfEvent> requestedEvents = new Vector<ITmfEvent>();
final TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BIG_BANG, TmfTimestamp.BIG_CRUNCH);
- final TmfEventRequest request = new TmfEventRequest(ITmfEvent.class, range, NB_EVENTS, BLOCK_SIZE) {
+ final TmfEventRequest request = new TmfEventRequest(ITmfEvent.class,
+ range, 0, NB_EVENTS, ExecutionType.FOREGROUND) {
int nbRead = 0;
+
@Override
public void handleData(final ITmfEvent event) {
super.handleData(event);
requestedEvents.add(event);
- if (++nbRead == BLOCK_SIZE) {
+ if (++nbRead == limit) {
cancel();
}
}
providers[0].sendRequest(request);
request.waitForCompletion();
- assertEquals("nbEvents", BLOCK_SIZE, requestedEvents.size());
+ assertEquals("nbEvents", limit, requestedEvents.size());
assertTrue("isCompleted", request.isCompleted());
assertTrue("isCancelled", request.isCancelled());
}
assertFalse ("Open trace", fTrace == null);
assertEquals("getType", ITmfEvent.class, fTrace.getType());
assertNull ("getResource", fTrace.getResource());
- assertEquals("getCacheSize", BLOCK_SIZE, fTrace.getCacheSize());
assertEquals("getStreamingInterval", 0, fTrace.getStreamingInterval());
- assertEquals("getName", TEST_STREAM, fTrace.getName());
+ assertEquals("getName", TEST_TRACE.getPath(), fTrace.getName());
assertEquals("getNbEvents", NB_EVENTS, fTrace.getNbEvents());
assertEquals("getRange-start", 1, fTrace.getTimeRange().getStartTime().getValue());
TmfTraceStub trace = null;
File testfile = null;
try {
- final URL location = FileLocator.find(TmfCoreTestPlugin.getDefault().getBundle(), new Path(DIRECTORY + File.separator + TEST_STREAM), null);
+ final URL location = FileLocator.find(TmfCoreTestPlugin.getDefault().getBundle(), new Path(TEST_TRACE.getFullPath()), null);
testfile = new File(FileLocator.toFileURL(location).toURI());
- trace = new TmfTraceStub(testfile.toURI().getPath());
+ trace = new TmfTraceStub(testfile.toURI().getPath(), ITmfTrace.DEFAULT_TRACE_CACHE_SIZE, false, null, null);
// verify initial values
TmfTimestamp defaultInitRange = new TmfTimestamp(DEFAULT_INITIAL_OFFSET_VALUE, ITmfTimestamp.NANOSECOND_SCALE);
assertEquals("getInitialRangeOffset", defaultInitRange, trace.getInitialRangeOffset());
- assertEquals("getCurrentTime", TmfTimestamp.ZERO, trace.getCurrentTime());
- assertEquals("getCurrentRange", TmfTimeRange.NULL_RANGE, trace.getCurrentRange());
trace.setInitialRangeOffset(new TmfTimestamp(5, ITmfTimestamp.MILLISECOND_SCALE));
- trace.indexTrace();
+ trace.indexTrace(true);
+
+ TmfTimestamp initRange = new TmfTimestamp(5, ITmfTimestamp.MILLISECOND_SCALE);
+ assertEquals("getInitialRangeOffset", initRange, trace.getInitialRangeOffset());
+
} catch (final URISyntaxException e) {
fail("URISyntaxException");
} catch (final IOException e) {
fail("IOException");
}
- assertFalse ("Open trace", trace == null);
-
- TmfTimestamp initRange = new TmfTimestamp(5, ITmfTimestamp.MILLISECOND_SCALE);
- assertEquals("getInitialRangeOffset", initRange, trace.getInitialRangeOffset());
- assertEquals("getCurrentTime", trace.getTimeRange().getStartTime(), trace.getCurrentTime());
+ }
- ITmfTimestamp startTimestamp = trace.getTimeRange().getStartTime();
- long endValue = startTimestamp.getValue() + initRange.normalize(0, startTimestamp.getScale()).getValue();
- ITmfTimestamp endTimestamp = new TmfTimestamp(endValue, startTimestamp.getScale());
- TmfTimeRange expectedRange = new TmfTimeRange(startTimestamp, endTimestamp);
- assertEquals("getCurrentRange", expectedRange, trace.getCurrentRange());
+ /**
+ * Run the String getHostId() method test
+ */
+ @Test
+ public void testTraceHostId() {
+ String a = fTrace.getHostId();
+ assertEquals("A-Test-10K", a);
}
}
projects / deliverable / tracecompass.git / blobdiff