[Bug292967] Second part of request coalescing + unit tests + minor fixes.

37 files changed, 489 insertions, 1306 deletions

diff --git a/lttng/org.eclipse.linuxtools.lttng.tests/src/org/eclipse/linuxtools/lttng/tests/AllLTTngCoreTests.java b/lttng/org.eclipse.linuxtools.lttng.tests/src/org/eclipse/linuxtools/lttng/tests/AllLTTngCoreTests.java
index 09ab7ed5f0..a6b1f483e6 100644
--- a/lttng/org.eclipse.linuxtools.lttng.tests/src/org/eclipse/linuxtools/lttng/tests/AllLTTngCoreTests.java
+++ b/lttng/org.eclipse.linuxtools.lttng.tests/src/org/eclipse/linuxtools/lttng/tests/AllLTTngCoreTests.java
@@ -3,11 +3,6 @@ package org.eclipse.linuxtools.lttng.tests;
 import junit.framework.Test;
 import junit.framework.TestSuite;
 
-import org.eclipse.linuxtools.lttng.control.LTTngSyntheticEventProviderTest;
-import org.eclipse.linuxtools.lttng.control.LTTngSyntheticEventProviderTextTest;
-import org.eclipse.linuxtools.lttng.model.LTTngTreeNodeTest;
-import org.eclipse.linuxtools.lttng.state.experiment.StateExperimentManagerTextTest;
-import org.eclipse.linuxtools.lttng.state.resource.LTTngStateResourceTest;
 import org.eclipse.linuxtools.lttng.tests.event.LttngEventContentTest;
 import org.eclipse.linuxtools.lttng.tests.event.LttngEventFieldTest;
 import org.eclipse.linuxtools.lttng.tests.event.LttngEventReferenceTest;
@@ -44,12 +39,6 @@ public class AllLTTngCoreTests {
         
         suite.addTestSuite(LTTngTextTraceTest.class);
         suite.addTestSuite(LTTngTraceTest.class);
-
-		suite.addTestSuite(LTTngSyntheticEventProviderTest.class);
-		suite.addTestSuite(LTTngSyntheticEventProviderTextTest.class);
-		suite.addTestSuite(LTTngTreeNodeTest.class);
-		suite.addTestSuite(StateExperimentManagerTextTest.class);
-		suite.addTestSuite(LTTngStateResourceTest.class);
 		//$JUnit-END$
 		return suite;
 	}
diff --git a/lttng/org.eclipse.linuxtools.lttng.ui/src/org/eclipse/linuxtools/lttng/ui/views/project/ProjectView.java b/lttng/org.eclipse.linuxtools.lttng.ui/src/org/eclipse/linuxtools/lttng/ui/views/project/ProjectView.java
index bf4bb190e3..6b02df6c4f 100644
--- a/lttng/org.eclipse.linuxtools.lttng.ui/src/org/eclipse/linuxtools/lttng/ui/views/project/ProjectView.java
+++ b/lttng/org.eclipse.linuxtools.lttng.ui/src/org/eclipse/linuxtools/lttng/ui/views/project/ProjectView.java
@@ -178,7 +178,7 @@ public class ProjectView extends TmfView {
         	}
             fSelectedExperiment = new TmfExperiment<LttngEvent>(LttngEvent.class, expId, traces);
             fSelectedExperiment.indexExperiment(waitForCompletion);
-            broadcast(new TmfExperimentSelectedSignal(this, fSelectedExperiment));
+            broadcast(new TmfExperimentSelectedSignal<LttngEvent>(this, fSelectedExperiment));
         } catch (FileNotFoundException e) {
             return;
         } catch (Exception e) {
diff --git a/lttng/org.eclipse.linuxtools.lttng.ui/src/org/eclipse/linuxtools/lttng/ui/views/statistics/StatisticsView.java b/lttng/org.eclipse.linuxtools.lttng.ui/src/org/eclipse/linuxtools/lttng/ui/views/statistics/StatisticsView.java
index 08b6246050..146bd49336 100644
--- a/lttng/org.eclipse.linuxtools.lttng.ui/src/org/eclipse/linuxtools/lttng/ui/views/statistics/StatisticsView.java
+++ b/lttng/org.eclipse.linuxtools.lttng.ui/src/org/eclipse/linuxtools/lttng/ui/views/statistics/StatisticsView.java
@@ -321,7 +321,11 @@ public class StatisticsView extends TmfView implements IStateDataRequestListener
 	}
 
 	public StatisticsView(String viewName) {
-		super("StatisticsView");
+		super(viewName);
+	}
+
+	public StatisticsView() {
+		this("StatisticsView");
 	}
 
 	/*
diff --git a/lttng/org.eclipse.linuxtools.lttng.ui/src/org/eclipse/linuxtools/lttng/ui/views/timeframe/TimeFrameView.java b/lttng/org.eclipse.linuxtools.lttng.ui/src/org/eclipse/linuxtools/lttng/ui/views/timeframe/TimeFrameView.java
index 9b203ee549..b43fd91b41 100644
--- a/lttng/org.eclipse.linuxtools.lttng.ui/src/org/eclipse/linuxtools/lttng/ui/views/timeframe/TimeFrameView.java
+++ b/lttng/org.eclipse.linuxtools.lttng.ui/src/org/eclipse/linuxtools/lttng/ui/views/timeframe/TimeFrameView.java
@@ -257,7 +257,7 @@ public class TimeFrameView extends TmfView {
      * @param signal
      */
     @TmfSignalHandler
-    public void experimentSelected(TmfExperimentSelectedSignal signal) {
+    public void experimentSelected(TmfExperimentSelectedSignal<LttngEvent> signal) {
 
         // Update the trace reference
         fExperiment = (TmfExperiment<LttngEvent>) signal.getExperiment();
diff --git a/lttng/org.eclipse.linuxtools.lttng/src/org/eclipse/linuxtools/lttng/state/StateDataRequest.java b/lttng/org.eclipse.linuxtools.lttng/src/org/eclipse/linuxtools/lttng/state/StateDataRequest.java
index 558433db23..6a97e05bb6 100644
--- a/lttng/org.eclipse.linuxtools.lttng/src/org/eclipse/linuxtools/lttng/state/StateDataRequest.java
+++ b/lttng/org.eclipse.linuxtools.lttng/src/org/eclipse/linuxtools/lttng/state/StateDataRequest.java
@@ -89,8 +89,7 @@ public class StateDataRequest extends TmfEventRequest<LttngEvent> {
 	 * @param broadcast
 	 *            true: All views, false: only to registered listeners
 	 */
-	public void startRequestInd(TmfExperiment<LttngEvent> experiment, boolean broadcast,
-			boolean waitForCompletion) {
+	public void startRequestInd(TmfExperiment<LttngEvent> experiment, boolean broadcast) {
 		if (broadcast) {
 			// Notify all state views.
 			this.broadcast = broadcast;
@@ -103,7 +102,7 @@ public class StateDataRequest extends TmfEventRequest<LttngEvent> {
 		}
 
 		// trigger the start to process this request
-		experiment.processRequest(this, waitForCompletion);
+		experiment.sendRequest(this);
 	}
 
 	/**
@@ -187,4 +186,8 @@ public class StateDataRequest extends TmfEventRequest<LttngEvent> {
 	public boolean isclearDataInd() {
 		return clearDataInd;
 	}
+
+	@Override
+	public void handleData() {
+	}
 }
\ No newline at end of file
diff --git a/lttng/org.eclipse.linuxtools.lttng/src/org/eclipse/linuxtools/lttng/state/StateManager.java b/lttng/org.eclipse.linuxtools.lttng/src/org/eclipse/linuxtools/lttng/state/StateManager.java
index bb2c94de6c..b4ef5a2b0b 100644
--- a/lttng/org.eclipse.linuxtools.lttng/src/org/eclipse/linuxtools/lttng/state/StateManager.java
+++ b/lttng/org.eclipse.linuxtools.lttng/src/org/eclipse/linuxtools/lttng/state/StateManager.java
@@ -118,9 +118,9 @@ public class StateManager extends Observable {
 			boolean clearPreviousData) {
 		// New log in use, read all events and build state transition stack
 		if (experiment != null) {
-			if (fExperiment != null && fExperiment != experiment) {
-				this.fExperiment.deregister();
-			}
+//			if (fExperiment != null && fExperiment != experiment) {
+//				this.fExperiment.deregister();
+//			}
 
 			this.fExperiment = experiment;
 
@@ -146,8 +146,7 @@ public class StateManager extends Observable {
 					null);
 			request.setclearDataInd(clearPreviousData);
 
-			// Wait for completion
-			request.startRequestInd(fExperiment, true, true);
+			request.startRequestInd(fExperiment, true);
 
 			if (TraceDebug.isDEBUG()) {
 				StringBuilder sb = new StringBuilder(
@@ -192,7 +191,7 @@ public class StateManager extends Observable {
 		// Process request to that point
 		StateDataRequest request = getDataRequestByTimeRange(trange, listener);
 		// don't wait for completion i.e. allow cancellations
-		request.startRequestInd(fExperiment, false, false);
+		request.startRequestInd(fExperiment, false);
 
 		if (TraceDebug.isDEBUG()) {
 			TraceDebug
diff --git a/lttng/org.eclipse.linuxtools.lttng/src/org/eclipse/linuxtools/lttng/state/experiment/StateExperimentManager.java b/lttng/org.eclipse.linuxtools.lttng/src/org/eclipse/linuxtools/lttng/state/experiment/StateExperimentManager.java
index f3faf3a053..e6c5415b06 100644
--- a/lttng/org.eclipse.linuxtools.lttng/src/org/eclipse/linuxtools/lttng/state/experiment/StateExperimentManager.java
+++ b/lttng/org.eclipse.linuxtools.lttng/src/org/eclipse/linuxtools/lttng/state/experiment/StateExperimentManager.java
@@ -113,7 +113,7 @@ public class StateExperimentManager extends TmfComponent {
 	 */
 	@SuppressWarnings("unchecked")
 	@TmfSignalHandler
-	public void experimentSelected(TmfExperimentSelectedSignal signal) {
+	public void experimentSelected(TmfExperimentSelectedSignal<LttngEvent> signal) {
 		// TmfExperiment experiment = signal.getExperiment();
 		// ITmfTrace[] traces = experiment.getTraces();
 		// for (ITmfTrace trace : traces) {
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 d6f4d82cf0..46a1147d9e 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
@@ -1,36 +1,49 @@
-/*******************************************************************************
- * 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;
 
 import junit.framework.Test;
 import junit.framework.TestSuite;
 
-/**
- * <b><u>AllTmfCoreTests</u></b>
- * <p>
- * Master test suite for TMF Core.
- */
+import org.eclipse.linuxtools.tmf.tests.component.TmfEventProviderTest;
+import org.eclipse.linuxtools.tmf.tests.component.TmfProviderManagerTest;
+import org.eclipse.linuxtools.tmf.tests.event.TmfEventContentTest;
+import org.eclipse.linuxtools.tmf.tests.event.TmfEventFieldTest;
+import org.eclipse.linuxtools.tmf.tests.event.TmfEventReferenceTest;
+import org.eclipse.linuxtools.tmf.tests.event.TmfEventSourceTest;
+import org.eclipse.linuxtools.tmf.tests.event.TmfEventTest;
+import org.eclipse.linuxtools.tmf.tests.event.TmfEventTypeTest;
+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.TmfDataRequestTest;
+import org.eclipse.linuxtools.tmf.tests.request.TmfEventRequestTest;
+import org.eclipse.linuxtools.tmf.tests.trace.TmfExperimentTest;
+import org.eclipse.linuxtools.tmf.tests.trace.TmfTraceTest;
+
 public class AllTmfCoreTests {
 
 	public static Test suite() {
 		TestSuite suite = new TestSuite(AllTmfCoreTests.class.getName());
 		//$JUnit-BEGIN$
-		suite.addTestSuite(TmfCorePluginTest.class);
-		suite.addTest(org.eclipse.linuxtools.tmf.tests.event.AllTests.suite());
-		suite.addTest(org.eclipse.linuxtools.tmf.tests.request.AllTests.suite());
-		suite.addTest(org.eclipse.linuxtools.tmf.tests.component.AllTests.suite());
-		suite.addTest(org.eclipse.linuxtools.tmf.tests.trace.AllTests.suite());
-		suite.addTest(org.eclipse.linuxtools.tmf.tests.experiment.AllTests.suite());
+		suite.addTestSuite(TmfEventProviderTest.class);
+		suite.addTestSuite(TmfProviderManagerTest.class);
+
+		suite.addTestSuite(TmfEventFieldTest.class);
+		suite.addTestSuite(TmfEventContentTest.class);
+		suite.addTestSuite(TmfEventTypeTest.class);
+		suite.addTestSuite(TmfEventSourceTest.class);
+		suite.addTestSuite(TmfTraceEventTest.class);
+		suite.addTestSuite(TmfEventReferenceTest.class);
+		suite.addTestSuite(TmfTimestampTest.class);
+		suite.addTestSuite(TmfTimeRangeTest.class);
+		suite.addTestSuite(TmfEventTest.class);
+
+		suite.addTestSuite(TmfDataRequestTest.class);
+		suite.addTestSuite(TmfEventRequestTest.class);
+		suite.addTestSuite(TmfCoalescedDataRequestTest.class);
+
+		suite.addTestSuite(TmfTraceTest.class);
+		suite.addTestSuite(TmfExperimentTest.class);
 		//$JUnit-END$
 		return suite;
 	}
diff --git a/lttng/org.eclipse.linuxtools.tmf.tests/src/org/eclipse/linuxtools/tmf/tests/component/AllTests.java b/lttng/org.eclipse.linuxtools.tmf.tests/src/org/eclipse/linuxtools/tmf/tests/component/AllTests.java
index 78a0532399..411ae21f3f 100644
--- a/lttng/org.eclipse.linuxtools.tmf.tests/src/org/eclipse/linuxtools/tmf/tests/component/AllTests.java
+++ b/lttng/org.eclipse.linuxtools.tmf.tests/src/org/eclipse/linuxtools/tmf/tests/component/AllTests.java
@@ -8,8 +8,8 @@ public class AllTests {
 	public static Test suite() {
 		TestSuite suite = new TestSuite(AllTests.class.getName());
 		//$JUnit-BEGIN$
-		suite.addTestSuite(TmfProviderManagerTest.class);
 		suite.addTestSuite(TmfEventProviderTest.class);
+		suite.addTestSuite(TmfProviderManagerTest.class);
 		//$JUnit-END$
 		return suite;
 	}
diff --git a/lttng/org.eclipse.linuxtools.tmf.tests/src/org/eclipse/linuxtools/tmf/tests/component/TmfClientTest.java b/lttng/org.eclipse.linuxtools.tmf.tests/src/org/eclipse/linuxtools/tmf/tests/component/TmfClientTest.java
deleted file mode 100644
index a50052ee0f..0000000000
--- a/lttng/org.eclipse.linuxtools.tmf.tests/src/org/eclipse/linuxtools/tmf/tests/component/TmfClientTest.java
+++ /dev/null
@@ -1,193 +0,0 @@
-/*******************************************************************************
- * 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.component;
-
-import java.io.IOException;
-import java.util.Vector;
-
-import junit.framework.TestCase;
-
-import org.eclipse.linuxtools.tmf.component.TmfDataProvider;
-import org.eclipse.linuxtools.tmf.component.TmfEventProviderStub;
-import org.eclipse.linuxtools.tmf.component.TmfProviderManager;
-import org.eclipse.linuxtools.tmf.component.TmfSyntheticEventProviderStub;
-import org.eclipse.linuxtools.tmf.event.TmfEvent;
-import org.eclipse.linuxtools.tmf.event.TmfSyntheticEventStub;
-import org.eclipse.linuxtools.tmf.event.TmfTimeRange;
-import org.eclipse.linuxtools.tmf.event.TmfTimestamp;
-import org.eclipse.linuxtools.tmf.request.TmfEventRequest;
-import org.eclipse.linuxtools.tmf.trace.TmfTraceStub;
-
-/**
- * <b><u>TmfClientTest</u></b>
- * <p>
- * TODO: Implement me. Please.
- */
-public class TmfClientTest extends TestCase {
-
-	TmfEventProviderStub fEventProvider;
-	TmfSyntheticEventProviderStub fSyntheticEventProvider;
-
-	public TmfClientTest(String name) throws IOException {
-		super(name);
-	}
-
-	@Override
-	protected void setUp() throws Exception {
-		super.setUp();
-		fEventProvider = new TmfEventProviderStub();
-		fSyntheticEventProvider = new TmfSyntheticEventProviderStub();
-	}
-
-	@Override
-	protected void tearDown() throws Exception {
-		super.tearDown();
-		fEventProvider.deregister();
-		fSyntheticEventProvider.deregister();
-	}
-
-	// ------------------------------------------------------------------------
-	// getProviders (more a sanity check than a test)
-	// ------------------------------------------------------------------------
-
-	@SuppressWarnings("unchecked")
-	public void testGetProviders() {
-
-		// There should be 2 TmfEvent providers: a TmfTraceStub and a TmfEventProviderStub
-		TmfDataProvider<TmfEvent>[] eventProviders = (TmfDataProvider<TmfEvent>[]) TmfProviderManager.getProviders(TmfEvent.class);
-		assertTrue(eventProviders.length == 2);
-
-		eventProviders = (TmfDataProvider<TmfEvent>[]) TmfProviderManager.getProviders(TmfEvent.class, TmfTraceStub.class);
-		assertTrue(eventProviders.length == 1);
-
-		eventProviders = (TmfDataProvider<TmfEvent>[]) TmfProviderManager.getProviders(TmfEvent.class, TmfEventProviderStub.class);
-		assertTrue(eventProviders.length == 1);
-
-		// There should be 1 TmfSyntheticEventStub provider
-		eventProviders = (TmfDataProvider<TmfEvent>[]) TmfProviderManager.getProviders(TmfSyntheticEventStub.class);
-		assertTrue(eventProviders.length == 1);
-	}
-
-	// ------------------------------------------------------------------------
-	// getSyntheticEvent
-	// ------------------------------------------------------------------------
-
-	@SuppressWarnings("unchecked")
-	public void testGetPlainEvents() {
-
-        final int BLOCK_SIZE = 100;
-        final int NB_EVENTS  = 1000;
-        final Vector<TmfEvent> requestedEvents = new Vector<TmfEvent>();
-
-        // Get the TmfSyntheticEventStub provider
-		TmfDataProvider<TmfEvent>[] eventProviders = (TmfDataProvider<TmfEvent>[]) TmfProviderManager.getProviders(TmfEvent.class, TmfEventProviderStub.class);
-		TmfDataProvider<TmfEvent> provider = eventProviders[0];
-
-        TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BigBang, TmfTimestamp.BigCrunch);
-        final TmfEventRequest<TmfEvent> request =
-        	new TmfEventRequest<TmfEvent>(TmfEvent.class, range, NB_EVENTS, BLOCK_SIZE) {
-            	@Override
-            	public void handleData() {
-            		TmfEvent[] events = getData();
-            		for (TmfEvent e : events) {
-            			requestedEvents.add(e);
-            		}
-            	}
-        	};
-        provider.processRequest(request, true);
-
-        assertEquals("nbEvents", NB_EVENTS, requestedEvents.size());
-        assertTrue("isCompleted",  request.isCompleted());
-        assertFalse("isCancelled", request.isCancelled());
-
-        // Make that we have distinct events.
-        // Don't go overboard: we are not validating the stub! 
-        for (int i = 0; i < NB_EVENTS; i++) {
-            assertEquals("Distinct events", i+1, requestedEvents.get(i).getTimestamp().getValue());
-        }
-	}
-
-	@SuppressWarnings("unchecked")
-	private void getSyntheticData(final TmfTimeRange range, final int nbEvents, final int blockSize) {
-
-        final Vector<TmfSyntheticEventStub> requestedEvents = new Vector<TmfSyntheticEventStub>();
-
-        // Get the event provider
-		TmfDataProvider<TmfSyntheticEventStub>[] eventProviders = (TmfDataProvider<TmfSyntheticEventStub>[]) TmfProviderManager.getProviders(TmfSyntheticEventStub.class);
-		TmfDataProvider<TmfSyntheticEventStub> provider = eventProviders[0];
-
-        final TmfEventRequest<TmfSyntheticEventStub> request =
-        	new TmfEventRequest<TmfSyntheticEventStub>(TmfSyntheticEventStub.class, range, nbEvents, blockSize) {
-            	@Override
-            	public void handleData() {
-            		TmfSyntheticEventStub[] events = getData();
-            		for (TmfSyntheticEventStub e : events) {
-            			requestedEvents.add(e);
-            		}
-            	}
-        	};
-        provider.processRequest(request, true);
-
-        if (nbEvents != -1)
-        	assertEquals("nbEvents", nbEvents, requestedEvents.size());
-        assertTrue("isCompleted", request.isCompleted());
-        assertFalse("isCancelled", request.isCancelled());
-
-        // For each base event, the stub will queue 2 identical synthetic events
-        // Ensure that the events are queued properly.
-        // Don't go overboard: we are not validating the stub!
-        for (int i = 0; i < (nbEvents / 2); i++) {
-            assertEquals("Distinct events", i+1, requestedEvents.get(2 * i + 0).getTimestamp().getValue());
-            assertEquals("Distinct events", i+1, requestedEvents.get(2 * i + 1).getTimestamp().getValue());
-        }
-	}
-
-	// The following tests are the same but for the size of the requested blocks
-	// with regards to the size of the TmfSyntheticEventProviderStub block
-    public void testGetSyntheticEvents_EqualBlockSizes() {
-        TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BigBang, TmfTimestamp.BigCrunch);
-		getSyntheticData(range, 1000, TmfSyntheticEventProviderStub.BLOCK_SIZE);
-	}
-
-	public void testGetSyntheticEvents_SmallerBlock() {
-        TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BigBang, TmfTimestamp.BigCrunch);
-		getSyntheticData(range, 1000, TmfSyntheticEventProviderStub.BLOCK_SIZE / 2);
-	}
-
-	public void testGetSyntheticEvents_LargerBlock() {
-        TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BigBang, TmfTimestamp.BigCrunch);
-		getSyntheticData(range, 1000, TmfSyntheticEventProviderStub.BLOCK_SIZE * 2);
-	}
-
-	public void testGetSyntheticEvents_TimeRange() {
-		TmfTimestamp start = new TmfTimestamp(   1, (byte) -3, 0);
-		TmfTimestamp end   = new TmfTimestamp(1000, (byte) -3, 0);
-        TmfTimeRange range = new TmfTimeRange(start, end);
-		getSyntheticData(range, -1, TmfSyntheticEventProviderStub.BLOCK_SIZE);
-	}
-
-	public void testGetSyntheticEvents_WeirdTimeRange1() {
-		TmfTimestamp start = TmfTimestamp.BigBang;
-		TmfTimestamp end   = new TmfTimestamp(0, (byte) -3, 0);
-        TmfTimeRange range = new TmfTimeRange(start, end);
-		getSyntheticData(range, -1, TmfSyntheticEventProviderStub.BLOCK_SIZE);
-	}
-
-	public void testGetSyntheticEvents_WeirdTimeRange2() {
-		TmfTimestamp start = new TmfTimestamp(0, (byte) -3, 0);
-		TmfTimestamp end   = TmfTimestamp.BigCrunch;
-        TmfTimeRange range = new TmfTimeRange(start, end);
-		getSyntheticData(range, -1, TmfSyntheticEventProviderStub.BLOCK_SIZE);
-	}
-
-}
diff --git a/lttng/org.eclipse.linuxtools.tmf.tests/src/org/eclipse/linuxtools/tmf/tests/component/TmfEventProviderTest.java b/lttng/org.eclipse.linuxtools.tmf.tests/src/org/eclipse/linuxtools/tmf/tests/component/TmfEventProviderTest.java
index 5acb7ae46a..6cec0d0382 100644
--- a/lttng/org.eclipse.linuxtools.tmf.tests/src/org/eclipse/linuxtools/tmf/tests/component/TmfEventProviderTest.java
+++ b/lttng/org.eclipse.linuxtools.tmf.tests/src/org/eclipse/linuxtools/tmf/tests/component/TmfEventProviderTest.java
@@ -31,7 +31,7 @@ import org.eclipse.linuxtools.tmf.trace.TmfTraceStub;
 /**
  * <b><u>TmfClientTest</u></b>
  * <p>
- * Test suite for the TmfEventProvider class.
+ * TODO: Implement me. Please.
  */
 public class TmfEventProviderTest extends TestCase {
 
@@ -52,8 +52,8 @@ public class TmfEventProviderTest extends TestCase {
 	@Override
 	protected void tearDown() throws Exception {
 		super.tearDown();
-		fEventProvider.dispose();
-		fSyntheticEventProvider.dispose();
+		fEventProvider.deregister();
+		fSyntheticEventProvider.deregister();
 	}
 
 	// ------------------------------------------------------------------------
@@ -65,17 +65,17 @@ public class TmfEventProviderTest extends TestCase {
 
 		// There should be 2 TmfEvent providers: a TmfTraceStub and a TmfEventProviderStub
 		ITmfDataProvider<TmfEvent>[] eventProviders = (ITmfDataProvider<TmfEvent>[]) TmfProviderManager.getProviders(TmfEvent.class);
-		assertEquals("getProviders", 2, eventProviders.length);
+		assertTrue(eventProviders.length == 2);
 
 		eventProviders = (ITmfDataProvider<TmfEvent>[]) TmfProviderManager.getProviders(TmfEvent.class, TmfTraceStub.class);
-		assertEquals("getProviders", 1, eventProviders.length);
+		assertTrue(eventProviders.length == 1);
 
 		eventProviders = (ITmfDataProvider<TmfEvent>[]) TmfProviderManager.getProviders(TmfEvent.class, TmfEventProviderStub.class);
-		assertEquals("getProviders", 1, eventProviders.length);
+		assertTrue(eventProviders.length == 1);
 
 		// There should be 1 TmfSyntheticEventStub provider
 		eventProviders = (ITmfDataProvider<TmfEvent>[]) TmfProviderManager.getProviders(TmfSyntheticEventStub.class);
-		assertEquals("getProviders", 1, eventProviders.length);
+		assertTrue(eventProviders.length == 1);
 	}
 
 	// ------------------------------------------------------------------------
@@ -83,7 +83,7 @@ public class TmfEventProviderTest extends TestCase {
 	// ------------------------------------------------------------------------
 
 	@SuppressWarnings("unchecked")
-	public void testGetPlainEvents() throws InterruptedException {
+	public void testGetPlainEvents() {
 
         final int BLOCK_SIZE = 100;
         final int NB_EVENTS  = 1000;
@@ -119,7 +119,7 @@ public class TmfEventProviderTest extends TestCase {
 	}
 
 	@SuppressWarnings("unchecked")
-	private void getSyntheticData(final TmfTimeRange range, final int nbEvents, final int blockSize) throws InterruptedException {
+	private void getSyntheticData(final TmfTimeRange range, final int nbEvents, final int blockSize) {
 
         final Vector<TmfSyntheticEventStub> requestedEvents = new Vector<TmfSyntheticEventStub>();
 
@@ -156,36 +156,36 @@ public class TmfEventProviderTest extends TestCase {
 
 	// The following tests are the same but for the size of the requested blocks
 	// with regards to the size of the TmfSyntheticEventProviderStub block
-    public void testGetSyntheticEvents_EqualBlockSizes() throws InterruptedException {
+    public void testGetSyntheticEvents_EqualBlockSizes() {
         TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BigBang, TmfTimestamp.BigCrunch);
 		getSyntheticData(range, 1000, TmfSyntheticEventProviderStub.BLOCK_SIZE);
 	}
 
-	public void testGetSyntheticEvents_SmallerBlock() throws InterruptedException {
+	public void testGetSyntheticEvents_SmallerBlock() {
         TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BigBang, TmfTimestamp.BigCrunch);
 		getSyntheticData(range, 1000, TmfSyntheticEventProviderStub.BLOCK_SIZE / 2);
 	}
 
-	public void testGetSyntheticEvents_LargerBlock() throws InterruptedException {
+	public void testGetSyntheticEvents_LargerBlock() {
         TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BigBang, TmfTimestamp.BigCrunch);
 		getSyntheticData(range, 1000, TmfSyntheticEventProviderStub.BLOCK_SIZE * 2);
 	}
 
-	public void testGetSyntheticEvents_TimeRange() throws InterruptedException {
+	public void testGetSyntheticEvents_TimeRange() {
 		TmfTimestamp start = new TmfTimestamp(   1, (byte) -3, 0);
 		TmfTimestamp end   = new TmfTimestamp(1000, (byte) -3, 0);
         TmfTimeRange range = new TmfTimeRange(start, end);
 		getSyntheticData(range, -1, TmfSyntheticEventProviderStub.BLOCK_SIZE);
 	}
 
-	public void testGetSyntheticEvents_WeirdTimeRange1() throws InterruptedException {
+	public void testGetSyntheticEvents_WeirdTimeRange1() {
 		TmfTimestamp start = TmfTimestamp.BigBang;
 		TmfTimestamp end   = new TmfTimestamp(0, (byte) -3, 0);
         TmfTimeRange range = new TmfTimeRange(start, end);
 		getSyntheticData(range, -1, TmfSyntheticEventProviderStub.BLOCK_SIZE);
 	}
 
-	public void testGetSyntheticEvents_WeirdTimeRange2() throws InterruptedException {
+	public void testGetSyntheticEvents_WeirdTimeRange2() {
 		TmfTimestamp start = new TmfTimestamp(0, (byte) -3, 0);
 		TmfTimestamp end   = TmfTimestamp.BigCrunch;
         TmfTimeRange range = new TmfTimeRange(start, end);
@@ -201,17 +201,17 @@ public class TmfEventProviderTest extends TestCase {
 
 		// There should be 2 TmfEvent providers: a TmfTraceStub and a TmfEventProviderStub
 		ITmfDataProvider<TmfEvent>[] eventProviders = (ITmfDataProvider<TmfEvent>[]) TmfProviderManager.getProviders(TmfEvent.class);
-		assertEquals("getProviders", 2, eventProviders.length);
+		assertTrue(eventProviders.length == 2);
 
 		eventProviders = (ITmfDataProvider<TmfEvent>[]) TmfProviderManager.getProviders(TmfEvent.class, TmfTraceStub.class);
-		assertEquals("getProviders", 1, eventProviders.length);
+		assertTrue(eventProviders.length == 1);
 
 		eventProviders = (ITmfDataProvider<TmfEvent>[]) TmfProviderManager.getProviders(TmfEvent.class, TmfEventProviderStub.class);
-		assertEquals("getProviders", 1, eventProviders.length);
+		assertTrue(eventProviders.length == 1);
 
 		// There should be 1 TmfSyntheticEventStub provider
 		eventProviders = (ITmfDataProvider<TmfEvent>[]) TmfProviderManager.getProviders(TmfSyntheticEventStub.class);
-		assertEquals("getProviders", 1, eventProviders.length);
+		assertTrue(eventProviders.length == 1);
 	}
 
 }
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 c00b5d51bf..8962239db5 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
@@ -12,6 +12,7 @@ public class AllTests {
 		//$JUnit-BEGIN$
 		suite.addTestSuite(TmfDataRequestTest.class);
 		suite.addTestSuite(TmfEventRequestTest.class);
+		suite.addTestSuite(TmfCoalescedDataRequestTest.class);
 		//$JUnit-END$
 		return suite;
 	}
diff --git a/lttng/org.eclipse.linuxtools.tmf.tests/src/org/eclipse/linuxtools/tmf/tests/request/TmfCoalescedDataRequestTest.java b/lttng/org.eclipse.linuxtools.tmf.tests/src/org/eclipse/linuxtools/tmf/tests/request/TmfCoalescedDataRequestTest.java
index 3187347c12..6cc5c15e02 100644
--- a/lttng/org.eclipse.linuxtools.tmf.tests/src/org/eclipse/linuxtools/tmf/tests/request/TmfCoalescedDataRequestTest.java
+++ b/lttng/org.eclipse.linuxtools.tmf.tests/src/org/eclipse/linuxtools/tmf/tests/request/TmfCoalescedDataRequestTest.java
@@ -16,10 +16,6 @@ package org.eclipse.linuxtools.tmf.tests.request;
 import junit.framework.TestCase;
 
 import org.eclipse.linuxtools.tmf.event.TmfEvent;
-import org.eclipse.linuxtools.tmf.event.TmfEventReference;
-import org.eclipse.linuxtools.tmf.event.TmfEventSource;
-import org.eclipse.linuxtools.tmf.event.TmfEventType;
-import org.eclipse.linuxtools.tmf.event.TmfTimestamp;
 import org.eclipse.linuxtools.tmf.request.TmfCoalescedDataRequest;
 import org.eclipse.linuxtools.tmf.request.TmfDataRequest;
 import org.eclipse.linuxtools.tmf.request.TmfDataRequestStub;
@@ -27,25 +23,11 @@ import org.eclipse.linuxtools.tmf.request.TmfDataRequestStub;
 /**
  * <b><u>TmfCoalescedDataRequestTest</u></b>
  * <p>
- * Test suite for the TmfCoalescedDataRequest class.
+ * TODO: Implement me. Please.
  */
 public class TmfCoalescedDataRequestTest extends TestCase {
 
 	// ------------------------------------------------------------------------
-	// Variables
-	// ------------------------------------------------------------------------
-
-	private static TmfCoalescedDataRequest<TmfEvent> fRequest1;
-	private static TmfCoalescedDataRequest<TmfEvent> fRequest2;
-	private static TmfCoalescedDataRequest<TmfEvent> fRequest3;
-	private static TmfCoalescedDataRequest<TmfEvent> fRequest4;
-
-	private static TmfCoalescedDataRequest<TmfEvent> fRequest1b;
-	private static TmfCoalescedDataRequest<TmfEvent> fRequest1c;
-
-	private static int fRequestCount;
-	
-	// ------------------------------------------------------------------------
 	// Housekeeping
 	// ------------------------------------------------------------------------
 
@@ -55,51 +37,12 @@ public class TmfCoalescedDataRequestTest extends TestCase {
 
 	@Override
 	public void setUp() throws Exception {
-		super.setUp();
-		TmfDataRequest.reset();
-		fRequest1  = new TmfCoalescedDataRequest<TmfEvent>(TmfEvent.class, 10, 100, 200);
-		fRequest2  = new TmfCoalescedDataRequest<TmfEvent>(TmfEvent.class, 20, 100, 200);
-		fRequest3  = new TmfCoalescedDataRequest<TmfEvent>(TmfEvent.class, 20, 200, 200);
-		fRequest4  = new TmfCoalescedDataRequest<TmfEvent>(TmfEvent.class, 20, 200, 300);
-
-		fRequest1b = new TmfCoalescedDataRequest<TmfEvent>(TmfEvent.class, 10, 100, 200);
-		fRequest1c = new TmfCoalescedDataRequest<TmfEvent>(TmfEvent.class, 10, 100, 200);
-
-		fRequestCount = fRequest1c.getRequestId() + 1;
 	}
 
 	@Override
 	public void tearDown() throws Exception {
-		super.tearDown();
 	}
 
-	private TmfCoalescedDataRequest<TmfEvent> setupTestRequest(final boolean[] flags) {
-		
-		TmfCoalescedDataRequest<TmfEvent> request = new TmfCoalescedDataRequest<TmfEvent>(TmfEvent.class, 10, 100, 200) {
-		    @Override
-			public void handleCompleted() {
-		    	super.handleCompleted();
-		    	flags[0] = true;
-		    }
-		    @Override
-		    public void handleSuccess() {
-		    	super.handleSuccess();
-		    	flags[1] = true;
-		    }
-		    @Override
-		    public void handleFailure() {
-		    	super.handleFailure();
-		    	flags[2] = true;
-		    }
-		    @Override
-		    public void handleCancel() {
-		    	super.handleCancel();
-		    	flags[3] = true;
-		    }
-		};
-		return request;
-	}
-	
 	// ------------------------------------------------------------------------
 	// Constructors
 	// ------------------------------------------------------------------------
@@ -107,128 +50,33 @@ public class TmfCoalescedDataRequestTest extends TestCase {
 	public void testTmfCoalescedDataRequest() {
 		TmfCoalescedDataRequest<TmfEvent> request = new TmfCoalescedDataRequest<TmfEvent>(TmfEvent.class);
 
-        assertEquals("getRequestId", fRequestCount++, request.getRequestId());
-        assertEquals("getDataType",  TmfEvent.class, request.getDataType());
-
-        assertEquals("getIndex", 0, request.getIndex());
+        assertEquals("getIndex",             0, request.getIndex());
         assertEquals("getNbRequestedEvents", TmfDataRequest.ALL_DATA, request.getNbRequested());
         assertEquals("getBlockize", TmfDataRequest.DEFAULT_BLOCK_SIZE, request.getBlockize());
-
-        assertFalse("isCompleted", request.isCompleted());
-        assertFalse("isFailed", request.isFailed());
-        assertFalse("isCancelled", request.isCancelled());
-
-        assertEquals("getNbRead", 0, request.getNbRead());
 	}
 
 	public void testTmfCoalescedDataRequestIndex() {
 		TmfCoalescedDataRequest<TmfEvent> request = new TmfCoalescedDataRequest<TmfEvent>(TmfEvent.class, 10);
 
-        assertEquals("getRequestId", fRequestCount++, request.getRequestId());
-        assertEquals("getDataType",  TmfEvent.class, request.getDataType());
-
-        assertEquals("getIndex", 10, request.getIndex());
+        assertEquals("getIndex",             10, request.getIndex());
         assertEquals("getNbRequestedEvents", TmfDataRequest.ALL_DATA, request.getNbRequested());
         assertEquals("getBlockize", TmfDataRequest.DEFAULT_BLOCK_SIZE, request.getBlockize());
-
-        assertFalse("isCompleted", request.isCompleted());
-        assertFalse("isFailed", request.isFailed());
-        assertFalse("isCancelled", request.isCancelled());
-
-        assertEquals("getNbRead", 0, request.getNbRead());
 	}
 
 	public void testTmfCoalescedDataRequestIndexNbRequested() {
 		TmfCoalescedDataRequest<TmfEvent> request = new TmfCoalescedDataRequest<TmfEvent>(TmfEvent.class, 10, 100);
 
-        assertEquals("getRequestId", fRequestCount++, request.getRequestId());
-        assertEquals("getDataType",  TmfEvent.class, request.getDataType());
-
-        assertEquals("getIndex", 10, request.getIndex());
+        assertEquals("getIndex",              10, request.getIndex());
         assertEquals("getNbRequestedEvents", 100, request.getNbRequested());
         assertEquals("getBlockize", TmfDataRequest.DEFAULT_BLOCK_SIZE, request.getBlockize());
-
-        assertFalse("isCompleted", request.isCompleted());
-        assertFalse("isFailed", request.isFailed());
-        assertFalse("isCancelled", request.isCancelled());
-
-        assertEquals("getNbRead", 0, request.getNbRead());
 	}
 
 	public void testTmfCoalescedDataRequestIndexNbEventsBlocksize() {
 		TmfCoalescedDataRequest<TmfEvent> request = new TmfCoalescedDataRequest<TmfEvent>(TmfEvent.class, 10, 100, 200);
 
-        assertEquals("getRequestId", fRequestCount++, request.getRequestId());
-        assertEquals("getDataType",  TmfEvent.class, request.getDataType());
-
-        assertEquals("getIndex", 10, request.getIndex());
+        assertEquals("getIndex",              10, request.getIndex());
         assertEquals("getNbRequestedEvents", 100, request.getNbRequested());
-        assertEquals("getBlockize", 200, request.getBlockize());
-
-        assertFalse("isCompleted", request.isCompleted());
-        assertFalse("isFailed", request.isFailed());
-        assertFalse("isCancelled", request.isCancelled());
-
-        assertEquals("getNbRead", 0, request.getNbRead());
-	}
-
-	// ------------------------------------------------------------------------
-	// equals
-	// ------------------------------------------------------------------------
-
-	public void testEqualsReflexivity() throws Exception {
-        assertTrue("equals", fRequest1.equals(fRequest1));
-        assertTrue("equals", fRequest2.equals(fRequest2));
-
-        assertFalse("equals", fRequest1.equals(fRequest2));
-        assertFalse("equals", fRequest2.equals(fRequest1));
-	}
-
-	public void testEqualsSymmetry() throws Exception {
-        assertTrue("equals", fRequest1.equals(fRequest1b));
-        assertTrue("equals", fRequest1b.equals(fRequest1));
-
-        assertFalse("equals", fRequest1.equals(fRequest3));
-        assertFalse("equals", fRequest2.equals(fRequest3));
-        assertFalse("equals", fRequest3.equals(fRequest1));
-        assertFalse("equals", fRequest3.equals(fRequest2));
-	}
-	
-	public void testEqualsTransivity() throws Exception {
-        assertTrue("equals", fRequest1.equals(fRequest1b));
-        assertTrue("equals", fRequest1b.equals(fRequest1c));
-        assertTrue("equals", fRequest1.equals(fRequest1c));
-	}
-	
-	public void testEqualsNull() throws Exception {
-        assertFalse("equals", fRequest1.equals(null));
-        assertFalse("equals", fRequest2.equals(null));
-	}
-
-	// ------------------------------------------------------------------------
-	// hashCode
-	// ------------------------------------------------------------------------
-
-	public void testHashCode() throws Exception {
-        assertTrue("hashCode", fRequest1.hashCode() == fRequest1.hashCode());
-        assertTrue("hashCode", fRequest2.hashCode() == fRequest2.hashCode());
-		assertTrue("hashCode", fRequest1.hashCode() != fRequest2.hashCode());
-	}
-	
-	// ------------------------------------------------------------------------
-	// toString
-	// ------------------------------------------------------------------------
-
-	public void testToString() {
-        String expected1 = "[TmfCoalescedDataRequest(0,TmfEvent,10,100,200)]";
-        String expected2 = "[TmfCoalescedDataRequest(1,TmfEvent,20,100,200)]";
-        String expected3 = "[TmfCoalescedDataRequest(2,TmfEvent,20,200,200)]";
-        String expected4 = "[TmfCoalescedDataRequest(3,TmfEvent,20,200,300)]";
-
-        assertEquals("toString", expected1, fRequest1.toString());
-        assertEquals("toString", expected2, fRequest2.toString());
-        assertEquals("toString", expected3, fRequest3.toString());
-        assertEquals("toString", expected4, fRequest4.toString());
+        assertEquals("getBlockize",          200, request.getBlockize());
 	}
 
 	// ------------------------------------------------------------------------
@@ -248,165 +96,4 @@ public class TmfCoalescedDataRequestTest extends TestCase {
         assertFalse("isCompatible", coalescedRequest.isCompatible(request4));
 	}
 
-	// ------------------------------------------------------------------------
-	// setData/getData
-	// ------------------------------------------------------------------------
-
-	public void testSetData() {
-
-		TmfCoalescedDataRequest<TmfEvent> coalescedRequest = new TmfCoalescedDataRequest<TmfEvent>(TmfEvent.class, 10, 100, 200);
-		TmfDataRequest<TmfEvent> request1 = new TmfDataRequestStub<TmfEvent>(TmfEvent.class, 10, 100, 200);
-		TmfDataRequest<TmfEvent> request2 = new TmfDataRequestStub<TmfEvent>(TmfEvent.class, 10, 100, 200);
-		coalescedRequest.addRequest(request1);
-		coalescedRequest.addRequest(request2);
-
-		// Initialize the data
-		int nbEvents = 10;
-		TmfEvent[] events = new TmfEvent[nbEvents];
-		for (int i = 0; i < nbEvents; i++) {
-			events[i] = new TmfEvent(new TmfTimestamp(i), new TmfEventSource(),
-					new TmfEventType(), new TmfEventReference());
-		}
-
-		coalescedRequest.setData(events);
-		coalescedRequest.handleData();
-
-		// Validate the coalescing request
-		assertEquals("setData", nbEvents, coalescedRequest.getNbRead());
-		TmfEvent[] eventsRead1 = coalescedRequest.getData();
-		assertEquals("getData", nbEvents, eventsRead1.length);
-		for (int i = 0; i < nbEvents; i++) {
-			assertEquals("getData", i, eventsRead1[i].getTimestamp().getValue());
-		}
-
-		// Validate the first coalesced request
-		assertEquals("setData", nbEvents, request1.getNbRead());
-		TmfEvent[] eventsRead2 = request1.getData();
-		assertEquals("getData", nbEvents, eventsRead2.length);
-		for (int i = 0; i < nbEvents; i++) {
-			assertEquals("getData", i, eventsRead2[i].getTimestamp().getValue());
-		}
-
-		// Validate the second coalesced request
-		assertEquals("setData", nbEvents, request2.getNbRead());
-		TmfEvent[] eventsRead3 = request2.getData();
-		assertEquals("getData", nbEvents, eventsRead3.length);
-		for (int i = 0; i < nbEvents; i++) {
-			assertEquals("getData", i, eventsRead3[i].getTimestamp().getValue());
-		}
-	}
-
-	// ------------------------------------------------------------------------
-	// done
-	// ------------------------------------------------------------------------
-
-	public void testDone() {
-		
-		// Test request
-		final boolean[] crFlags = new boolean[4];
-		TmfCoalescedDataRequest<TmfEvent> request = setupTestRequest(crFlags);
-		TmfDataRequest<TmfEvent> subRequest1 = new TmfDataRequestStub<TmfEvent>(TmfEvent.class, 10, 100, 200);
-		TmfDataRequest<TmfEvent> subRequest2 = new TmfDataRequestStub<TmfEvent>(TmfEvent.class, 10, 100, 200);
-		request.addRequest(subRequest1);
-		request.addRequest(subRequest2);
-
-		request.done();
-
-		// Validate the coalescing request
-		assertTrue ("isCompleted", request.isCompleted());
-		assertFalse("isFailed",    request.isFailed());
-		assertFalse("isCancelled", request.isCancelled());
-
-		assertTrue ("handleCompleted", crFlags[0]);
-		assertTrue ("handleSuccess",   crFlags[1]);
-		assertFalse("handleFailure",   crFlags[2]);
-		assertFalse("handleCancel",    crFlags[3]);
-
-		// Validate the first coalesced request
-		assertTrue ("isCompleted", subRequest1.isCompleted());
-		assertFalse("isFailed",    subRequest1.isFailed());
-		assertFalse("isCancelled", subRequest1.isCancelled());
-
-		// Validate the second coalesced request
-		assertTrue ("isCompleted", subRequest2.isCompleted());
-		assertFalse("isFailed",    subRequest2.isFailed());
-		assertFalse("isCancelled", subRequest2.isCancelled());
-	}
-
-	// ------------------------------------------------------------------------
-	// fail
-	// ------------------------------------------------------------------------
-
-	public void testFail() {
-		
-		final boolean[] crFlags = new boolean[4];
-		TmfCoalescedDataRequest<TmfEvent> request = setupTestRequest(crFlags);
-		TmfDataRequest<TmfEvent> subRequest1 = new TmfDataRequestStub<TmfEvent>(TmfEvent.class, 10, 100, 200);
-		TmfDataRequest<TmfEvent> subRequest2 = new TmfDataRequestStub<TmfEvent>(TmfEvent.class, 10, 100, 200);
-		request.addRequest(subRequest1);
-		request.addRequest(subRequest2);
-
-		request.fail();
-
-		// Validate the coalescing request
-		assertTrue ("isCompleted", request.isCompleted());
-		assertTrue ("isFailed",    request.isFailed());
-		assertFalse("isCancelled", request.isCancelled());
-
-		assertTrue ("handleCompleted", crFlags[0]);
-		assertFalse("handleSuccess",   crFlags[1]);
-		assertTrue ("handleFailure",   crFlags[2]);
-		assertFalse("handleCancel",    crFlags[3]);
-
-		// Validate the first coalesced request
-		assertTrue ("isCompleted", subRequest1.isCompleted());
-		assertTrue ("isFailed",    subRequest1.isFailed());
-		assertFalse("isCancelled", subRequest1.isCancelled());
-
-		// Validate the second coalesced request
-		assertTrue ("isCompleted", subRequest2.isCompleted());
-		assertTrue ("isFailed",    subRequest2.isFailed());
-		assertFalse("isCancelled", subRequest2.isCancelled());
-	}
-
-	// ------------------------------------------------------------------------
-	// cancel
-	// ------------------------------------------------------------------------
-
-	public void testCancel() {
-
-		final boolean[] crFlags = new boolean[4];
-		TmfCoalescedDataRequest<TmfEvent> request = setupTestRequest(crFlags);
-		TmfDataRequest<TmfEvent> subRequest1 = new TmfDataRequestStub<TmfEvent>(TmfEvent.class, 10, 100, 200);
-		TmfDataRequest<TmfEvent> subRequest2 = new TmfDataRequestStub<TmfEvent>(TmfEvent.class, 10, 100, 200);
-		request.addRequest(subRequest1);
-		request.addRequest(subRequest2);
-
-		request.cancel();
-
-		// Validate the coalescing request
-		assertTrue ("isCompleted", request.isCompleted());
-		assertFalse("isFailed",    request.isFailed());
-		assertTrue ("isCancelled", request.isCancelled());
-
-		assertTrue ("handleCompleted", crFlags[0]);
-		assertFalse("handleSuccess",   crFlags[1]);
-		assertFalse("handleFailure",   crFlags[2]);
-		assertTrue ("handleCancel",    crFlags[3]);
-
-		// Validate the first coalesced request
-		assertTrue ("isCompleted", subRequest1.isCompleted());
-		assertFalse("isFailed",    subRequest1.isFailed());
-		assertTrue ("isCancelled", subRequest1.isCancelled());
-
-		// Validate the second coalesced request
-		assertTrue ("isCompleted", subRequest2.isCompleted());
-		assertFalse("isFailed",    subRequest2.isFailed());
-		assertTrue ("isCancelled", subRequest2.isCancelled());
-	}
-
-	// ------------------------------------------------------------------------
-	// waitForCompletion
-	// ------------------------------------------------------------------------
-
 }
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 0b0bd714dd..645f67acf8 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
@@ -25,15 +25,10 @@ import org.eclipse.core.runtime.Path;
 import org.eclipse.linuxtools.tmf.component.ITmfDataProvider;
 import org.eclipse.linuxtools.tmf.component.TmfProviderManager;
 import org.eclipse.linuxtools.tmf.event.TmfEvent;
-import org.eclipse.linuxtools.tmf.event.TmfEventReference;
-import org.eclipse.linuxtools.tmf.event.TmfEventSource;
-import org.eclipse.linuxtools.tmf.event.TmfEventType;
 import org.eclipse.linuxtools.tmf.event.TmfTimeRange;
 import org.eclipse.linuxtools.tmf.event.TmfTimestamp;
-import org.eclipse.linuxtools.tmf.request.TmfCoalescedDataRequest;
 import org.eclipse.linuxtools.tmf.request.TmfCoalescedEventRequest;
 import org.eclipse.linuxtools.tmf.request.TmfDataRequest;
-import org.eclipse.linuxtools.tmf.request.TmfDataRequestStub;
 import org.eclipse.linuxtools.tmf.request.TmfEventRequest;
 import org.eclipse.linuxtools.tmf.request.TmfEventRequestStub;
 import org.eclipse.linuxtools.tmf.signal.TmfSignal;
@@ -45,28 +40,34 @@ import org.eclipse.linuxtools.tmf.trace.TmfTraceStub;
 /**
  * <b><u>TmfCoalescedEventRequestTest</u></b>
  * <p>
- * Test suite for the TmfCoalescedEventRequest class.
+ * TODO: Implement me. Please.
  */
 public class TmfCoalescedEventRequestTest extends TestCase {
 
-	// ------------------------------------------------------------------------
-	// Variables
-	// ------------------------------------------------------------------------
+    private static final String DIRECTORY   = "testfiles";
+    private static final String TEST_STREAM = "M-Test-10K";
+    private static final int    NB_EVENTS   = 10000;
+    private static final int    BLOCK_SIZE  = 100;
 
-	private static TmfTimeRange range1 = new TmfTimeRange(TmfTimeRange.Eternity);
-	private static TmfTimeRange range2 = new TmfTimeRange(new TmfTimestamp(), TmfTimestamp.BigCrunch);
-	
-	private static TmfCoalescedEventRequest<TmfEvent> fRequest1;
-	private static TmfCoalescedEventRequest<TmfEvent> fRequest2;
-	private static TmfCoalescedEventRequest<TmfEvent> fRequest3;
-	private static TmfCoalescedEventRequest<TmfEvent> fRequest4;
+    private static TmfTraceStub fTrace      = null;
 
-	private static TmfCoalescedEventRequest<TmfEvent> fRequest1b;
-	private static TmfCoalescedEventRequest<TmfEvent> fRequest1c;
+    private TmfTraceStub setupTrace(String path) {
+    	if (fTrace == null) {
+    		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(), 500, true);
+    	        fTrace = trace;
+    		} catch (URISyntaxException e) {
+    			e.printStackTrace();
+    		} catch (IOException e) {
+    			e.printStackTrace();
+    		}
+    	}
+    	return fTrace;
+    }
 
-	private static int fRequestCount;
-	
-	// ------------------------------------------------------------------------
+    // ------------------------------------------------------------------------
 	// Housekeeping
 	// ------------------------------------------------------------------------
 
@@ -77,16 +78,6 @@ public class TmfCoalescedEventRequestTest extends TestCase {
 	@Override
 	public void setUp() throws Exception {
 		super.setUp();
-		TmfEventRequest.reset();
-		fRequest1  = new TmfCoalescedEventRequest<TmfEvent>(TmfEvent.class, range1, 100, 200);
-		fRequest2  = new TmfCoalescedEventRequest<TmfEvent>(TmfEvent.class, range2, 100, 200);
-		fRequest3  = new TmfCoalescedEventRequest<TmfEvent>(TmfEvent.class, range2, 200, 200);
-		fRequest4  = new TmfCoalescedEventRequest<TmfEvent>(TmfEvent.class, range2, 200, 300);
-
-		fRequest1b = new TmfCoalescedEventRequest<TmfEvent>(TmfEvent.class, range1, 100, 200);
-		fRequest1c = new TmfCoalescedEventRequest<TmfEvent>(TmfEvent.class, range1, 100, 200);
-
-		fRequestCount = fRequest1c.getRequestId() + 1;
 	}
 
 	@Override
@@ -94,176 +85,55 @@ public class TmfCoalescedEventRequestTest extends TestCase {
 		super.tearDown();
 	}
 
-	private TmfCoalescedEventRequest<TmfEvent> setupTestRequest(final boolean[] flags) {
-		
-		TmfCoalescedEventRequest<TmfEvent> request = new TmfCoalescedEventRequest<TmfEvent>(TmfEvent.class, range1, 100, 200) {
-		    @Override
-			public void handleCompleted() {
-		    	super.handleCompleted();
-		    	flags[0] = true;
-		    }
-		    @Override
-		    public void handleSuccess() {
-		    	super.handleSuccess();
-		    	flags[1] = true;
-		    }
-		    @Override
-		    public void handleFailure() {
-		    	super.handleFailure();
-		    	flags[2] = true;
-		    }
-		    @Override
-		    public void handleCancel() {
-		    	super.handleCancel();
-		    	flags[3] = true;
-		    }
-		};
-		return request;
-	}
-	
 	// ------------------------------------------------------------------------
 	// Constructors
 	// ------------------------------------------------------------------------
 
 	public void testTmfCoalescedEventRequest() {
-		TmfCoalescedEventRequest<TmfEvent> request = new TmfCoalescedEventRequest<TmfEvent>(TmfEvent.class);
-
-        assertEquals("getRequestId", fRequestCount++, request.getRequestId());
-        assertEquals("getDataType",  TmfEvent.class, request.getDataType());
+        TmfCoalescedEventRequest<TmfEvent> request = new TmfCoalescedEventRequest<TmfEvent>(TmfEvent.class);
 
-        assertEquals("getRange", range1, request.getRange());
-        assertEquals("getNbRequestedEvents", TmfEventRequest.ALL_DATA, request.getNbRequested());
-        assertEquals("getBlockize", TmfEventRequest.DEFAULT_BLOCK_SIZE, request.getBlockize());
+        assertEquals("StartTime", TmfTimestamp.BigBang,   request.getRange().getStartTime());
+        assertEquals("EndTime",   TmfTimestamp.BigCrunch, request.getRange().getEndTime());
 
-        assertFalse("isCompleted", request.isCompleted());
-        assertFalse("isFailed", request.isFailed());
-        assertFalse("isCancelled", request.isCancelled());
-
-        assertEquals("getNbRead", 0, request.getNbRead());
+        assertEquals("getIndex",             0, request.getIndex());
+        assertEquals("getNbRequestedEvents", TmfDataRequest.ALL_DATA, request.getNbRequested());
+        assertEquals("getBlockize", TmfDataRequest.DEFAULT_BLOCK_SIZE, request.getBlockize());
 	}
 
-	public void testTmfCoalescedEventRequestIndex() {
-		TmfCoalescedEventRequest<TmfEvent> request = new TmfCoalescedEventRequest<TmfEvent>(TmfEvent.class, range1);
-
-        assertEquals("getRequestId", fRequestCount++, request.getRequestId());
-        assertEquals("getDataType",  TmfEvent.class, request.getDataType());
+	public void testTmfCoalescedEventRequestTimeRange() {
+        TmfTimeRange range = new TmfTimeRange(new TmfTimestamp(), TmfTimestamp.BigCrunch);
+        TmfCoalescedEventRequest<TmfEvent> request = new TmfCoalescedEventRequest<TmfEvent>(TmfEvent.class, range);
 
-        assertEquals("getRange", range1, request.getRange());
-        assertEquals("getNbRequestedEvents", TmfEventRequest.ALL_DATA, request.getNbRequested());
-        assertEquals("getBlockize", TmfEventRequest.DEFAULT_BLOCK_SIZE, request.getBlockize());
+        assertEquals("StartTime", range.getStartTime(), request.getRange().getStartTime());
+        assertEquals("EndTime",   range.getEndTime(),   request.getRange().getEndTime());
 
-        assertFalse("isCompleted", request.isCompleted());
-        assertFalse("isFailed", request.isFailed());
-        assertFalse("isCancelled", request.isCancelled());
-
-        assertEquals("getNbRead", 0, request.getNbRead());
+        assertEquals("getIndex",             0, request.getIndex());
+        assertEquals("getNbRequestedEvents", TmfDataRequest.ALL_DATA, request.getNbRequested());
+        assertEquals("getBlockize", TmfDataRequest.DEFAULT_BLOCK_SIZE, request.getBlockize());
 	}
 
-	public void testTmfCoalescedEventRequestIndexNbRequested() {
-		TmfCoalescedEventRequest<TmfEvent> request = new TmfCoalescedEventRequest<TmfEvent>(TmfEvent.class, range1, 100);
+	public void testTmfCoalescedEventRequestTimeRangeNbRequested() {
+        TmfTimeRange range = new TmfTimeRange(new TmfTimestamp(), TmfTimestamp.BigCrunch);
+        TmfCoalescedEventRequest<TmfEvent> request = new TmfCoalescedEventRequest<TmfEvent>(TmfEvent.class, range, 100);
 
-        assertEquals("getRequestId", fRequestCount++, request.getRequestId());
-        assertEquals("getDataType",  TmfEvent.class, request.getDataType());
+        assertEquals("StartTime", range.getStartTime(), request.getRange().getStartTime());
+        assertEquals("EndTime",   range.getEndTime(),   request.getRange().getEndTime());
 
-        assertEquals("getRange", range1, request.getRange());
+        assertEquals("getIndex",               0, request.getIndex());
         assertEquals("getNbRequestedEvents", 100, request.getNbRequested());
-        assertEquals("getBlockize", TmfEventRequest.DEFAULT_BLOCK_SIZE, request.getBlockize());
-
-        assertFalse("isCompleted", request.isCompleted());
-        assertFalse("isFailed", request.isFailed());
-        assertFalse("isCancelled", request.isCancelled());
-
-        assertEquals("getNbRead", 0, request.getNbRead());
+        assertEquals("getBlockize", TmfDataRequest.DEFAULT_BLOCK_SIZE, request.getBlockize());
 	}
 
-	public void testTmfCoalescedEventRequestIndexNbEventsBlocksize() {
-		TmfCoalescedEventRequest<TmfEvent> request = new TmfCoalescedEventRequest<TmfEvent>(TmfEvent.class, range1, 100, 200);
+	public void testTmfCoalescedEventRequestTimeRangeNbRequestedBlocksize() {
+        TmfTimeRange range = new TmfTimeRange(new TmfTimestamp(), TmfTimestamp.BigCrunch);
+        TmfCoalescedEventRequest<TmfEvent> request = new TmfCoalescedEventRequest<TmfEvent>(TmfEvent.class, range, 100, 200);
 
-        assertEquals("getRequestId", fRequestCount++, request.getRequestId());
-        assertEquals("getDataType",  TmfEvent.class, request.getDataType());
+        assertEquals("StartTime", range.getStartTime(), request.getRange().getStartTime());
+        assertEquals("EndTime",   range.getEndTime(),   request.getRange().getEndTime());
 
-        assertEquals("getRange", range1, request.getRange());
+        assertEquals("getIndex",               0, request.getIndex());
         assertEquals("getNbRequestedEvents", 100, request.getNbRequested());
-        assertEquals("getBlockize", 200, request.getBlockize());
-
-        assertFalse("isCompleted", request.isCompleted());
-        assertFalse("isFailed", request.isFailed());
-        assertFalse("isCancelled", request.isCancelled());
-
-        assertEquals("getNbRead", 0, request.getNbRead());
-	}
-
-	// ------------------------------------------------------------------------
-	// equals
-	// ------------------------------------------------------------------------
-
-	public void testEqualsReflexivity() throws Exception {
-        assertTrue("equals", fRequest1.equals(fRequest1));
-        assertTrue("equals", fRequest2.equals(fRequest2));
-
-        assertFalse("equals", fRequest1.equals(fRequest2));
-        assertFalse("equals", fRequest2.equals(fRequest1));
-	}
-
-	public void testEqualsSymmetry() throws Exception {
-        assertTrue("equals", fRequest1.equals(fRequest1b));
-        assertTrue("equals", fRequest1b.equals(fRequest1));
-
-        assertFalse("equals", fRequest1.equals(fRequest3));
-        assertFalse("equals", fRequest2.equals(fRequest3));
-        assertFalse("equals", fRequest3.equals(fRequest1));
-        assertFalse("equals", fRequest3.equals(fRequest2));
-	}
-	
-	public void testEqualsTransivity() throws Exception {
-        assertTrue("equals", fRequest1.equals(fRequest1b));
-        assertTrue("equals", fRequest1b.equals(fRequest1c));
-        assertTrue("equals", fRequest1.equals(fRequest1c));
-	}
-	
-	public void testEqualsNull() throws Exception {
-        assertFalse("equals", fRequest1.equals(null));
-        assertFalse("equals", fRequest2.equals(null));
-	}
-
-	public void testEqualsSuper() throws Exception {
-		TmfCoalescedDataRequest<TmfEvent> dataRequest1 = new TmfCoalescedDataRequest<TmfEvent>(
-			fRequest1.getDataType(), fRequest1.getIndex(), fRequest1.getNbRequested(), fRequest1.getBlockize());
-		TmfCoalescedDataRequest<TmfEvent> dataRequest2 = new TmfCoalescedDataRequest<TmfEvent>(
-			fRequest1.getDataType(), fRequest1.getIndex(), fRequest1.getNbRequested(), fRequest1.getBlockize());
-		TmfCoalescedDataRequest<TmfEvent> dataRequest3 = new TmfCoalescedDataRequest<TmfEvent>(
-			fRequest3.getDataType(), fRequest3.getIndex(), fRequest3.getNbRequested(), fRequest3.getBlockize());
-
-		assertTrue("equals", fRequest1.equals(dataRequest2));
-        assertTrue("equals", fRequest2.equals(dataRequest1));
-        assertFalse("equals", fRequest1.equals(dataRequest3));
-        assertFalse("equals", fRequest3.equals(dataRequest1));
-	}
-
-	// ------------------------------------------------------------------------
-	// hashCode
-	// ------------------------------------------------------------------------
-
-	public void testHashCode() throws Exception {
-        assertTrue("hashCode", fRequest1.hashCode() == fRequest1.hashCode());
-        assertTrue("hashCode", fRequest2.hashCode() == fRequest2.hashCode());
-		assertTrue("hashCode", fRequest1.hashCode() != fRequest2.hashCode());
-	}
-	
-	// ------------------------------------------------------------------------
-	// toString
-	// ------------------------------------------------------------------------
-
-	public void testToString() {
-        String expected1 = "[TmfCoalescedEventRequest(0,TmfEvent," + range1 + ",100,200)]";
-        String expected2 = "[TmfCoalescedEventRequest(1,TmfEvent," + range2 + ",100,200)]";
-        String expected3 = "[TmfCoalescedEventRequest(2,TmfEvent," + range2 + ",200,200)]";
-        String expected4 = "[TmfCoalescedEventRequest(3,TmfEvent," + range2 + ",200,300)]";
-
-        assertEquals("toString", expected1, fRequest1.toString());
-        assertEquals("toString", expected2, fRequest2.toString());
-        assertEquals("toString", expected3, fRequest3.toString());
-        assertEquals("toString", expected4, fRequest4.toString());
+        assertEquals("getBlockize",          200, request.getBlockize());
 	}
 
 	// ------------------------------------------------------------------------
@@ -271,207 +141,26 @@ public class TmfCoalescedEventRequestTest extends TestCase {
 	// ------------------------------------------------------------------------
 
 	public void testIsCompatible() {
-		TmfCoalescedEventRequest<TmfEvent> coalescedRequest = new TmfCoalescedEventRequest<TmfEvent>(TmfEvent.class, range1, 100, 200);
-		TmfEventRequest<TmfEvent> request1 = new TmfEventRequestStub<TmfEvent>(TmfEvent.class, range1, 100, 200);
-		TmfEventRequest<TmfEvent> request2 = new TmfEventRequestStub<TmfEvent>(TmfEvent.class, range2, 100, 200);
-		TmfEventRequest<TmfEvent> request3 = new TmfEventRequestStub<TmfEvent>(TmfEvent.class, range1, 101, 200);
-		TmfEventRequest<TmfEvent> request4 = new TmfEventRequestStub<TmfEvent>(TmfEvent.class, range1, 100, 201);
-		TmfDataRequest<TmfEvent>  request5 = new TmfDataRequestStub<TmfEvent> (TmfEvent.class,     10, 100, 201);
+		TmfTimestamp startTime = new TmfTimestamp(10);
+		TmfTimestamp endTime   = new TmfTimestamp(20);
+        TmfTimeRange range1 = new TmfTimeRange(startTime, endTime);
+        TmfTimeRange range2 = new TmfTimeRange(TmfTimestamp.BigBang, endTime);
+        TmfTimeRange range3 = new TmfTimeRange(startTime, TmfTimestamp.BigCrunch);
+
+        TmfCoalescedEventRequest<TmfEvent> coalescedRequest = new TmfCoalescedEventRequest<TmfEvent>(TmfEvent.class, range1);
+		TmfDataRequest<TmfEvent> request1 = new TmfEventRequestStub<TmfEvent>(TmfEvent.class, range1);
+		TmfDataRequest<TmfEvent> request2 = new TmfEventRequestStub<TmfEvent>(TmfEvent.class, range2);
+		TmfDataRequest<TmfEvent> request3 = new TmfEventRequestStub<TmfEvent>(TmfEvent.class, range3);
 
         assertTrue ("isCompatible", coalescedRequest.isCompatible(request1));
         assertFalse("isCompatible", coalescedRequest.isCompatible(request2));
         assertFalse("isCompatible", coalescedRequest.isCompatible(request3));
-        assertFalse("isCompatible", coalescedRequest.isCompatible(request4));
-        assertFalse("isCompatible", coalescedRequest.isCompatible(request5));
 	}
 
 	// ------------------------------------------------------------------------
-	// setData/getData
-	// ------------------------------------------------------------------------
-
-	public void testSetData() {
-
-		TmfCoalescedEventRequest<TmfEvent> coalescedRequest = new TmfCoalescedEventRequest<TmfEvent>(TmfEvent.class, range1, 100, 200);
-		TmfEventRequest<TmfEvent> request1 = new TmfEventRequestStub<TmfEvent>(TmfEvent.class, range1, 100, 200);
-		TmfEventRequest<TmfEvent> request2 = new TmfEventRequestStub<TmfEvent>(TmfEvent.class, range1, 100, 200);
-		coalescedRequest.addRequest(request1);
-		coalescedRequest.addRequest(request2);
-
-		// Initialize the data
-		int nbEvents = 10;
-		TmfEvent[] events = new TmfEvent[nbEvents];
-		for (int i = 0; i < nbEvents; i++) {
-			events[i] = new TmfEvent(new TmfTimestamp(i), new TmfEventSource(),
-					new TmfEventType(), new TmfEventReference());
-		}
-
-		coalescedRequest.setData(events);
-		coalescedRequest.handleData();
-
-		// Validate the coalescing request
-		assertEquals("setData", nbEvents, coalescedRequest.getNbRead());
-		TmfEvent[] eventsRead1 = coalescedRequest.getData();
-		assertEquals("getData", nbEvents, eventsRead1.length);
-		for (int i = 0; i < nbEvents; i++) {
-			assertEquals("getData", i, eventsRead1[i].getTimestamp().getValue());
-		}
-
-		// Validate the first coalesced request
-		assertEquals("setData", nbEvents, request1.getNbRead());
-		TmfEvent[] eventsRead2 = request1.getData();
-		assertEquals("getData", nbEvents, eventsRead2.length);
-		for (int i = 0; i < nbEvents; i++) {
-			assertEquals("getData", i, eventsRead2[i].getTimestamp().getValue());
-		}
-
-		// Validate the second coalesced request
-		assertEquals("setData", nbEvents, request2.getNbRead());
-		TmfEvent[] eventsRead3 = request2.getData();
-		assertEquals("getData", nbEvents, eventsRead3.length);
-		for (int i = 0; i < nbEvents; i++) {
-			assertEquals("getData", i, eventsRead3[i].getTimestamp().getValue());
-		}
-	}
-
-	// ------------------------------------------------------------------------
-	// done
-	// ------------------------------------------------------------------------
-
-	public void testDone() {
-		
-		// Test request
-		final boolean[] crFlags = new boolean[4];
-		TmfCoalescedEventRequest<TmfEvent> request = setupTestRequest(crFlags);
-		TmfEventRequest<TmfEvent> subRequest1 = new TmfEventRequestStub<TmfEvent>(TmfEvent.class, range1, 100, 200);
-		TmfEventRequest<TmfEvent> subRequest2 = new TmfEventRequestStub<TmfEvent>(TmfEvent.class, range1, 100, 200);
-		request.addRequest(subRequest1);
-		request.addRequest(subRequest2);
-
-		request.done();
-
-		// Validate the coalescing request
-		assertTrue ("isCompleted", request.isCompleted());
-		assertFalse("isFailed",    request.isFailed());
-		assertFalse("isCancelled", request.isCancelled());
-
-		assertTrue ("handleCompleted", crFlags[0]);
-		assertTrue ("handleSuccess",   crFlags[1]);
-		assertFalse("handleFailure",   crFlags[2]);
-		assertFalse("handleCancel",    crFlags[3]);
-
-		// Validate the first coalesced request
-		assertTrue ("isCompleted", subRequest1.isCompleted());
-		assertFalse("isFailed",    subRequest1.isFailed());
-		assertFalse("isCancelled", subRequest1.isCancelled());
-
-		// Validate the second coalesced request
-		assertTrue ("isCompleted", subRequest2.isCompleted());
-		assertFalse("isFailed",    subRequest2.isFailed());
-		assertFalse("isCancelled", subRequest2.isCancelled());
-	}
-
-	// ------------------------------------------------------------------------
-	// fail
-	// ------------------------------------------------------------------------
-
-	public void testFail() {
-		
-		final boolean[] crFlags = new boolean[4];
-		TmfCoalescedEventRequest<TmfEvent> request = setupTestRequest(crFlags);
-		TmfEventRequest<TmfEvent> subRequest1 = new TmfEventRequestStub<TmfEvent>(TmfEvent.class, range1, 100, 200);
-		TmfEventRequest<TmfEvent> subRequest2 = new TmfEventRequestStub<TmfEvent>(TmfEvent.class, range1, 100, 200);
-		request.addRequest(subRequest1);
-		request.addRequest(subRequest2);
-
-		request.fail();
-
-		// Validate the coalescing request
-		assertTrue ("isCompleted", request.isCompleted());
-		assertTrue ("isFailed",    request.isFailed());
-		assertFalse("isCancelled", request.isCancelled());
-
-		assertTrue ("handleCompleted", crFlags[0]);
-		assertFalse("handleSuccess",   crFlags[1]);
-		assertTrue ("handleFailure",   crFlags[2]);
-		assertFalse("handleCancel",    crFlags[3]);
-
-		// Validate the first coalesced request
-		assertTrue ("isCompleted", subRequest1.isCompleted());
-		assertTrue ("isFailed",    subRequest1.isFailed());
-		assertFalse("isCancelled", subRequest1.isCancelled());
-
-		// Validate the second coalesced request
-		assertTrue ("isCompleted", subRequest2.isCompleted());
-		assertTrue ("isFailed",    subRequest2.isFailed());
-		assertFalse("isCancelled", subRequest2.isCancelled());
-	}
-
-	// ------------------------------------------------------------------------
-	// cancel
-	// ------------------------------------------------------------------------
-
-	public void testCancel() {
-
-		final boolean[] crFlags = new boolean[4];
-		TmfCoalescedEventRequest<TmfEvent> request = setupTestRequest(crFlags);
-		TmfEventRequest<TmfEvent> subRequest1 = new TmfEventRequestStub<TmfEvent>(TmfEvent.class, range1, 100, 200);
-		TmfEventRequest<TmfEvent> subRequest2 = new TmfEventRequestStub<TmfEvent>(TmfEvent.class, range1, 100, 200);
-		request.addRequest(subRequest1);
-		request.addRequest(subRequest2);
-
-		request.cancel();
-
-		// Validate the coalescing request
-		assertTrue ("isCompleted", request.isCompleted());
-		assertFalse("isFailed",    request.isFailed());
-		assertTrue ("isCancelled", request.isCancelled());
-
-		assertTrue ("handleCompleted", crFlags[0]);
-		assertFalse("handleSuccess",   crFlags[1]);
-		assertFalse("handleFailure",   crFlags[2]);
-		assertTrue ("handleCancel",    crFlags[3]);
-
-		// Validate the first coalesced request
-		assertTrue ("isCompleted", subRequest1.isCompleted());
-		assertFalse("isFailed",    subRequest1.isFailed());
-		assertTrue ("isCancelled", subRequest1.isCancelled());
-
-		// Validate the second coalesced request
-		assertTrue ("isCompleted", subRequest2.isCompleted());
-		assertFalse("isFailed",    subRequest2.isFailed());
-		assertTrue ("isCancelled", subRequest2.isCancelled());
-	}
-
-	// ------------------------------------------------------------------------
-	// waitForCompletion
-	// ------------------------------------------------------------------------
-
-	// ------------------------------------------------------------------------
 	// Coalescing
 	// ------------------------------------------------------------------------
 
-    private static final String DIRECTORY   = "testfiles";
-    private static final String TEST_STREAM = "A-Test-10K";
-    private static final int    NB_EVENTS   = 10000;
-    private static final int    BLOCK_SIZE  = 100;
-
-    // Initialize the test trace
-    private static TmfTraceStub fTrace = null;
-    private synchronized TmfTraceStub setupTrace(String path) {
-    	if (fTrace == null) {
-    		try {
-    	        URL location = FileLocator.find(TmfCoreTestPlugin.getDefault().getBundle(), new Path(path), null);
-    			File test = new File(FileLocator.toFileURL(location).toURI());
-    	        fTrace = new TmfTraceStub(test.getPath(), 500);
-    		} catch (URISyntaxException e) {
-    			e.printStackTrace();
-    		} catch (IOException e) {
-    			e.printStackTrace();
-    		}
-    	}
-    	return fTrace;
-    }
-
 	Vector<TmfEvent> requestedEvents1;
     Vector<TmfEvent> requestedEvents2;
     Vector<TmfEvent> requestedEvents3;
@@ -480,14 +169,11 @@ public class TmfCoalescedEventRequestTest extends TestCase {
     TmfEventRequest<TmfEvent> request2;
     TmfEventRequest<TmfEvent> request3;
 
-    ITmfDataProvider<TmfEvent>[] providers;
-
     private class TmfTestTriggerSignal extends TmfSignal {
     	public final boolean forceCancel;
 		public TmfTestTriggerSignal(Object source, boolean cancel) {
 			super(source);
 			forceCancel = cancel;
-
 		}
     }
 
@@ -538,7 +224,7 @@ public class TmfCoalescedEventRequestTest extends TestCase {
             }
         };
 
-        providers = (ITmfDataProvider<TmfEvent>[]) TmfProviderManager.getProviders(TmfEvent.class, TmfTraceStub.class);
+        ITmfDataProvider<TmfEvent>[] providers = (ITmfDataProvider<TmfEvent>[]) TmfProviderManager.getProviders(TmfEvent.class, TmfTraceStub.class);
         providers[0].sendRequest(request1);
         providers[0].sendRequest(request2);
         providers[0].sendRequest(request3);
@@ -546,7 +232,7 @@ public class TmfCoalescedEventRequestTest extends TestCase {
 
     public void testCoalescedRequest() throws Exception {
 
-		fTrace = setupTrace(DIRECTORY + File.separator + TEST_STREAM);
+		setupTrace(DIRECTORY + File.separator + TEST_STREAM);
 
     	TmfSignalManager.register(this);
 		TmfTestTriggerSignal signal = new TmfTestTriggerSignal(this, false);
@@ -577,13 +263,10 @@ public class TmfCoalescedEventRequestTest extends TestCase {
         }
 
         TmfSignalManager.deregister(this);
-        fTrace.dispose();
-        fTrace = null;
     }
     
 	public void testCancelCoalescedRequest() throws Exception {
-
-		fTrace = setupTrace(DIRECTORY + File.separator + TEST_STREAM);
+		setupTrace(DIRECTORY + File.separator + TEST_STREAM);
 
     	TmfSignalManager.register(this);
 		TmfTestTriggerSignal signal = new TmfTestTriggerSignal(this, true);
@@ -613,8 +296,7 @@ public class TmfCoalescedEventRequestTest extends TestCase {
         }
 
         TmfSignalManager.deregister(this);
-        fTrace.dispose();
-        fTrace = null;
     }
 
+
 }
diff --git a/lttng/org.eclipse.linuxtools.tmf.tests/src/org/eclipse/linuxtools/tmf/tests/request/TmfDataRequestTest.java b/lttng/org.eclipse.linuxtools.tmf.tests/src/org/eclipse/linuxtools/tmf/tests/request/TmfDataRequestTest.java
index 491a9bda5f..fd2266f4ee 100644
--- a/lttng/org.eclipse.linuxtools.tmf.tests/src/org/eclipse/linuxtools/tmf/tests/request/TmfDataRequestTest.java
+++ b/lttng/org.eclipse.linuxtools.tmf.tests/src/org/eclipse/linuxtools/tmf/tests/request/TmfDataRequestTest.java
@@ -16,6 +16,7 @@ import junit.framework.TestCase;
 
 import org.eclipse.linuxtools.tmf.event.TmfEvent;
 import org.eclipse.linuxtools.tmf.request.TmfDataRequest;
+import org.eclipse.linuxtools.tmf.request.TmfDataRequestStub;
 
 /**
  * <b><u>TmfDataRequestTest</u></b>
@@ -47,7 +48,7 @@ public class TmfDataRequestTest extends TestCase {
 	// ------------------------------------------------------------------------
 
 	public void testTmfDataRequest() {
-        TmfDataRequest<TmfEvent> request = new TmfDataRequest<TmfEvent>(TmfEvent.class);
+        TmfDataRequest<TmfEvent> request = new TmfDataRequestStub<TmfEvent>(TmfEvent.class);
 
         assertEquals("getIndex",             0, request.getIndex());
         assertEquals("getNbRequestedEvents", TmfDataRequest.ALL_DATA, request.getNbRequested());
@@ -55,7 +56,7 @@ public class TmfDataRequestTest extends TestCase {
 	}
 
 	public void testTmfDataRequestIndex() {
-        TmfDataRequest<TmfEvent> request = new TmfDataRequest<TmfEvent>(TmfEvent.class, 10);
+        TmfDataRequest<TmfEvent> request = new TmfDataRequestStub<TmfEvent>(TmfEvent.class, 10);
 
         assertEquals("getIndex",             10, request.getIndex());
         assertEquals("getNbRequestedEvents", TmfDataRequest.ALL_DATA, request.getNbRequested());
@@ -63,7 +64,7 @@ public class TmfDataRequestTest extends TestCase {
 	}
 
 	public void testTmfDataRequestIndexNbRequested() {
-        TmfDataRequest<TmfEvent> request = new TmfDataRequest<TmfEvent>(TmfEvent.class, 10, 100);
+        TmfDataRequest<TmfEvent> request = new TmfDataRequestStub<TmfEvent>(TmfEvent.class, 10, 100);
 
         assertEquals("getIndex",              10, request.getIndex());
         assertEquals("getNbRequestedEvents", 100, request.getNbRequested());
@@ -71,11 +72,45 @@ public class TmfDataRequestTest extends TestCase {
 	}
 
 	public void testTmfDataRequestIndexNbEventsBlocksize() {
-        TmfDataRequest<TmfEvent> request = new TmfDataRequest<TmfEvent>(TmfEvent.class, 10, 100, 200);
+        TmfDataRequest<TmfEvent> request = new TmfDataRequestStub<TmfEvent>(TmfEvent.class, 10, 100, 200);
 
         assertEquals("getIndex",              10, request.getIndex());
         assertEquals("getNbRequestedEvents", 100, request.getNbRequested());
         assertEquals("getBlockize",          200, request.getBlockize());
 	}
 
+	// ------------------------------------------------------------------------
+	// equals
+	// ------------------------------------------------------------------------
+
+	public void testEquals_Reflexivity() {
+        TmfDataRequest<TmfEvent> request = new TmfDataRequestStub<TmfEvent>(TmfEvent.class, 10, 100, 200);
+
+        assertTrue("request.equals(request)", request.equals(request));
+	}
+
+	public void testEquals_Symmetry() {
+        TmfDataRequest<TmfEvent> request1 = new TmfDataRequestStub<TmfEvent>(TmfEvent.class, 10, 100, 200);
+        TmfDataRequest<TmfEvent> request2 = new TmfDataRequestStub<TmfEvent>(TmfEvent.class, 10, 100, 200);
+        TmfDataRequest<TmfEvent> request3 = new TmfDataRequestStub<TmfEvent>(TmfEvent.class, 20, 100, 200);
+
+        assertTrue("request1.equals(request2)", request1.equals(request2));
+        assertTrue("request2.equals(request1)", request2.equals(request1));
+
+        assertFalse("request1.equals(request3)", request1.equals(request3));
+        assertFalse("request3.equals(request1)", request3.equals(request1));
+        assertFalse("request2.equals(request3)", request2.equals(request3));
+        assertFalse("request3.equals(request2)", request3.equals(request2));
+	}
+
+	public void testEquals_Transivity() {
+        TmfDataRequest<TmfEvent> request1 = new TmfDataRequestStub<TmfEvent>(TmfEvent.class, 10, 100, 200);
+        TmfDataRequest<TmfEvent> request2 = new TmfDataRequestStub<TmfEvent>(TmfEvent.class, 10, 100, 200);
+        TmfDataRequest<TmfEvent> request3 = new TmfDataRequestStub<TmfEvent>(TmfEvent.class, 10, 100, 200);
+
+        assertTrue("request1.equals(request2)", request1.equals(request2));
+        assertTrue("request2.equals(request3)", request2.equals(request3));
+        assertTrue("request1.equals(request3)", request1.equals(request3));
+	}
+
 }
\ No newline at end of file
diff --git a/lttng/org.eclipse.linuxtools.tmf.tests/src/org/eclipse/linuxtools/tmf/tests/request/TmfEventRequestTest.java b/lttng/org.eclipse.linuxtools.tmf.tests/src/org/eclipse/linuxtools/tmf/tests/request/TmfEventRequestTest.java
index 6116c95c28..de1f1666f3 100644
--- a/lttng/org.eclipse.linuxtools.tmf.tests/src/org/eclipse/linuxtools/tmf/tests/request/TmfEventRequestTest.java
+++ b/lttng/org.eclipse.linuxtools.tmf.tests/src/org/eclipse/linuxtools/tmf/tests/request/TmfEventRequestTest.java
@@ -19,6 +19,7 @@ import org.eclipse.linuxtools.tmf.event.TmfTimeRange;
 import org.eclipse.linuxtools.tmf.event.TmfTimestamp;
 import org.eclipse.linuxtools.tmf.request.TmfDataRequest;
 import org.eclipse.linuxtools.tmf.request.TmfEventRequest;
+import org.eclipse.linuxtools.tmf.request.TmfEventRequestStub;
 
 /**
  * <b><u>TmfEventRequestTest</u></b>
@@ -49,8 +50,8 @@ public class TmfEventRequestTest extends TestCase {
 	// Constructors
 	// ------------------------------------------------------------------------
 
-	public void testTmfDataRequest() {
-        TmfEventRequest<TmfEvent> request = new TmfEventRequest<TmfEvent>(TmfEvent.class);
+	public void testTmfEventRequest() {
+        TmfEventRequest<TmfEvent> request = new TmfEventRequestStub<TmfEvent>(TmfEvent.class);
 
         assertEquals("StartTime", TmfTimestamp.BigBang,   request.getRange().getStartTime());
         assertEquals("EndTime",   TmfTimestamp.BigCrunch, request.getRange().getEndTime());
@@ -60,9 +61,9 @@ public class TmfEventRequestTest extends TestCase {
         assertEquals("getBlockize", TmfDataRequest.DEFAULT_BLOCK_SIZE, request.getBlockize());
 	}
 
-	public void testTmfDataRequestTimeRange() {
+	public void testTmfEventRequestTimeRange() {
         TmfTimeRange range = new TmfTimeRange(new TmfTimestamp(), TmfTimestamp.BigCrunch);
-        TmfEventRequest<TmfEvent> request = new TmfEventRequest<TmfEvent>(TmfEvent.class, range);
+        TmfEventRequest<TmfEvent> request = new TmfEventRequestStub<TmfEvent>(TmfEvent.class, range);
 
         assertEquals("StartTime", range.getStartTime(), request.getRange().getStartTime());
         assertEquals("EndTime",   range.getEndTime(),   request.getRange().getEndTime());
@@ -72,9 +73,9 @@ public class TmfEventRequestTest extends TestCase {
         assertEquals("getBlockize", TmfDataRequest.DEFAULT_BLOCK_SIZE, request.getBlockize());
 	}
 
-	public void testTmfDataRequestTimeRangeNbRequested() {
+	public void testTmfEventRequestTimeRangeNbRequested() {
         TmfTimeRange range = new TmfTimeRange(new TmfTimestamp(), TmfTimestamp.BigCrunch);
-        TmfEventRequest<TmfEvent> request = new TmfEventRequest<TmfEvent>(TmfEvent.class, range, 100);
+        TmfEventRequest<TmfEvent> request = new TmfEventRequestStub<TmfEvent>(TmfEvent.class, range, 100);
 
         assertEquals("StartTime", range.getStartTime(), request.getRange().getStartTime());
         assertEquals("EndTime",   range.getEndTime(),   request.getRange().getEndTime());
@@ -84,9 +85,9 @@ public class TmfEventRequestTest extends TestCase {
         assertEquals("getBlockize", TmfDataRequest.DEFAULT_BLOCK_SIZE, request.getBlockize());
 	}
 
-	public void testTmfDataRequestTimeRangeNbRequestedBlocksize() {
+	public void testTmfEventRequestTimeRangeNbRequestedBlocksize() {
         TmfTimeRange range = new TmfTimeRange(new TmfTimestamp(), TmfTimestamp.BigCrunch);
-        TmfEventRequest<TmfEvent> request = new TmfEventRequest<TmfEvent>(TmfEvent.class, range, 100, 200);
+        TmfEventRequest<TmfEvent> request = new TmfEventRequestStub<TmfEvent>(TmfEvent.class, range, 100, 200);
 
         assertEquals("StartTime", range.getStartTime(), request.getRange().getStartTime());
         assertEquals("EndTime",   range.getEndTime(),   request.getRange().getEndTime());
@@ -96,4 +97,48 @@ public class TmfEventRequestTest extends TestCase {
         assertEquals("getBlockize",          200, request.getBlockize());
 	}
 
+	// ------------------------------------------------------------------------
+	// equals
+	// ------------------------------------------------------------------------
+
+	public void testEquals_Reflexivity() {
+        TmfTimeRange range = new TmfTimeRange(new TmfTimestamp(), TmfTimestamp.BigCrunch);
+        TmfEventRequest<TmfEvent> request = new TmfEventRequestStub<TmfEvent>(TmfEvent.class, range, 100, 200);
+
+        assertTrue("request.equals(request)", request.equals(request));
+	}
+
+	public void testEquals_Symmetry() {
+        TmfTimeRange range1 = new TmfTimeRange(new TmfTimestamp(), TmfTimestamp.BigCrunch);
+        TmfTimeRange range2 = new TmfTimeRange(new TmfTimestamp(), TmfTimestamp.BigCrunch);
+        TmfTimeRange range3 = new TmfTimeRange(new TmfTimestamp(), TmfTimestamp.Zero);
+
+        TmfEventRequest<TmfEvent> request1 = new TmfEventRequestStub<TmfEvent>(TmfEvent.class, range1, 100, 200);
+        TmfEventRequest<TmfEvent> request2 = new TmfEventRequestStub<TmfEvent>(TmfEvent.class, range2, 100, 200);
+        TmfEventRequest<TmfEvent> request3 = new TmfEventRequestStub<TmfEvent>(TmfEvent.class, range3, 100, 200);
+
+        assertTrue("request1.equals(request2)", request1.equals(request2));
+        assertTrue("request2.equals(request1)", request2.equals(request1));
+
+        assertFalse("request1.equals(request3)", request1.equals(request3));
+        assertFalse("request3.equals(request1)", request3.equals(request1));
+        assertFalse("request2.equals(request3)", request2.equals(request3));
+        assertFalse("request3.equals(request2)", request3.equals(request2));
+	}
+
+	public void testEquals_Transivity() {
+        TmfTimeRange range1 = new TmfTimeRange(new TmfTimestamp(), TmfTimestamp.BigCrunch);
+
+        TmfEventRequest<TmfEvent> request1 = new TmfEventRequestStub<TmfEvent>(TmfEvent.class, range1, 100, 200);
+        TmfEventRequest<TmfEvent> request2 = new TmfEventRequestStub<TmfEvent>(TmfEvent.class, range1, 100, 200);
+        TmfEventRequest<TmfEvent> request3 = new TmfEventRequestStub<TmfEvent>(TmfEvent.class, range1, 100, 200);
+
+        assertTrue("request1.equals(request2)", request1.equals(request2));
+        assertTrue("request1.equals(request3)", request1.equals(request3));
+        assertTrue("request2.equals(request1)", request2.equals(request1));
+        assertTrue("request2.equals(request3)", request2.equals(request3));
+        assertTrue("request3.equals(request1)", request3.equals(request1));
+        assertTrue("request3.equals(request2)", request3.equals(request2));
+	}
+
 }
\ No newline at end of file
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 732fa14647..6ef340bcac 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
@@ -206,7 +206,8 @@ public class TmfExperimentTest extends TestCase {
                 }
             }
         };
-        fExperiment.processRequest(request, true);
+        fExperiment.sendRequest(request);
+        request.waitForCompletion();
 
         assertEquals("nbEvents", nbEvents, requestedEvents.size());
         assertTrue("isCompleted",  request.isCompleted());
@@ -234,7 +235,8 @@ public class TmfExperimentTest extends TestCase {
                 }
             }
         };
-        fExperiment.processRequest(request, true);
+        fExperiment.sendRequest(request);
+        request.waitForCompletion();
 
         assertEquals("nbEvents", nbEvents, requestedEvents.size());
         assertTrue("isCompleted",  request.isCompleted());
@@ -263,7 +265,8 @@ public class TmfExperimentTest extends TestCase {
                 }
             }
         };
-        fExperiment.processRequest(request, true);
+        fExperiment.sendRequest(request);
+        request.waitForCompletion();
 
         assertEquals("nbEvents", nbExpectedEvents, requestedEvents.size());
         assertTrue("isCompleted",  request.isCompleted());
@@ -297,7 +300,8 @@ public class TmfExperimentTest extends TestCase {
                 cancel();
             }
         };
-        fExperiment.processRequest(request, true);
+        fExperiment.sendRequest(request);
+        request.waitForCompletion();
 
         assertEquals("nbEvents",  blockSize, requestedEvents.size());
         assertTrue("isCompleted", request.isCompleted());
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 b2460d2888..14ffe0d5b9 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
@@ -22,7 +22,7 @@ import junit.framework.TestCase;
 
 import org.eclipse.core.runtime.FileLocator;
 import org.eclipse.core.runtime.Path;
-import org.eclipse.linuxtools.tmf.component.TmfDataProvider;
+import org.eclipse.linuxtools.tmf.component.ITmfDataProvider;
 import org.eclipse.linuxtools.tmf.component.TmfProviderManager;
 import org.eclipse.linuxtools.tmf.event.TmfEvent;
 import org.eclipse.linuxtools.tmf.event.TmfTimeRange;
@@ -226,8 +226,9 @@ public class TmfTraceTest extends TestCase {
                 }
             }
         };
-        TmfDataProvider<TmfEvent>[] providers = (TmfDataProvider<TmfEvent>[]) TmfProviderManager.getProviders(TmfEvent.class, TmfTraceStub.class);
-        providers[0].processRequest(request, true);
+        ITmfDataProvider<TmfEvent>[] providers = (ITmfDataProvider<TmfEvent>[]) TmfProviderManager.getProviders(TmfEvent.class, TmfTraceStub.class);
+        providers[0].sendRequest(request);
+        request.waitForCompletion();
 
         assertEquals("nbEvents", NB_EVENTS, requestedEvents.size());
         assertTrue("isCompleted",  request.isCompleted());
@@ -255,8 +256,9 @@ public class TmfTraceTest extends TestCase {
                 }
             }
         };
-        TmfDataProvider<TmfEvent>[] providers = (TmfDataProvider<TmfEvent>[]) TmfProviderManager.getProviders(TmfEvent.class, TmfTraceStub.class);
-        providers[0].processRequest(request, true);
+        ITmfDataProvider<TmfEvent>[] providers = (ITmfDataProvider<TmfEvent>[]) TmfProviderManager.getProviders(TmfEvent.class, TmfTraceStub.class);
+        providers[0].sendRequest(request);
+        request.waitForCompletion();
 
         assertEquals("nbEvents", NB_EVENTS, requestedEvents.size());
         assertTrue("isCompleted",  request.isCompleted());
@@ -289,8 +291,9 @@ public class TmfTraceTest extends TestCase {
                 cancel();
             }
         };
-        TmfDataProvider<TmfEvent>[] providers = (TmfDataProvider<TmfEvent>[]) TmfProviderManager.getProviders(TmfEvent.class, TmfTraceStub.class);
-        providers[0].processRequest(request, true);
+        ITmfDataProvider<TmfEvent>[] providers = (ITmfDataProvider<TmfEvent>[]) TmfProviderManager.getProviders(TmfEvent.class, TmfTraceStub.class);
+        providers[0].sendRequest(request);
+        request.waitForCompletion();
 
         assertEquals("nbEvents",  NB_EVENTS, requestedEvents.size());
         assertTrue("isCompleted", request.isCompleted());
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 6c277a63b1..676db78a10 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
@@ -53,6 +53,12 @@ public class TmfEventProviderStub extends TmfEventProvider<TmfEvent> {
     public TmfEventProviderStub() throws IOException {
     	this(DIRECTORY + File.separator + TEST_STREAM);
     }
+
+    @Override
+    public void deregister() {
+    	fTrace.deregister();
+    	super.deregister();
+    }
     
     // ------------------------------------------------------------------------
     // TmfEventProvider
diff --git a/lttng/org.eclipse.linuxtools.tmf.tests/stubs/org/eclipse/linuxtools/tmf/component/TmfSyntheticEventProviderStub.java b/lttng/org.eclipse.linuxtools.tmf.tests/stubs/org/eclipse/linuxtools/tmf/component/TmfSyntheticEventProviderStub.java
index bbbbdd07ce..75e21d2e02 100644
--- a/lttng/org.eclipse.linuxtools.tmf.tests/stubs/org/eclipse/linuxtools/tmf/component/TmfSyntheticEventProviderStub.java
+++ b/lttng/org.eclipse.linuxtools.tmf.tests/stubs/org/eclipse/linuxtools/tmf/component/TmfSyntheticEventProviderStub.java
@@ -39,8 +39,8 @@ public class TmfSyntheticEventProviderStub extends TmfEventProvider<TmfSynthetic
 	public ITmfContext armRequest(final TmfDataRequest<TmfSyntheticEventStub> request) {
 
 		// Get the TmfSyntheticEventStub provider
-		TmfDataProvider<TmfEvent>[] eventProviders = (TmfDataProvider<TmfEvent>[]) TmfProviderManager.getProviders(TmfEvent.class, TmfEventProviderStub.class);
-		TmfDataProvider<TmfEvent> provider = eventProviders[0];
+		ITmfDataProvider<TmfEvent>[] eventProviders = (ITmfDataProvider<TmfEvent>[]) TmfProviderManager.getProviders(TmfEvent.class, TmfEventProviderStub.class);
+		ITmfDataProvider<TmfEvent> provider = eventProviders[0];
 
 		// make sure we have the right type of request
 		if (!(request instanceof TmfEventRequest<?>)) {
@@ -64,7 +64,7 @@ public class TmfSyntheticEventProviderStub extends TmfEventProvider<TmfSynthetic
             		}
             	}
         	};
-        provider.processRequest(subRequest, false);
+        provider.sendRequest(subRequest); // , false);
 
         // Return a dummy context
         return new TmfContext();
diff --git a/lttng/org.eclipse.linuxtools.tmf.tests/stubs/org/eclipse/linuxtools/tmf/request/TmfDataRequestStub.java b/lttng/org.eclipse.linuxtools.tmf.tests/stubs/org/eclipse/linuxtools/tmf/request/TmfDataRequestStub.java
index f5630a4596..7e41522d0e 100644
--- a/lttng/org.eclipse.linuxtools.tmf.tests/stubs/org/eclipse/linuxtools/tmf/request/TmfDataRequestStub.java
+++ b/lttng/org.eclipse.linuxtools.tmf.tests/stubs/org/eclipse/linuxtools/tmf/request/TmfDataRequestStub.java
@@ -25,14 +25,14 @@ public class TmfDataRequestStub<T extends TmfData> extends TmfDataRequest<T> {
      * Default constructor
      */
     public TmfDataRequestStub(Class<T> dataType) {
-        super(dataType);
+        this(dataType, 0, ALL_DATA, DEFAULT_BLOCK_SIZE);
     }
 
     /**
      * @param nbRequested
      */
     public TmfDataRequestStub(Class<T> dataType, int index) {
-        super(dataType, index);
+        this(dataType, index, ALL_DATA, DEFAULT_BLOCK_SIZE);
     }
 
     /**
@@ -40,7 +40,7 @@ public class TmfDataRequestStub<T extends TmfData> extends TmfDataRequest<T> {
      * @param nbRequested
      */
     public TmfDataRequestStub(Class<T> dataType, int index, int nbRequested) {
-    	super(dataType, index, nbRequested);
+        this(dataType, index, nbRequested, DEFAULT_BLOCK_SIZE);
     }
 
     /**
diff --git a/lttng/org.eclipse.linuxtools.tmf.tests/stubs/org/eclipse/linuxtools/tmf/request/TmfEventRequestStub.java b/lttng/org.eclipse.linuxtools.tmf.tests/stubs/org/eclipse/linuxtools/tmf/request/TmfEventRequestStub.java
index 4c7f74dae7..fc305b69b6 100644
--- a/lttng/org.eclipse.linuxtools.tmf.tests/stubs/org/eclipse/linuxtools/tmf/request/TmfEventRequestStub.java
+++ b/lttng/org.eclipse.linuxtools.tmf.tests/stubs/org/eclipse/linuxtools/tmf/request/TmfEventRequestStub.java
@@ -26,14 +26,14 @@ public class TmfEventRequestStub<T extends TmfEvent> extends TmfEventRequest<T>
      * @param range
      */
     public TmfEventRequestStub(Class<T> dataType) {
-    	super(dataType);
+        this(dataType, TmfTimeRange.Eternity, ALL_DATA, DEFAULT_BLOCK_SIZE);
     }
 
     /**
      * @param range
      */
     public TmfEventRequestStub(Class<T> dataType, TmfTimeRange range) {
-    	super(dataType, range);
+        this(dataType, range, ALL_DATA, DEFAULT_BLOCK_SIZE);
     }
 
     /**
@@ -41,7 +41,7 @@ public class TmfEventRequestStub<T extends TmfEvent> extends TmfEventRequest<T>
      * @param nbRequested
      */
     public TmfEventRequestStub(Class<T> dataType, TmfTimeRange range, int nbRequested) {
-    	super(dataType, range, nbRequested);
+        this(dataType, range, nbRequested, DEFAULT_BLOCK_SIZE);
     }
     
     /**
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 e7b07fc276..64565ce2df 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
@@ -171,7 +171,8 @@ public class TmfEventsView extends TmfView {
 						}
 					}
 				};
-				fExperiment.processRequest(request, true);
+				fExperiment.sendRequest(request);
+		        request.waitForCompletion();
 				
 				if (cache[0] != null && cacheStartIndex == index) {
 					item.setText(extractItemFields(cache[0]));
@@ -187,7 +188,7 @@ public class TmfEventsView extends TmfView {
     	// If an experiment is already selected, update the table
     	fExperiment = (TmfExperiment<TmfEvent>) TmfExperiment.getCurrentExperiment();
     	if (fExperiment != null) {
-    		experimentSelected(new TmfExperimentSelectedSignal(fTable, fExperiment));
+    		experimentSelected(new TmfExperimentSelectedSignal<TmfEvent>(fTable, fExperiment));
     	}
     }
 
@@ -245,7 +246,7 @@ public class TmfEventsView extends TmfView {
     
 	@SuppressWarnings("unchecked")
 	@TmfSignalHandler
-    public void experimentSelected(TmfExperimentSelectedSignal signal) {
+    public void experimentSelected(TmfExperimentSelectedSignal<TmfEvent> signal) {
 		// Update the trace reference
     	fExperiment = (TmfExperiment<TmfEvent>) signal.getExperiment();
     	setPartName(fTitlePrefix + " - " + fExperiment.getName());
diff --git a/lttng/org.eclipse.linuxtools.tmf/src/org/eclipse/linuxtools/tmf/component/ITmfDataProvider.java b/lttng/org.eclipse.linuxtools.tmf/src/org/eclipse/linuxtools/tmf/component/ITmfDataProvider.java
index fd0afbc4ec..23eefd3d34 100644
--- a/lttng/org.eclipse.linuxtools.tmf/src/org/eclipse/linuxtools/tmf/component/ITmfDataProvider.java
+++ b/lttng/org.eclipse.linuxtools.tmf/src/org/eclipse/linuxtools/tmf/component/ITmfDataProvider.java
@@ -1,33 +1,10 @@
-/*******************************************************************************
- * 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.component;
 
 import org.eclipse.linuxtools.tmf.event.TmfData;
-import org.eclipse.linuxtools.tmf.request.ITmfDataRequest;
+import org.eclipse.linuxtools.tmf.request.TmfDataRequest;
 
-/**
- * <b><u>ITmfDataRequest</u></b>
- * <p>
- * TODO: Implement me. Please.
- */
 public interface ITmfDataProvider<T extends TmfData> {
 
-	// ------------------------------------------------------------------------
-	// Constants
-	// ------------------------------------------------------------------------
-
-    public enum ExecutionType { SHORT, LONG };
-    
     /**
      * Queues the request for processing.
      * 
@@ -35,8 +12,6 @@ public interface ITmfDataProvider<T extends TmfData> {
      * 
 	 * @param request The request to process
 	 */
-	public void sendRequest(ITmfDataRequest<T> request);
-	public void sendRequest(ITmfDataRequest<T> request, ExecutionType type);
-	public void fireRequests();
+	public void sendRequest(TmfDataRequest<T> request);
 
 }
diff --git a/lttng/org.eclipse.linuxtools.tmf/src/org/eclipse/linuxtools/tmf/component/TmfDataProvider.java b/lttng/org.eclipse.linuxtools.tmf/src/org/eclipse/linuxtools/tmf/component/TmfDataProvider.java
index acdbbfa322..ae68357fb6 100644
--- a/lttng/org.eclipse.linuxtools.tmf/src/org/eclipse/linuxtools/tmf/component/TmfDataProvider.java
+++ b/lttng/org.eclipse.linuxtools.tmf/src/org/eclipse/linuxtools/tmf/component/TmfDataProvider.java
@@ -16,9 +16,11 @@ import java.lang.reflect.Array;
 import java.util.Vector;
 import java.util.concurrent.BlockingQueue;
 import java.util.concurrent.LinkedBlockingQueue;
+import java.util.concurrent.SynchronousQueue;
 
 import org.eclipse.linuxtools.tmf.event.TmfData;
-import org.eclipse.linuxtools.tmf.request.ITmfRequestHandler;
+import org.eclipse.linuxtools.tmf.request.ITmfDataRequest;
+import org.eclipse.linuxtools.tmf.request.TmfCoalescedDataRequest;
 import org.eclipse.linuxtools.tmf.request.TmfDataRequest;
 import org.eclipse.linuxtools.tmf.request.TmfRequestExecutor;
 import org.eclipse.linuxtools.tmf.signal.TmfEndSynchSignal;
@@ -39,7 +41,7 @@ import org.eclipse.linuxtools.tmf.trace.ITmfContext;
  * <p>
  * TODO: Add support for providing multiple data types.
  */
-public abstract class TmfDataProvider<T extends TmfData> extends TmfComponent implements ITmfRequestHandler<T> {
+public abstract class TmfDataProvider<T extends TmfData> extends TmfComponent implements ITmfDataProvider<T> {
 
 	final protected Class<T> fType;
 
@@ -48,8 +50,10 @@ public abstract class TmfDataProvider<T extends TmfData> extends TmfComponent im
 	protected final BlockingQueue<T> fDataQueue;
 	protected final TmfRequestExecutor fExecutor;
 
+	private Integer fSynchDepth;
+
 	// ------------------------------------------------------------------------
-	// Constructors (enforce that a type be supplied) 
+	// Constructors
 	// ------------------------------------------------------------------------
 	
 	public TmfDataProvider(String name, Class<T> type) {
@@ -60,8 +64,10 @@ public abstract class TmfDataProvider<T extends TmfData> extends TmfComponent im
 		super(name);
 		fQueueSize = queueSize;
 		fType = type;
-		fDataQueue = new LinkedBlockingQueue<T>(fQueueSize);
+		fDataQueue = (queueSize > 1) ? new LinkedBlockingQueue<T>(fQueueSize) : new SynchronousQueue<T>();
+
 		fExecutor = new TmfRequestExecutor();
+		fSynchDepth = 0;
 		register();
 	}
 
@@ -85,25 +91,58 @@ public abstract class TmfDataProvider<T extends TmfData> extends TmfComponent im
 	// ITmfRequestHandler
 	// ------------------------------------------------------------------------
 
-	// TODO: Request coalescing, filtering, result dispatching
+	public void sendRequest(final TmfDataRequest<T> request) {
+
+		if (fSynchDepth > 0) {
+			// We are in coalescing mode: client should NEVER wait
+			// (otherwise we will have deadlock...)
+			coalesceDataRequest(request);
+		} else {
+			// Process the request immediately 
+			queueRequest(request);
+		}
+	}
+
+	/**
+	 * This method queues the coalesced requests.
+	 * 
+	 * @param thread
+	 */
+	private synchronized void fireRequests() {
+		for (TmfDataRequest<T> request : fPendingCoalescedRequests) {
+			queueRequest(request);
+		}
+		fPendingCoalescedRequests.clear();
+	}
+
+	// ------------------------------------------------------------------------
+	// Coalescing (primitive test...)
+	// ------------------------------------------------------------------------
 
-	public void processRequest(final TmfDataRequest<T> request, boolean waitForCompletion) {
+	protected Vector<TmfCoalescedDataRequest<T>> fPendingCoalescedRequests = new Vector<TmfCoalescedDataRequest<T>>();
 
-//		System.out.println("[" + getName() + "]" + " New request: " + request.getRequestId());
-//		if (request.getRequestId() == 0) {
-//			System.out.println("");
-//		}
-		
-		//Process the request 
-		processDataRequest(request);
+	protected synchronized void newCoalescedDataRequest(TmfDataRequest<T> request) {
+		TmfCoalescedDataRequest<T> coalescedRequest =
+			new TmfCoalescedDataRequest<T>(fType, request.getIndex(), request.getNbRequested(), request.getBlockize());
+		coalescedRequest.addRequest(request);
+		fPendingCoalescedRequests.add(coalescedRequest);
+	}
 
-		// Wait for completion if requested
-    	if (waitForCompletion) {
-			request.waitForCompletion();
+	protected synchronized void coalesceDataRequest(TmfDataRequest<T> request) {
+		for (TmfCoalescedDataRequest<T> req : fPendingCoalescedRequests) {
+			if (req.isCompatible(request)) {
+				req.addRequest(request);
+				return;
+			}
 		}
+		newCoalescedDataRequest(request);
 	}
 
-	protected void processDataRequest(final TmfDataRequest<T> request) {
+	// ------------------------------------------------------------------------
+	// Request processing
+	// ------------------------------------------------------------------------
+
+	protected void queueRequest(final TmfDataRequest<T> request) {
 
 		// Process the request
 		Thread thread = new Thread() {
@@ -153,7 +192,7 @@ public abstract class TmfDataProvider<T extends TmfData> extends TmfComponent im
 	 * @param data
 	 */
 	@SuppressWarnings("unchecked")
-	protected void pushData(TmfDataRequest<T> request, Vector<T> data) {
+	protected void pushData(ITmfDataRequest<T> request, Vector<T> data) {
 		synchronized(request) {
 			if (!request.isCompleted()) {
 				T[] result = (T[]) Array.newInstance(fType, data.size());
@@ -166,6 +205,15 @@ public abstract class TmfDataProvider<T extends TmfData> extends TmfComponent im
 	}
 
 	/**
+	 * Initialize the provider based on the request. The context is
+	 * provider specific and will be updated by getNext().
+	 * 
+	 * @param request
+	 * @return an application specific context; null if request can't be serviced
+	 */
+	public abstract ITmfContext armRequest(TmfDataRequest<T> request);
+	
+	/**
 	 * Return the next piece of data based on the context supplied. The context
 	 * would typically be updated for the subsequent read.
 	 * 
@@ -182,6 +230,11 @@ public abstract class TmfDataProvider<T extends TmfData> extends TmfComponent im
 		return null;
 	}
 
+	/**
+	 * Makes the generated result data available for getNext()
+	 * 
+	 * @param data
+	 */
 	public void queueResult(T data) {
 		try {
 			fDataQueue.put(data);
@@ -191,15 +244,6 @@ public abstract class TmfDataProvider<T extends TmfData> extends TmfComponent im
 	}
 
 	/**
-	 * Initialize the provider based on the request. The context is
-	 * provider specific and will be updated by getNext().
-	 * 
-	 * @param request
-	 * @return an application specific context; null if request can't be serviced
-	 */
-	public abstract ITmfContext armRequest(TmfDataRequest<T> request);
-	
-	/**
 	 * Checks if the data meets the request completion criteria.
 	 * 
 	 * @param request
@@ -210,16 +254,25 @@ public abstract class TmfDataProvider<T extends TmfData> extends TmfComponent im
 		return request.isCompleted() || nbRead >= request.getNbRequested();
 	}
 
+	// ------------------------------------------------------------------------
+	// Signal handlers
+	// ------------------------------------------------------------------------
+
 	@TmfSignalHandler
 	public void startSynch(TmfStartSynchSignal signal) {
-//		if (getName().equals("MyExperiment"))
-//			System.out.println("[" + getName() + "]" + " Start synch: " + signal.getReference());
+		synchronized(fSynchDepth) {
+			fSynchDepth++;
+		}
 	}
 
 	@TmfSignalHandler
 	public void endSynch(TmfEndSynchSignal signal) {
-//		if (getName().equals("MyExperiment"))
-//			System.out.println("[" + getName() + "]" + " End synch: " + signal.getReference());
+		synchronized(fSynchDepth) {
+			fSynchDepth--;
+			if (fSynchDepth == 0) {
+				fireRequests();
+			}
+		}
 	}
 
 }
diff --git a/lttng/org.eclipse.linuxtools.tmf/src/org/eclipse/linuxtools/tmf/component/TmfEventProvider.java b/lttng/org.eclipse.linuxtools.tmf/src/org/eclipse/linuxtools/tmf/component/TmfEventProvider.java
index 1654b78639..ae9a16a5ad 100644
--- a/lttng/org.eclipse.linuxtools.tmf/src/org/eclipse/linuxtools/tmf/component/TmfEventProvider.java
+++ b/lttng/org.eclipse.linuxtools.tmf/src/org/eclipse/linuxtools/tmf/component/TmfEventProvider.java
@@ -14,6 +14,7 @@ package org.eclipse.linuxtools.tmf.component;
 
 import org.eclipse.linuxtools.tmf.event.TmfEvent;
 import org.eclipse.linuxtools.tmf.event.TmfTimestamp;
+import org.eclipse.linuxtools.tmf.request.TmfCoalescedEventRequest;
 import org.eclipse.linuxtools.tmf.request.TmfDataRequest;
 import org.eclipse.linuxtools.tmf.request.TmfEventRequest;
 
@@ -42,4 +43,15 @@ public abstract class TmfEventProvider<T extends TmfEvent> extends TmfDataProvid
 		return dataRequestCompleted;
 	}
 
+	@Override
+	protected synchronized void newCoalescedDataRequest(TmfDataRequest<T> request) {
+		if (request instanceof TmfEventRequest<?>) {
+			TmfEventRequest<T> eventRequest = (TmfEventRequest<T>) request;
+			TmfCoalescedEventRequest<T> coalescedRequest = 
+				new TmfCoalescedEventRequest<T>(fType, eventRequest.getRange(), eventRequest.getNbRequested(), eventRequest.getBlockize());
+			coalescedRequest.addRequest(eventRequest);
+			fPendingCoalescedRequests.add(coalescedRequest);
+		}
+	}
+
 }
diff --git a/lttng/org.eclipse.linuxtools.tmf/src/org/eclipse/linuxtools/tmf/event/TmfTimeRange.java b/lttng/org.eclipse.linuxtools.tmf/src/org/eclipse/linuxtools/tmf/event/TmfTimeRange.java
index 5f90f796ba..9c634bae02 100644
--- a/lttng/org.eclipse.linuxtools.tmf/src/org/eclipse/linuxtools/tmf/event/TmfTimeRange.java
+++ b/lttng/org.eclipse.linuxtools.tmf/src/org/eclipse/linuxtools/tmf/event/TmfTimeRange.java
@@ -13,7 +13,7 @@
 package org.eclipse.linuxtools.tmf.event;
 
 /**
- * <b><u>TmfTimeWindow</u></b>
+ * <b><u>TmfTimeRange</u></b>
  * <p>
  * A utility class to define time ranges.
  */
@@ -63,6 +63,16 @@ public class TmfTimeRange {
 		fEndTime   = other.fEndTime;
 	}
 
+    @Override
+    public boolean equals(Object other) {
+    	if (other instanceof TmfTimeRange) {
+    		TmfTimeRange range = (TmfTimeRange) other;
+    		return range.fStartTime.equals(fStartTime) &&
+    		       range.fEndTime.equals(fEndTime);
+    	}
+    	return false;
+    }
+
     // ========================================================================
     // Accessors
     // ========================================================================
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 098b59c8d2..b809c1102a 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
@@ -370,50 +370,6 @@ public class TmfExperiment<T extends TmfEvent> extends TmfEventProvider<T> imple
 		return context;
 	}
 
-//	/**
-//	 * Given an experiment event index, position the set of traces so a call
-//	 * to getNextEvent() will retrieve the corresponding event.
-//	 * 
-//	 * @param index
-//	 * @param context
-//	 */
-//	private synchronized void positionTraces(long index, TmfExperimentContext context) {
-//
-//		// Extract the relevant information
-//		ITmfTrace[] traces = context.getTraces();
-//		TmfEvent[]  events = context.getEvents();
-//		TmfContext[] contexts = context.getContexts();
-//
-//		int page = 0;		// The checkpoint page
-//		int current = 0;	// The current event index (rank)
-//
-//		// If there is no checkpoint created yet, start from the beginning
-//		if (fCheckpoints.size() == 0) {
-//			for (int i = 0; i < contexts.length; i++) {
-//				contexts[i] = traces[i].seekLocation(null).clone();
-//				events[i] = traces[i].parseEvent(contexts[i]);
-//			}
-//		}
-//		else {
-//			page = (int) index / fIndexPageSize;
-//			if (page >= fCheckpoints.size()) {
-//				page = fCheckpoints.size() - 1;
-//			}
-//
-////			TmfContext[] checkpoint = fCheckpoints.elementAt(page).getContexts();
-//			for (int i = 0; i < contexts.length; i++) {
-//				contexts[i] = checkpoint[i].clone();
-//				events[i] = traces[i].parseEvent(contexts[i]);
-//			}
-//			current = page * fIndexPageSize;
-//		}
-//
-//		// Position the traces at the requested index
-//		while (current++ < index) {
-//			getNextEvent(context);
-//		}
-//	}
-
 	/**
 	 * Scan the next events from all traces and return the next one
 	 * in chronological order.
@@ -449,58 +405,11 @@ public class TmfExperiment<T extends TmfEvent> extends TmfEventProvider<T> imple
     	return null;
 	}
 
-	//	public TmfEvent getNextEvent(TmfExperimentContext context) {
-//		// TODO: Consider the time adjustment
-//		int trace = 0;
-//		TmfTimestamp timestamp = TmfTimestamp.BigCrunch;
-//		if (context.getEvents()[trace] != null) {
-//			timestamp = context.getEvents()[trace].getTimestamp();
-//		}
-//		for (int i = 1; i < context.getTraces().length; i++) {
-//			if (context.getEvents()[i].getTimestamp() != null) {
-//				TmfTimestamp otherTS = context.getEvents()[i].getTimestamp();
-//				if (otherTS.compareTo(timestamp, true) < 0) {
-//					trace = i;
-//					timestamp = otherTS;
-//				}
-//			}
-//		}
-//		TmfEvent event = context.getTraces()[trace].getNextEvent(context.getContexts()[trace]);
-//		context.getEvents()[trace] = context.getTraces()[trace].parseEvent(context.getContexts()[trace]);
-//		return event;
-//	}
-
 	public TmfEvent parseEvent(TmfContext context) {
 		// TODO Auto-generated method stub
 		return null;
 	}
 
-//	/**
-//	 * Scan the next events from all traces and return the next one
-//	 * in chronological order.
-//	 * 
-//	 * @param context
-//	 * @return
-//	 */
-//	private TmfTimestamp getNextEventTimestamp(TmfExperimentContext context) {
-//		// TODO: Consider the time adjustment
-//		int trace = 0;
-//		TmfTimestamp timestamp = TmfTimestamp.BigCrunch;
-//		if (context.getEvents()[trace] != null) {
-//			timestamp = context.getEvents()[trace].getTimestamp();
-//		}
-//		for (int i = 1; i < context.getTraces().length; i++) {
-//			if (context.getEvents()[i].getTimestamp() != null) {
-//				TmfTimestamp otherTS = context.getEvents()[i].getTimestamp();
-//				if (otherTS.compareTo(timestamp, true) < 0) {
-//					trace = i;
-//					timestamp = otherTS;
-//				}
-//			}
-//		}
-//		return timestamp;
-//	}
-
 	/* (non-Javadoc)
 	 * @see java.lang.Object#toString()
 	 */
@@ -679,7 +588,7 @@ public class TmfExperiment<T extends TmfEvent> extends TmfEventProvider<T> imple
     // ------------------------------------------------------------------------
 
     @TmfSignalHandler
-    public void experimentSelected(TmfExperimentSelectedSignal signal) {
+    public void experimentSelected(TmfExperimentSelectedSignal<T> signal) {
 		fCurrentExperiment = signal.getExperiment();
 //    	if (signal.getExperiment() == this) {
 //    		indexExperiment(true);
diff --git a/lttng/org.eclipse.linuxtools.tmf/src/org/eclipse/linuxtools/tmf/experiment/TmfExperimentSelectedSignal.java b/lttng/org.eclipse.linuxtools.tmf/src/org/eclipse/linuxtools/tmf/experiment/TmfExperimentSelectedSignal.java
index 4d55793d1c..6aafbaa083 100644
--- a/lttng/org.eclipse.linuxtools.tmf/src/org/eclipse/linuxtools/tmf/experiment/TmfExperimentSelectedSignal.java
+++ b/lttng/org.eclipse.linuxtools.tmf/src/org/eclipse/linuxtools/tmf/experiment/TmfExperimentSelectedSignal.java
@@ -20,11 +20,11 @@ import org.eclipse.linuxtools.tmf.signal.TmfSignal;
  * <p>
  * TODO: Implement me. Please.
  */
-public class TmfExperimentSelectedSignal extends TmfSignal {
+public class TmfExperimentSelectedSignal<T extends TmfEvent> extends TmfSignal {
 
-	private final TmfExperiment<? extends TmfEvent> fExperiment;
+	private final TmfExperiment<T> fExperiment;
 	
-	public TmfExperimentSelectedSignal(Object source, TmfExperiment<? extends TmfEvent> experiment) {
+	public TmfExperimentSelectedSignal(Object source, TmfExperiment<T> experiment) {
 		super(source);
 		fExperiment = experiment;
 	}
diff --git a/lttng/org.eclipse.linuxtools.tmf/src/org/eclipse/linuxtools/tmf/request/ITmfDataRequest.java b/lttng/org.eclipse.linuxtools.tmf/src/org/eclipse/linuxtools/tmf/request/ITmfDataRequest.java
index 3290ca8dbf..32ae0d8012 100644
--- a/lttng/org.eclipse.linuxtools.tmf/src/org/eclipse/linuxtools/tmf/request/ITmfDataRequest.java
+++ b/lttng/org.eclipse.linuxtools.tmf/src/org/eclipse/linuxtools/tmf/request/ITmfDataRequest.java
@@ -33,7 +33,7 @@ public interface ITmfDataRequest<T extends TmfData> {
     /**
      * @return request ID
      */
-    public int getRequestId();
+    public long getRequestId();
 
     /**
 	 * @return the index of the first event requested
@@ -59,7 +59,6 @@ public interface ITmfDataRequest<T extends TmfData> {
 	// Request state
 	// ------------------------------------------------------------------------
 
-    public boolean isRunning();
     public boolean isCompleted();
     public boolean isFailed();
     public boolean isCancelled();
@@ -76,7 +75,6 @@ public interface ITmfDataRequest<T extends TmfData> {
 	// Request handling
 	// ------------------------------------------------------------------------
 
-    public void handleStarted();
     public void handleCompleted();
     public void handleSuccess();
     public void handleFailure();
@@ -86,13 +84,12 @@ public interface ITmfDataRequest<T extends TmfData> {
      * To suspend the client thread until the request completes
      * (or is canceled).
      */
-    public void waitForCompletion() throws InterruptedException;
+    public void waitForCompletion();
 
 	// ------------------------------------------------------------------------
 	// Request state modifiers
 	// ------------------------------------------------------------------------
 
-    public void start();
     public void done();
     public void fail();
     public void cancel();
diff --git a/lttng/org.eclipse.linuxtools.tmf/src/org/eclipse/linuxtools/tmf/request/ITmfRequestHandler.java b/lttng/org.eclipse.linuxtools.tmf/src/org/eclipse/linuxtools/tmf/request/ITmfRequestHandler.java
deleted file mode 100644
index 579ce9b98d..0000000000
--- a/lttng/org.eclipse.linuxtools.tmf/src/org/eclipse/linuxtools/tmf/request/ITmfRequestHandler.java
+++ /dev/null
@@ -1,36 +0,0 @@
-/*******************************************************************************
- * 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.request;
-
-import org.eclipse.linuxtools.tmf.event.TmfData;
-
-/**
- * <b><u>ITmfRequestHandler</u></b>
- * <p>
- * TODO: Implement me. Please.
- * @param <V>
- */
-public interface ITmfRequestHandler<T extends TmfData> {
-
-    /**
-     * Process the request. The client thread can be suspended until the 
-     * request is completed (e.g. for a specific range of events) or it
-     * can choose to process the events asynchronously (e.g. for streaming).
-     * 
-     * If the request can't be serviced, it will fail (i.e. isFailed() will be set).
-     * 
-	 * @param request The request to process
-	 * @param waitForCompletion Suspend the client thread until the request completes
-	 */
-	public void processRequest(TmfDataRequest<T> request, boolean waitForCompletion);
-}
diff --git a/lttng/org.eclipse.linuxtools.tmf/src/org/eclipse/linuxtools/tmf/request/TmfCoalescedDataRequest.java b/lttng/org.eclipse.linuxtools.tmf/src/org/eclipse/linuxtools/tmf/request/TmfCoalescedDataRequest.java
index 957b1aee5f..f47b6f5459 100644
--- a/lttng/org.eclipse.linuxtools.tmf/src/org/eclipse/linuxtools/tmf/request/TmfCoalescedDataRequest.java
+++ b/lttng/org.eclipse.linuxtools.tmf/src/org/eclipse/linuxtools/tmf/request/TmfCoalescedDataRequest.java
@@ -27,7 +27,7 @@ public class TmfCoalescedDataRequest<T extends TmfData> extends TmfDataRequest<T
     // Attributes
     // ------------------------------------------------------------------------
 
-	protected Vector<ITmfDataRequest<T>> fRequests = new Vector<ITmfDataRequest<T>>();
+	protected Vector<TmfDataRequest<T>> fRequests = new Vector<TmfDataRequest<T>>();
 
     // ------------------------------------------------------------------------
     // Constructor
@@ -68,13 +68,13 @@ public class TmfCoalescedDataRequest<T extends TmfData> extends TmfDataRequest<T
     // Management
     // ------------------------------------------------------------------------
 
-	public void addRequest(ITmfDataRequest<T> request) {
+	public void addRequest(TmfDataRequest<T> request) {
 		fRequests.add(request);
 	}
 
-	public boolean isCompatible(ITmfDataRequest<T> request) {
+	public boolean isCompatible(TmfDataRequest<T> request) {
 
-		boolean ok = request.getIndex() == getIndex();
+		boolean ok = request.getIndex() == getIndex();;
 		ok &= request.getNbRequested() == getNbRequested();
 		ok &= request.getBlockize() == getBlockize();
 		
@@ -87,61 +87,59 @@ public class TmfCoalescedDataRequest<T extends TmfData> extends TmfDataRequest<T
 
     @Override
 	public void handleData() {
-    	for (ITmfDataRequest<T> request : fRequests) {
+    	for (TmfDataRequest<T> request : fRequests) {
     		request.setData(getData());
     		request.handleData();
     	}
     }
 
     @Override
-    public void done() {
-    	for (ITmfDataRequest<T> request : fRequests) {
-    		request.done();
+    public void handleCompleted() {
+    	for (TmfDataRequest<T> request : fRequests) {
+    		request.handleCompleted();
     	}
-    	super.done();
     }
 
     @Override
-    public void fail() {
-    	for (ITmfDataRequest<T> request : fRequests) {
-    		request.fail();
+    public void handleSuccess() {
+    	for (TmfDataRequest<T> request : fRequests) {
+    		request.handleSuccess();
     	}
-    	super.fail();
     }
 
     @Override
-    public void cancel() {
-    	for (ITmfDataRequest<T> request : fRequests) {
-    		request.cancel();
+    public void handleFailure() {
+    	for (TmfDataRequest<T> request : fRequests) {
+    		request.handleFailure();
     	}
-    	super.cancel();
     }
 
-    // ------------------------------------------------------------------------
-    // Object
-    // ------------------------------------------------------------------------
+    @Override
+    public void handleCancel() {
+    	for (TmfDataRequest<T> request : fRequests) {
+    		request.handleCancel();
+    	}
+    }
 
     @Override
-    // All requests have a unique id
-    public int hashCode() {
-    	return super.hashCode();
+    public void done() {
+    	for (TmfDataRequest<T> request : fRequests) {
+    		request.done();
+    	}
     }
 
     @Override
-    public boolean equals(Object other) {
-    	if (other instanceof TmfCoalescedDataRequest<?>) {
-    		TmfCoalescedDataRequest<?> request = (TmfCoalescedDataRequest<?>) other;
-       		return 	(request.getDataType()    == getDataType()) &&
-       				(request.getIndex()       == getIndex())    &&
-       				(request.getNbRequested() == getNbRequested());
-       	}
-       	return false;
+    public void fail() {
+    	for (TmfDataRequest<T> request : fRequests) {
+    		request.fail();
+    	}
     }
 
     @Override
-    public String toString() {
-		return "[TmfCoalescedDataRequest(" + getRequestId() + "," + getDataType().getSimpleName() 
-			+ "," + getIndex() + "," + getNbRequested() + "," + getBlockize() + ")]";
+    public void cancel() {
+    	for (TmfDataRequest<T> request : fRequests) {
+    		request.cancel();
+    	}
     }
 
 }
diff --git a/lttng/org.eclipse.linuxtools.tmf/src/org/eclipse/linuxtools/tmf/request/TmfCoalescedEventRequest.java b/lttng/org.eclipse.linuxtools.tmf/src/org/eclipse/linuxtools/tmf/request/TmfCoalescedEventRequest.java
index 59a6dea598..2caab92ae2 100644
--- a/lttng/org.eclipse.linuxtools.tmf/src/org/eclipse/linuxtools/tmf/request/TmfCoalescedEventRequest.java
+++ b/lttng/org.eclipse.linuxtools.tmf/src/org/eclipse/linuxtools/tmf/request/TmfCoalescedEventRequest.java
@@ -14,7 +14,6 @@ package org.eclipse.linuxtools.tmf.request;
 
 import org.eclipse.linuxtools.tmf.event.TmfEvent;
 import org.eclipse.linuxtools.tmf.event.TmfTimeRange;
-import org.eclipse.linuxtools.tmf.event.TmfTimestamp;
 
 /**
  * <b><u>TmfCoalescedEventRequest</u></b>
@@ -27,7 +26,7 @@ public class TmfCoalescedEventRequest<T extends TmfEvent> extends TmfCoalescedDa
     // Attributes
     // ------------------------------------------------------------------------
 
-	private TmfTimeRange fRange;	// The requested events time range
+	private final TmfTimeRange fRange;	// The requested events time range
 
     // ------------------------------------------------------------------------
     // Constructor
@@ -70,45 +69,17 @@ public class TmfCoalescedEventRequest<T extends TmfEvent> extends TmfCoalescedDa
     // ------------------------------------------------------------------------
 
 	@Override
-	public boolean isCompatible(ITmfDataRequest<T> request) {
-		if (request instanceof ITmfEventRequest<?>) {
+	public boolean isCompatible(TmfDataRequest<T> request) {
+		if (request instanceof TmfEventRequest<?>) {
 			boolean ok = getNbRequested() == request.getNbRequested();
 			ok &= getBlockize() == request.getBlockize();
-			if (ok) {
-				TmfTimestamp startTime = ((ITmfEventRequest<T>) request).getRange().getStartTime();
-				TmfTimestamp endTime   = ((ITmfEventRequest<T>) request).getRange().getEndTime();
-				if (!fRange.contains(startTime))
-					fRange = new TmfTimeRange(startTime, fRange.getEndTime());
-				if (!fRange.contains(endTime))
-					fRange = new TmfTimeRange(fRange.getStartTime(), endTime);
-			}
+			ok &= fRange.equals(((TmfEventRequest<T>) request).getRange());
 			return ok;
 		}
 		return false;
 	}
 
     // ------------------------------------------------------------------------
-    // ITmfDataRequest
-    // ------------------------------------------------------------------------
-
-    @Override
-	public void handleData() {
-    	for (ITmfDataRequest<T> request : fRequests) {
-    		if (request instanceof TmfEventRequest) {
-    			TmfEventRequest<T> req = (TmfEventRequest<T>) request;
-        		T[] data = getData();
-        		if (data.length > 0 && req.getRange().contains(data[0].getTimestamp())) {
-            		req.setData(data);
-            		req.handleData();
-        		}
-    		}
-    		else {
-    			super.handleData();
-    		}
-    	}
-    }
-
-    // ------------------------------------------------------------------------
     // ITmfEventRequest
     // ------------------------------------------------------------------------
 
@@ -116,35 +87,4 @@ public class TmfCoalescedEventRequest<T extends TmfEvent> extends TmfCoalescedDa
 		return fRange;
 	}
 	
-    // ------------------------------------------------------------------------
-    // Object
-    // ------------------------------------------------------------------------
-
-    @Override
-    // All requests have a unique id
-    public int hashCode() {
-    	return super.hashCode();
-    }
-
-    @Override
-    public boolean equals(Object other) {
-    	if (other instanceof TmfCoalescedEventRequest<?>) {
-    		TmfCoalescedEventRequest<?> request = (TmfCoalescedEventRequest<?>) other;
-       		return 	(request.getDataType()    == getDataType()) &&
-       				(request.getIndex()       == getIndex())    &&
-       				(request.getNbRequested() == getNbRequested()) &&
-       	    		(request.getRange().equals(getRange()));
-       	}
-    	if (other instanceof TmfCoalescedDataRequest<?>) {
-       		return super.equals(other);
-    	}
-  		return false;
-    }
-
-    @Override
-    public String toString() {
-		return "[TmfCoalescedEventRequest(" + getRequestId() + "," + getDataType().getSimpleName() 
-			+ "," + getRange() + "," + getNbRequested() + "," + getBlockize() + ")]";
-    }
-
 }
diff --git a/lttng/org.eclipse.linuxtools.tmf/src/org/eclipse/linuxtools/tmf/request/TmfDataRequest.java b/lttng/org.eclipse.linuxtools.tmf/src/org/eclipse/linuxtools/tmf/request/TmfDataRequest.java
index f51d0e19bb..a96dc6367b 100644
--- a/lttng/org.eclipse.linuxtools.tmf/src/org/eclipse/linuxtools/tmf/request/TmfDataRequest.java
+++ b/lttng/org.eclipse.linuxtools.tmf/src/org/eclipse/linuxtools/tmf/request/TmfDataRequest.java
@@ -66,7 +66,7 @@ import org.eclipse.linuxtools.tmf.event.TmfData;
  * 
  * TODO: Implement request failures (codes, etc...)
  */
-public class TmfDataRequest<T extends TmfData> {
+public abstract class TmfDataRequest<T extends TmfData> implements ITmfDataRequest<T> {
 
     // ------------------------------------------------------------------------
     // Constants
@@ -84,7 +84,7 @@ public class TmfDataRequest<T extends TmfData> {
     // Attributes
     // ------------------------------------------------------------------------
 
-    private final Class<? extends TmfData> fDataType;
+    private final Class<T> fDataType;
     private final int fRequestId;  			// A unique request ID
     private final int fIndex;      			// The index (rank) of the requested event
     private final int fNbRequested;  		// The number of requested events (ALL_DATA for all)
@@ -105,14 +105,14 @@ public class TmfDataRequest<T extends TmfData> {
     /**
      * Default constructor
      */
-    public TmfDataRequest(Class<? extends TmfData> dataType) {
+    public TmfDataRequest(Class<T> dataType) {
         this(dataType, 0, ALL_DATA, DEFAULT_BLOCK_SIZE);
     }
 
     /**
      * @param nbRequested
      */
-    public TmfDataRequest(Class<? extends TmfData> dataType, int index) {
+    public TmfDataRequest(Class<T> dataType, int index) {
         this(dataType, index, ALL_DATA, DEFAULT_BLOCK_SIZE);
     }
 
@@ -120,7 +120,7 @@ public class TmfDataRequest<T extends TmfData> {
      * @param index
      * @param nbRequested
      */
-    public TmfDataRequest(Class<? extends TmfData> dataType, int index, int nbRequested) {
+    public TmfDataRequest(Class<T> dataType, int index, int nbRequested) {
         this(dataType, index, nbRequested, DEFAULT_BLOCK_SIZE);
     }
 
@@ -129,7 +129,7 @@ public class TmfDataRequest<T extends TmfData> {
      * @param nbRequested
      * @param blockSize
      */
-    public TmfDataRequest(Class<? extends TmfData> dataType, int index, int nbRequested, int blockSize) {
+    public TmfDataRequest(Class<T> dataType, int index, int nbRequested, int blockSize) {
     	fRequestId   = fRequestNumber++;
     	fDataType    = dataType;
     	fIndex       = index;
@@ -137,7 +137,24 @@ public class TmfDataRequest<T extends TmfData> {
     	fBlockSize   = blockSize;
     	fNbRead      = 0;
     }
-    
+
+    @Override
+    public boolean equals(Object other) {
+    	if (other instanceof TmfDataRequest<?>) {
+    		TmfDataRequest<?> request = (TmfDataRequest<?>) other;
+    		return 	(request.fDataType    == fDataType) &&
+    				(request.fIndex       == fIndex)    &&
+    				(request.fNbRequested == fNbRequested);
+    	}
+    	return false;
+    }
+
+//    @Override
+//    public int hashCode() {
+//    	int hash = 0;
+//    	return hash;
+//    }
+
     // ------------------------------------------------------------------------
     // Accessors
     // ------------------------------------------------------------------------
@@ -150,9 +167,9 @@ public class TmfDataRequest<T extends TmfData> {
 	}
 
 	/**
-	 * @return the index
+	 * @return the index of the first event requested
 	 */
-	public long getIndex() {
+	public int getIndex() {
 		return fIndex;
 	}
 
@@ -201,7 +218,7 @@ public class TmfDataRequest<T extends TmfData> {
     /**
      * @return the requested data type
      */
-    public Class<?> getDataType() {
+    public Class<T> getDataType() {
         return fDataType;
     }
 
@@ -241,8 +258,7 @@ public class TmfDataRequest<T extends TmfData> {
      *
      * @param events - an array of events
      */
-    public void handleData() {
-    }
+    public abstract void handleData();
 
     /**
      * Handle the completion of the request. It is called when there is no more
diff --git a/lttng/org.eclipse.linuxtools.tmf/src/org/eclipse/linuxtools/tmf/request/TmfEventRequest.java b/lttng/org.eclipse.linuxtools.tmf/src/org/eclipse/linuxtools/tmf/request/TmfEventRequest.java
index 678125cf36..742d978ff3 100644
--- a/lttng/org.eclipse.linuxtools.tmf/src/org/eclipse/linuxtools/tmf/request/TmfEventRequest.java
+++ b/lttng/org.eclipse.linuxtools.tmf/src/org/eclipse/linuxtools/tmf/request/TmfEventRequest.java
@@ -20,7 +20,7 @@ import org.eclipse.linuxtools.tmf.event.TmfTimeRange;
  * <p>
  * Implement me. Please.
  */
-public class TmfEventRequest<T extends TmfEvent> extends TmfDataRequest<T> {
+public abstract class TmfEventRequest<T extends TmfEvent> extends TmfDataRequest<T> implements ITmfEventRequest<T> {
 
     // ------------------------------------------------------------------------
     // Attributes
@@ -35,14 +35,14 @@ public class TmfEventRequest<T extends TmfEvent> extends TmfDataRequest<T> {
     /**
      * @param range
      */
-    public TmfEventRequest(Class<? extends TmfEvent> dataType) {
+    public TmfEventRequest(Class<T> dataType) {
         this(dataType, TmfTimeRange.Eternity, ALL_DATA, DEFAULT_BLOCK_SIZE);
     }
 
     /**
      * @param range
      */
-    public TmfEventRequest(Class<? extends TmfEvent> dataType, TmfTimeRange range) {
+    public TmfEventRequest(Class<T> dataType, TmfTimeRange range) {
         this(dataType, range, ALL_DATA, DEFAULT_BLOCK_SIZE);
     }
 
@@ -50,7 +50,7 @@ public class TmfEventRequest<T extends TmfEvent> extends TmfDataRequest<T> {
      * @param range
      * @param nbRequested
      */
-    public TmfEventRequest(Class<? extends TmfEvent> dataType, TmfTimeRange range, int nbRequested) {
+    public TmfEventRequest(Class<T> dataType, TmfTimeRange range, int nbRequested) {
         this(dataType, range, nbRequested, DEFAULT_BLOCK_SIZE);
     }
     
@@ -59,11 +59,20 @@ public class TmfEventRequest<T extends TmfEvent> extends TmfDataRequest<T> {
      * @param nbRequested
      * @param blockSize Size of the largest blocks expected
      */
-    public TmfEventRequest(Class<? extends TmfEvent> dataType, TmfTimeRange range, int nbRequested, int blockSize) {
+    public TmfEventRequest(Class<T> dataType, TmfTimeRange range, int nbRequested, int blockSize) {
     	super(dataType, 0, nbRequested, blockSize);
     	fRange = range;
     }
 
+    @Override
+    public boolean equals(Object other) {
+    	if (other instanceof TmfEventRequest<?>) {
+    		TmfEventRequest<?> request = (TmfEventRequest<?>) other;
+    		return super.equals(other) && request.fRange.equals(fRange);
+    	}
+    	return false;
+    }
+
     // ------------------------------------------------------------------------
     // Accessors
     // ------------------------------------------------------------------------
diff --git a/lttng/org.eclipse.linuxtools.tmf/src/org/eclipse/linuxtools/tmf/request/TmfRequestExecutor.java b/lttng/org.eclipse.linuxtools.tmf/src/org/eclipse/linuxtools/tmf/request/TmfRequestExecutor.java
index 2094d38287..6e4e202481 100644
--- a/lttng/org.eclipse.linuxtools.tmf/src/org/eclipse/linuxtools/tmf/request/TmfRequestExecutor.java
+++ b/lttng/org.eclipse.linuxtools.tmf/src/org/eclipse/linuxtools/tmf/request/TmfRequestExecutor.java
@@ -1,3 +1,15 @@
+/*******************************************************************************
+ * 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.request;
 
 import java.util.Queue;
@@ -5,6 +17,11 @@ import java.util.concurrent.Executor;
 import java.util.concurrent.Executors;
 import java.util.concurrent.LinkedBlockingQueue;
 
+/**
+ * <b><u>TmfRequestExecutor</u></b>
+ *
+ * Implement me. Please.
+ */
 public class TmfRequestExecutor implements Executor {
 
 	private final Executor fExecutor;
diff --git a/lttng/org.eclipse.linuxtools.tmf/src/org/eclipse/linuxtools/tmf/trace/TmfTrace.java b/lttng/org.eclipse.linuxtools.tmf/src/org/eclipse/linuxtools/tmf/trace/TmfTrace.java
index 08bb053a68..5fee0a54e7 100644
--- a/lttng/org.eclipse.linuxtools.tmf/src/org/eclipse/linuxtools/tmf/trace/TmfTrace.java
+++ b/lttng/org.eclipse.linuxtools.tmf/src/org/eclipse/linuxtools/tmf/trace/TmfTrace.java
@@ -25,6 +25,7 @@ import org.eclipse.linuxtools.tmf.component.TmfEventProvider;
 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.request.TmfCoalescedEventRequest;
 import org.eclipse.linuxtools.tmf.request.TmfDataRequest;
 import org.eclipse.linuxtools.tmf.request.TmfEventRequest;
 
@@ -174,6 +175,9 @@ public abstract class TmfTrace<T extends TmfEvent> extends TmfEventProvider<T> i
 		if (request instanceof TmfEventRequest<?>) {
 			return seekEvent(((TmfEventRequest<T>) request).getRange().getStartTime());
 		}
+		if (request instanceof TmfCoalescedEventRequest<?>) {
+			return seekEvent(((TmfCoalescedEventRequest<T>) request).getRange().getStartTime());
+		}
 		return null;
 	}