Make the TmfLocation final and get rid of clone()

[deliverable/tracecompass.git] / org.eclipse.linuxtools.tmf.core.tests / src / org / eclipse / linuxtools / tmf / core / tests / trace / TmfTraceTest.java

diff --git a/org.eclipse.linuxtools.tmf.core.tests/src/org/eclipse/linuxtools/tmf/core/tests/trace/TmfTraceTest.java b/org.eclipse.linuxtools.tmf.core.tests/src/org/eclipse/linuxtools/tmf/core/tests/trace/TmfTraceTest.java
index a0bab9788d86811d62a9e8f46448a2ee0e23ef02..143dc5ff3fc4e0305de66a0b2edb3280812829e3 100644 (file)
--- a/org.eclipse.linuxtools.tmf.core.tests/src/org/eclipse/linuxtools/tmf/core/tests/trace/TmfTraceTest.java
+++ b/org.eclipse.linuxtools.tmf.core.tests/src/org/eclipse/linuxtools/tmf/core/tests/trace/TmfTraceTest.java
@@ -44,7 +44,7 @@ import org.eclipse.linuxtools.tmf.tests.stubs.trace.TmfTraceStub;
 /**
  * Test suite for the TmfTrace class.
  */
-@SuppressWarnings({ "nls" })
+@SuppressWarnings({"nls","javadoc"})
 public class TmfTraceTest extends TestCase {
 
     // ------------------------------------------------------------------------
@@ -63,7 +63,10 @@ public class TmfTraceTest extends TestCase {
     // Housekeeping
     // ------------------------------------------------------------------------
 
-    public TmfTraceTest(final String name) throws Exception {
+    /**
+     * @param name the test name
+     */
+    public TmfTraceTest(final String name) {
         super(name);
     }
 
@@ -106,7 +109,8 @@ public class TmfTraceTest extends TestCase {
     // Constructors
     // ------------------------------------------------------------------------
 
-    public void testStandardConstructor() throws Exception {
+    @SuppressWarnings("null")
+    public void testStandardConstructor() throws TmfTraceException {
         TmfTraceStub trace = null;
         File testfile = null;
         try {
@@ -135,7 +139,8 @@ public class TmfTraceTest extends TestCase {
         assertEquals("getEndTime",     NB_EVENTS, trace.getEndTime().getValue());
     }
 
-    public void testStandardConstructorCacheSize() throws Exception {
+    @SuppressWarnings("null")
+    public void testStandardConstructorCacheSize() throws TmfTraceException {
         TmfTraceStub trace = null;
         File testfile = null;
         try {
@@ -188,7 +193,8 @@ public class TmfTraceTest extends TestCase {
         assertEquals("getEndTime",     NB_EVENTS, trace.getEndTime().getValue());
     }
 
-    public void testFullConstructor() throws Exception {
+    @SuppressWarnings("null")
+    public void testFullConstructor() throws TmfTraceException {
         TmfTraceStub trace = null;
         File testfile = null;
         try {
@@ -217,7 +223,8 @@ public class TmfTraceTest extends TestCase {
         assertEquals("getEndTime",     NB_EVENTS, trace.getEndTime().getValue());
     }
 
-    public void testLiveTraceConstructor() throws Exception {
+    @SuppressWarnings("null")
+    public void testLiveTraceConstructor() throws TmfTraceException {
         TmfTraceStub trace = null;
         File testfile = null;
         final long interval = 100;
@@ -247,8 +254,8 @@ public class TmfTraceTest extends TestCase {
         assertEquals("getEndTime",     NB_EVENTS, trace.getEndTime().getValue());
     }
 
-    @SuppressWarnings({ "unchecked", "rawtypes" })
-    public void testCopyConstructor() throws Exception {
+    @SuppressWarnings("null")
+    public void testCopyConstructor() throws TmfTraceException {
         TmfTraceStub original = null;
         TmfTraceStub trace = null;
         File testfile = null;
@@ -293,7 +300,7 @@ public class TmfTraceTest extends TestCase {
     // Trace initialization
     // ------------------------------------------------------------------------
 
-    public void testInitializeNullPath() throws Exception {
+    public void testInitializeNullPath() {
 
         // Instantiate an "empty" trace
         final TmfTraceStub trace = new TmfTraceStub();
@@ -307,8 +314,8 @@ public class TmfTraceTest extends TestCase {
             fail("TmfTrace.initialize() - wrong exception thrown");
         }
     }
-        
-    public void testInitializeSimplePath() throws Exception {
+
+    public void testInitializeSimplePath() {
 
         // Instantiate an "empty" trace
         final TmfTraceStub trace = new TmfTraceStub();
@@ -335,7 +342,7 @@ public class TmfTraceTest extends TestCase {
         assertEquals("getEndTime",     Long.MIN_VALUE, trace.getEndTime().getValue());
     }
 
-    public void testInitializeNormalPath() throws Exception {
+    public void testInitializeNormalPath() {
 
         // Instantiate an "empty" trace
         final TmfTraceStub trace = new TmfTraceStub();
@@ -363,7 +370,7 @@ public class TmfTraceTest extends TestCase {
         assertEquals("getEndTime",     Long.MIN_VALUE, trace.getEndTime().getValue());
     }
 
-    public void testInitTrace() throws Exception {
+    public void testInitTrace() throws URISyntaxException, IOException, TmfTraceException, InterruptedException {
 
         // Instantiate an "empty" trace
         final TmfTraceStub trace = new TmfTraceStub();
@@ -414,7 +421,7 @@ public class TmfTraceTest extends TestCase {
     // Set/Get streaming interval
     // ------------------------------------------------------------------------
 
-    public void testSetStreamingInterval() throws Exception {
+    public void testSetStreamingInterval() throws TmfTraceException {
         final TmfTraceStub trace = new TmfTraceStub(fTrace);
 
         long interval = 0;
@@ -423,15 +430,15 @@ public class TmfTraceTest extends TestCase {
         interval = 100;
         trace.setStreamingInterval(interval);
         assertEquals("getStreamingInterval", interval, trace.getStreamingInterval());
-        
+
         interval = -1;
         trace.setStreamingInterval(interval);
         assertEquals("getStreamingInterval", 0, trace.getStreamingInterval());
-        
+
         interval = 0;
         trace.setStreamingInterval(interval);
         assertEquals("getStreamingInterval", interval, trace.getStreamingInterval());
-        
+
         trace.dispose();
     }
 
@@ -439,7 +446,7 @@ public class TmfTraceTest extends TestCase {
     // Set/Get time range
     // ------------------------------------------------------------------------
 
-    public void testSetTimeRange() throws Exception {
+    public void testSetTimeRange() throws TmfTraceException {
         final TmfTraceStub trace = new TmfTraceStub(fTrace);
         trace.indexTrace();
 
@@ -457,7 +464,7 @@ public class TmfTraceTest extends TestCase {
         trace.dispose();
     }
 
-    public void testSetStartTime() throws Exception {
+    public void testSetStartTime() throws TmfTraceException {
         final TmfTraceStub trace = new TmfTraceStub(fTrace);
         trace.indexTrace();
 
@@ -475,7 +482,7 @@ public class TmfTraceTest extends TestCase {
         trace.dispose();
     }
 
-    public void testSetEndTime() throws Exception {
+    public void testSetEndTime() throws TmfTraceException {
         final TmfTraceStub trace = new TmfTraceStub(fTrace);
         trace.indexTrace();
 
@@ -493,7 +500,7 @@ public class TmfTraceTest extends TestCase {
         trace.dispose();
     }
 
-    public void testSetNbEvents() throws Exception {
+    public void testSetNbEvents() throws TmfTraceException {
         final TmfTraceStub trace = new TmfTraceStub(fTrace);
         trace.indexTrace();
 
@@ -518,7 +525,7 @@ public class TmfTraceTest extends TestCase {
     // seekEvent on location (note: does not reliably set the rank)
     // ------------------------------------------------------------------------
 
-    public void testSeekEventOnCacheBoundary() throws Exception {
+    public void testSeekEventOnCacheBoundary() {
 
         // Position trace at event rank 0
         ITmfContext context = fTrace.seekEvent(0);
@@ -564,7 +571,7 @@ public class TmfTraceTest extends TestCase {
         assertEquals("Event rank", ITmfContext.UNKNOWN_RANK, context.getRank());
     }
 
-    public void testSeekEventNotOnCacheBoundary() throws Exception {
+    public void testSeekEventNotOnCacheBoundary() {
 
         // Position trace at event rank 9
         ITmfContext tmpContext = fTrace.seekEvent(new TmfTimestamp(10, SCALE, 0));
@@ -619,7 +626,7 @@ public class TmfTraceTest extends TestCase {
         assertEquals("Event rank", ITmfContext.UNKNOWN_RANK, context.getRank());
     }
 
-    public void testSeekEventOutOfScope() throws Exception {
+    public void testSeekEventOutOfScope() {
 
         // Position trace at beginning
         ITmfContext tmpContext = fTrace.seekEvent(0);
@@ -647,7 +654,7 @@ public class TmfTraceTest extends TestCase {
     // seekEvent on timestamp (note: does not reliably set the rank)
     // ------------------------------------------------------------------------
 
-    public void testSeekEventOnNullTimestamp() throws Exception {
+    public void testSeekEventOnNullTimestamp() {
 
         // Position trace at event rank 0
         ITmfContext context = fTrace.seekEvent((ITmfTimestamp) null);
@@ -658,7 +665,7 @@ public class TmfTraceTest extends TestCase {
         assertEquals("Event rank", 0, context.getRank());
     }
 
-    public void testSeekEventOnTimestampOnCacheBoundary() throws Exception {
+    public void testSeekEventOnTimestampOnCacheBoundary() {
 
         // Position trace at event rank 0
         ITmfContext context = fTrace.seekEvent(new TmfTimestamp(1, SCALE, 0));
@@ -697,7 +704,7 @@ public class TmfTraceTest extends TestCase {
         assertEquals("Event rank", 4001, context.getRank());
     }
 
-    public void testSeekEventOnTimestampNotOnCacheBoundary() throws Exception {
+    public void testSeekEventOnTimestampNotOnCacheBoundary() {
 
         // Position trace at event rank 1
         ITmfContext context = fTrace.seekEvent(new TmfTimestamp(2, SCALE, 0));
@@ -760,7 +767,7 @@ public class TmfTraceTest extends TestCase {
         assertEquals("Event rank", 4501, context.getRank());
     }
 
-    public void testSeekEventOnTimestampOutOfScope() throws Exception {
+    public void testSeekEventOnTimestampOutOfScope() {
 
         // Position trace at beginning
         ITmfContext context = fTrace.seekEvent(new TmfTimestamp(-1, SCALE, 0));
@@ -791,7 +798,7 @@ public class TmfTraceTest extends TestCase {
     // seekEvent on rank
     // ------------------------------------------------------------------------
 
-    public void testSeekEventOnNegativeRank() throws Exception {
+    public void testSeekEventOnNegativeRank() {
 
         // Position trace at event rank 0
         ITmfContext context = fTrace.seekEvent(-1);
@@ -802,7 +809,7 @@ public class TmfTraceTest extends TestCase {
         assertEquals("Event rank", 0, context.getRank());
     }
 
-    public void testSeekOnRankOnCacheBoundary() throws Exception {
+    public void testSeekOnRankOnCacheBoundary() {
 
         // On lower bound, returns the first event (ts = 1)
         ITmfContext context = fTrace.seekEvent(0);
@@ -841,7 +848,7 @@ public class TmfTraceTest extends TestCase {
         assertEquals("Event rank", 4001, context.getRank());
     }
 
-    public void testSeekOnRankNotOnCacheBoundary() throws Exception {
+    public void testSeekOnRankNotOnCacheBoundary() {
 
         // Position trace at event rank 9
         ITmfContext context = fTrace.seekEvent(9);
@@ -892,7 +899,7 @@ public class TmfTraceTest extends TestCase {
         assertEquals("Event rank", 4501, context.getRank());
     }
 
-    public void testSeekEventOnRankOutOfScope() throws Exception {
+    public void testSeekEventOnRankOutOfScope() {
 
         // Position trace at beginning
         ITmfContext context = fTrace.seekEvent(-1);
@@ -923,7 +930,7 @@ public class TmfTraceTest extends TestCase {
     // parseEvent - make sure parseEvent doesn't update the context
     // ------------------------------------------------------------------------
 
-    public void testParseEvent() throws Exception {
+    public void testParseEvent() {
 
         final int NB_READS = 20;
 
@@ -968,7 +975,7 @@ public class TmfTraceTest extends TestCase {
     // getNext - updates the context
     // ------------------------------------------------------------------------
 
-    public void testGetNextAfteSeekingOnTS_1() throws Exception {
+    public void testGetNextAfteSeekingOnTS_1() {
 
         final long INITIAL_TS = 1;
         final int NB_READS = 20;
@@ -990,7 +997,7 @@ public class TmfTraceTest extends TestCase {
         assertEquals("Event rank", INITIAL_TS + NB_READS - 1, context.getRank());
     }
 
-    public void testGetNextAfteSeekingOnTS_2() throws Exception {
+    public void testGetNextAfteSeekingOnTS_2() {
 
         final long INITIAL_TS = 2;
         final int NB_READS = 20;
@@ -1012,7 +1019,7 @@ public class TmfTraceTest extends TestCase {
         assertEquals("Event rank", INITIAL_TS + NB_READS - 1, context.getRank());
     }
 
-    public void testGetNextAfteSeekingOnTS_3() throws Exception {
+    public void testGetNextAfteSeekingOnTS_3() {
 
         final long INITIAL_TS = 500;
         final int NB_READS = 20;
@@ -1034,7 +1041,7 @@ public class TmfTraceTest extends TestCase {
         assertEquals("Event rank", INITIAL_TS + NB_READS - 1, context.getRank());
     }
 
-    public void testGetNextAfterSeekingOnRank_1() throws Exception {
+    public void testGetNextAfterSeekingOnRank_1() {
 
         final long INITIAL_RANK = 0L;
         final int NB_READS = 20;
@@ -1056,7 +1063,7 @@ public class TmfTraceTest extends TestCase {
         assertEquals("Event rank", INITIAL_RANK + NB_READS, context.getRank());
     }
 
-    public void testGetNextAfterSeekingOnRank_2() throws Exception {
+    public void testGetNextAfterSeekingOnRank_2() {
 
         final long INITIAL_RANK = 1L;
         final int NB_READS = 20;
@@ -1078,7 +1085,7 @@ public class TmfTraceTest extends TestCase {
         assertEquals("Event rank", INITIAL_RANK + NB_READS, context.getRank());
     }
 
-    public void testGetNextAfterSeekingOnRank_3() throws Exception {
+    public void testGetNextAfterSeekingOnRank_3() {
 
         final long INITIAL_RANK = 500L;
         final int NB_READS = 20;
@@ -1100,9 +1107,9 @@ public class TmfTraceTest extends TestCase {
         assertEquals("Event rank", INITIAL_RANK + NB_READS, context.getRank());
     }
 
-    public void testGetNextAfterSeekingOnLocation_1() throws Exception {
+    public void testGetNextAfterSeekingOnLocation_1() {
 
-        final ITmfLocation<?> INITIAL_LOC = null;
+        final ITmfLocation INITIAL_LOC = null;
         final long INITIAL_TS = 1;
         final int NB_READS = 20;
 
@@ -1123,9 +1130,9 @@ public class TmfTraceTest extends TestCase {
         assertEquals("Event rank", INITIAL_TS + NB_READS - 1, context.getRank());
     }
 
-    public void testGetNextAfterSeekingOnLocation_2() throws Exception {
+    public void testGetNextAfterSeekingOnLocation_2() {
 
-        final ITmfLocation<?> INITIAL_LOC = fTrace.seekEvent(1L).getLocation();
+        final ITmfLocation INITIAL_LOC = fTrace.seekEvent(1L).getLocation();
         final long INITIAL_TS = 2;
         final int NB_READS = 20;
 
@@ -1144,9 +1151,9 @@ public class TmfTraceTest extends TestCase {
         assertEquals("Event timestamp", INITIAL_TS + NB_READS, event.getTimestamp().getValue());
     }
 
-    public void testGetNextAfterSeekingOnLocation_3() throws Exception {
+    public void testGetNextAfterSeekingOnLocation_3() {
 
-        final ITmfLocation<?> INITIAL_LOC = fTrace.seekEvent(500L).getLocation();
+        final ITmfLocation INITIAL_LOC = fTrace.seekEvent(500L).getLocation();
         final long INITIAL_TS = 501;
         final int NB_READS = 20;
 
@@ -1165,20 +1172,20 @@ public class TmfTraceTest extends TestCase {
         assertEquals("Event timestamp", INITIAL_TS + NB_READS, event.getTimestamp().getValue());
     }
 
-    public void testGetNextLocation() throws Exception {
+    public void testGetNextLocation() {
         ITmfContext context1 = fTrace.seekEvent(0);
         fTrace.getNext(context1);
-        ITmfLocation<?> location = context1.getLocation().clone();
+        ITmfLocation location = context1.getLocation();
         ITmfEvent event1 = fTrace.getNext(context1);
         ITmfContext context2 = fTrace.seekEvent(location);
         ITmfEvent event2 = fTrace.getNext(context2);
         assertEquals("Event timestamp", event1.getTimestamp().getValue(), event2.getTimestamp().getValue());
     }
 
-    public void testGetNextEndLocation() throws Exception {
+    public void testGetNextEndLocation() {
         ITmfContext context1 = fTrace.seekEvent(fTrace.getNbEvents() - 1);
         fTrace.getNext(context1);
-        ITmfLocation<?> location = context1.getLocation().clone();
+        ITmfLocation location = context1.getLocation();
         ITmfContext context2 = fTrace.seekEvent(location);
         ITmfEvent event = fTrace.getNext(context2);
         assertNull("Event", event);
@@ -1188,20 +1195,20 @@ public class TmfTraceTest extends TestCase {
     // processRequest
     // ------------------------------------------------------------------------
 
-    @SuppressWarnings("unchecked")
-    public void testProcessEventRequestForAllEvents() throws Exception {
+    @SuppressWarnings("hiding")
+    public void testProcessEventRequestForAllEvents() throws InterruptedException {
         final int BLOCK_SIZE =  1;
-        final Vector<TmfEvent> requestedEvents = new Vector<TmfEvent>();
+        final Vector<ITmfEvent> requestedEvents = new Vector<ITmfEvent>();
 
         final TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BIG_BANG, TmfTimestamp.BIG_CRUNCH);
-        final TmfEventRequest<TmfEvent> request = new TmfEventRequest<TmfEvent>(TmfEvent.class, range, NB_EVENTS, BLOCK_SIZE) {
+        final TmfEventRequest request = new TmfEventRequest(TmfEvent.class, range, NB_EVENTS, BLOCK_SIZE) {
             @Override
-            public void handleData(final TmfEvent event) {
+            public void handleData(final ITmfEvent event) {
                 super.handleData(event);
                 requestedEvents.add(event);
             }
         };
-        final ITmfDataProvider<TmfEvent>[] providers = (ITmfDataProvider<TmfEvent>[]) TmfProviderManager.getProviders(TmfEvent.class, TmfTraceStub.class);
+        final ITmfDataProvider[] providers = TmfProviderManager.getProviders(TmfEvent.class, TmfTraceStub.class);
         providers[0].sendRequest(request);
         request.waitForCompletion();
 
@@ -1216,21 +1223,21 @@ public class TmfTraceTest extends TestCase {
         }
     }
 
-    @SuppressWarnings("unchecked")
-    public void testProcessEventRequestForNbEvents() throws Exception {
+    @SuppressWarnings("hiding")
+    public void testProcessEventRequestForNbEvents() throws InterruptedException {
         final int BLOCK_SIZE = 100;
         final int NB_EVENTS  = 1000;
-        final Vector<TmfEvent> requestedEvents = new Vector<TmfEvent>();
+        final Vector<ITmfEvent> requestedEvents = new Vector<ITmfEvent>();
 
         final TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BIG_BANG, TmfTimestamp.BIG_CRUNCH);
-        final TmfEventRequest<TmfEvent> request = new TmfEventRequest<TmfEvent>(TmfEvent.class, range, NB_EVENTS, BLOCK_SIZE) {
+        final TmfEventRequest request = new TmfEventRequest(TmfEvent.class, range, NB_EVENTS, BLOCK_SIZE) {
             @Override
-            public void handleData(final TmfEvent event) {
+            public void handleData(final ITmfEvent event) {
                 super.handleData(event);
                 requestedEvents.add(event);
             }
         };
-        final ITmfDataProvider<TmfEvent>[] providers = (ITmfDataProvider<TmfEvent>[]) TmfProviderManager.getProviders(TmfEvent.class, TmfTraceStub.class);
+        final ITmfDataProvider[] providers = TmfProviderManager.getProviders(TmfEvent.class, TmfTraceStub.class);
         providers[0].sendRequest(request);
         request.waitForCompletion();
 
@@ -1245,22 +1252,22 @@ public class TmfTraceTest extends TestCase {
         }
     }
 
-    @SuppressWarnings("unchecked")
-    public void testProcessEventRequestForSomeEvents() throws Exception {
+    @SuppressWarnings("hiding")
+    public void testProcessEventRequestForSomeEvents() throws InterruptedException {
         final int BLOCK_SIZE =  1;
         final long startTime = 100;
         final int NB_EVENTS  = 1000;
-        final Vector<TmfEvent> requestedEvents = new Vector<TmfEvent>();
+        final Vector<ITmfEvent> requestedEvents = new Vector<ITmfEvent>();
 
         final TmfTimeRange range = new TmfTimeRange(new TmfTimestamp(startTime, SCALE), TmfTimestamp.BIG_CRUNCH);
-        final TmfEventRequest<TmfEvent> request = new TmfEventRequest<TmfEvent>(TmfEvent.class, range, NB_EVENTS, BLOCK_SIZE) {
+        final TmfEventRequest request = new TmfEventRequest(TmfEvent.class, range, NB_EVENTS, BLOCK_SIZE) {
             @Override
-            public void handleData(final TmfEvent event) {
+            public void handleData(final ITmfEvent event) {
                 super.handleData(event);
                 requestedEvents.add(event);
             }
         };
-        final ITmfDataProvider<TmfEvent>[] providers = (ITmfDataProvider<TmfEvent>[]) TmfProviderManager.getProviders(TmfEvent.class, TmfTraceStub.class);
+        final ITmfDataProvider[] providers = TmfProviderManager.getProviders(TmfEvent.class, TmfTraceStub.class);
         providers[0].sendRequest(request);
         request.waitForCompletion();
 
@@ -1275,23 +1282,23 @@ public class TmfTraceTest extends TestCase {
         }
     }
 
-    @SuppressWarnings("unchecked")
-    public void testProcessEventRequestForOtherEvents() throws Exception {
+    @SuppressWarnings("hiding")
+    public void testProcessEventRequestForOtherEvents() throws InterruptedException {
         final int BLOCK_SIZE =  1;
         final int startIndex = 99;
         final long startTime = 100;
         final int NB_EVENTS  = 1000;
-        final Vector<TmfEvent> requestedEvents = new Vector<TmfEvent>();
+        final Vector<ITmfEvent> requestedEvents = new Vector<ITmfEvent>();
 
         final TmfTimeRange range = new TmfTimeRange(new TmfTimestamp(startTime, SCALE), TmfTimestamp.BIG_CRUNCH);
-        final TmfEventRequest<TmfEvent> request = new TmfEventRequest<TmfEvent>(TmfEvent.class, range, startIndex, NB_EVENTS, BLOCK_SIZE) {
+        final TmfEventRequest request = new TmfEventRequest(TmfEvent.class, range, startIndex, NB_EVENTS, BLOCK_SIZE) {
             @Override
-            public void handleData(final TmfEvent event) {
+            public void handleData(final ITmfEvent event) {
                 super.handleData(event);
                 requestedEvents.add(event);
             }
         };
-        final ITmfDataProvider<TmfEvent>[] providers = (ITmfDataProvider<TmfEvent>[]) TmfProviderManager.getProviders(TmfEvent.class, TmfTraceStub.class);
+        final ITmfDataProvider[] providers = TmfProviderManager.getProviders(TmfEvent.class, TmfTraceStub.class);
         providers[0].sendRequest(request);
         request.waitForCompletion();
 
@@ -1306,20 +1313,20 @@ public class TmfTraceTest extends TestCase {
         }
     }
 
-    @SuppressWarnings("unchecked")
-    public void testProcessDataRequestForSomeEvents() throws Exception {
+    @SuppressWarnings("hiding")
+    public void testProcessDataRequestForSomeEvents() throws InterruptedException {
         final int startIndex = 100;
         final int NB_EVENTS  = 1000;
-        final Vector<TmfEvent> requestedEvents = new Vector<TmfEvent>();
+        final Vector<ITmfEvent> requestedEvents = new Vector<ITmfEvent>();
 
-        final TmfDataRequest<TmfEvent> request = new TmfDataRequest<TmfEvent>(TmfEvent.class, startIndex, NB_EVENTS) {
+        final TmfDataRequest request = new TmfDataRequest(TmfEvent.class, startIndex, NB_EVENTS) {
             @Override
-            public void handleData(final TmfEvent event) {
+            public void handleData(final ITmfEvent event) {
                 super.handleData(event);
                 requestedEvents.add(event);
             }
         };
-        final ITmfDataProvider<TmfEvent>[] providers = (ITmfDataProvider<TmfEvent>[]) TmfProviderManager.getProviders(TmfEvent.class, TmfTraceStub.class);
+        final ITmfDataProvider[] providers = TmfProviderManager.getProviders(TmfEvent.class, TmfTraceStub.class);
         providers[0].sendRequest(request);
         request.waitForCompletion();
 
@@ -1338,15 +1345,14 @@ public class TmfTraceTest extends TestCase {
     // cancel
     // ------------------------------------------------------------------------
 
-    @SuppressWarnings("unchecked")
-    public void testCancel() throws Exception {
-        final Vector<TmfEvent> requestedEvents = new Vector<TmfEvent>();
+    public void testCancel() throws InterruptedException {
+        final Vector<ITmfEvent> requestedEvents = new Vector<ITmfEvent>();
 
         final TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BIG_BANG, TmfTimestamp.BIG_CRUNCH);
-        final TmfEventRequest<TmfEvent> request = new TmfEventRequest<TmfEvent>(TmfEvent.class, range, NB_EVENTS, BLOCK_SIZE) {
+        final TmfEventRequest request = new TmfEventRequest(TmfEvent.class, range, NB_EVENTS, BLOCK_SIZE) {
             int nbRead = 0;
             @Override
-            public void handleData(final TmfEvent event) {
+            public void handleData(final ITmfEvent event) {
                 super.handleData(event);
                 requestedEvents.add(event);
                 if (++nbRead == BLOCK_SIZE) {
@@ -1354,7 +1360,7 @@ public class TmfTraceTest extends TestCase {
                 }
             }
         };
-        final ITmfDataProvider<TmfEvent>[] providers = (ITmfDataProvider<TmfEvent>[]) TmfProviderManager.getProviders(TmfEvent.class, TmfTraceStub.class);
+        final ITmfDataProvider[] providers = TmfProviderManager.getProviders(TmfEvent.class, TmfTraceStub.class);
         providers[0].sendRequest(request);
         request.waitForCompletion();
 
@@ -1367,7 +1373,7 @@ public class TmfTraceTest extends TestCase {
     // toString
     // ------------------------------------------------------------------------
 
-    public void testDefaultTmfTraceStub() throws Exception {
+    public void testDefaultTmfTraceStub() {
         assertFalse ("Open trace", fTrace == null);
         assertEquals("getType",  TmfEvent.class, fTrace.getType());
         assertNull  ("getResource", fTrace.getResource());