X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=org.eclipse.linuxtools.tmf.core.tests%2Fsrc%2Forg%2Feclipse%2Flinuxtools%2Ftmf%2Fcore%2Ftests%2Ftrace%2FTmfTraceTest.java;h=496a6d0b1dbef488af2b1b9b48edc1d31e6ea58c;hb=a94410d92f16c8ce3870bb2e1538b93e038e4f78;hp=dba2a4540613a061fac55c3ec91a5b99cf353530;hpb=6151d86cb1e3f18d4eb446347fe249f8b26dfa0d;p=deliverable%2Ftracecompass.git diff --git a/org.eclipse.linuxtools.tmf.core.tests/src/org/eclipse/linuxtools/tmf/core/tests/trace/TmfTraceTest.java b/org.eclipse.linuxtools.tmf.core.tests/src/org/eclipse/linuxtools/tmf/core/tests/trace/TmfTraceTest.java index dba2a45406..496a6d0b1d 100644 --- a/org.eclipse.linuxtools.tmf.core.tests/src/org/eclipse/linuxtools/tmf/core/tests/trace/TmfTraceTest.java +++ b/org.eclipse.linuxtools.tmf.core.tests/src/org/eclipse/linuxtools/tmf/core/tests/trace/TmfTraceTest.java @@ -1,5 +1,5 @@ /******************************************************************************* - * 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 @@ -9,48 +9,59 @@ * 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.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"; private static final int BLOCK_SIZE = 500; @@ -63,22 +74,13 @@ public class TmfTraceTest extends TestCase { // 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; } @@ -109,6 +111,7 @@ public class TmfTraceTest extends TestCase { // Constructors // ------------------------------------------------------------------------ + @Test @SuppressWarnings("null") public void testStandardConstructor() throws TmfTraceException { TmfTraceStub trace = null; @@ -125,7 +128,7 @@ public class TmfTraceTest extends TestCase { } 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()); @@ -139,6 +142,7 @@ public class TmfTraceTest extends TestCase { assertEquals("getEndTime", NB_EVENTS, trace.getEndTime().getValue()); } + @Test @SuppressWarnings("null") public void testStandardConstructorCacheSize() throws TmfTraceException { TmfTraceStub trace = null; @@ -155,7 +159,7 @@ public class TmfTraceTest extends TestCase { } 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()); @@ -179,7 +183,7 @@ public class TmfTraceTest extends TestCase { 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()); @@ -193,6 +197,7 @@ public class TmfTraceTest extends TestCase { assertEquals("getEndTime", NB_EVENTS, trace.getEndTime().getValue()); } + @Test @SuppressWarnings("null") public void testFullConstructor() throws TmfTraceException { TmfTraceStub trace = null; @@ -209,7 +214,7 @@ public class TmfTraceTest extends TestCase { } 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()); @@ -223,6 +228,7 @@ public class TmfTraceTest extends TestCase { assertEquals("getEndTime", NB_EVENTS, trace.getEndTime().getValue()); } + @Test @SuppressWarnings("null") public void testLiveTraceConstructor() throws TmfTraceException { TmfTraceStub trace = null; @@ -240,7 +246,7 @@ public class TmfTraceTest extends TestCase { } 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()); @@ -254,6 +260,7 @@ public class TmfTraceTest extends TestCase { assertEquals("getEndTime", NB_EVENTS, trace.getEndTime().getValue()); } + @Test @SuppressWarnings("null") public void testCopyConstructor() throws TmfTraceException { TmfTraceStub original = null; @@ -272,7 +279,7 @@ public class TmfTraceTest extends TestCase { } 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()); @@ -300,13 +307,13 @@ public class TmfTraceTest extends TestCase { // 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 @@ -315,20 +322,20 @@ public class TmfTraceTest extends TestCase { } } + @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()); @@ -336,14 +343,14 @@ public class TmfTraceTest extends TestCase { assertEquals("getName", path, trace.getName()); assertEquals("getNbEvents", 0, trace.getNbEvents()); - assertEquals("getRange-start", Long.MAX_VALUE, trace.getTimeRange().getStartTime().getValue()); + assertEquals("getRange-start", Long.MIN_VALUE, trace.getTimeRange().getStartTime().getValue()); assertEquals("getRange-end", Long.MIN_VALUE, trace.getTimeRange().getEndTime().getValue()); - assertEquals("getStartTime", Long.MAX_VALUE, trace.getStartTime().getValue()); + assertEquals("getStartTime", Long.MIN_VALUE, trace.getStartTime().getValue()); assertEquals("getEndTime", Long.MIN_VALUE, trace.getEndTime().getValue()); } + @Test public void testInitializeNormalPath() { - // Instantiate an "empty" trace final TmfTraceStub trace = new TmfTraceStub(); @@ -351,12 +358,12 @@ public class TmfTraceTest extends TestCase { 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()); @@ -364,14 +371,14 @@ public class TmfTraceTest extends TestCase { assertEquals("getName", name, trace.getName()); assertEquals("getNbEvents", 0, trace.getNbEvents()); - assertEquals("getRange-start", Long.MAX_VALUE, trace.getTimeRange().getStartTime().getValue()); + assertEquals("getRange-start", Long.MIN_VALUE, trace.getTimeRange().getStartTime().getValue()); assertEquals("getRange-end", Long.MIN_VALUE, trace.getTimeRange().getEndTime().getValue()); - assertEquals("getStartTime", Long.MAX_VALUE, trace.getStartTime().getValue()); + assertEquals("getStartTime", Long.MIN_VALUE, trace.getStartTime().getValue()); 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(); @@ -382,18 +389,18 @@ public class TmfTraceTest extends TestCase { assertEquals("getName", "", trace.getName()); assertEquals("getNbEvents", 0, trace.getNbEvents()); - assertEquals("getRange-start", Long.MAX_VALUE, trace.getTimeRange().getStartTime().getValue()); + assertEquals("getRange-start", Long.MIN_VALUE, trace.getTimeRange().getStartTime().getValue()); assertEquals("getRange-end", Long.MIN_VALUE, trace.getTimeRange().getEndTime().getValue()); - assertEquals("getStartTime", Long.MAX_VALUE, trace.getStartTime().getValue()); + assertEquals("getStartTime", Long.MIN_VALUE, trace.getStartTime().getValue()); 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 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) { @@ -404,7 +411,7 @@ public class TmfTraceTest extends TestCase { 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()); @@ -421,6 +428,7 @@ public class TmfTraceTest extends TestCase { // Set/Get streaming interval // ------------------------------------------------------------------------ + @Test public void testSetStreamingInterval() throws TmfTraceException { final TmfTraceStub trace = new TmfTraceStub(fTrace); @@ -446,6 +454,7 @@ public class TmfTraceTest extends TestCase { // Set/Get time range // ------------------------------------------------------------------------ + @Test public void testSetTimeRange() throws TmfTraceException { final TmfTraceStub trace = new TmfTraceStub(fTrace); trace.indexTrace(); @@ -464,6 +473,7 @@ public class TmfTraceTest extends TestCase { trace.dispose(); } + @Test public void testSetStartTime() throws TmfTraceException { final TmfTraceStub trace = new TmfTraceStub(fTrace); trace.indexTrace(); @@ -482,6 +492,7 @@ public class TmfTraceTest extends TestCase { trace.dispose(); } + @Test public void testSetEndTime() throws TmfTraceException { final TmfTraceStub trace = new TmfTraceStub(fTrace); trace.indexTrace(); @@ -500,6 +511,7 @@ public class TmfTraceTest extends TestCase { trace.dispose(); } + @Test public void testSetNbEvents() throws TmfTraceException { final TmfTraceStub trace = new TmfTraceStub(fTrace); trace.indexTrace(); @@ -521,12 +533,39 @@ public class TmfTraceTest extends TestCase { trace.dispose(); } + // ------------------------------------------------------------------------ + // 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.getStateSystems().get("something"); + assertNull(ss); + } + + /** + * Make sure the returned map is unmodifiable. + */ + @Test(expected=UnsupportedOperationException.class) + public void testGetStateSystem_readOnly() { + Map 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); @@ -571,8 +610,8 @@ public class TmfTraceTest extends TestCase { 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()); @@ -626,8 +665,8 @@ public class TmfTraceTest extends TestCase { 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()); @@ -654,8 +693,8 @@ public class TmfTraceTest extends TestCase { // 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()); @@ -665,8 +704,8 @@ public class TmfTraceTest extends TestCase { 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()); @@ -704,8 +743,8 @@ public class TmfTraceTest extends TestCase { 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()); @@ -767,8 +806,8 @@ public class TmfTraceTest extends TestCase { 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()); @@ -798,8 +837,8 @@ public class TmfTraceTest extends TestCase { // seekEvent on rank // ------------------------------------------------------------------------ + @Test public void testSeekEventOnNegativeRank() { - // Position trace at event rank 0 ITmfContext context = fTrace.seekEvent(-1); assertEquals("Event rank", 0, context.getRank()); @@ -809,8 +848,8 @@ public class TmfTraceTest extends TestCase { 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()); @@ -848,8 +887,8 @@ public class TmfTraceTest extends TestCase { 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()); @@ -899,8 +938,8 @@ public class TmfTraceTest extends TestCase { 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()); @@ -930,8 +969,8 @@ public class TmfTraceTest extends TestCase { // 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) @@ -975,8 +1014,8 @@ public class TmfTraceTest extends TestCase { // getNext - updates the context // ------------------------------------------------------------------------ + @Test public void testGetNextAfteSeekingOnTS_1() { - final long INITIAL_TS = 1; final int NB_READS = 20; @@ -997,8 +1036,8 @@ public class TmfTraceTest extends TestCase { 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; @@ -1019,8 +1058,8 @@ public class TmfTraceTest extends TestCase { 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; @@ -1041,8 +1080,8 @@ public class TmfTraceTest extends TestCase { 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; @@ -1063,8 +1102,8 @@ public class TmfTraceTest extends TestCase { assertEquals("Event rank", INITIAL_RANK + NB_READS, context.getRank()); } + @Test public void testGetNextAfterSeekingOnRank_2() { - final long INITIAL_RANK = 1L; final int NB_READS = 20; @@ -1085,8 +1124,8 @@ public class TmfTraceTest extends TestCase { assertEquals("Event rank", INITIAL_RANK + NB_READS, context.getRank()); } + @Test public void testGetNextAfterSeekingOnRank_3() { - final long INITIAL_RANK = 500L; final int NB_READS = 20; @@ -1107,8 +1146,8 @@ public class TmfTraceTest extends TestCase { 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; @@ -1130,8 +1169,8 @@ public class TmfTraceTest extends TestCase { 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; @@ -1151,8 +1190,8 @@ public class TmfTraceTest extends TestCase { 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; @@ -1172,20 +1211,22 @@ public class TmfTraceTest extends TestCase { assertEquals("Event timestamp", INITIAL_TS + NB_READS, event.getTimestamp().getValue()); } + @Test public void testGetNextLocation() { ITmfContext context1 = fTrace.seekEvent(0); fTrace.getNext(context1); - ITmfLocation location = context1.getLocation().clone(); + ITmfLocation location = context1.getLocation(); ITmfEvent event1 = fTrace.getNext(context1); ITmfContext context2 = fTrace.seekEvent(location); ITmfEvent event2 = fTrace.getNext(context2); assertEquals("Event timestamp", event1.getTimestamp().getValue(), event2.getTimestamp().getValue()); } + @Test public void testGetNextEndLocation() { ITmfContext context1 = fTrace.seekEvent(fTrace.getNbEvents() - 1); fTrace.getNext(context1); - ITmfLocation location = context1.getLocation().clone(); + ITmfLocation location = context1.getLocation(); ITmfContext context2 = fTrace.seekEvent(location); ITmfEvent event = fTrace.getNext(context2); assertNull("Event", event); @@ -1195,20 +1236,20 @@ public class TmfTraceTest extends TestCase { // processRequest // ------------------------------------------------------------------------ - @SuppressWarnings("hiding") + @Test public void testProcessEventRequestForAllEvents() throws InterruptedException { - final int BLOCK_SIZE = 1; + final int blockSize = 1; final Vector requestedEvents = new Vector(); 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(); @@ -1223,120 +1264,120 @@ public class TmfTraceTest extends TestCase { } } - @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 requestedEvents = new Vector(); 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 requestedEvents = new Vector(); 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 requestedEvents = new Vector(); 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 requestedEvents = new Vector(); - 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()); } } @@ -1345,11 +1386,12 @@ public class TmfTraceTest extends TestCase { // cancel // ------------------------------------------------------------------------ + @Test public void testCancel() throws InterruptedException { final Vector requestedEvents = new Vector(); 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) { @@ -1360,7 +1402,7 @@ public class TmfTraceTest extends TestCase { } } }; - final ITmfDataProvider[] providers = TmfProviderManager.getProviders(TmfEvent.class, TmfTraceStub.class); + final ITmfDataProvider[] providers = TmfProviderManager.getProviders(ITmfEvent.class, TmfTraceStub.class); providers[0].sendRequest(request); request.waitForCompletion(); @@ -1373,9 +1415,10 @@ public class TmfTraceTest extends TestCase { // 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()); @@ -1394,4 +1437,41 @@ public class TmfTraceTest extends TestCase { assertEquals("toString", expected, fTrace.toString()); } + // ------------------------------------------------------------------------ + // getInitialRangeOffset, getCurrentRange, getCurrentTime + // ------------------------------------------------------------------------ + + @Test + public void testCurrentTimeValues() 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()); + // 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(); + } 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()); + } }