[Bug291070] Fix for multi-traces support at the framework level + unit tests

12 files changed, 444 insertions, 68 deletions

diff --git a/lttng/org.eclipse.linuxtools.tmf.tests/src/org/eclipse/linuxtools/tmf/tests/AllTmfCoreTests.java b/lttng/org.eclipse.linuxtools.tmf.tests/src/org/eclipse/linuxtools/tmf/tests/AllTmfCoreTests.java
index 46a1147d9e..5a36462a96 100644
--- a/lttng/org.eclipse.linuxtools.tmf.tests/src/org/eclipse/linuxtools/tmf/tests/AllTmfCoreTests.java
+++ b/lttng/org.eclipse.linuxtools.tmf.tests/src/org/eclipse/linuxtools/tmf/tests/AllTmfCoreTests.java
@@ -15,9 +15,11 @@ import org.eclipse.linuxtools.tmf.tests.event.TmfTimeRangeTest;
 import org.eclipse.linuxtools.tmf.tests.event.TmfTimestampTest;
 import org.eclipse.linuxtools.tmf.tests.event.TmfTraceEventTest;
 import org.eclipse.linuxtools.tmf.tests.request.TmfCoalescedDataRequestTest;
+import org.eclipse.linuxtools.tmf.tests.request.TmfCoalescedEventRequestTest;
 import org.eclipse.linuxtools.tmf.tests.request.TmfDataRequestTest;
 import org.eclipse.linuxtools.tmf.tests.request.TmfEventRequestTest;
 import org.eclipse.linuxtools.tmf.tests.trace.TmfExperimentTest;
+import org.eclipse.linuxtools.tmf.tests.trace.TmfMultiTraceExperimentTest;
 import org.eclipse.linuxtools.tmf.tests.trace.TmfTraceTest;
 
 public class AllTmfCoreTests {
@@ -41,9 +43,11 @@ public class AllTmfCoreTests {
 		suite.addTestSuite(TmfDataRequestTest.class);
 		suite.addTestSuite(TmfEventRequestTest.class);
 		suite.addTestSuite(TmfCoalescedDataRequestTest.class);
+		suite.addTestSuite(TmfCoalescedEventRequestTest.class);
 
 		suite.addTestSuite(TmfTraceTest.class);
 		suite.addTestSuite(TmfExperimentTest.class);
+		suite.addTestSuite(TmfMultiTraceExperimentTest.class);
 		//$JUnit-END$
 		return suite;
 	}
diff --git a/lttng/org.eclipse.linuxtools.tmf.tests/src/org/eclipse/linuxtools/tmf/tests/request/AllTests.java b/lttng/org.eclipse.linuxtools.tmf.tests/src/org/eclipse/linuxtools/tmf/tests/request/AllTests.java
index 8962239db5..dbbd060825 100644
--- a/lttng/org.eclipse.linuxtools.tmf.tests/src/org/eclipse/linuxtools/tmf/tests/request/AllTests.java
+++ b/lttng/org.eclipse.linuxtools.tmf.tests/src/org/eclipse/linuxtools/tmf/tests/request/AllTests.java
@@ -13,6 +13,7 @@ public class AllTests {
 		suite.addTestSuite(TmfDataRequestTest.class);
 		suite.addTestSuite(TmfEventRequestTest.class);
 		suite.addTestSuite(TmfCoalescedDataRequestTest.class);
+		suite.addTestSuite(TmfCoalescedEventRequestTest.class);
 		//$JUnit-END$
 		return suite;
 	}
diff --git a/lttng/org.eclipse.linuxtools.tmf.tests/src/org/eclipse/linuxtools/tmf/tests/request/TmfCoalescedEventRequestTest.java b/lttng/org.eclipse.linuxtools.tmf.tests/src/org/eclipse/linuxtools/tmf/tests/request/TmfCoalescedEventRequestTest.java
index 645f67acf8..06aa1ea8c8 100644
--- a/lttng/org.eclipse.linuxtools.tmf.tests/src/org/eclipse/linuxtools/tmf/tests/request/TmfCoalescedEventRequestTest.java
+++ b/lttng/org.eclipse.linuxtools.tmf.tests/src/org/eclipse/linuxtools/tmf/tests/request/TmfCoalescedEventRequestTest.java
@@ -45,7 +45,7 @@ import org.eclipse.linuxtools.tmf.trace.TmfTraceStub;
 public class TmfCoalescedEventRequestTest extends TestCase {
 
     private static final String DIRECTORY   = "testfiles";
-    private static final String TEST_STREAM = "M-Test-10K";
+    private static final String TEST_STREAM = "A-Test-10K";
     private static final int    NB_EVENTS   = 10000;
     private static final int    BLOCK_SIZE  = 100;
 
diff --git a/lttng/org.eclipse.linuxtools.tmf.tests/src/org/eclipse/linuxtools/tmf/tests/trace/AllTests.java b/lttng/org.eclipse.linuxtools.tmf.tests/src/org/eclipse/linuxtools/tmf/tests/trace/AllTests.java
index f67f69f1b1..a7a2646c9d 100644
--- a/lttng/org.eclipse.linuxtools.tmf.tests/src/org/eclipse/linuxtools/tmf/tests/trace/AllTests.java
+++ b/lttng/org.eclipse.linuxtools.tmf.tests/src/org/eclipse/linuxtools/tmf/tests/trace/AllTests.java
@@ -12,6 +12,7 @@ public class AllTests {
 		//$JUnit-BEGIN$
 		suite.addTestSuite(TmfTraceTest.class);
 		suite.addTestSuite(TmfExperimentTest.class);
+		suite.addTestSuite(TmfMultiTraceExperimentTest.class);
 		//$JUnit-END$
 		return suite;
 	}
diff --git a/lttng/org.eclipse.linuxtools.tmf.tests/src/org/eclipse/linuxtools/tmf/tests/trace/TmfExperimentTest.java b/lttng/org.eclipse.linuxtools.tmf.tests/src/org/eclipse/linuxtools/tmf/tests/trace/TmfExperimentTest.java
index 6ef340bcac..203fd90d06 100644
--- a/lttng/org.eclipse.linuxtools.tmf.tests/src/org/eclipse/linuxtools/tmf/tests/trace/TmfExperimentTest.java
+++ b/lttng/org.eclipse.linuxtools.tmf.tests/src/org/eclipse/linuxtools/tmf/tests/trace/TmfExperimentTest.java
@@ -40,12 +40,12 @@ import org.eclipse.linuxtools.tmf.trace.TmfTraceStub;
 public class TmfExperimentTest extends TestCase {
 
     private static final String DIRECTORY   = "testfiles";
-    private static final String TEST_STREAM = "M-Test-10K";
+    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 ITmfTrace fTrace;
+    private static ITmfTrace[] fTrace;
     private static TmfExperiment<TmfEvent> fExperiment;
 
     private static byte SCALE = (byte) -3;
@@ -54,13 +54,14 @@ public class TmfExperimentTest extends TestCase {
     // Housekeeping
     // ------------------------------------------------------------------------
 
-    private ITmfTrace setupTrace(String path) {
+    private ITmfTrace[] setupTrace(String path) {
     	if (fTrace == null) {
+    		fTrace = new ITmfTrace[1];
     		try {
     	        URL location = FileLocator.find(TmfCoreTestPlugin.getPlugin().getBundle(), new Path(path), null);
     			File test = new File(FileLocator.toFileURL(location).toURI());
     			TmfTraceStub trace = new TmfTraceStub(test.getPath(), true);
-    			fTrace = trace;
+    			fTrace[0] = trace;
     		} catch (URISyntaxException e) {
     			e.printStackTrace();
     		} catch (IOException e) {
@@ -72,7 +73,7 @@ public class TmfExperimentTest extends TestCase {
 
     private void setupExperiment() {
     	if (fExperiment == null) {
-            fExperiment = new TmfExperiment<TmfEvent>(TmfEvent.class, EXPERIMENT, new ITmfTrace[] { fTrace });
+            fExperiment = new TmfExperiment<TmfEvent>(TmfEvent.class, EXPERIMENT, fTrace);
             fExperiment.indexExperiment(true);
     	}
     }
@@ -111,7 +112,7 @@ public class TmfExperimentTest extends TestCase {
     // seek
     // ------------------------------------------------------------------------
 
-    public void testSeekEOnCacheBoundary() throws Exception {
+    public void testSeekOnCacheBoundary() throws Exception {
     	TmfExperimentContext context = fExperiment.seekLocation(null);
 
     	context = fExperiment.seekEvent(new TmfTimestamp(1, SCALE, 0));
@@ -320,4 +321,15 @@ public class TmfExperimentTest extends TestCase {
         assertEquals("getRank", 1000, fExperiment.getRank(new TmfTimestamp(1001, (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)));
+    }
+
 }
\ No newline at end of file
diff --git a/lttng/org.eclipse.linuxtools.tmf.tests/src/org/eclipse/linuxtools/tmf/tests/trace/TmfMultiTraceExperimentTest.java b/lttng/org.eclipse.linuxtools.tmf.tests/src/org/eclipse/linuxtools/tmf/tests/trace/TmfMultiTraceExperimentTest.java
new file mode 100644
index 0000000000..1bb47fe6af
--- /dev/null
+++ b/lttng/org.eclipse.linuxtools.tmf.tests/src/org/eclipse/linuxtools/tmf/tests/trace/TmfMultiTraceExperimentTest.java
@@ -0,0 +1,340 @@
+/*******************************************************************************
+ * Copyright (c) 2009, 2010 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
+ *******************************************************************************/
+
+package org.eclipse.linuxtools.tmf.tests.trace;
+
+import java.io.File;
+import java.io.IOException;
+import java.net.URISyntaxException;
+import java.net.URL;
+import java.util.Vector;
+
+import junit.framework.TestCase;
+
+import org.eclipse.core.runtime.FileLocator;
+import org.eclipse.core.runtime.Path;
+import org.eclipse.linuxtools.tmf.event.TmfEvent;
+import org.eclipse.linuxtools.tmf.event.TmfTimeRange;
+import org.eclipse.linuxtools.tmf.event.TmfTimestamp;
+import org.eclipse.linuxtools.tmf.experiment.TmfExperiment;
+import org.eclipse.linuxtools.tmf.experiment.TmfExperimentContext;
+import org.eclipse.linuxtools.tmf.request.TmfEventRequest;
+import org.eclipse.linuxtools.tmf.tests.TmfCoreTestPlugin;
+import org.eclipse.linuxtools.tmf.trace.ITmfTrace;
+import org.eclipse.linuxtools.tmf.trace.TmfTraceStub;
+
+/**
+ * <b><u>TmfExperimentTest</u></b>
+ * <p>
+ * TODO: Implement me. Please.
+ */
+public class TmfMultiTraceExperimentTest extends TestCase {
+
+    private static final String DIRECTORY    = "testfiles";
+    private static final String TEST_STREAM1 = "O-Test-10K";
+    private static final String TEST_STREAM2 = "E-Test-10K";
+    private static final String EXPERIMENT   = "MyExperiment";
+    private static int          NB_EVENTS    = 20000;
+    private static int    fDefaultBlockSize  = 1000;
+
+    private static ITmfTrace[] fTrace;
+    private static TmfExperiment<TmfEvent> fExperiment;
+
+    private static byte SCALE = (byte) -3;
+
+    // ------------------------------------------------------------------------
+    // Housekeeping
+    // ------------------------------------------------------------------------
+
+    private ITmfTrace[] setupTrace(String path1, String path2) {
+    	if (fTrace == null) {
+    		fTrace = new ITmfTrace[2];
+    		try {
+    	        URL location = FileLocator.find(TmfCoreTestPlugin.getPlugin().getBundle(), new Path(path1), null);
+    			File test = new File(FileLocator.toFileURL(location).toURI());
+    			TmfTraceStub trace1 = new TmfTraceStub(test.getPath(), true);
+    			fTrace[0] = trace1;
+    	        location = FileLocator.find(TmfCoreTestPlugin.getPlugin().getBundle(), new Path(path2), null);
+    			test = new File(FileLocator.toFileURL(location).toURI());
+    			TmfTraceStub trace2 = new TmfTraceStub(test.getPath(), true);
+    			fTrace[1] = trace2;
+    		} catch (URISyntaxException e) {
+    			e.printStackTrace();
+    		} catch (IOException e) {
+    			e.printStackTrace();
+    		}
+    	}
+    	return fTrace;
+    }
+
+    private void setupExperiment() {
+    	if (fExperiment == null) {
+            fExperiment = new TmfExperiment<TmfEvent>(TmfEvent.class, EXPERIMENT, fTrace);
+            fExperiment.indexExperiment(true);
+    	}
+    }
+
+	public TmfMultiTraceExperimentTest(String name) throws Exception {
+		super(name);
+	}
+
+	@Override
+	protected void setUp() throws Exception {
+		super.setUp();
+		setupTrace(DIRECTORY + File.separator + TEST_STREAM1, DIRECTORY + File.separator + TEST_STREAM2);
+		setupExperiment();
+	}
+
+	@Override
+	protected void tearDown() throws Exception {
+		super.tearDown();
+	}
+
+    // ------------------------------------------------------------------------
+    // Constructor
+    // ------------------------------------------------------------------------
+
+	public void testBasicTmfExperiment() {
+		assertEquals("GetId", EXPERIMENT, fExperiment.getName());
+        assertEquals("GetEpoch", TmfTimestamp.Zero, fExperiment.getEpoch());
+        assertEquals("GetNbEvents", NB_EVENTS, fExperiment.getNbEvents());
+
+        TmfTimeRange timeRange = fExperiment.getTimeRange();
+        assertEquals("getStartTime", 1, timeRange.getStartTime().getValue());
+        assertEquals("getEndTime", NB_EVENTS, timeRange.getEndTime().getValue());
+	}
+
+    // ------------------------------------------------------------------------
+    // seek
+    // ------------------------------------------------------------------------
+
+    public void testSeekOnCacheBoundary() throws Exception {
+    	TmfExperimentContext context = fExperiment.seekLocation(null);
+
+    	context = fExperiment.seekEvent(new TmfTimestamp(1, SCALE, 0));
+    	TmfEvent event = fExperiment.getNextEvent(context);
+        assertEquals("Event timestamp", 1, event.getTimestamp().getValue());
+        assertEquals("Event rank", 1, context.getRank());
+
+    	context = fExperiment.seekEvent(new TmfTimestamp(1001, SCALE, 0));
+        event = fExperiment.getNextEvent(context);
+        assertEquals("Event timestamp", 1001, event.getTimestamp().getValue());
+        assertEquals("Event rank", 1001, context.getRank());
+
+    	context = fExperiment.seekEvent(new TmfTimestamp(4001, SCALE, 0));
+        event = fExperiment.getNextEvent(context);
+        assertEquals("Event timestamp", 4001, event.getTimestamp().getValue());
+        assertEquals("Event rank", 4001, context.getRank());
+    }
+
+    public void testSeekNotOnCacheBoundary() throws Exception {
+    	TmfExperimentContext context = fExperiment.seekLocation(null);
+
+    	context = fExperiment.seekEvent(new TmfTimestamp(10, SCALE, 0));
+    	TmfEvent event = fExperiment.getNextEvent(context);
+        assertEquals("Event timestamp", 10, event.getTimestamp().getValue());
+        assertEquals("Event rank", 10, context.getRank());
+
+    	context = fExperiment.seekEvent(new TmfTimestamp(999, SCALE, 0));
+        event = fExperiment.getNextEvent(context);
+        assertEquals("Event timestamp", 999, event.getTimestamp().getValue());
+        assertEquals("Event rank", 999, context.getRank());
+
+    	context = fExperiment.seekEvent(new TmfTimestamp(1001, SCALE, 0));
+        event = fExperiment.getNextEvent(context);
+        assertEquals("Event timestamp", 1001, event.getTimestamp().getValue());
+        assertEquals("Event rank", 1001, context.getRank());
+
+    	context = fExperiment.seekEvent(new TmfTimestamp(4499, SCALE, 0));
+        event = fExperiment.getNextEvent(context);
+        assertEquals("Event timestamp", 4499, event.getTimestamp().getValue());
+        assertEquals("Event rank", 4499, context.getRank());
+    }
+
+    public void testSeekForEventOutOfBounds() throws Exception {
+    	TmfExperimentContext context = fExperiment.seekLocation(null);
+
+    	// On lower bound, returns the first event (ts = 1)
+    	context = fExperiment.seekEvent(new TmfTimestamp(-1, SCALE, 0));
+        TmfEvent event = fExperiment.getNextEvent(context);
+        assertEquals("Event timestamp", 1, event.getTimestamp().getValue());
+
+        // On higher bound, returns null (no event)
+    	context = fExperiment.seekEvent(new TmfTimestamp(NB_EVENTS + 1, SCALE, 0));
+        event = fExperiment.getNextEvent(context);
+        assertEquals("Event timestamp", null, event);
+    }
+
+    public void testSeekOnIndex() throws Exception {
+    	TmfExperimentContext context = fExperiment.seekLocation(null);
+
+    	// On lower bound, returns the first event (ts = 1)
+    	context = fExperiment.seekEvent(0);
+        TmfEvent event = fExperiment.getNextEvent(context);
+        assertEquals("Event timestamp", 1, event.getTimestamp().getValue());
+
+        // On higher bound
+    	context = fExperiment.seekEvent(NB_EVENTS - 1);
+        event = fExperiment.getNextEvent(context);
+        assertEquals("Event timestamp", NB_EVENTS, event.getTimestamp().getValue());
+
+        // Above high bound
+    	context = fExperiment.seekEvent(NB_EVENTS);
+        event = fExperiment.getNextEvent(context);
+        assertEquals("Event", null, event);
+    }
+
+    // ------------------------------------------------------------------------
+    // processRequest
+    // ------------------------------------------------------------------------
+
+    public void testProcessRequestForNbEvents() throws Exception {
+        final int blockSize = 100;
+        final int nbEvents  = 1000;
+        final Vector<TmfEvent> requestedEvents = new Vector<TmfEvent>();
+
+        TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BigBang, TmfTimestamp.BigCrunch);
+        final TmfEventRequest<TmfEvent> request = new TmfEventRequest<TmfEvent>(TmfEvent.class, range, nbEvents, blockSize) {
+            @Override
+            public void handleData() {
+            	TmfEvent[] events = getData();
+                for (TmfEvent e : events) {
+                    requestedEvents.add(e);
+                }
+            }
+        };
+        fExperiment.sendRequest(request);
+        request.waitForCompletion();
+
+        assertEquals("nbEvents", nbEvents, requestedEvents.size());
+        assertTrue("isCompleted",  request.isCompleted());
+        assertFalse("isCancelled", request.isCancelled());
+
+        // Ensure that we have distinct events.
+        // Don't go overboard: we are not validating the stub! 
+        for (int i = 0; i < nbEvents; i++) {
+            assertEquals("Distinct events", i+1, requestedEvents.get(i).getTimestamp().getValue());
+        }
+    }
+    
+    public void testProcessRequestForNbEvents2() throws Exception {
+        final int blockSize = 2 * NB_EVENTS;
+        final int nbEvents = 1000;
+        final Vector<TmfEvent> requestedEvents = new Vector<TmfEvent>();
+
+        TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BigBang, TmfTimestamp.BigCrunch);
+        final TmfEventRequest<TmfEvent> request = new TmfEventRequest<TmfEvent>(TmfEvent.class, range, nbEvents, blockSize) {
+            @Override
+            public void handleData() {
+            	TmfEvent[] events = getData();
+                for (TmfEvent e : events) {
+                    requestedEvents.add(e);
+                }
+            }
+        };
+        fExperiment.sendRequest(request);
+        request.waitForCompletion();
+
+        assertEquals("nbEvents", nbEvents, requestedEvents.size());
+        assertTrue("isCompleted",  request.isCompleted());
+        assertFalse("isCancelled", request.isCancelled());
+
+        // Ensure that we have distinct events.
+        // Don't go overboard: we are not validating the stub! 
+        for (int i = 0; i < nbEvents; i++) {
+            assertEquals("Distinct events", i+1, requestedEvents.get(i).getTimestamp().getValue());
+        }
+    }
+    
+    public void testProcessRequestForAllEvents() throws Exception {
+        final int nbEvents  = TmfEventRequest.ALL_DATA;
+        final int blockSize =  1;
+        final Vector<TmfEvent> requestedEvents = new Vector<TmfEvent>();
+        long nbExpectedEvents = fExperiment.getNbEvents();
+
+        TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BigBang, TmfTimestamp.BigCrunch);
+        final TmfEventRequest<TmfEvent> request = new TmfEventRequest<TmfEvent>(TmfEvent.class, range, nbEvents, blockSize) {
+            @Override
+            public void handleData() {
+            	TmfEvent[] events = getData();
+                for (TmfEvent e : events) {
+                    requestedEvents.add(e);
+                }
+            }
+        };
+        fExperiment.sendRequest(request);
+        request.waitForCompletion();
+
+        assertEquals("nbEvents", nbExpectedEvents, 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 < nbExpectedEvents; i++) {
+            assertEquals("Distinct events", i+1, requestedEvents.get(i).getTimestamp().getValue());
+        }
+    }
+    
+    // ------------------------------------------------------------------------
+    // cancel
+    // ------------------------------------------------------------------------
+
+    public void testCancel() throws Exception {
+        final int nbEvents  = NB_EVENTS;
+        final int blockSize =  fDefaultBlockSize;
+        final Vector<TmfEvent> requestedEvents = new Vector<TmfEvent>();
+
+        TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BigBang, TmfTimestamp.BigCrunch);
+        final TmfEventRequest<TmfEvent> request = new TmfEventRequest<TmfEvent>(TmfEvent.class, range, nbEvents, blockSize) {
+            @Override
+            public void handleData() {
+            	TmfEvent[] events = getData();
+                for (TmfEvent e : events) {
+                    requestedEvents.add(e);
+                }
+                // Cancel request after the first chunk is received
+                cancel();
+            }
+        };
+        fExperiment.sendRequest(request);
+        request.waitForCompletion();
+
+        assertEquals("nbEvents",  blockSize, requestedEvents.size());
+        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)));
+    }
+
+    // ------------------------------------------------------------------------
+    // 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)));
+    }
+
+}
\ No newline at end of file
diff --git a/lttng/org.eclipse.linuxtools.tmf.tests/src/org/eclipse/linuxtools/tmf/tests/trace/TmfTraceTest.java b/lttng/org.eclipse.linuxtools.tmf.tests/src/org/eclipse/linuxtools/tmf/tests/trace/TmfTraceTest.java
index 14ffe0d5b9..075a9201fd 100644
--- a/lttng/org.eclipse.linuxtools.tmf.tests/src/org/eclipse/linuxtools/tmf/tests/trace/TmfTraceTest.java
+++ b/lttng/org.eclipse.linuxtools.tmf.tests/src/org/eclipse/linuxtools/tmf/tests/trace/TmfTraceTest.java
@@ -40,7 +40,7 @@ import org.eclipse.linuxtools.tmf.trace.TmfTraceStub;
 public class TmfTraceTest extends TestCase {
 
     private static final String DIRECTORY   = "testfiles";
-    private static final String TEST_STREAM = "M-Test-10K";
+    private static final String TEST_STREAM = "A-Test-10K";
     private static final int    NB_EVENTS   = 10000;
     private static TmfTraceStub fTrace      = null;
 
diff --git a/lttng/org.eclipse.linuxtools.tmf.tests/stubs/org/eclipse/linuxtools/tmf/CreateTestFiles.java b/lttng/org.eclipse.linuxtools.tmf.tests/stubs/org/eclipse/linuxtools/tmf/CreateTestFiles.java
index db6ea3a09b..d2d66abccb 100644
--- a/lttng/org.eclipse.linuxtools.tmf.tests/stubs/org/eclipse/linuxtools/tmf/CreateTestFiles.java
+++ b/lttng/org.eclipse.linuxtools.tmf.tests/stubs/org/eclipse/linuxtools/tmf/CreateTestFiles.java
@@ -39,8 +39,10 @@ public class CreateTestFiles {
     // ========================================================================
 
 	private static final String DIRECTORY = "testfiles";
-	private static final String FILE_NAMES[] = { "Test-10", "Test-1K", "Test-10K", "Test-100K" };
-    private static final int    FILE_SIZES[] = {       10 ,     1000 ,     10000 ,     100000  };
+//	private static final String FILE_NAMES[] = { "Test-10", "Test-1K", "Test-10K", "Test-100K" };
+//    private static final int    FILE_SIZES[] = {       10 ,     1000 ,     10000 ,     100000  };
+	private static final String FILE_NAMES[] = { "Test-10K" };
+    private static final int    FILE_SIZES[] = {     10000  };
 
     private static final int NB_SOURCES = 15;  
     private static final int NB_TYPES   =  7;  
@@ -62,8 +64,9 @@ public class CreateTestFiles {
 
         for (int i = 0; i < FILE_SIZES.length; i++) {
             try {
-            	createTestFile("testfiles" + File.separator + "M-" + FILE_NAMES[i], FILE_SIZES[i], true);
-                createTestFile("testfiles" + File.separator + "R-" + FILE_NAMES[i], FILE_SIZES[i], false);
+            	createTestFile("testfiles" + File.separator + "O-" + FILE_NAMES[i], FILE_SIZES[i], true,  true);
+            	createTestFile("testfiles" + File.separator + "E-" + FILE_NAMES[i], FILE_SIZES[i], true,  false);
+                createTestFile("testfiles" + File.separator + "R-" + FILE_NAMES[i], FILE_SIZES[i], false, false);
             } catch (Exception e) {
             }
         }
@@ -82,15 +85,15 @@ public class CreateTestFiles {
      * @throws FileNotFoundException
      * @throws IOException
      */
-    private static void createTestFile(String file, int size, boolean monotonic) throws FileNotFoundException, IOException {
+    private static void createTestFile(String file, int size, boolean monotonic, boolean odd) throws FileNotFoundException, IOException {
         DataOutputStream out;
         System.out.println("Creating " + file);
         out = new DataOutputStream(new BufferedOutputStream(new FileOutputStream(file)));
 
         Random generator = new Random(19580427 + size);
-        long ts = 0;
+        long ts = (monotonic && odd) ? -1 : 0;
         for (int i = 0; i < size; i++) {
-            ts += monotonic ? 1 : generator.nextInt(10);
+            ts += monotonic ? 2 : generator.nextInt(10);
             int sourceIndex = i % NB_SOURCES;
             int typeIndex   = i % NB_TYPES;
             out.writeLong(ts);                      // Timestamp
diff --git a/lttng/org.eclipse.linuxtools.tmf.tests/stubs/org/eclipse/linuxtools/tmf/component/TmfEventProviderStub.java b/lttng/org.eclipse.linuxtools.tmf.tests/stubs/org/eclipse/linuxtools/tmf/component/TmfEventProviderStub.java
index 676db78a10..1e3b080f55 100644
--- a/lttng/org.eclipse.linuxtools.tmf.tests/stubs/org/eclipse/linuxtools/tmf/component/TmfEventProviderStub.java
+++ b/lttng/org.eclipse.linuxtools.tmf.tests/stubs/org/eclipse/linuxtools/tmf/component/TmfEventProviderStub.java
@@ -35,7 +35,7 @@ import org.eclipse.linuxtools.tmf.trace.TmfTraceStub;
 public class TmfEventProviderStub extends TmfEventProvider<TmfEvent> {
 
     private static final String DIRECTORY   = "testfiles";
-    private static final String TEST_STREAM = "M-Test-10K";
+    private static final String TEST_STREAM = "A-Test-10K";
 
     private TmfTraceStub fTrace;
 
diff --git a/lttng/org.eclipse.linuxtools.tmf.tests/testfiles/M-Test-10K b/lttng/org.eclipse.linuxtools.tmf.tests/testfiles/M-Test-10K
deleted file mode 100644
index cfb674ae46..0000000000
--- a/lttng/org.eclipse.linuxtools.tmf.tests/testfiles/M-Test-10K
+++ /dev/null
diff --git a/lttng/org.eclipse.linuxtools.tmf.ui/src/org/eclipse/linuxtools/tmf/ui/views/TmfEventsView.java b/lttng/org.eclipse.linuxtools.tmf.ui/src/org/eclipse/linuxtools/tmf/ui/views/TmfEventsView.java
index 64565ce2df..3d38ad0422 100644
--- a/lttng/org.eclipse.linuxtools.tmf.ui/src/org/eclipse/linuxtools/tmf/ui/views/TmfEventsView.java
+++ b/lttng/org.eclipse.linuxtools.tmf.ui/src/org/eclipse/linuxtools/tmf/ui/views/TmfEventsView.java
@@ -167,7 +167,7 @@ public class TmfEventsView extends TmfView {
 						if ( (tmpEvent != null) && (tmpEvent.length > 0) ) {
 							cache = tmpEvent;
 							cacheStartIndex = index;
-							cacheEndIndex = index + cache.length;
+							cacheEndIndex = index + tmpEvent.length;
 						}
 					}
 				};
@@ -255,7 +255,7 @@ public class TmfEventsView extends TmfView {
         fTable.getDisplay().asyncExec(new Runnable() {
         	public void run() {
         		// TODO: Potentially long operation. Add some feedback for the user
-        		fTable.setSelection(0);
+       			fTable.setSelection(0);
             	fTable.clearAll();
 				cacheStartIndex = cacheEndIndex = 0;	// Clear the cache
             	fTable.setItemCount((int) fExperiment.getNbEvents());        
diff --git a/lttng/org.eclipse.linuxtools.tmf/src/org/eclipse/linuxtools/tmf/experiment/TmfExperiment.java b/lttng/org.eclipse.linuxtools.tmf/src/org/eclipse/linuxtools/tmf/experiment/TmfExperiment.java
index b809c1102a..432af9c7a5 100644
--- a/lttng/org.eclipse.linuxtools.tmf/src/org/eclipse/linuxtools/tmf/experiment/TmfExperiment.java
+++ b/lttng/org.eclipse.linuxtools.tmf/src/org/eclipse/linuxtools/tmf/experiment/TmfExperiment.java
@@ -170,13 +170,11 @@ public class TmfExperiment<T extends TmfEvent> extends TmfEventProvider<T> imple
      * Returns the rank of the first event with the requested timestamp.
      * If none, returns the index of the next event (if any).
      *  
-     * @param ts
+     * @param timestamp
      * @return
      */
-    public long getRank(TmfTimestamp ts) {
-        // FIXME: Go over all the traces
-    	ITmfTrace trace = fTraces[0];
-    	TmfContext context = trace.seekEvent(ts);
+    public long getRank(TmfTimestamp timestamp) {
+    	TmfExperimentContext context = seekEvent(timestamp);
     	return context.getRank();
     }
 
@@ -188,12 +186,9 @@ public class TmfExperiment<T extends TmfEvent> extends TmfEventProvider<T> imple
      * @return
      */
     public TmfTimestamp getTimestamp(int index) {
-        // FIXME: Go over all the traces
-    	ITmfTrace trace = fTraces[0];
-    	TmfContext context = trace.seekEvent(index);
-    	TmfEvent event = trace.getNextEvent(context);
-    	TmfTimestamp timestamp = (event != null) ? event.getTimestamp() : null;
-    	return timestamp;
+    	TmfExperimentContext context = seekEvent(index);
+    	TmfEvent event = parseEvent(context);
+    	return (event != null) ? event.getTimestamp() : null;
     }
 
     // ------------------------------------------------------------------------
@@ -276,7 +271,7 @@ public class TmfExperiment<T extends TmfEvent> extends TmfEventProvider<T> imple
 	// NOTE: This is a fine example of pathological coupling...
 	public TmfExperimentContext seekLocation(ITmfLocation<?> location) {
 		if (location instanceof TmfExperimentLocation || location == null) {
-			ITmfLocation<?>[] oldloc = (location != null) ? ((TmfExperimentLocation) location).getLocation() : new TmfExperimentLocation[fTraces.length];
+			ITmfLocation<?>[] prvloc = (location != null) ? ((TmfExperimentLocation) location).getLocation() : new TmfExperimentLocation[fTraces.length];
 			ITmfLocation<?>[] newloc = new ITmfLocation[fTraces.length];
 			TmfContext[] contexts = new TmfContext[fTraces.length];
 
@@ -285,7 +280,7 @@ public class TmfExperiment<T extends TmfEvent> extends TmfEventProvider<T> imple
 
 			long rank = 0;
 			for (int i = 0; i < fTraces.length; i++) {
-				contexts[i] = fTraces[i].seekLocation(oldloc[i]);
+				contexts[i] = fTraces[i].seekLocation(prvloc[i]);
 				newloc[i]   = contexts[i].getLocation();	// No clone here
 				events[i]   = fTraces[i].parseEvent(contexts[i]);
 				rank += contexts[i].getRank();
@@ -327,20 +322,17 @@ public class TmfExperiment<T extends TmfEvent> extends TmfEventProvider<T> imple
         	}
         }
 
-        TmfExperimentContext nextEventContext = seekLocation(location);
-        nextEventContext.setRank(index * fIndexPageSize);
-        TmfExperimentContext currentEventContext = new TmfExperimentContext(nextEventContext);
+        TmfExperimentContext context = seekLocation(location);
+        context.setRank(index * fIndexPageSize);
 
         // And get the event
-        TmfEvent event = getNextEvent(nextEventContext);
+        TmfEvent event = parseEvent(context);
         while (event != null && event.getTimestamp().compareTo(timestamp, false) < 0) {
-            currentEventContext = new TmfExperimentContext(nextEventContext);
-//        	currentEventContext.setLocation(nextEventContext.getLocation());
-//        	currentEventContext.updateRank(1);
-        	event = getNextEvent(nextEventContext);
+        	getNextEvent(context);
+        	event = parseEvent(context);
         }
 
-        return currentEventContext;
+        return context;
 	}
 
 	public TmfExperimentContext seekEvent(long rank) {
@@ -380,34 +372,56 @@ public class TmfExperiment<T extends TmfEvent> extends TmfEventProvider<T> imple
 	public synchronized TmfEvent getNextEvent(TmfContext context) {
 		if (context instanceof TmfExperimentContext) {
 			TmfExperimentContext expContext = (TmfExperimentContext) context;
-			int trace = 0;
+			int trace = -1;
 			TmfTimestamp timestamp = TmfTimestamp.BigCrunch;
-			if (expContext.getEvents()[trace] != null) {
-				timestamp = expContext.getEvents()[trace].getTimestamp();
-			}
-			for (int i = 1; i < expContext.getTraces().length; i++) {
-				if (expContext.getEvents()[i].getTimestamp() != null) {
-					TmfTimestamp otherTS = expContext.getEvents()[i].getTimestamp();
-					if (otherTS.compareTo(timestamp, true) < 0) {
-						trace = i;
-						timestamp = otherTS;
+			for (int i = 0; i < expContext.getTraces().length; i++) {
+				if (expContext.getEvents()[i] != null) {
+					if (expContext.getEvents()[i].getTimestamp() != null) {
+						TmfTimestamp otherTS = expContext.getEvents()[i].getTimestamp();
+						if (otherTS.compareTo(timestamp, true) < 0) {
+							trace = i;
+							timestamp = otherTS;
+						}
 					}
 				}
 			}
-			TmfContext trcloc = expContext.getContexts()[trace];
-			TmfEvent event = expContext.getTraces()[trace].parseEvent(trcloc);
-			TmfExperimentLocation exploc = (TmfExperimentLocation) expContext.getLocation();
-			exploc.getLocation()[trace] = trcloc.getLocation().clone();
-			expContext.updateRank(1);
-			expContext.getEvents()[trace] = expContext.getTraces()[trace].getNextEvent(trcloc);
-			return event;
+
+			if (trace >= 0) {
+				TmfContext trcloc = expContext.getContexts()[trace];
+				TmfEvent event = expContext.getTraces()[trace].getNextEvent(trcloc);
+				TmfExperimentLocation exploc = (TmfExperimentLocation) expContext.getLocation();
+				exploc.getLocation()[trace] = trcloc.getLocation().clone();
+				expContext.getEvents()[trace] = expContext.getTraces()[trace].parseEvent(trcloc);
+				expContext.updateRank(1);
+				return event;
+			}
 		}
     	return null;
 	}
 
 	public TmfEvent parseEvent(TmfContext context) {
-		// TODO Auto-generated method stub
-		return null;
+		if (context instanceof TmfExperimentContext) {
+			TmfExperimentContext expContext = (TmfExperimentContext) context;
+			int trace = -1;
+			TmfTimestamp timestamp = TmfTimestamp.BigCrunch;
+			for (int i = 0; i < expContext.getTraces().length; i++) {
+				if (expContext.getEvents()[i] != null) {
+					if (expContext.getEvents()[i].getTimestamp() != null) {
+						TmfTimestamp otherTS = expContext.getEvents()[i].getTimestamp();
+						if (otherTS.compareTo(timestamp, true) < 0) {
+							trace = i;
+							timestamp = otherTS;
+						}
+					}
+				}
+			}
+			if (trace >= 0) {
+				TmfContext trcloc = expContext.getContexts()[trace];
+				expContext.getEvents()[trace] = expContext.getTraces()[trace].parseEvent(trcloc);
+				return expContext.getEvents()[trace];
+			}
+		}
+    	return null;
 	}
 
 	/* (non-Javadoc)
@@ -507,7 +521,7 @@ public class TmfExperiment<T extends TmfEvent> extends TmfEventProvider<T> imple
             	TmfExperimentLocation location = (TmfExperimentLocation) context.getLocation();
 
                 // Get the first event
-               	TmfEvent event = getNextEvent(context);
+               	TmfEvent event = parseEvent(context);
                	if (event != null) {
                     startTime = new TmfTimestamp(event.getTimestamp());
                	}
@@ -535,7 +549,8 @@ public class TmfExperiment<T extends TmfEvent> extends TmfEventProvider<T> imple
                         location = (TmfExperimentLocation) context.getLocation();
            			}
 
-           			event = getNextEvent(context);
+           			getNextEvent(context);
+           			event = parseEvent(context);
                 }
 
             }
@@ -559,27 +574,27 @@ public class TmfExperiment<T extends TmfEvent> extends TmfEventProvider<T> imple
     	broadcast(new TmfRangeSynchSignal(this, range, null));
 	}
    
-	// ========================================================================
-	// Toubleshooting code
-	// ========================================================================
-
+//	// ========================================================================
+//	// Toubleshooting code
+//	// ========================================================================
+//
 //	private void dumpCheckpoints() {
 //		System.out.println("-----");
 //		System.out.println("Checkpoints of " + fExperimentId);
 //		for (int i = 0; i < fCheckpoints.size(); i++) {
 //        	System.out.println("Entry:" + i);
 //        	TmfCheckpoint checkpoint = fCheckpoints.get(i);
-//        	long rank = 0; 
+////        	long rank = 0; 
 //        	for (int j = 0; j < fTraces.length; j++) {
 //        		ITmfTrace trace = fTraces[j];
 //            	TmfExperimentContext context = seekLocation(checkpoint.getLocation());
 //            	TmfContext[] traces = context.getContexts();
-//        		rank += context.getRank(); 
+////        		rank += context.getRank(); 
 //            	TmfEvent event = fTraces[j].getNextEvent(new TmfContext(traces[j]));
 //            	System.out.println("  ["  + trace.getName() + "] rank: " + context.getRank() + ", timestamp: " + event.getTimestamp());
 //            	assert (checkpoint.getTimestamp().compareTo(event.getTimestamp(), false) == 0);
 //        	}
-//        	System.out.println("Sum of ranks: " + rank + " (expected: " + i * fIndexPageSize + ")");
+////        	System.out.println("Sum of ranks: " + rank + " (expected: " + i * fIndexPageSize + ")");
 //        }
 //	}