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.TmfCoalescedDataRequest;
import org.eclipse.linuxtools.tmf.request.TmfCoalescedEventRequest;
-import org.eclipse.linuxtools.tmf.request.TmfDataRequest;
import org.eclipse.linuxtools.tmf.request.TmfEventRequest;
import org.eclipse.linuxtools.tmf.request.TmfEventRequestStub;
import org.eclipse.linuxtools.tmf.signal.TmfSignal;
/**
* <b><u>TmfCoalescedEventRequestTest</u></b>
* <p>
- * TODO: Implement me. Please.
+ * Test suite for the TmfCoalescedEventRequest class.
*/
+@SuppressWarnings("nls")
public class TmfCoalescedEventRequestTest extends TestCase {
- 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;
+ // ------------------------------------------------------------------------
+ // Variables
+ // ------------------------------------------------------------------------
- private static TmfTraceStub fTrace = null;
+ 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 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 TmfCoalescedEventRequest<TmfEvent> fRequest1b;
+ private static TmfCoalescedEventRequest<TmfEvent> fRequest1c;
- // ------------------------------------------------------------------------
+ private static int fRequestCount;
+
+ // ------------------------------------------------------------------------
// Housekeeping
// ------------------------------------------------------------------------
@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
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);
+ TmfCoalescedEventRequest<TmfEvent> request = new TmfCoalescedEventRequest<TmfEvent>(TmfEvent.class);
+
+ assertEquals("getRequestId", fRequestCount++, request.getRequestId());
+ assertEquals("getDataType", TmfEvent.class, request.getDataType());
+
+ assertEquals("getRange", range1, request.getRange());
+ assertEquals("getNbRequestedEvents", TmfEventRequest.ALL_DATA, request.getNbRequested());
- 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("getIndex", 0, request.getIndex());
- assertEquals("getNbRequestedEvents", TmfDataRequest.ALL_DATA, request.getNbRequested());
- assertEquals("getBlockize", TmfDataRequest.DEFAULT_BLOCK_SIZE, request.getBlockize());
+ assertEquals("getNbRead", 0, request.getNbRead());
}
- public void testTmfCoalescedEventRequestTimeRange() {
- TmfTimeRange range = new TmfTimeRange(new TmfTimestamp(), TmfTimestamp.BigCrunch);
- TmfCoalescedEventRequest<TmfEvent> request = new TmfCoalescedEventRequest<TmfEvent>(TmfEvent.class, range);
+ public void testTmfCoalescedEventRequestIndex() {
+ TmfCoalescedEventRequest<TmfEvent> request = new TmfCoalescedEventRequest<TmfEvent>(TmfEvent.class, range1);
- assertEquals("StartTime", range.getStartTime(), request.getRange().getStartTime());
- assertEquals("EndTime", range.getEndTime(), request.getRange().getEndTime());
+ assertEquals("getRequestId", fRequestCount++, request.getRequestId());
+ assertEquals("getDataType", TmfEvent.class, request.getDataType());
- assertEquals("getIndex", 0, request.getIndex());
- assertEquals("getNbRequestedEvents", TmfDataRequest.ALL_DATA, request.getNbRequested());
- assertEquals("getBlockize", TmfDataRequest.DEFAULT_BLOCK_SIZE, request.getBlockize());
+ assertEquals("getRange", range1, request.getRange());
+ assertEquals("getNbRequestedEvents", TmfEventRequest.ALL_DATA, request.getNbRequested());
+
+ assertFalse("isCompleted", request.isCompleted());
+ assertFalse("isFailed", request.isFailed());
+ assertFalse("isCancelled", request.isCancelled());
+
+ assertEquals("getNbRead", 0, request.getNbRead());
}
- public void testTmfCoalescedEventRequestTimeRangeNbRequested() {
- TmfTimeRange range = new TmfTimeRange(new TmfTimestamp(), TmfTimestamp.BigCrunch);
- TmfCoalescedEventRequest<TmfEvent> request = new TmfCoalescedEventRequest<TmfEvent>(TmfEvent.class, range, 100);
+ public void testTmfCoalescedEventRequestIndexNbRequested() {
+ TmfCoalescedEventRequest<TmfEvent> request = new TmfCoalescedEventRequest<TmfEvent>(TmfEvent.class, range1, 100);
- assertEquals("StartTime", range.getStartTime(), request.getRange().getStartTime());
- assertEquals("EndTime", range.getEndTime(), request.getRange().getEndTime());
+ assertEquals("getRequestId", fRequestCount++, request.getRequestId());
+ assertEquals("getDataType", TmfEvent.class, request.getDataType());
- assertEquals("getIndex", 0, request.getIndex());
+ assertEquals("getRange", range1, request.getRange());
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 testTmfCoalescedEventRequestTimeRangeNbRequestedBlocksize() {
- TmfTimeRange range = new TmfTimeRange(new TmfTimestamp(), TmfTimestamp.BigCrunch);
- TmfCoalescedEventRequest<TmfEvent> request = new TmfCoalescedEventRequest<TmfEvent>(TmfEvent.class, range, 100, 200);
+ public void testTmfCoalescedEventRequestIndexNbEventsBlocksize() {
+ TmfCoalescedEventRequest<TmfEvent> request = new TmfCoalescedEventRequest<TmfEvent>(TmfEvent.class, range1, 100, 200);
- assertEquals("StartTime", range.getStartTime(), request.getRange().getStartTime());
- assertEquals("EndTime", range.getEndTime(), request.getRange().getEndTime());
+ assertEquals("getRequestId", fRequestCount++, request.getRequestId());
+ assertEquals("getDataType", TmfEvent.class, request.getDataType());
- assertEquals("getIndex", 0, request.getIndex());
+ assertEquals("getRange", range1, request.getRange());
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());
+ TmfCoalescedDataRequest<TmfEvent> dataRequest2 = new TmfCoalescedDataRequest<TmfEvent>(
+ fRequest1.getDataType(), fRequest1.getIndex(), fRequest1.getNbRequested());
+ TmfCoalescedDataRequest<TmfEvent> dataRequest3 = new TmfCoalescedDataRequest<TmfEvent>(
+ fRequest3.getDataType(), fRequest3.getIndex(), fRequest3.getNbRequested());
+
+ 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 + ",0,100,200)]";
+ String expected2 = "[TmfCoalescedEventRequest(1,TmfEvent," + range2 + ",0,100,200)]";
+ String expected3 = "[TmfCoalescedEventRequest(2,TmfEvent," + range2 + ",0,200,200)]";
+ String expected4 = "[TmfCoalescedEventRequest(3,TmfEvent," + range2 + ",0,200,300)]";
+
+ assertEquals("toString", expected1, fRequest1.toString());
+ assertEquals("toString", expected2, fRequest2.toString());
+ assertEquals("toString", expected3, fRequest3.toString());
+ assertEquals("toString", expected4, fRequest4.toString());
}
// ------------------------------------------------------------------------
// ------------------------------------------------------------------------
public void testIsCompatible() {
- 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);
+ 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);
assertTrue ("isCompatible", coalescedRequest.isCompatible(request1));
- assertFalse("isCompatible", coalescedRequest.isCompatible(request2));
+ assertTrue ("isCompatible", coalescedRequest.isCompatible(request2));
assertFalse("isCompatible", coalescedRequest.isCompatible(request3));
}
+ // ------------------------------------------------------------------------
+ // 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;
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;
+
}
}
requestedEvents1 = new Vector<TmfEvent>();
request1 = new TmfEventRequest<TmfEvent>(TmfEvent.class, range, NB_EVENTS, BLOCK_SIZE) {
+ int nbRead = 0;
@Override
- public void handleData() {
+ public void handleData(TmfEvent event) {
+ super.handleData(event);
if (!isCompleted()) {
- TmfEvent[] events = getData();
- for (TmfEvent e : events) {
- requestedEvents1.add(e);
- }
- if (signal.forceCancel)
+ requestedEvents1.add(event);
+ if (++nbRead >= BLOCK_SIZE && signal.forceCancel)
cancel();
}
}
requestedEvents2 = new Vector<TmfEvent>();
request2 = new TmfEventRequest<TmfEvent>(TmfEvent.class, range, NB_EVENTS, BLOCK_SIZE) {
@Override
- public void handleData() {
+ public void handleData(TmfEvent event) {
+ super.handleData(event);
if (!isCompleted()) {
- TmfEvent[] events = getData();
- for (TmfEvent e : events) {
- requestedEvents2.add(e);
- }
+ requestedEvents2.add(event);
}
}
};
requestedEvents3 = new Vector<TmfEvent>();
request3 = new TmfEventRequest<TmfEvent>(TmfEvent.class, range, NB_EVENTS, BLOCK_SIZE) {
@Override
- public void handleData() {
+ public void handleData(TmfEvent event) {
+ super.handleData(event);
if (!isCompleted()) {
- TmfEvent[] events = getData();
- for (TmfEvent e : events) {
- requestedEvents3.add(e);
- }
+ requestedEvents3.add(event);
}
}
};
- ITmfDataProvider<TmfEvent>[] providers = (ITmfDataProvider<TmfEvent>[]) TmfProviderManager.getProviders(TmfEvent.class, TmfTraceStub.class);
+ providers = (ITmfDataProvider<TmfEvent>[]) TmfProviderManager.getProviders(TmfEvent.class, TmfTraceStub.class);
providers[0].sendRequest(request1);
providers[0].sendRequest(request2);
providers[0].sendRequest(request3);
public void testCoalescedRequest() throws Exception {
- setupTrace(DIRECTORY + File.separator + TEST_STREAM);
+ fTrace = setupTrace(DIRECTORY + File.separator + TEST_STREAM);
TmfSignalManager.register(this);
TmfTestTriggerSignal signal = new TmfTestTriggerSignal(this, false);
}
TmfSignalManager.deregister(this);
+ fTrace.dispose();
+ fTrace = null;
}
public void testCancelCoalescedRequest() throws Exception {
- setupTrace(DIRECTORY + File.separator + TEST_STREAM);
+
+ fTrace = setupTrace(DIRECTORY + File.separator + TEST_STREAM);
TmfSignalManager.register(this);
TmfTestTriggerSignal signal = new TmfTestTriggerSignal(this, true);
}
TmfSignalManager.deregister(this);
+ fTrace.dispose();
+ fTrace = null;
}
-
}
projects / deliverable / tracecompass.git / blobdiff