X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=org.eclipse.linuxtools.tmf.core.tests%2Fsrc%2Forg%2Feclipse%2Flinuxtools%2Ftmf%2Fcore%2Ftests%2Ftrace%2FTmfExperimentTest.java;h=d3ca984e19179661c85b0ff2c7633254dbedc55c;hb=d62bb1853c3388385d5ce10b0302b3dde139c3ab;hp=d466d5f6d8517016665e6b95c7068ae17b533598;hpb=a4115405ef5641fdeed325e2b063bdf82c728770;p=deliverable%2Ftracecompass.git diff --git a/org.eclipse.linuxtools.tmf.core.tests/src/org/eclipse/linuxtools/tmf/core/tests/trace/TmfExperimentTest.java b/org.eclipse.linuxtools.tmf.core.tests/src/org/eclipse/linuxtools/tmf/core/tests/trace/TmfExperimentTest.java index d466d5f6d8..d3ca984e19 100644 --- a/org.eclipse.linuxtools.tmf.core.tests/src/org/eclipse/linuxtools/tmf/core/tests/trace/TmfExperimentTest.java +++ b/org.eclipse.linuxtools.tmf.core.tests/src/org/eclipse/linuxtools/tmf/core/tests/trace/TmfExperimentTest.java @@ -1,13 +1,14 @@ /******************************************************************************* - * Copyright (c) 2009, 2010 Ericsson - * + * Copyright (c) 2009, 2010, 2012 Ericsson + * * All rights reserved. This program and the accompanying materials are * made available under the terms of the Eclipse Public License v1.0 which * accompanies this distribution, and is available at * http://www.eclipse.org/legal/epl-v10.html - * + * * Contributors: * Francois Chouinard - Initial API and implementation + * Francois Chouinard - Adjusted for new Trace Model *******************************************************************************/ package org.eclipse.linuxtools.tmf.core.tests.trace; @@ -20,37 +21,45 @@ import java.util.Vector; import junit.framework.TestCase; +import org.eclipse.core.resources.IFile; 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.internal.tmf.core.trace.TmfExperimentLocation; 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.experiment.TmfExperiment; -import org.eclipse.linuxtools.tmf.core.experiment.TmfExperimentContext; +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.tests.TmfCoreTestPlugin; +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.TmfCheckpoint; -import org.eclipse.linuxtools.tmf.core.trace.TmfContext; -import org.eclipse.linuxtools.tmf.stubs.trace.TmfTraceStub; +import org.eclipse.linuxtools.tmf.core.trace.TmfExperiment; +import org.eclipse.linuxtools.tmf.core.trace.TmfLongLocation; +import org.eclipse.linuxtools.tmf.tests.stubs.trace.TmfExperimentStub; +import org.eclipse.linuxtools.tmf.tests.stubs.trace.TmfTraceStub; /** - * TmfExperimentTest - *

- * TODO: Implement me. Please. + * Test suite for the TmfExperiment class (single trace). */ -@SuppressWarnings("nls") +@SuppressWarnings({"nls","javadoc"}) public class TmfExperimentTest extends TestCase { + // ------------------------------------------------------------------------ + // Attributes + // ------------------------------------------------------------------------ + private static final String DIRECTORY = "testfiles"; private static final String TEST_STREAM = "A-Test-10K"; private static final String EXPERIMENT = "MyExperiment"; private static int NB_EVENTS = 10000; - private static int fDefaultBlockSize = 1000; + private static int BLOCK_SIZE = 1000; - private static ITmfTrace[] fTraces; - private static TmfExperiment fExperiment; + private ITmfTrace[] fTestTraces; + private TmfExperimentStub fExperiment; private static byte SCALE = (byte) -3; @@ -58,473 +67,772 @@ public class TmfExperimentTest extends TestCase { // Housekeeping // ------------------------------------------------------------------------ - private synchronized ITmfTrace[] setupTrace(String path) { - if (fTraces == null) { - fTraces = new ITmfTrace[1]; - try { - URL location = FileLocator.find(TmfCoreTestPlugin.getDefault().getBundle(), new Path(path), null); - File test = new File(FileLocator.toFileURL(location).toURI()); - TmfTraceStub trace = new TmfTraceStub(test.getPath(), true); - fTraces[0] = trace; - } catch (URISyntaxException e) { - e.printStackTrace(); - } catch (IOException e) { - e.printStackTrace(); - } - } - return fTraces; - } - - @SuppressWarnings("unchecked") + private synchronized ITmfTrace[] setupTrace(final String path) { + if (fTestTraces == null) { + fTestTraces = new ITmfTrace[1]; + try { + final URL location = FileLocator.find(TmfCoreTestPlugin.getDefault().getBundle(), new Path(path), null); + final File test = new File(FileLocator.toFileURL(location).toURI()); + final TmfTraceStub trace = new TmfTraceStub(test.getPath(), 0, true); + fTestTraces[0] = trace; + } catch (final TmfTraceException e) { + e.printStackTrace(); + } catch (final URISyntaxException e) { + e.printStackTrace(); + } catch (final IOException e) { + e.printStackTrace(); + } + } + return fTestTraces; + } + private synchronized void setupExperiment() { - if (fExperiment == null) { - fExperiment = new TmfExperiment(TmfEvent.class, EXPERIMENT, (ITmfTrace[]) fTraces); -// fExperiment.indexExperiment(); - } + if (fExperiment == null) { + fExperiment = new TmfExperimentStub(EXPERIMENT, fTestTraces, BLOCK_SIZE); + fExperiment.getIndexer().buildIndex(0, TmfTimeRange.ETERNITY, true); + } } - public TmfExperimentTest(String name) throws Exception { - super(name); - } + /** + * @param name the test name + */ + public TmfExperimentTest(final String name) { + super(name); + } - @Override - protected void setUp() throws Exception { - super.setUp(); - setupTrace(DIRECTORY + File.separator + TEST_STREAM); - setupExperiment(); - } + @Override + protected void setUp() throws Exception { + super.setUp(); + setupTrace(DIRECTORY + File.separator + TEST_STREAM); + setupExperiment(); + } - @Override - protected void tearDown() throws Exception { - super.tearDown(); - } + @Override + protected void tearDown() throws Exception { + super.tearDown(); + } // ------------------------------------------------------------------------ // Constructor // ------------------------------------------------------------------------ - public void testBasicTmfExperimentConstructor() { - assertEquals("GetId", EXPERIMENT, fExperiment.getName()); - assertEquals("GetEpoch", TmfTimestamp.ZERO, fExperiment.getEpoch()); + public void testSimpleTmfExperimentConstructor() { + + TmfExperiment experiment = new TmfExperiment(TmfEvent.class, EXPERIMENT, fTestTraces); + assertEquals("GetId", EXPERIMENT, experiment.getName()); + assertEquals("GetCacheSize", TmfExperiment.DEFAULT_INDEX_PAGE_SIZE, experiment.getCacheSize()); + experiment.dispose(); + + experiment = new TmfExperiment(TmfEvent.class, EXPERIMENT, null); + experiment.dispose(); + } + + public void testNormalTmfExperimentConstructor() { + + assertEquals("GetId", EXPERIMENT, fExperiment.getName()); assertEquals("GetNbEvents", NB_EVENTS, fExperiment.getNbEvents()); - TmfTimeRange timeRange = fExperiment.getTimeRange(); + final long nbExperimentEvents = fExperiment.getNbEvents(); + assertEquals("GetNbEvents", NB_EVENTS, nbExperimentEvents); + + final long nbTraceEvents = fExperiment.getTraces()[0].getNbEvents(); + assertEquals("GetNbEvents", NB_EVENTS, nbTraceEvents); + + final TmfTimeRange timeRange = fExperiment.getTimeRange(); assertEquals("getStartTime", 1, timeRange.getStartTime().getValue()); assertEquals("getEndTime", NB_EVENTS, timeRange.getEndTime().getValue()); - } + } + + @SuppressWarnings("static-access") + public void testSetCurrentExperiment() { + + TmfExperiment experiment = new TmfExperiment(TmfEvent.class, EXPERIMENT, fTestTraces); + experiment.setCurrentExperiment(experiment); + assertEquals("getCurrentExperiment", experiment, experiment.getCurrentExperiment()); + + TmfExperiment experiment2 = new TmfExperiment(TmfEvent.class, EXPERIMENT, null); + experiment.setCurrentExperiment(experiment2); + assertEquals("getCurrentExperiment", experiment2, experiment.getCurrentExperiment()); + + experiment.dispose(); + experiment2.dispose(); + } // ------------------------------------------------------------------------ - // Verify checkpoints - // Note: seekLocation() does not reliably set the rank + // getTimestamp // ------------------------------------------------------------------------ - public void testValidateCheckpoints() throws Exception { + public void testGetTimestamp() { + assertEquals("getTimestamp", new TmfTimestamp( 1, (byte) -3), fExperiment.getTimestamp( 0)); + assertEquals("getTimestamp", new TmfTimestamp( 2, (byte) -3), fExperiment.getTimestamp( 1)); + assertEquals("getTimestamp", new TmfTimestamp( 11, (byte) -3), fExperiment.getTimestamp( 10)); + assertEquals("getTimestamp", new TmfTimestamp( 101, (byte) -3), fExperiment.getTimestamp( 100)); + assertEquals("getTimestamp", new TmfTimestamp( 1001, (byte) -3), fExperiment.getTimestamp(1000)); + assertEquals("getTimestamp", new TmfTimestamp( 2001, (byte) -3), fExperiment.getTimestamp(2000)); + assertEquals("getTimestamp", new TmfTimestamp( 2501, (byte) -3), fExperiment.getTimestamp(2500)); + assertEquals("getTimestamp", new TmfTimestamp(10000, (byte) -3), fExperiment.getTimestamp(9999)); + assertNull("getTimestamp", fExperiment.getTimestamp(10000)); + } - Vector checkpoints = fExperiment.getCheckpoints(); -// int pageSize = fExperiment.getCacheSize(); - assertTrue("Checkpoints exist", checkpoints != null); + // ------------------------------------------------------------------------ + // Bookmarks file handling + // ------------------------------------------------------------------------ - // Validate that each checkpoint points to the right event - for (int i = 0; i < checkpoints.size(); i++) { - TmfCheckpoint checkpoint = checkpoints.get(i); - TmfExperimentContext context = fExperiment.seekLocation(checkpoint.getLocation()); - ITmfEvent event = fExperiment.parseEvent(context); -// assertEquals("Event rank", context.getRank(), i * pageSize); - assertTrue("Timestamp", (checkpoint.getTimestamp().compareTo(event.getTimestamp(), false) == 0)); - } + public void testBookmarks() { + assertNull("GetBookmarksFile", fExperiment.getBookmarksFile()); + IFile bookmarks = (IFile) fTestTraces[0].getResource(); + fExperiment.setBookmarksFile(bookmarks); + assertEquals("GetBookmarksFile", bookmarks, fExperiment.getBookmarksFile()); } // ------------------------------------------------------------------------ - // parseEvent - make sure parseEvent doesn't update the context + // seekEvent by location // ------------------------------------------------------------------------ - public void testParseEvent() throws Exception { + public void testSeekBadLocation() { + ITmfContext context = fExperiment.seekEvent(new TmfLongLocation(0L)); + assertNull("seekEvent", context); + } - // On lower bound, returns the first event (ts = 0) - TmfContext context = fExperiment.seekEvent(new TmfTimestamp(0, SCALE, 0)); + public void testSeekNoTrace() { + TmfExperiment experiment = new TmfExperiment(TmfEvent.class, EXPERIMENT, null); + ITmfContext context = experiment.seekEvent((TmfExperimentLocation) null); + assertNull("seekEvent", context); + experiment.dispose(); + } - ITmfEvent event = fExperiment.parseEvent(context); - assertEquals("Event timestamp", 1, event.getTimestamp().getValue()); + // ------------------------------------------------------------------------ + // seekEvent on ratio + // ------------------------------------------------------------------------ - event = fExperiment.parseEvent(context); + public void testSeekEventOnRatio() { + + // First event + ITmfContext context = fExperiment.seekEvent(0.0); + assertEquals("Context rank", 0, context.getRank()); + ITmfEvent event = fExperiment.parseEvent(context); assertEquals("Event timestamp", 1, event.getTimestamp().getValue()); + assertEquals("Context rank", 0, context.getRank()); + // Middle event + int midTrace = NB_EVENTS / 2; + context = fExperiment.seekEvent(0.5); + assertEquals("Context rank", midTrace, context.getRank()); event = fExperiment.parseEvent(context); - assertEquals("Event timestamp", 1, event.getTimestamp().getValue()); + assertEquals("Event timestamp", midTrace + 1, event.getTimestamp().getValue()); + assertEquals("Context rank", midTrace, context.getRank()); - for (int i = 1; i < 20; i++) { - event = fExperiment.getNextEvent(context); - assertEquals("Event timestamp", i, event.getTimestamp().getValue()); - } + // Last event + context = fExperiment.seekEvent(1.0); + assertEquals("Context rank", NB_EVENTS, context.getRank()); + event = fExperiment.parseEvent(context); + assertNull("Event timestamp", event); + assertEquals("Context rank", NB_EVENTS, context.getRank()); + // Beyond last event + context = fExperiment.seekEvent(1.1); + assertEquals("Context rank", NB_EVENTS, context.getRank()); event = fExperiment.parseEvent(context); - assertEquals("Event timestamp", 20, event.getTimestamp().getValue()); + assertNull("Event timestamp", event); + assertEquals("Context rank", NB_EVENTS, context.getRank()); + // Negative ratio + context = fExperiment.seekEvent(-0.5); + assertEquals("Context rank", 0, context.getRank()); event = fExperiment.parseEvent(context); - assertEquals("Event timestamp", 20, event.getTimestamp().getValue()); + assertEquals("Event timestamp", 1, event.getTimestamp().getValue()); + assertEquals("Context rank", 0, context.getRank()); + } + + public void testGetLocationRatio() { + + // First event + ITmfContext context = fExperiment.seekEvent((ITmfLocation) null); + double ratio = fExperiment.getLocationRatio(context.getLocation()); + context = fExperiment.seekEvent(ratio); + double ratio2 = fExperiment.getLocationRatio(context.getLocation()); + assertEquals("getLocationRatio", ratio, ratio2); + + // Middle event + context = fExperiment.seekEvent(NB_EVENTS / 2); + ratio = fExperiment.getLocationRatio(context.getLocation()); + context = fExperiment.seekEvent(ratio); + ratio2 = fExperiment.getLocationRatio(context.getLocation()); + assertEquals("getLocationRatio", ratio, ratio2); + + // Last event + context = fExperiment.seekEvent(NB_EVENTS - 1); + ratio = fExperiment.getLocationRatio(context.getLocation()); + context = fExperiment.seekEvent(ratio); + ratio2 = fExperiment.getLocationRatio(context.getLocation()); + assertEquals("getLocationRatio", ratio, ratio2); } +// @SuppressWarnings("rawtypes") +// public void testGetCurrentLocation() { +// ITmfContext context = fExperiment.seekEvent((ITmfLocation) null); +// ITmfLocation location = fExperiment.getCurrentLocation(); +// assertEquals("getCurrentLocation", location, context.getLocation()); +// } + // ------------------------------------------------------------------------ - // getNextEvent - updates the context + // seekEvent on rank // ------------------------------------------------------------------------ - public void testGetNextEvent() throws Exception { + public void testSeekRankOnCacheBoundary() { + + long cacheSize = fExperiment.getCacheSize(); + + // On lower bound, returns the first event (TS = 1) + ITmfContext context = fExperiment.seekEvent(0); + assertEquals("Context rank", 0, context.getRank()); - // On lower bound, returns the first event (ts = 0) - TmfContext context = fExperiment.seekEvent(new TmfTimestamp(0, SCALE, 0)); - ITmfEvent event = fExperiment.getNextEvent(context); + ITmfEvent event = fExperiment.getNext(context); assertEquals("Event timestamp", 1, event.getTimestamp().getValue()); + assertEquals("Context rank", 1, context.getRank()); - for (int i = 2; i < 20; i++) { - event = fExperiment.getNextEvent(context); - assertEquals("Event timestamp", i, event.getTimestamp().getValue()); - } + // Position trace at event rank [cacheSize] + context = fExperiment.seekEvent(cacheSize); + assertEquals("Context rank", cacheSize, context.getRank()); + + event = fExperiment.getNext(context); + assertEquals("Event timestamp", cacheSize + 1, event.getTimestamp().getValue()); + assertEquals("Context rank", cacheSize + 1, context.getRank()); + + // Position trace at event rank [4 * cacheSize] + context = fExperiment.seekEvent(4 * cacheSize); + assertEquals("Context rank", 4 * cacheSize, context.getRank()); + + event = fExperiment.getNext(context); + assertEquals("Event timestamp", 4 * cacheSize + 1, event.getTimestamp().getValue()); + assertEquals("Context rank", 4 * cacheSize + 1, context.getRank()); } - // ------------------------------------------------------------------------ - // seekLocation - // Note: seekLocation() does not reliably set the rank - // ------------------------------------------------------------------------ + public void testSeekRankNotOnCacheBoundary() { - public void testSeekLocationOnCacheBoundary() throws Exception { + long cacheSize = fExperiment.getCacheSize(); - // Position trace at event rank 0 - TmfContext context = fExperiment.seekLocation(null); -// assertEquals("Event rank", 0, context.getRank()); - ITmfEvent event = fExperiment.parseEvent(context); - assertEquals("Event timestamp", 1, event.getTimestamp().getValue()); -// assertEquals("Event rank", 0, context.getRank()); - event = fExperiment.getNextEvent(context); - assertEquals("Event timestamp", 1, event.getTimestamp().getValue()); -// assertEquals("Event rank", 1, context.getRank()); - - // Position trace at event rank 1000 - TmfContext tmpContext = fExperiment.seekEvent(new TmfTimestamp(1001, SCALE, 0)); - context = fExperiment.seekLocation(tmpContext.getLocation().clone()); -// assertEquals("Event rank", 1000, context.getRank()); - event = fExperiment.parseEvent(context); - assertEquals("Event timestamp", 1001, event.getTimestamp().getValue()); -// assertEquals("Event rank", 1000, context.getRank()); - event = fExperiment.getNextEvent(context); - assertEquals("Event timestamp", 1001, event.getTimestamp().getValue()); -// assertEquals("Event rank", 1001, context.getRank()); - - // Position trace at event rank 4000 - tmpContext = fExperiment.seekEvent(new TmfTimestamp(4001, SCALE, 0)); - context = fExperiment.seekLocation(tmpContext.getLocation().clone()); -// assertEquals("Event rank", 4000, context.getRank()); - event = fExperiment.parseEvent(context); - assertEquals("Event timestamp", 4001, event.getTimestamp().getValue()); -// assertEquals("Event rank", 4000, context.getRank()); - event = fExperiment.getNextEvent(context); - assertEquals("Event timestamp", 4001, event.getTimestamp().getValue()); -// assertEquals("Event rank", 4001, context.getRank()); - } - - public void testSeekLocationNotOnCacheBoundary() throws Exception { - - // Position trace at event rank 9 - TmfContext tmpContext = fExperiment.seekEvent(new TmfTimestamp(10, SCALE, 0)); - TmfContext context = fExperiment.seekLocation(tmpContext.getLocation().clone()); -// assertEquals("Event rank", 9, context.getRank()); - ITmfEvent event = fExperiment.parseEvent(context); - assertEquals("Event timestamp", 10, event.getTimestamp().getValue()); -// assertEquals("Event rank", 9, context.getRank()); - event = fExperiment.getNextEvent(context); + // Position trace at event rank 9 + ITmfContext context = fExperiment.seekEvent(9); + assertEquals("Context rank", 9, context.getRank()); + + ITmfEvent event = fExperiment.getNext(context); assertEquals("Event timestamp", 10, event.getTimestamp().getValue()); -// assertEquals("Event rank", 10, context.getRank()); + assertEquals("Context rank", 10, context.getRank()); - // Position trace at event rank 999 - tmpContext = fExperiment.seekEvent(new TmfTimestamp(1000, SCALE, 0)); - context = fExperiment.seekLocation(tmpContext.getLocation().clone()); -// assertEquals("Event rank", 999, context.getRank()); - event = fExperiment.parseEvent(context); - assertEquals("Event timestamp", 1000, event.getTimestamp().getValue()); -// assertEquals("Event rank", 999, context.getRank()); - event = fExperiment.getNextEvent(context); - assertEquals("Event timestamp", 1000, event.getTimestamp().getValue()); -// assertEquals("Event rank", 1000, context.getRank()); + // Position trace at event rank [cacheSize - 1] + context = fExperiment.seekEvent(cacheSize - 1); + assertEquals("Context rank", cacheSize - 1, context.getRank()); - // Position trace at event rank 1001 - tmpContext = fExperiment.seekEvent(new TmfTimestamp(1002, SCALE, 0)); - context = fExperiment.seekLocation(tmpContext.getLocation().clone()); -// assertEquals("Event rank", 1001, context.getRank()); - event = fExperiment.parseEvent(context); - assertEquals("Event timestamp", 1002, event.getTimestamp().getValue()); -// assertEquals("Event rank", 1001, context.getRank()); - event = fExperiment.getNextEvent(context); - assertEquals("Event timestamp", 1002, event.getTimestamp().getValue()); -// assertEquals("Event rank", 1002, context.getRank()); + event = fExperiment.getNext(context); + assertEquals("Event timestamp", cacheSize, event.getTimestamp().getValue()); + assertEquals("Context rank", cacheSize, context.getRank()); - // Position trace at event rank 4500 - tmpContext = fExperiment.seekEvent(new TmfTimestamp(4501, SCALE, 0)); - context = fExperiment.seekLocation(tmpContext.getLocation().clone()); -// assertEquals("Event rank", 4500, context.getRank()); - event = fExperiment.parseEvent(context); - assertEquals("Event timestamp", 4501, event.getTimestamp().getValue()); -// assertEquals("Event rank", 4500, context.getRank()); - event = fExperiment.getNextEvent(context); + // Position trace at event rank [cacheSize + 1] + context = fExperiment.seekEvent(cacheSize + 1); + assertEquals("Context rank", cacheSize + 1, context.getRank()); + + event = fExperiment.getNext(context); + assertEquals("Event timestamp", cacheSize + 2, event.getTimestamp().getValue()); + assertEquals("Context rank", cacheSize + 2, context.getRank()); + + // Position trace at event rank 4500 + context = fExperiment.seekEvent(4500); + assertEquals("Context rank", 4500, context.getRank()); + + event = fExperiment.getNext(context); assertEquals("Event timestamp", 4501, event.getTimestamp().getValue()); -// assertEquals("Event rank", 4501, context.getRank()); + assertEquals("Context rank", 4501, context.getRank()); } - public void testSeekLocationOutOfScope() throws Exception { + public void testSeekRankOutOfScope() { - // Position trace at beginning - TmfContext tmpContext = fExperiment.seekLocation(null); - TmfContext context = fExperiment.seekLocation(tmpContext.getLocation().clone()); -// assertEquals("Event rank", 0, context.getRank()); - ITmfEvent event = fExperiment.parseEvent(context); - assertEquals("Event timestamp", 1, event.getTimestamp().getValue()); -// assertEquals("Event rank", 0, context.getRank()); - event = fExperiment.getNextEvent(context); + // Position trace at beginning + ITmfContext context = fExperiment.seekEvent(-1); + assertEquals("Event rank", 0, context.getRank()); + + ITmfEvent event = fExperiment.getNext(context); assertEquals("Event timestamp", 1, event.getTimestamp().getValue()); -// assertEquals("Event rank", 1, context.getRank()); + assertEquals("Context rank", 1, context.getRank()); - // Position trace at event passed the end - tmpContext = fExperiment.seekEvent(new TmfTimestamp(NB_EVENTS + 1, SCALE, 0)); - context = fExperiment.seekLocation(tmpContext.getLocation().clone()); -// assertEquals("Event rank", NB_EVENTS, context.getRank()); - event = fExperiment.parseEvent(context); - assertEquals("Event timestamp", null, event); -// assertEquals("Event rank", NB_EVENTS, context.getRank()); - event = fExperiment.getNextEvent(context); - assertEquals("Event timestamp", null, event); -// assertEquals("Event rank", NB_EVENTS, context.getRank()); + // Position trace at event passed the end + context = fExperiment.seekEvent(NB_EVENTS); + assertEquals("Context rank", NB_EVENTS, context.getRank()); + + event = fExperiment.getNext(context); + assertNull("Event", event); + assertEquals("Context rank", NB_EVENTS, context.getRank()); } // ------------------------------------------------------------------------ // seekEvent on timestamp // ------------------------------------------------------------------------ - public void testSeekEventOnTimestampOnCacheBoundary() throws Exception { + public void testSeekTimestampOnCacheBoundary() { - // Position trace at event rank 0 - TmfContext context = fExperiment.seekEvent(new TmfTimestamp(1, SCALE, 0)); - assertEquals("Event rank", 0, context.getRank()); - ITmfEvent event = fExperiment.parseEvent(context); - assertEquals("Event timestamp", 1, event.getTimestamp().getValue()); - assertEquals("Event rank", 0, context.getRank()); - event = fExperiment.getNextEvent(context); + long cacheSize = fExperiment.getCacheSize(); + + // Position trace at event rank 0 + ITmfContext context = fExperiment.seekEvent(new TmfTimestamp(1, SCALE, 0)); + assertEquals("Context rank", 0, context.getRank()); + + ITmfEvent event = fExperiment.getNext(context); assertEquals("Event timestamp", 1, event.getTimestamp().getValue()); - assertEquals("Event rank", 1, context.getRank()); + assertEquals("Context rank", 1, context.getRank()); - // Position trace at event rank 1000 - context = fExperiment.seekEvent(new TmfTimestamp(1001, SCALE, 0)); - assertEquals("Event rank", 1000, context.getRank()); - event = fExperiment.parseEvent(context); - assertEquals("Event timestamp", 1001, event.getTimestamp().getValue()); - assertEquals("Event rank", 1000, context.getRank()); - event = fExperiment.getNextEvent(context); - assertEquals("Event timestamp", 1001, event.getTimestamp().getValue()); - assertEquals("Event rank", 1001, context.getRank()); - - // Position trace at event rank 4000 - context = fExperiment.seekEvent(new TmfTimestamp(4001, SCALE, 0)); - assertEquals("Event rank", 4000, context.getRank()); - event = fExperiment.parseEvent(context); - assertEquals("Event timestamp", 4001, event.getTimestamp().getValue()); - assertEquals("Event rank", 4000, context.getRank()); - event = fExperiment.getNextEvent(context); - assertEquals("Event timestamp", 4001, event.getTimestamp().getValue()); - assertEquals("Event rank", 4001, context.getRank()); - } - - public void testSeekEventOnTimestampNotOnCacheBoundary() throws Exception { - - // Position trace at event rank 1 - TmfContext context = fExperiment.seekEvent(new TmfTimestamp(2, SCALE, 0)); - assertEquals("Event rank", 1, context.getRank()); - ITmfEvent event = fExperiment.parseEvent(context); - assertEquals("Event timestamp", 2, event.getTimestamp().getValue()); - assertEquals("Event rank", 1, context.getRank()); - event = fExperiment.getNextEvent(context); + // Position trace at event rank [cacheSize] + context = fExperiment.seekEvent(new TmfTimestamp(cacheSize + 1, SCALE, 0)); + assertEquals("Event rank", cacheSize, context.getRank()); + + event = fExperiment.getNext(context); + assertEquals("Event timestamp", cacheSize + 1, event.getTimestamp().getValue()); + assertEquals("Context rank", cacheSize + 1, context.getRank()); + + // Position trace at event rank [4 * cacheSize] + context = fExperiment.seekEvent(new TmfTimestamp(4 * cacheSize + 1, SCALE, 0)); + assertEquals("Context rank", 4 * cacheSize, context.getRank()); + + event = fExperiment.getNext(context); + assertEquals("Event timestamp", 4 * cacheSize + 1, event.getTimestamp().getValue()); + assertEquals("Context rank", 4 * cacheSize + 1, context.getRank()); + } + + 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()); + + ITmfEvent event = fExperiment.getNext(context); assertEquals("Event timestamp", 2, event.getTimestamp().getValue()); - assertEquals("Event rank", 2, context.getRank()); + assertEquals("Context rank", 2, context.getRank()); - // Position trace at event rank 9 - context = fExperiment.seekEvent(new TmfTimestamp(10, SCALE, 0)); - assertEquals("Event rank", 9, context.getRank()); - event = fExperiment.parseEvent(context); - assertEquals("Event timestamp", 10, event.getTimestamp().getValue()); - assertEquals("Event rank", 9, context.getRank()); - event = fExperiment.getNextEvent(context); + // Position trace at event rank 9 (TS = 10) + context = fExperiment.seekEvent(new TmfTimestamp(10, SCALE, 0)); + assertEquals("Context rank", 9, context.getRank()); + + event = fExperiment.getNext(context); assertEquals("Event timestamp", 10, event.getTimestamp().getValue()); - assertEquals("Event rank", 10, context.getRank()); + assertEquals("Context rank", 10, context.getRank()); - // Position trace at event rank 999 + // Position trace at event rank 999 (TS = 1000) context = fExperiment.seekEvent(new TmfTimestamp(1000, SCALE, 0)); - assertEquals("Event rank", 999, context.getRank()); - event = fExperiment.parseEvent(context); - assertEquals("Event timestamp", 1000, event.getTimestamp().getValue()); - assertEquals("Event rank", 999, context.getRank()); - event = fExperiment.getNextEvent(context); + assertEquals("Context rank", 999, context.getRank()); + + event = fExperiment.getNext(context); assertEquals("Event timestamp", 1000, event.getTimestamp().getValue()); - assertEquals("Event rank", 1000, context.getRank()); + assertEquals("Context rank", 1000, context.getRank()); - // Position trace at event rank 1001 + // Position trace at event rank 1001 (TS = 1002) context = fExperiment.seekEvent(new TmfTimestamp(1002, SCALE, 0)); - assertEquals("Event rank", 1001, context.getRank()); - event = fExperiment.parseEvent(context); - assertEquals("Event timestamp", 1002, event.getTimestamp().getValue()); - assertEquals("Event rank", 1001, context.getRank()); - event = fExperiment.getNextEvent(context); + assertEquals("Context rank", 1001, context.getRank()); + + event = fExperiment.getNext(context); assertEquals("Event timestamp", 1002, event.getTimestamp().getValue()); - assertEquals("Event rank", 1002, context.getRank()); + assertEquals("Context rank", 1002, context.getRank()); - // Position trace at event rank 4500 + // Position trace at event rank 4500 (TS = 4501) context = fExperiment.seekEvent(new TmfTimestamp(4501, SCALE, 0)); - assertEquals("Event rank", 4500, context.getRank()); - event = fExperiment.parseEvent(context); - assertEquals("Event timestamp", 4501, event.getTimestamp().getValue()); - assertEquals("Event rank", 4500, context.getRank()); - event = fExperiment.getNextEvent(context); + assertEquals("Context rank", 4500, context.getRank()); + + event = fExperiment.getNext(context); assertEquals("Event timestamp", 4501, event.getTimestamp().getValue()); - assertEquals("Event rank", 4501, context.getRank()); + assertEquals("Context rank", 4501, context.getRank()); } - public void testSeekEventOnTimestampoutOfScope() throws Exception { + public void testSeekTimestampOutOfScope() { - // Position trace at beginning - TmfContext context = fExperiment.seekEvent(new TmfTimestamp(-1, SCALE, 0)); + // Position trace at beginning + ITmfContext context = fExperiment.seekEvent(new TmfTimestamp(-1, SCALE, 0)); assertEquals("Event rank", 0, context.getRank()); - ITmfEvent event = fExperiment.parseEvent(context); - assertEquals("Event timestamp", 1, event.getTimestamp().getValue()); - assertEquals("Event rank", 0, context.getRank()); - event = fExperiment.getNextEvent(context); + + ITmfEvent event = fExperiment.getNext(context); assertEquals("Event timestamp", 1, event.getTimestamp().getValue()); assertEquals("Event rank", 1, context.getRank()); - // Position trace at event passed the end + // Position trace at event passed the end context = fExperiment.seekEvent(new TmfTimestamp(NB_EVENTS + 1, SCALE, 0)); - assertEquals("Event rank", NB_EVENTS, context.getRank()); - event = fExperiment.parseEvent(context); - assertEquals("Event timestamp", null, event); - assertEquals("Event rank", NB_EVENTS, context.getRank()); - event = fExperiment.getNextEvent(context); - assertEquals("Event timestamp", null, event); - assertEquals("Event rank", NB_EVENTS, context.getRank()); + event = fExperiment.getNext(context); + assertNull("Event location", event); + assertEquals("Event rank", ITmfContext.UNKNOWN_RANK, context.getRank()); } // ------------------------------------------------------------------------ - // seekEvent on rank + // seekEvent by location (context rank is undefined) // ------------------------------------------------------------------------ - public void testSeekOnRankOnCacheBoundary() throws Exception { + public void testSeekLocationOnCacheBoundary() { - // On lower bound, returns the first event (ts = 1) - TmfContext context = fExperiment.seekEvent(0); - assertEquals("Event rank", 0, context.getRank()); - ITmfEvent event = fExperiment.parseEvent(context); - assertEquals("Event timestamp", 1, event.getTimestamp().getValue()); - assertEquals("Event rank", 0, context.getRank()); - event = fExperiment.getNextEvent(context); + long cacheSize = fExperiment.getCacheSize(); + + // Position trace at event rank 0 + ITmfContext tmpContext = fExperiment.seekEvent(0); + ITmfContext context = fExperiment.seekEvent(tmpContext.getLocation()); + + ITmfEvent event = fExperiment.getNext(context); assertEquals("Event timestamp", 1, event.getTimestamp().getValue()); - assertEquals("Event rank", 1, context.getRank()); - // Position trace at event rank 1000 - context = fExperiment.seekEvent(1000); - assertEquals("Event rank", 1000, context.getRank()); - event = fExperiment.parseEvent(context); - assertEquals("Event timestamp", 1001, event.getTimestamp().getValue()); - assertEquals("Event rank", 1000, context.getRank()); - event = fExperiment.getNextEvent(context); - assertEquals("Event timestamp", 1001, event.getTimestamp().getValue()); - assertEquals("Event rank", 1001, context.getRank()); - - // Position trace at event rank 4000 - context = fExperiment.seekEvent(4000); - assertEquals("Event rank", 4000, context.getRank()); - event = fExperiment.parseEvent(context); - assertEquals("Event timestamp", 4001, event.getTimestamp().getValue()); - assertEquals("Event rank", 4000, context.getRank()); - event = fExperiment.getNextEvent(context); - assertEquals("Event timestamp", 4001, event.getTimestamp().getValue()); - assertEquals("Event rank", 4001, context.getRank()); - } - - public void testSeekOnRankNotOnCacheBoundary() throws Exception { - - // Position trace at event rank 9 - TmfContext context = fExperiment.seekEvent(9); - assertEquals("Event rank", 9, context.getRank()); - ITmfEvent event = fExperiment.parseEvent(context); - assertEquals("Event timestamp", 10, event.getTimestamp().getValue()); - assertEquals("Event rank", 9, context.getRank()); - event = fExperiment.getNextEvent(context); - assertEquals("Event timestamp", 10, event.getTimestamp().getValue()); - assertEquals("Event rank", 10, context.getRank()); + event = fExperiment.getNext(context); + assertEquals("Event timestamp", 2, event.getTimestamp().getValue()); - // Position trace at event rank 999 - context = fExperiment.seekEvent(999); - assertEquals("Event rank", 999, context.getRank()); - event = fExperiment.parseEvent(context); - assertEquals("Event timestamp", 1000, event.getTimestamp().getValue()); - assertEquals("Event rank", 999, context.getRank()); - event = fExperiment.getNextEvent(context); - assertEquals("Event timestamp", 1000, event.getTimestamp().getValue()); - assertEquals("Event rank", 1000, context.getRank()); + // Position trace at event rank 'cacheSize' + tmpContext = fExperiment.seekEvent(cacheSize); + context = fExperiment.seekEvent(tmpContext.getLocation()); - // Position trace at event rank 1001 - context = fExperiment.seekEvent(1001); - assertEquals("Event rank", 1001, context.getRank()); - event = fExperiment.parseEvent(context); - assertEquals("Event timestamp", 1002, event.getTimestamp().getValue()); - assertEquals("Event rank", 1001, context.getRank()); - event = fExperiment.getNextEvent(context); - assertEquals("Event timestamp", 1002, event.getTimestamp().getValue()); - assertEquals("Event rank", 1002, context.getRank()); + event = fExperiment.getNext(context); + assertEquals("Event timestamp", cacheSize + 1, event.getTimestamp().getValue()); - // Position trace at event rank 4500 - context = fExperiment.seekEvent(4500); - assertEquals("Event rank", 4500, context.getRank()); - event = fExperiment.parseEvent(context); - assertEquals("Event timestamp", 4501, event.getTimestamp().getValue()); - assertEquals("Event rank", 4500, context.getRank()); - event = fExperiment.getNextEvent(context); + event = fExperiment.getNext(context); + assertEquals("Event timestamp", cacheSize + 2, event.getTimestamp().getValue()); + + // Position trace at event rank 4 * 'cacheSize' + tmpContext = fExperiment.seekEvent(4 * cacheSize); + context = fExperiment.seekEvent(tmpContext.getLocation()); + + event = fExperiment.getNext(context); + assertEquals("Event timestamp", 4 * cacheSize + 1, event.getTimestamp().getValue()); + + event = fExperiment.getNext(context); + assertEquals("Event timestamp", 4 * cacheSize + 2, event.getTimestamp().getValue()); + } + + public void testSeekLocationNotOnCacheBoundary() { + + long cacheSize = fExperiment.getCacheSize(); + + // Position trace at event 'cacheSize' - 1 + ITmfContext tmpContext = fExperiment.seekEvent(cacheSize - 1); + ITmfContext context = fExperiment.seekEvent(tmpContext.getLocation()); + + ITmfEvent event = fExperiment.getNext(context); + assertEquals("Event timestamp", cacheSize, event.getTimestamp().getValue()); + + event = fExperiment.getNext(context); + assertEquals("Event timestamp", cacheSize + 1, event.getTimestamp().getValue()); + + // Position trace at event rank 2 * 'cacheSize' - 1 + tmpContext = fExperiment.seekEvent(2 * cacheSize - 1); + context = fExperiment.seekEvent(tmpContext.getLocation()); + context = fExperiment.seekEvent(2 * cacheSize - 1); + + event = fExperiment.getNext(context); + assertEquals("Event timestamp", 2 * cacheSize, event.getTimestamp().getValue()); + + event = fExperiment.getNext(context); + assertEquals("Event timestamp", 2 * cacheSize + 1, event.getTimestamp().getValue()); + + // Position trace at event rank 4500 + tmpContext = fExperiment.seekEvent(4500); + context = fExperiment.seekEvent(tmpContext.getLocation()); + + event = fExperiment.getNext(context); assertEquals("Event timestamp", 4501, event.getTimestamp().getValue()); - assertEquals("Event rank", 4501, context.getRank()); + + event = fExperiment.getNext(context); + assertEquals("Event timestamp", 4502, event.getTimestamp().getValue()); } - public void testSeekEventOnRankOfScope() throws Exception { + public void testSeekLocationOutOfScope() { - // Position trace at beginning - TmfContext context = fExperiment.seekEvent(-1); - assertEquals("Event rank", 0, context.getRank()); - ITmfEvent event = fExperiment.parseEvent(context); - assertEquals("Event timestamp", 1, event.getTimestamp().getValue()); - assertEquals("Event rank", 0, context.getRank()); - event = fExperiment.getNextEvent(context); + // Position trace at beginning + ITmfContext context = fExperiment.seekEvent((ITmfLocation) null); + + ITmfEvent event = fExperiment.getNext(context); assertEquals("Event timestamp", 1, event.getTimestamp().getValue()); - assertEquals("Event rank", 1, context.getRank()); + } + + // ------------------------------------------------------------------------ + // getNext - updates the context + // ------------------------------------------------------------------------ + + private static void validateContextRanks(ITmfContext context) { + assertTrue("Experiment context type", context instanceof TmfExperimentContext); + TmfExperimentContext ctx = (TmfExperimentContext) context; + + int nbTraces = ctx.getContexts().length; + + // 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(); + if (rank == -1) { + expRank = -1; + break; + } + expRank += rank; + } + assertEquals("Experiment context rank", expRank, ctx.getRank()); + } + + public void testGetNextAfteSeekingOnTS_1() { + + final long INITIAL_TS = 1; + final int NB_READS = 20; + + // On lower bound, returns the first event (ts = 1) + final ITmfContext context = fExperiment.seekEvent(new TmfTimestamp(INITIAL_TS, SCALE, 0)); + + validateContextRanks(context); + + // Read NB_EVENTS + ITmfEvent event; + for (int i = 0; i < NB_READS; i++) { + event = fExperiment.getNext(context); + assertEquals("Event timestamp", INITIAL_TS + i, event.getTimestamp().getValue()); + assertEquals("Event rank", INITIAL_TS + i, context.getRank()); + } + + // Make sure we stay positioned + event = fExperiment.parseEvent(context); + assertEquals("Event timestamp", INITIAL_TS + NB_READS, event.getTimestamp().getValue()); + assertEquals("Event rank", INITIAL_TS + NB_READS - 1, context.getRank()); + + validateContextRanks(context); + } + + public void testGetNextAfteSeekingOnTS_2() { + + final long INITIAL_TS = 2; + final int NB_READS = 20; + + // On lower bound, returns the first event (ts = 2) + final ITmfContext context = fExperiment.seekEvent(new TmfTimestamp(INITIAL_TS, SCALE, 0)); + + validateContextRanks(context); + + // Read NB_EVENTS + ITmfEvent event; + for (int i = 0; i < NB_READS; i++) { + event = fExperiment.getNext(context); + assertEquals("Event timestamp", INITIAL_TS + i, event.getTimestamp().getValue()); + assertEquals("Event rank", INITIAL_TS + i, context.getRank()); + } + + // Make sure we stay positioned + event = fExperiment.parseEvent(context); + assertEquals("Event timestamp", INITIAL_TS + NB_READS, event.getTimestamp().getValue()); + assertEquals("Event rank", INITIAL_TS + NB_READS - 1, context.getRank()); + + validateContextRanks(context); + } + + public void testGetNextAfteSeekingOnTS_3() { + + final long INITIAL_TS = 500; + final int NB_READS = 20; + + // On lower bound, returns the first event (ts = 500) + final ITmfContext context = fExperiment.seekEvent(new TmfTimestamp(INITIAL_TS, SCALE, 0)); + + validateContextRanks(context); + + // Read NB_EVENTS + ITmfEvent event; + for (int i = 0; i < NB_READS; i++) { + event = fExperiment.getNext(context); + assertEquals("Event timestamp", INITIAL_TS + i, event.getTimestamp().getValue()); + assertEquals("Event rank", INITIAL_TS + i, context.getRank()); + } + + // Make sure we stay positioned + event = fExperiment.parseEvent(context); + assertEquals("Event timestamp", INITIAL_TS + NB_READS, event.getTimestamp().getValue()); + assertEquals("Event rank", INITIAL_TS + NB_READS - 1, context.getRank()); + + validateContextRanks(context); + } + + public void testGetNextAfterSeekingOnRank_1() { + + final long INITIAL_RANK = 0L; + final int NB_READS = 20; + + // On lower bound, returns the first event (rank = 0) + final ITmfContext context = fExperiment.seekEvent(INITIAL_RANK); + + validateContextRanks(context); + + // Read NB_EVENTS + ITmfEvent event; + for (int i = 0; i < NB_READS; i++) { + event = fExperiment.getNext(context); + assertEquals("Event timestamp", INITIAL_RANK + i + 1, event.getTimestamp().getValue()); + assertEquals("Event rank", INITIAL_RANK + i + 1, context.getRank()); + } + + // Make sure we stay positioned + event = fExperiment.parseEvent(context); + assertEquals("Event timestamp", INITIAL_RANK + NB_READS + 1, event.getTimestamp().getValue()); + assertEquals("Event rank", INITIAL_RANK + NB_READS, context.getRank()); + + validateContextRanks(context); + } + + public void testGetNextAfterSeekingOnRank_2() { + + final long INITIAL_RANK = 1L; + final int NB_READS = 20; + + // On lower bound, returns the first event (rank = 0) + final ITmfContext context = fExperiment.seekEvent(INITIAL_RANK); + + validateContextRanks(context); + + // Read NB_EVENTS + ITmfEvent event; + for (int i = 0; i < NB_READS; i++) { + event = fExperiment.getNext(context); + assertEquals("Event timestamp", INITIAL_RANK + i + 1, event.getTimestamp().getValue()); + assertEquals("Event rank", INITIAL_RANK + i + 1, context.getRank()); + } + + // Make sure we stay positioned + event = fExperiment.parseEvent(context); + assertEquals("Event timestamp", INITIAL_RANK + NB_READS + 1, event.getTimestamp().getValue()); + assertEquals("Event rank", INITIAL_RANK + NB_READS, context.getRank()); + + validateContextRanks(context); + } + + public void testGetNextAfterSeekingOnRank_3() { + + final long INITIAL_RANK = 500L; + final int NB_READS = 20; + + // On lower bound, returns the first event (rank = 0) + final ITmfContext context = fExperiment.seekEvent(INITIAL_RANK); + + validateContextRanks(context); + + // Read NB_EVENTS + ITmfEvent event; + for (int i = 0; i < NB_READS; i++) { + event = fExperiment.getNext(context); + assertEquals("Event timestamp", INITIAL_RANK + i + 1, event.getTimestamp().getValue()); + assertEquals("Event rank", INITIAL_RANK + i + 1, context.getRank()); + } + + // Make sure we stay positioned + event = fExperiment.parseEvent(context); + assertEquals("Event timestamp", INITIAL_RANK + NB_READS + 1, event.getTimestamp().getValue()); + assertEquals("Event rank", INITIAL_RANK + NB_READS, context.getRank()); + + validateContextRanks(context); + } + + public void testGetNextAfterSeekingOnLocation_1() { + + final ITmfLocation INITIAL_LOC = null; + final long INITIAL_TS = 1; + final int NB_READS = 20; + + // On lower bound, returns the first event (ts = 1) + final ITmfContext context = fExperiment.seekEvent(INITIAL_LOC); + + validateContextRanks(context); + + // Read NB_EVENTS + ITmfEvent event; + for (int i = 0; i < NB_READS; i++) { + event = fExperiment.getNext(context); + assertEquals("Event timestamp", INITIAL_TS + i, event.getTimestamp().getValue()); + assertEquals("Event rank", INITIAL_TS + i, context.getRank()); + } + + // Make sure we stay positioned + event = fExperiment.parseEvent(context); + assertEquals("Event timestamp", INITIAL_TS + NB_READS, event.getTimestamp().getValue()); + assertEquals("Event rank", INITIAL_TS + NB_READS - 1, context.getRank()); + + validateContextRanks(context); + } + + public void testGetNextAfterSeekingOnLocation_2() { + + final ITmfLocation INITIAL_LOC = fExperiment.seekEvent(1L).getLocation(); + final long INITIAL_TS = 2; + final int NB_READS = 20; + + // On lower bound, returns the first event (ts = 2) + final ITmfContext context = fExperiment.seekEvent(INITIAL_LOC); + + validateContextRanks(context); + + // Read NB_EVENTS + ITmfEvent event; + for (int i = 0; i < NB_READS; i++) { + event = fExperiment.getNext(context); + assertEquals("Event timestamp", INITIAL_TS + i, event.getTimestamp().getValue()); + } + + // Make sure we stay positioned + event = fExperiment.parseEvent(context); + assertEquals("Event timestamp", INITIAL_TS + NB_READS, event.getTimestamp().getValue()); + + validateContextRanks(context); + } + + public void testGetNextAfterSeekingOnLocation_3() { + + final ITmfLocation INITIAL_LOC = fExperiment.seekEvent(500L).getLocation(); + final long INITIAL_TS = 501; + final int NB_READS = 20; + + // On lower bound, returns the first event (ts = 501) + final ITmfContext context = fExperiment.seekEvent(INITIAL_LOC); + + validateContextRanks(context); + + // Read NB_EVENTS + ITmfEvent event; + for (int i = 0; i < NB_READS; i++) { + event = fExperiment.getNext(context); + assertEquals("Event timestamp", INITIAL_TS + i, event.getTimestamp().getValue()); + } + + // Make sure we stay positioned + event = fExperiment.parseEvent(context); + assertEquals("Event timestamp", INITIAL_TS + NB_READS, event.getTimestamp().getValue()); + + validateContextRanks(context); + } + + public void testGetNextLocation() { + ITmfContext context1 = fExperiment.seekEvent(0); + fExperiment.getNext(context1); + 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()); + } + + public void testGetNextEndLocation() { + ITmfContext context1 = fExperiment.seekEvent(fExperiment.getNbEvents() - 1); + fExperiment.getNext(context1); + ITmfLocation location = context1.getLocation(); + ITmfContext context2 = fExperiment.seekEvent(location); + ITmfEvent event = fExperiment.getNext(context2); + assertNull("Event", event); + } - // Position trace at event passed the end - context = fExperiment.seekEvent(NB_EVENTS); - assertEquals("Event rank", NB_EVENTS, context.getRank()); - event = fExperiment.parseEvent(context); - assertEquals("Event timestamp", null, event); - assertEquals("Event rank", NB_EVENTS, context.getRank()); - event = fExperiment.getNextEvent(context); - assertEquals("Event timestamp", null, event); - assertEquals("Event rank", NB_EVENTS, context.getRank()); - } - // ------------------------------------------------------------------------ // processRequest // ------------------------------------------------------------------------ - public void testProcessRequestForNbEvents() throws Exception { + public void testProcessRequestForNbEvents() throws InterruptedException { + final int blockSize = 100; final int nbEvents = 1000; - final Vector requestedEvents = new Vector(); - - TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BIG_BANG, TmfTimestamp.BIG_CRUNCH); - final TmfEventRequest request = new TmfEventRequest(TmfEvent.class, range, nbEvents, blockSize) { - @Override - public void handleData(TmfEvent event) { - super.handleData(event); - requestedEvents.add(event); - } + final Vector requestedEvents = new Vector(); + + final TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BIG_BANG, TmfTimestamp.BIG_CRUNCH); + final TmfEventRequest request = new TmfEventRequest(TmfEvent.class, range, nbEvents, blockSize) { + @Override + public void handleData(final ITmfEvent event) { + super.handleData(event); + requestedEvents.add(event); + } }; fExperiment.sendRequest(request); request.waitForCompletion(); @@ -534,24 +842,25 @@ public class TmfExperimentTest extends TestCase { assertFalse("isCancelled", request.isCancelled()); // Ensure that we have distinct events. - // Don't go overboard: we are not validating the stub! + // 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 Exception { + + public void testProcessRequestForNbEvents2() throws InterruptedException { + final int blockSize = 2 * NB_EVENTS; final int nbEvents = 1000; - final Vector requestedEvents = new Vector(); - - TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BIG_BANG, TmfTimestamp.BIG_CRUNCH); - final TmfEventRequest request = new TmfEventRequest(TmfEvent.class, range, nbEvents, blockSize) { - @Override - public void handleData(TmfEvent event) { - super.handleData(event); - requestedEvents.add(event); - } + final Vector requestedEvents = new Vector(); + + final TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BIG_BANG, TmfTimestamp.BIG_CRUNCH); + final TmfEventRequest request = new TmfEventRequest(TmfEvent.class, range, nbEvents, blockSize) { + @Override + public void handleData(final ITmfEvent event) { + super.handleData(event); + requestedEvents.add(event); + } }; fExperiment.sendRequest(request); request.waitForCompletion(); @@ -561,25 +870,26 @@ public class TmfExperimentTest extends TestCase { assertFalse("isCancelled", request.isCancelled()); // Ensure that we have distinct events. - // Don't go overboard: we are not validating the stub! + // 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 testProcessRequestForAllEvents() throws Exception { - final int nbEvents = TmfEventRequest.ALL_DATA; + + public void testProcessRequestForAllEvents() throws InterruptedException { + + final int nbEvents = TmfDataRequest.ALL_DATA; final int blockSize = 1; - final Vector requestedEvents = new Vector(); - long nbExpectedEvents = fExperiment.getNbEvents(); - - TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BIG_BANG, TmfTimestamp.BIG_CRUNCH); - final TmfEventRequest request = new TmfEventRequest(TmfEvent.class, range, nbEvents, blockSize) { - @Override - public void handleData(TmfEvent event) { - super.handleData(event); - requestedEvents.add(event); - } + final Vector requestedEvents = new Vector(); + final long nbExpectedEvents = NB_EVENTS; + + final TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BIG_BANG, TmfTimestamp.BIG_CRUNCH); + final TmfEventRequest request = new TmfEventRequest(TmfEvent.class, range, nbEvents, blockSize) { + @Override + public void handleData(final ITmfEvent event) { + super.handleData(event); + requestedEvents.add(event); + } }; fExperiment.sendRequest(request); request.waitForCompletion(); @@ -589,31 +899,39 @@ public class TmfExperimentTest extends TestCase { assertFalse("isCancelled", request.isCancelled()); // Ensure that we have distinct events. - // Don't go overboard: we are not validating the stub! + // Don't go overboard: we are not validating the stub! for (int i = 0; i < nbExpectedEvents; i++) { assertEquals("Distinct events", i+1, requestedEvents.get(i).getTimestamp().getValue()); } } - + // ------------------------------------------------------------------------ // cancel // ------------------------------------------------------------------------ - public void testCancel() throws Exception { + public void testCancel() throws InterruptedException { + final int nbEvents = NB_EVENTS; - final int blockSize = fDefaultBlockSize; - final Vector requestedEvents = new Vector(); - - TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BIG_BANG, TmfTimestamp.BIG_CRUNCH); - final TmfEventRequest request = new TmfEventRequest(TmfEvent.class, range, nbEvents, blockSize) { - int nbRead = 0; - @Override - public void handleData(TmfEvent event) { - super.handleData(event); - requestedEvents.add(event); - if (++nbRead == blockSize) - cancel(); - } + final int blockSize = BLOCK_SIZE; + final Vector requestedEvents = new Vector(); + + final TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BIG_BANG, TmfTimestamp.BIG_CRUNCH); + final TmfEventRequest request = new TmfEventRequest(TmfEvent.class, range, nbEvents, blockSize) { + int nbRead = 0; + @Override + public void handleData(final ITmfEvent event) { + super.handleData(event); + requestedEvents.add(event); + if (++nbRead == blockSize) { + cancel(); + } + } + @Override + public void handleCancel() { + if (requestedEvents.size() < blockSize) { + System.out.println("aie"); + } + } }; fExperiment.sendRequest(request); request.waitForCompletion(); @@ -622,32 +940,5 @@ public class TmfExperimentTest extends TestCase { assertTrue("isCompleted", request.isCompleted()); assertTrue("isCancelled", request.isCancelled()); } - - // ------------------------------------------------------------------------ - // getRank - // ------------------------------------------------------------------------ - - public void testGetRank() throws Exception { - assertEquals("getRank", 0, fExperiment.getRank(new TmfTimestamp())); - assertEquals("getRank", 0, fExperiment.getRank(new TmfTimestamp( 1, (byte) -3))); - assertEquals("getRank", 10, fExperiment.getRank(new TmfTimestamp( 11, (byte) -3))); - assertEquals("getRank", 100, fExperiment.getRank(new TmfTimestamp( 101, (byte) -3))); - assertEquals("getRank", 1000, fExperiment.getRank(new TmfTimestamp(1001, (byte) -3))); - assertEquals("getRank", 2000, fExperiment.getRank(new TmfTimestamp(2001, (byte) -3))); - assertEquals("getRank", 2500, fExperiment.getRank(new TmfTimestamp(2501, (byte) -3))); - } - - // ------------------------------------------------------------------------ - // getTimestamp - // ------------------------------------------------------------------------ - - public void testGetTimestamp() throws Exception { - assertTrue("getTimestamp", fExperiment.getTimestamp( 0).equals(new TmfTimestamp( 1, (byte) -3))); - assertTrue("getTimestamp", fExperiment.getTimestamp( 10).equals(new TmfTimestamp( 11, (byte) -3))); - assertTrue("getTimestamp", fExperiment.getTimestamp( 100).equals(new TmfTimestamp( 101, (byte) -3))); - assertTrue("getTimestamp", fExperiment.getTimestamp(1000).equals(new TmfTimestamp(1001, (byte) -3))); - assertTrue("getTimestamp", fExperiment.getTimestamp(2000).equals(new TmfTimestamp(2001, (byte) -3))); - assertTrue("getTimestamp", fExperiment.getTimestamp(2500).equals(new TmfTimestamp(2501, (byte) -3))); - } -} \ No newline at end of file +}