public void selectExperiment(LTTngExperimentNode experiment) {
String expId = experiment.getName();
if (fSelectedExperiment != null)
- fSelectedExperiment.deregister();
+ fSelectedExperiment.dispose();
try {
LTTngTraceNode[] traceEntries = experiment.getTraces();
int nbTraces = traceEntries.length;
*/
public static void dispose() {
if (experimentManager != null) {
- experimentManager.deregister();
+ experimentManager.dispose();
experimentManager = null;
instanceBook = null;
}
//$JUnit-BEGIN$
suite.addTestSuite(TmfCorePluginTest.class);
- suite.addTestSuite(TmfEventProviderTest.class);
- suite.addTestSuite(TmfProviderManagerTest.class);
-
suite.addTestSuite(TmfEventFieldTest.class);
suite.addTestSuite(TmfEventContentTest.class);
suite.addTestSuite(TmfEventTypeTest.class);
suite.addTestSuite(TmfEventRequestTest.class);
suite.addTestSuite(TmfCoalescedDataRequestTest.class);
suite.addTestSuite(TmfCoalescedEventRequestTest.class);
+// suite.addTestSuite(TmfRequestExecutorTest.class);
+
+ suite.addTestSuite(TmfEventProviderTest.class);
+ suite.addTestSuite(TmfProviderManagerTest.class);
suite.addTestSuite(TmfTraceTest.class);
suite.addTestSuite(TmfExperimentTest.class);
@Override
protected void tearDown() throws Exception {
super.tearDown();
- fEventProvider.deregister();
- fSyntheticEventProvider.deregister();
+ fEventProvider.dispose();
+ fSyntheticEventProvider.dispose();
}
// ------------------------------------------------------------------------
// ------------------------------------------------------------------------
@SuppressWarnings("unchecked")
- public void testGetPlainEvents() {
+ public void testGetPlainEvents() throws InterruptedException {
final int BLOCK_SIZE = 100;
final int NB_EVENTS = 1000;
}
@SuppressWarnings("unchecked")
- private void getSyntheticData(final TmfTimeRange range, final int nbEvents, final int blockSize) {
+ private void getSyntheticData(final TmfTimeRange range, final int nbEvents, final int blockSize) throws InterruptedException {
final Vector<TmfSyntheticEventStub> requestedEvents = new Vector<TmfSyntheticEventStub>();
// 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() {
+ public void testGetSyntheticEvents_EqualBlockSizes() throws InterruptedException {
TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BigBang, TmfTimestamp.BigCrunch);
getSyntheticData(range, 1000, TmfSyntheticEventProviderStub.BLOCK_SIZE);
}
- public void testGetSyntheticEvents_SmallerBlock() {
+ public void testGetSyntheticEvents_SmallerBlock() throws InterruptedException {
TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BigBang, TmfTimestamp.BigCrunch);
getSyntheticData(range, 1000, TmfSyntheticEventProviderStub.BLOCK_SIZE / 2);
}
- public void testGetSyntheticEvents_LargerBlock() {
+ public void testGetSyntheticEvents_LargerBlock() throws InterruptedException {
TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BigBang, TmfTimestamp.BigCrunch);
getSyntheticData(range, 1000, TmfSyntheticEventProviderStub.BLOCK_SIZE * 2);
}
- public void testGetSyntheticEvents_TimeRange() {
+ public void testGetSyntheticEvents_TimeRange() throws InterruptedException {
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() {
+ public void testGetSyntheticEvents_WeirdTimeRange1() throws InterruptedException {
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() {
+ public void testGetSyntheticEvents_WeirdTimeRange2() throws InterruptedException {
TmfTimestamp start = new TmfTimestamp(0, (byte) -3, 0);
TmfTimestamp end = TmfTimestamp.BigCrunch;
TmfTimeRange range = new TmfTimeRange(start, end);
import org.eclipse.linuxtools.tmf.component.TmfDataProvider;
import org.eclipse.linuxtools.tmf.component.TmfProviderManager;
import org.eclipse.linuxtools.tmf.event.TmfEvent;
-import org.eclipse.linuxtools.tmf.request.TmfDataRequest;
+import org.eclipse.linuxtools.tmf.request.ITmfDataRequest;
import org.eclipse.linuxtools.tmf.trace.ITmfContext;
/**
super("TestProvider1", type);
}
@Override
- public ITmfContext armRequest(TmfDataRequest<TmfEvent> request) {
+ public ITmfContext armRequest(ITmfDataRequest<TmfEvent> request) {
return null;
}
@Override
return null;
}
@Override
- public boolean isCompleted(TmfDataRequest<TmfEvent> request, TmfEvent data, int nbRead) {
+ public boolean isCompleted(ITmfDataRequest<TmfEvent> request, TmfEvent data, int nbRead) {
return false;
}
}
super("TestProvider2", type);
}
@Override
- public ITmfContext armRequest(TmfDataRequest<TmfEvent> request) {
+ public ITmfContext armRequest(ITmfDataRequest<TmfEvent> request) {
return null;
}
@Override
return null;
}
@Override
- public boolean isCompleted(TmfDataRequest<TmfEvent> request, TmfEvent data, int nbRead) {
+ public boolean isCompleted(ITmfDataRequest<TmfEvent> request, TmfEvent data, int nbRead) {
return false;
}
}
super("TestProvider3", type);
}
@Override
- public ITmfContext armRequest(TmfDataRequest<TmfEvent3> request) {
+ public ITmfContext armRequest(ITmfDataRequest<TmfEvent3> request) {
return null;
}
@Override
return null;
}
@Override
- public boolean isCompleted(TmfDataRequest<TmfEvent3> request, TmfEvent3 data, int nbRead) {
+ public boolean isCompleted(ITmfDataRequest<TmfEvent3> request, TmfEvent3 data, int nbRead) {
return false;
}
}
assertTrue(providers[0] == testProvider1);
// Unregister it
- testProvider1.deregister();
+ testProvider1.dispose();
providers = (TmfDataProvider<TmfEvent>[]) TmfProviderManager.getProviders(TmfEvent.class);
assertTrue(providers.length == 0);
assertTrue(providers[0] == testProvider2);
// Remove one
- testProvider1.deregister();
+ testProvider1.dispose();
providers = (TmfDataProvider<TmfEvent>[]) TmfProviderManager.getProviders(TmfEvent.class);
assertTrue(providers.length == 1);
assertTrue(providers[0] == testProvider2);
// Remove the other
- testProvider2.deregister();
+ testProvider2.dispose();
providers = (TmfDataProvider<TmfEvent>[]) TmfProviderManager.getProviders(TmfEvent.class);
assertTrue(providers.length == 0);
assertTrue(providers3[0] == testProvider3);
// Remove one
- testProvider1.deregister();
+ testProvider1.dispose();
providers = (TmfDataProvider<TmfEvent>[]) TmfProviderManager.getProviders(TmfEvent.class);
assertTrue(providers.length == 1);
assertTrue(providers3[0] == testProvider3);
// Remove another one
- testProvider2.deregister();
+ testProvider2.dispose();
providers = (TmfDataProvider<TmfEvent>[]) TmfProviderManager.getProviders(TmfEvent.class);
assertTrue(providers.length == 0);
assertTrue(providers3[0] == testProvider3);
// Remove the last one
- testProvider3.deregister();
+ testProvider3.dispose();
providers = (TmfDataProvider<TmfEvent>[]) TmfProviderManager.getProviders(TmfEvent.class);
assertTrue(providers.length == 0);
assertTrue("equals", !fStubContent.equals(null));
}
+ // ------------------------------------------------------------------------
+ // hashCode
+ // ------------------------------------------------------------------------
+
+ public void testHashCode() throws Exception {
+ assertTrue("hashCode", fBasicContent0.hashCode() == fBasicContent2.hashCode());
+ assertTrue("hashCode", fBasicContent0.hashCode() != fStubContent.hashCode());
+ }
+
+ public void testHashCode2() throws Exception {
+ TmfEventContent basicContent0 = new TmfEventContent(null, fRawContent0);
+ TmfEventContent basicContent1 = new TmfEventContent(fEvent, null);
+ TmfEventContent basicContent2 = new TmfEventContent(null, null);
+
+ assertTrue("hashCode", fBasicContent0.hashCode() != basicContent0.hashCode());
+ assertTrue("hashCode", fBasicContent0.hashCode() != basicContent1.hashCode());
+ assertTrue("hashCode", fBasicContent0.hashCode() != basicContent2.hashCode());
+
+ assertTrue("hashCode", basicContent0.hashCode() != basicContent1.hashCode());
+ assertTrue("hashCode", basicContent0.hashCode() != basicContent2.hashCode());
+
+ assertTrue("hashCode", basicContent1.hashCode() != basicContent2.hashCode());
+ }
+
// ------------------------------------------------------------------------
// toString
// ------------------------------------------------------------------------
assertTrue("equals", !fField3.equals(null));
}
+ // ------------------------------------------------------------------------
+ // hashCode
+ // ------------------------------------------------------------------------
+
+ public void testHashCode() throws Exception {
+ assertTrue("hashCode", fField0.hashCode() == fField1.hashCode());
+ assertTrue("hashCode", fField0.hashCode() != fField3.hashCode());
+ }
+
// ------------------------------------------------------------------------
// toString
// ------------------------------------------------------------------------
assertTrue("equals", !fReference3.equals(null));
}
+ // ------------------------------------------------------------------------
+ // hashCode
+ // ------------------------------------------------------------------------
+
+ public void testHashCode() throws Exception {
+ assertTrue("hashCode", fReference0.hashCode() == fReference1.hashCode());
+ assertTrue("hashCode", fReference0.hashCode() != fReference3.hashCode());
+ }
+
+ public void testHashCode2() throws Exception {
+ TmfEventReference reference0 = new TmfEventReference();
+ assertTrue("hashCode", fReference0.hashCode() != reference0.hashCode());
+ assertTrue("hashCode", fReference3.hashCode() != reference0.hashCode());
+ }
+
// ------------------------------------------------------------------------
// toString
// ------------------------------------------------------------------------
assertTrue("equals", !fSource3.equals(null));
}
+ // ------------------------------------------------------------------------
+ // hashCode
+ // ------------------------------------------------------------------------
+
+ public void testHashCode() throws Exception {
+ assertTrue("hashCode", fSource0.hashCode() == fSource1.hashCode());
+ assertTrue("hashCode", fSource0.hashCode() != fSource3.hashCode());
+ }
+
// ------------------------------------------------------------------------
// toString
// ------------------------------------------------------------------------
assertTrue("equals", !fEvent2.equals(null));
}
+ // ------------------------------------------------------------------------
+ // hashCode
+ // ------------------------------------------------------------------------
+
+ public void testHashCode() throws Exception {
+ TmfEvent event1 = new TmfEvent(fEvent1);
+ TmfEvent event2 = new TmfEvent(fEvent2);
+
+ assertTrue("hashCode", fEvent1.hashCode() == event1.hashCode());
+ assertTrue("hashCode", fEvent2.hashCode() == event2.hashCode());
+
+ assertTrue("hashCode", fEvent1.hashCode() != event2.hashCode());
+ assertTrue("hashCode", fEvent2.hashCode() != event1.hashCode());
+ }
+
// ------------------------------------------------------------------------
// toString
// ------------------------------------------------------------------------
assertTrue("equals", !fType3.equals(null));
}
+ // ------------------------------------------------------------------------
+ // hashCode
+ // ------------------------------------------------------------------------
+
+ public void testHashCode() throws Exception {
+ assertTrue("hashCode", fType0.hashCode() == fType1.hashCode());
+ assertTrue("hashCode", fType0.hashCode() != fType3.hashCode());
+ }
+
// ------------------------------------------------------------------------
// toString
// ------------------------------------------------------------------------
assertTrue("equals", !range1.equals(null));
}
+ // ------------------------------------------------------------------------
+ // hashCode
+ // ------------------------------------------------------------------------
+
+ public void testHashCode() throws Exception {
+ TmfTimestamp ts1 = new TmfTimestamp(12345);
+ TmfTimestamp ts2 = new TmfTimestamp(12350);
+ TmfTimeRange range1 = new TmfTimeRange(ts1, ts2);
+ TmfTimeRange range1b = new TmfTimeRange(range1);
+ TmfTimeRange range2 = new TmfTimeRange(TmfTimestamp.BigBang, TmfTimestamp.BigCrunch);
+ TmfTimeRange range2b = new TmfTimeRange(range2);
+
+ assertTrue("hashCode", range1.hashCode() == range1b.hashCode());
+ assertTrue("hashCode", range2.hashCode() == range2b.hashCode());
+
+ assertTrue("hashCode", range1.hashCode() != range2.hashCode());
+ }
+
// ------------------------------------------------------------------------
// toString
// ------------------------------------------------------------------------
assertTrue("equals", !ts1.equals(null));
}
+ // ------------------------------------------------------------------------
+ // hashCode
+ // ------------------------------------------------------------------------
+
+ public void testHashCode() throws Exception {
+ assertTrue("hashCode", ts0.hashCode() == ts0copy.hashCode());
+ assertTrue("hashCode", ts1.hashCode() == ts1copy.hashCode());
+
+ assertTrue("hashCode", ts0.hashCode() != ts1.hashCode());
+ }
+
// ------------------------------------------------------------------------
// toString
// ------------------------------------------------------------------------
suite.addTestSuite(TmfEventRequestTest.class);
suite.addTestSuite(TmfCoalescedDataRequestTest.class);
suite.addTestSuite(TmfCoalescedEventRequestTest.class);
+// suite.addTestSuite(TmfRequestExecutorTest.class);
//$JUnit-END$
return suite;
}
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;
/**
* <b><u>TmfCoalescedDataRequestTest</u></b>
* <p>
- * TODO: Implement me. Please.
+ * Test suite for the TmfCoalescedDataRequest class.
*/
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
// ------------------------------------------------------------------------
@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
// ------------------------------------------------------------------------
public void testTmfCoalescedDataRequest() {
TmfCoalescedDataRequest<TmfEvent> request = new TmfCoalescedDataRequest<TmfEvent>(TmfEvent.class);
- assertEquals("getIndex", 0, request.getIndex());
+ 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());
+
+ 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("getIndex", 10, request.getIndex());
+ assertEquals("getRequestId", fRequestCount++, request.getRequestId());
+ assertEquals("getDataType", TmfEvent.class, request.getDataType());
+
+ 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("getIndex", 10, request.getIndex());
+ assertEquals("getRequestId", fRequestCount++, request.getRequestId());
+ assertEquals("getDataType", TmfEvent.class, request.getDataType());
+
+ 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("getIndex", 10, request.getIndex());
+ assertEquals("getRequestId", fRequestCount++, request.getRequestId());
+ assertEquals("getDataType", TmfEvent.class, request.getDataType());
+
+ assertEquals("getIndex", 10, request.getIndex());
assertEquals("getNbRequestedEvents", 100, request.getNbRequested());
- assertEquals("getBlockize", 200, request.getBlockize());
+ 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 testEqualsConsistency() throws Exception {
+ assertTrue("equals", fRequest1.equals(fRequest1));
+ assertTrue("equals", fRequest1.equals(fRequest1));
+
+ assertTrue("equals", fRequest2.equals(fRequest2));
+ assertTrue("equals", fRequest2.equals(fRequest2));
+ }
+
+ 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());
}
// ------------------------------------------------------------------------
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
+ // ------------------------------------------------------------------------
+
}
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;
/**
* <b><u>TmfCoalescedEventRequestTest</u></b>
* <p>
- * TODO: Implement me. Please.
+ * Test suite for the TmfCoalescedEventRequest class.
*/
public class TmfCoalescedEventRequestTest extends TestCase {
- 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;
+ // ------------------------------------------------------------------------
+ // 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.getDefault().getBundle(), new Path(path), null);
- File test = new File(FileLocator.toFileURL(location).toURI());
- fTrace = new TmfTraceStub(test.getPath(), 500, true);
- fTrace.register();
- } 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("StartTime", TmfTimestamp.BigBang, request.getRange().getStartTime());
- assertEquals("EndTime", TmfTimestamp.BigCrunch, 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());
+ 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());
}
- 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("getRequestId", fRequestCount++, request.getRequestId());
+ assertEquals("getDataType", TmfEvent.class, request.getDataType());
+
+ 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("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 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());
+ 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());
}
- 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());
+ 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 testEqualsConsistency() throws Exception {
+ assertTrue("equals", fRequest1.equals(fRequest1));
+ assertTrue("equals", fRequest1.equals(fRequest1));
+
+ assertTrue("equals", fRequest2.equals(fRequest2));
+ assertTrue("equals", fRequest2.equals(fRequest2));
+ }
+
+ 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());
}
// ------------------------------------------------------------------------
// ------------------------------------------------------------------------
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);
+ TmfEventRequest<TmfEvent> request4 = new TmfEventRequestStub<TmfEvent>(TmfEvent.class, range1, 100, 201);
+ TmfDataRequest<TmfEvent> request5 = new TmfDataRequestStub<TmfEvent> (TmfEvent.class, 10, 100, 201);
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 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, true);
+ } 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;
+
}
}
}
};
- 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;
}
-
}
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.TmfDataRequest;
import org.eclipse.linuxtools.tmf.request.TmfDataRequestStub;
/**
* <b><u>TmfDataRequestTest</u></b>
* <p>
- * TODO: Implement me. Please.
+ * Test suite for the TmfDataRequest class.
*/
public class TmfDataRequestTest extends TestCase {
// ------------------------------------------------------------------------
+ // Variables
+ // ------------------------------------------------------------------------
+
+ private static TmfDataRequest<TmfEvent> fRequest1;
+ private static TmfDataRequest<TmfEvent> fRequest1b;
+ private static TmfDataRequest<TmfEvent> fRequest1c;
+ private static TmfDataRequest<TmfEvent> fRequest2;
+ private static TmfDataRequest<TmfEvent> fRequest3;
+ private static TmfDataRequest<TmfEvent> fRequest4;
+
+ private static int fRequestCount;
+
+ // ------------------------------------------------------------------------
// Housekeeping
// ------------------------------------------------------------------------
@Override
protected void setUp() throws Exception {
super.setUp();
+ TmfDataRequest.reset();
+ fRequest1 = new TmfDataRequestStub<TmfEvent>(TmfEvent.class, 10, 100, 200);
+ fRequest2 = new TmfDataRequestStub<TmfEvent>(TmfEvent.class, 20, 100, 200);
+ fRequest3 = new TmfDataRequestStub<TmfEvent>(TmfEvent.class, 20, 200, 200);
+ fRequest4 = new TmfDataRequestStub<TmfEvent>(TmfEvent.class, 20, 200, 300);
+ fRequest1b = new TmfDataRequestStub<TmfEvent>(TmfEvent.class, 10, 100, 200);
+ fRequest1c = new TmfDataRequestStub<TmfEvent>(TmfEvent.class, 10, 100, 200);
+ fRequestCount = fRequest1c.getRequestId() + 1;
}
@Override
super.tearDown();
}
+ private TmfDataRequest<TmfEvent> setupTestRequest(final boolean[] flags) {
+
+ TmfDataRequest<TmfEvent> request = new TmfDataRequestStub<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
// ------------------------------------------------------------------------
public void testTmfDataRequest() {
TmfDataRequest<TmfEvent> request = new TmfDataRequestStub<TmfEvent>(TmfEvent.class);
- assertEquals("getIndex", 0, request.getIndex());
+ 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());
+
+ assertFalse("isCompleted", request.isCompleted());
+ assertFalse("isFailed", request.isFailed());
+ assertFalse("isCancelled", request.isCancelled());
+
+ assertEquals("getNbRead", 0, request.getNbRead());
}
public void testTmfDataRequestIndex() {
TmfDataRequest<TmfEvent> request = new TmfDataRequestStub<TmfEvent>(TmfEvent.class, 10);
- assertEquals("getIndex", 10, request.getIndex());
+ assertEquals("getRequestId", fRequestCount++, request.getRequestId());
+ assertEquals("getDataType", TmfEvent.class, request.getDataType());
+
+ 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 testTmfDataRequestIndexNbRequested() {
TmfDataRequest<TmfEvent> request = new TmfDataRequestStub<TmfEvent>(TmfEvent.class, 10, 100);
- assertEquals("getIndex", 10, request.getIndex());
+ assertEquals("getRequestId", fRequestCount++, request.getRequestId());
+ assertEquals("getDataType", TmfEvent.class, request.getDataType());
+
+ 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 testTmfDataRequestIndexNbEventsBlocksize() {
TmfDataRequest<TmfEvent> request = new TmfDataRequestStub<TmfEvent>(TmfEvent.class, 10, 100, 200);
- assertEquals("getIndex", 10, request.getIndex());
+ assertEquals("getRequestId", fRequestCount++, request.getRequestId());
+ assertEquals("getDataType", TmfEvent.class, request.getDataType());
+
+ assertEquals("getIndex", 10, request.getIndex());
assertEquals("getNbRequestedEvents", 100, request.getNbRequested());
- assertEquals("getBlockize", 200, request.getBlockize());
+ 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 testEquals_Reflexivity() {
- TmfDataRequest<TmfEvent> request = new TmfDataRequestStub<TmfEvent>(TmfEvent.class, 10, 100, 200);
+ 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 testEqualsConsistency() throws Exception {
+ assertTrue("equals", fRequest1.equals(fRequest1));
+ assertTrue("equals", fRequest1.equals(fRequest1));
+
+ assertTrue("equals", fRequest2.equals(fRequest2));
+ assertTrue("equals", fRequest2.equals(fRequest2));
+ }
+
+ 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 = "[TmfDataRequest(0,TmfEvent,10,100,200)]";
+ String expected2 = "[TmfDataRequest(1,TmfEvent,20,100,200)]";
+ String expected3 = "[TmfDataRequest(2,TmfEvent,20,200,200)]";
+ String expected4 = "[TmfDataRequest(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());
+ }
+
+ // ------------------------------------------------------------------------
+ // setData/getData
+ // ------------------------------------------------------------------------
+
+ public void testSetData() {
+ // 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());
+ }
+
+ fRequest1.setData(events);
+ assertEquals("setData", nbEvents, fRequest1.getNbRead());
+
+ TmfEvent[] eventsRead = fRequest1.getData();
+ assertEquals("getData", nbEvents, eventsRead.length);
+
+ for (int i = 0; i < nbEvents; i++) {
+ assertEquals("getData", i, eventsRead[i].getTimestamp().getValue());
+ }
+ }
+
+ // ------------------------------------------------------------------------
+ // done
+ // ------------------------------------------------------------------------
+
+ public void testDone() {
+
+ final boolean[] flags = new boolean[4];
+ TmfDataRequest<TmfEvent> request = setupTestRequest(flags);
+ request.done();
+
+ assertTrue ("isCompleted", request.isCompleted());
+ assertFalse("isFailed", request.isFailed());
+ assertFalse("isCancelled", request.isCancelled());
- assertTrue("request.equals(request)", request.equals(request));
+ assertTrue ("handleCompleted", flags[0]);
+ assertTrue ("handleSuccess", flags[1]);
+ assertFalse("handleFailure", flags[2]);
+ assertFalse("handleCancel", flags[3]);
}
- 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);
+ // ------------------------------------------------------------------------
+ // fail
+ // ------------------------------------------------------------------------
- assertTrue("request1.equals(request2)", request1.equals(request2));
- assertTrue("request2.equals(request1)", request2.equals(request1));
+ public void testFail() {
+
+ final boolean[] flags = new boolean[4];
+ TmfDataRequest<TmfEvent> request = setupTestRequest(flags);
+ request.fail();
- 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));
+ assertTrue ("isCompleted", request.isCompleted());
+ assertTrue ("isFailed", request.isFailed());
+ assertFalse("isCancelled", request.isCancelled());
+
+ assertTrue ("handleCompleted", flags[0]);
+ assertFalse("handleSuccess", flags[1]);
+ assertTrue ("handleFailure", flags[2]);
+ assertFalse("handleCancel", flags[3]);
}
- 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);
+ // ------------------------------------------------------------------------
+ // cancel
+ // ------------------------------------------------------------------------
+
+ public void testCancel() {
+
+ final boolean[] flags = new boolean[4];
+ TmfDataRequest<TmfEvent> request = setupTestRequest(flags);
+ request.cancel();
+
+ assertTrue ("isCompleted", request.isCompleted());
+ assertFalse("isFailed", request.isFailed());
+ assertTrue ("isCancelled", request.isCancelled());
- assertTrue("request1.equals(request2)", request1.equals(request2));
- assertTrue("request2.equals(request3)", request2.equals(request3));
- assertTrue("request1.equals(request3)", request1.equals(request3));
+ assertTrue ("handleCompleted", flags[0]);
+ assertFalse("handleSuccess", flags[1]);
+ assertFalse("handleFailure", flags[2]);
+ assertTrue ("handleCancel", flags[3]);
}
+ // ------------------------------------------------------------------------
+ // waitForCompletion
+ // ------------------------------------------------------------------------
+
}
\ No newline at end of file
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.TmfTimeRange;
import org.eclipse.linuxtools.tmf.event.TmfTimestamp;
import org.eclipse.linuxtools.tmf.request.TmfDataRequest;
/**
* <b><u>TmfEventRequestTest</u></b>
* <p>
- * TODO: Implement me. Please.
+ * Test suite for the TmfEventRequest class.
*/
public class TmfEventRequestTest extends TestCase {
+ // ------------------------------------------------------------------------
+ // Variables
+ // ------------------------------------------------------------------------
+
+ private static TmfTimeRange range1 = new TmfTimeRange(TmfTimeRange.Eternity);
+ private static TmfTimeRange range2 = new TmfTimeRange(new TmfTimestamp(), TmfTimestamp.BigCrunch);
+
+ private static TmfEventRequest<TmfEvent> fRequest1;
+ private static TmfEventRequest<TmfEvent> fRequest1b;
+ private static TmfEventRequest<TmfEvent> fRequest1c;
+ private static TmfEventRequest<TmfEvent> fRequest2;
+ private static TmfEventRequest<TmfEvent> fRequest3;
+ private static TmfEventRequest<TmfEvent> fRequest4;
+
+ private static int fRequestCount;
+
// ------------------------------------------------------------------------
// Housekeeping
// ------------------------------------------------------------------------
@Override
protected void setUp() throws Exception {
super.setUp();
+ TmfDataRequest.reset();
+ fRequest1 = new TmfEventRequestStub<TmfEvent>(TmfEvent.class, range1, 100, 200);
+ fRequest2 = new TmfEventRequestStub<TmfEvent>(TmfEvent.class, range2, 100, 200);
+ fRequest3 = new TmfEventRequestStub<TmfEvent>(TmfEvent.class, range2, 200, 200);
+ fRequest4 = new TmfEventRequestStub<TmfEvent>(TmfEvent.class, range2, 200, 300);
+ fRequest1b = new TmfEventRequestStub<TmfEvent>(TmfEvent.class, range1, 100, 200);
+ fRequest1c = new TmfEventRequestStub<TmfEvent>(TmfEvent.class, range1, 100, 200);
+ fRequestCount = fRequest1c.getRequestId() + 1;
}
@Override
super.tearDown();
}
+ private TmfEventRequest<TmfEvent> setupTestRequest(final boolean[] flags) {
+
+ TmfEventRequest<TmfEvent> request = new TmfEventRequestStub<TmfEvent>(TmfEvent.class, new TmfTimeRange(TmfTimeRange.Eternity), 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 testTmfEventRequest() {
TmfEventRequest<TmfEvent> request = new TmfEventRequestStub<TmfEvent>(TmfEvent.class);
+ assertEquals("getRequestId", fRequestCount++, request.getRequestId());
+ assertEquals("getDataType", TmfEvent.class, request.getDataType());
+
assertEquals("StartTime", TmfTimestamp.BigBang, request.getRange().getStartTime());
assertEquals("EndTime", TmfTimestamp.BigCrunch, request.getRange().getEndTime());
- 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 testTmfEventRequestTimeRange() {
TmfTimeRange range = new TmfTimeRange(new TmfTimestamp(), TmfTimestamp.BigCrunch);
TmfEventRequest<TmfEvent> request = new TmfEventRequestStub<TmfEvent>(TmfEvent.class, range);
- 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("StartTime", new TmfTimestamp(), request.getRange().getStartTime());
+ assertEquals("EndTime", TmfTimestamp.BigCrunch, request.getRange().getEndTime());
- 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 testTmfEventRequestTimeRangeNbRequested() {
TmfTimeRange range = new TmfTimeRange(new TmfTimestamp(), TmfTimestamp.BigCrunch);
TmfEventRequest<TmfEvent> request = new TmfEventRequestStub<TmfEvent>(TmfEvent.class, range, 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("StartTime", new TmfTimestamp(), request.getRange().getStartTime());
+ assertEquals("EndTime", TmfTimestamp.BigCrunch, request.getRange().getEndTime());
- assertEquals("getIndex", 0, request.getIndex());
+ assertEquals("getIndex", 0, 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 testTmfEventRequestTimeRangeNbRequestedBlocksize() {
TmfTimeRange range = new TmfTimeRange(new TmfTimestamp(), TmfTimestamp.BigCrunch);
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());
+ assertEquals("getRequestId", fRequestCount++, request.getRequestId());
+ assertEquals("getDataType", TmfEvent.class, request.getDataType());
- assertEquals("getIndex", 0, request.getIndex());
+ assertEquals("StartTime", new TmfTimestamp(), request.getRange().getStartTime());
+ assertEquals("EndTime", TmfTimestamp.BigCrunch, request.getRange().getEndTime());
+
+ assertEquals("getIndex", 0, request.getIndex());
assertEquals("getNbRequestedEvents", 100, request.getNbRequested());
- assertEquals("getBlockize", 200, request.getBlockize());
+ 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 testEquals_Reflexivity() {
- TmfTimeRange range = new TmfTimeRange(new TmfTimestamp(), TmfTimestamp.BigCrunch);
- TmfEventRequest<TmfEvent> request = new TmfEventRequestStub<TmfEvent>(TmfEvent.class, range, 100, 200);
+ 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 testEqualsConsistency() throws Exception {
+ assertTrue("equals", fRequest1.equals(fRequest1));
+ assertTrue("equals", fRequest1.equals(fRequest1));
+
+ assertTrue("equals", fRequest2.equals(fRequest2));
+ assertTrue("equals", fRequest2.equals(fRequest2));
+ }
+
+ 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
+ // ------------------------------------------------------------------------
- assertTrue("request.equals(request)", request.equals(request));
+ public void testToString() {
+ String expected1 = "[TmfEventRequest(0,TmfEvent," + range1 + ",100,200)]";
+ String expected2 = "[TmfEventRequest(1,TmfEvent," + range2 + ",100,200)]";
+ String expected3 = "[TmfEventRequest(2,TmfEvent," + range2 + ",200,200)]";
+ String expected4 = "[TmfEventRequest(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());
}
- 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);
+ // ------------------------------------------------------------------------
+ // setData/getData
+ // ------------------------------------------------------------------------
+
+ public void testSetData() {
+ // 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());
+ }
- 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);
+ fRequest1.setData(events);
+ assertEquals("setData", nbEvents, fRequest1.getNbRead());
- assertTrue("request1.equals(request2)", request1.equals(request2));
- assertTrue("request2.equals(request1)", request2.equals(request1));
+ TmfEvent[] eventsRead = fRequest1.getData();
+ assertEquals("getData", nbEvents, eventsRead.length);
- 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));
+ for (int i = 0; i < nbEvents; i++) {
+ assertEquals("getData", i, eventsRead[i].getTimestamp().getValue());
+ }
}
- public void testEquals_Transivity() {
- TmfTimeRange range1 = new TmfTimeRange(new TmfTimestamp(), TmfTimestamp.BigCrunch);
+ // ------------------------------------------------------------------------
+ // done
+ // ------------------------------------------------------------------------
+
+ public void testDone() {
+
+ final boolean[] flags = new boolean[4];
+ TmfEventRequest<TmfEvent> request = setupTestRequest(flags);
+ request.done();
- 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 ("isCompleted", request.isCompleted());
+ assertFalse("isFailed", request.isFailed());
+ assertFalse("isCancelled", request.isCancelled());
- 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));
+ assertTrue ("handleCompleted", flags[0]);
+ assertTrue ("handleSuccess", flags[1]);
+ assertFalse("handleFailure", flags[2]);
+ assertFalse("handleCancel", flags[3]);
}
+ // ------------------------------------------------------------------------
+ // fail
+ // ------------------------------------------------------------------------
+
+ public void testFail() {
+
+ final boolean[] flags = new boolean[4];
+ TmfEventRequest<TmfEvent> request = setupTestRequest(flags);
+ request.fail();
+
+ assertTrue ("isCompleted", request.isCompleted());
+ assertTrue ("isFailed", request.isFailed());
+ assertFalse("isCancelled", request.isCancelled());
+
+ assertTrue ("handleCompleted", flags[0]);
+ assertFalse("handleSuccess", flags[1]);
+ assertTrue ("handleFailure", flags[2]);
+ assertFalse("handleCancel", flags[3]);
+ }
+
+ // ------------------------------------------------------------------------
+ // cancel
+ // ------------------------------------------------------------------------
+
+ public void testCancel() {
+
+ final boolean[] flags = new boolean[4];
+ TmfEventRequest<TmfEvent> request = setupTestRequest(flags);
+ request.cancel();
+
+ assertTrue ("isCompleted", request.isCompleted());
+ assertFalse("isFailed", request.isFailed());
+ assertTrue ("isCancelled", request.isCancelled());
+
+ assertTrue ("handleCompleted", flags[0]);
+ assertFalse("handleSuccess", flags[1]);
+ assertFalse("handleFailure", flags[2]);
+ assertTrue ("handleCancel", flags[3]);
+ }
+
+ // ------------------------------------------------------------------------
+ // waitForCompletion
+ // ------------------------------------------------------------------------
+
}
\ No newline at end of file
package org.eclipse.linuxtools.tmf.tests.request;
-import java.util.concurrent.Executors;
-
import junit.framework.TestCase;
-import org.eclipse.linuxtools.tmf.request.TmfRequestExecutor;
-
/**
* <b><u>TmfRequestExecutorTest</u></b>
*
*/
public class TmfRequestExecutorTest extends TestCase {
- // ------------------------------------------------------------------------
- // Variables
- // ------------------------------------------------------------------------
-
- // ------------------------------------------------------------------------
- // Housekeeping
- // ------------------------------------------------------------------------
-
/**
- * @param name the test name
+ * @param name
*/
public TmfRequestExecutorTest(String name) {
super(name);
}
- @Override
+ /* (non-Javadoc)
+ * @see junit.framework.TestCase#setUp()
+ */
protected void setUp() throws Exception {
super.setUp();
}
- @Override
+ /* (non-Javadoc)
+ * @see junit.framework.TestCase#tearDown()
+ */
protected void tearDown() throws Exception {
super.tearDown();
}
- // ------------------------------------------------------------------------
- // Constructors
- // ------------------------------------------------------------------------
+ /**
+ * Test method for {@link org.eclipse.linuxtools.tmf.request.TmfRequestExecutor#TmfRequestExecutor(java.util.concurrent.ExecutorService)}.
+ */
+ public void testTmfRequestExecutorExecutorService() {
+ fail("Not yet implemented");
+ }
/**
* Test method for {@link org.eclipse.linuxtools.tmf.request.TmfRequestExecutor#TmfRequestExecutor()}.
*/
public void testTmfRequestExecutor() {
- TmfRequestExecutor executor = new TmfRequestExecutor();
- assertEquals("nbPendingRequests", 0, executor.getNbPendingRequests());
- assertFalse("isShutdown", executor.isShutdown());
- assertFalse("isTerminated", executor.isTerminated());
+ fail("Not yet implemented");
}
/**
- * Test method for {@link org.eclipse.linuxtools.tmf.request.TmfRequestExecutor#TmfRequestExecutor(java.util.concurrent.ExecutorService)}.
+ * Test method for {@link org.eclipse.linuxtools.tmf.request.TmfRequestExecutor#start()}.
*/
- public void testTmfRequestExecutorExecutorService() {
- TmfRequestExecutor executor = new TmfRequestExecutor(Executors.newCachedThreadPool());
- assertEquals("nbPendingRequests", 0, executor.getNbPendingRequests());
- assertFalse("isShutdown", executor.isShutdown());
- assertFalse("isTerminated", executor.isTerminated());
+ public void testStart() {
+ fail("Not yet implemented");
}
/**
* Test method for {@link org.eclipse.linuxtools.tmf.request.TmfRequestExecutor#stop()}.
*/
public void testStop() {
- TmfRequestExecutor executor = new TmfRequestExecutor();
- executor.stop();
- assertEquals("nbPendingRequests", 0, executor.getNbPendingRequests());
- assertTrue("isShutdown", executor.isShutdown());
- assertTrue("isTerminated", executor.isTerminated());
+ fail("Not yet implemented");
}
- // ------------------------------------------------------------------------
- // execute
- // ------------------------------------------------------------------------
-
/**
* Test method for {@link org.eclipse.linuxtools.tmf.request.TmfRequestExecutor#execute(java.lang.Runnable)}.
*/
public void testExecute() {
-// fail("Not yet implemented");
+ fail("Not yet implemented");
}
- // ------------------------------------------------------------------------
- // toString
- // ------------------------------------------------------------------------
+ /**
+ * Test method for {@link org.eclipse.linuxtools.tmf.request.TmfRequestExecutor#scheduleNext()}.
+ */
+ public void testScheduleNext() {
+ fail("Not yet implemented");
+ }
/**
- * Test method for {@link org.eclipse.linuxtools.tmf.request.TmfRequestExecutor#toString()}.
+ * Test method for {@link org.eclipse.linuxtools.tmf.request.TmfRequestExecutor#queueRequest(java.lang.Runnable)}.
*/
- public void testToString() {
-// TmfRequestExecutor executor1 = new TmfRequestExecutor();
-// String expected1 = "[TmfRequestExecutor(DelegatedExecutorService)]";
-// assertEquals("toString", expected1, executor1.toString());
-//
-// TmfRequestExecutor executor2 = new TmfRequestExecutor(Executors.newCachedThreadPool());
-// String expected2 = "[TmfRequestExecutor(ThreadPoolExecutor)]";
-// assertEquals("toString", expected2, executor2.toString());
+ public void testQueueRequest() {
+ fail("Not yet implemented");
}
}
import org.eclipse.core.runtime.FileLocator;
import org.eclipse.core.runtime.Path;
import org.eclipse.linuxtools.tmf.event.TmfData;
-import org.eclipse.linuxtools.tmf.request.TmfDataRequest;
-import org.eclipse.linuxtools.tmf.request.TmfEventRequest;
+import org.eclipse.linuxtools.tmf.request.ITmfDataRequest;
+import org.eclipse.linuxtools.tmf.request.ITmfEventRequest;
import org.eclipse.linuxtools.tmf.tests.TmfCoreTestPlugin;
import org.eclipse.linuxtools.tmf.trace.ITmfContext;
-import org.eclipse.linuxtools.tmf.trace.TmfContext;
import org.eclipse.linuxtools.tmf.trace.TmfTraceStub;
/**
// ------------------------------------------------------------------------
@Override
- public ITmfContext armRequest(TmfDataRequest<TmfData> request) {
- if (request instanceof TmfEventRequest<?>) {
- TmfContext context = fTrace.seekEvent(((TmfEventRequest<?>) request).getRange().getStartTime());
+ public ITmfContext armRequest(ITmfDataRequest<TmfData> request) {
+ if (request instanceof ITmfEventRequest<?>) {
+ ITmfContext context = fTrace.seekEvent(((ITmfEventRequest<?>) request).getRange().getStartTime());
return context;
}
return null;
}
@Override
- public boolean isCompleted(TmfDataRequest<TmfData> request, TmfData data, int nbRead) {
+ public boolean isCompleted(ITmfDataRequest<TmfData> request, TmfData data, int nbRead) {
return false;
}
import org.eclipse.core.runtime.FileLocator;
import org.eclipse.core.runtime.Path;
import org.eclipse.linuxtools.tmf.event.TmfEvent;
-import org.eclipse.linuxtools.tmf.request.TmfDataRequest;
-import org.eclipse.linuxtools.tmf.request.TmfEventRequest;
+import org.eclipse.linuxtools.tmf.request.ITmfDataRequest;
+import org.eclipse.linuxtools.tmf.request.ITmfEventRequest;
import org.eclipse.linuxtools.tmf.tests.TmfCoreTestPlugin;
import org.eclipse.linuxtools.tmf.trace.ITmfContext;
-import org.eclipse.linuxtools.tmf.trace.TmfContext;
import org.eclipse.linuxtools.tmf.trace.TmfTraceStub;
/**
}
@Override
- public void deregister() {
- fTrace.deregister();
- super.deregister();
+ public void dispose() {
+ fTrace.dispose();
+ super.dispose();
}
// ------------------------------------------------------------------------
// ------------------------------------------------------------------------
@Override
- public ITmfContext armRequest(TmfDataRequest<TmfEvent> request) {
- if (request instanceof TmfEventRequest<?>) {
- TmfContext context = fTrace.seekEvent(((TmfEventRequest<?>) request).getRange().getStartTime());
+ public ITmfContext armRequest(ITmfDataRequest<TmfEvent> request) {
+ if (request instanceof ITmfEventRequest<?>) {
+ ITmfContext context = fTrace.seekEvent(((ITmfEventRequest<?>) request).getRange().getStartTime());
return context;
}
return null;
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.request.TmfDataRequest;
+import org.eclipse.linuxtools.tmf.request.ITmfDataRequest;
+import org.eclipse.linuxtools.tmf.request.ITmfEventRequest;
import org.eclipse.linuxtools.tmf.request.TmfEventRequest;
import org.eclipse.linuxtools.tmf.trace.ITmfContext;
import org.eclipse.linuxtools.tmf.trace.TmfContext;
super(TmfSyntheticEventStub.class);
}
- @Override
- public void register() {
- super.register();
- }
-
- @Override
- public void deregister() {
- super.deregister();
- }
-
@SuppressWarnings("unchecked")
@Override
- public ITmfContext armRequest(final TmfDataRequest<TmfSyntheticEventStub> request) {
+ public ITmfContext armRequest(final ITmfDataRequest<TmfSyntheticEventStub> request) {
// Get the TmfSyntheticEventStub provider
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<?>)) {
+ if (!(request instanceof ITmfEventRequest<?>)) {
request.cancel();
return null;
}
* Default constructor
*/
public TmfDataRequestStub(Class<T> dataType) {
- this(dataType, 0, ALL_DATA, DEFAULT_BLOCK_SIZE);
+ super(dataType);
}
/**
* @param nbRequested
*/
public TmfDataRequestStub(Class<T> dataType, int index) {
- this(dataType, index, ALL_DATA, DEFAULT_BLOCK_SIZE);
+ super(dataType, index);
}
/**
* @param nbRequested
*/
public TmfDataRequestStub(Class<T> dataType, int index, int nbRequested) {
- this(dataType, index, nbRequested, DEFAULT_BLOCK_SIZE);
+ super(dataType, index, nbRequested);
}
/**
* @param range
*/
public TmfEventRequestStub(Class<T> dataType) {
- this(dataType, TmfTimeRange.Eternity, ALL_DATA, DEFAULT_BLOCK_SIZE);
+ super(dataType);
}
/**
* @param range
*/
public TmfEventRequestStub(Class<T> dataType, TmfTimeRange range) {
- this(dataType, range, ALL_DATA, DEFAULT_BLOCK_SIZE);
+ super(dataType, range);
}
/**
* @param nbRequested
*/
public TmfEventRequestStub(Class<T> dataType, TmfTimeRange range, int nbRequested) {
- this(dataType, range, nbRequested, DEFAULT_BLOCK_SIZE);
+ super(dataType, range, nbRequested);
}
/**
}
};
fExperiment.sendRequest(request);
- request.waitForCompletion();
+ try {
+ request.waitForCompletion();
+ } catch (InterruptedException e) {
+ e.printStackTrace();
+ }
if (cache[0] != null && cacheStartIndex == index) {
item.setText(extractItemFields(cache[0]));
public TmfView(String viewName) {
super();
fName = viewName;
- register();
+ TmfSignalManager.register(this);
}
@Override
public void dispose() {
- deregister();
+ TmfSignalManager.deregister(this);
super.dispose();
}
return fName;
}
- public void register() {
- TmfSignalManager.register(this);
- }
-
- public void deregister() {
- TmfSignalManager.deregister(this);
- }
-
public void broadcast(TmfSignal signal) {
TmfSignalManager.dispatchSignal(signal);
}
public String getName();
/**
- * Register to the signal manager
+ * Dispose of the component
*/
- public void register();
-
- /**
- * De-register from the signal manager
- */
- public void deregister();
+ public void dispose();
/**
* Broadcast a signal to all the interested listeners.
package org.eclipse.linuxtools.tmf.component;
import org.eclipse.linuxtools.tmf.event.TmfData;
-import org.eclipse.linuxtools.tmf.request.TmfDataRequest;
+import org.eclipse.linuxtools.tmf.request.ITmfDataRequest;
public interface ITmfDataProvider<T extends TmfData> {
*
* @param request The request to process
*/
- public void sendRequest(TmfDataRequest<T> request);
+ public void sendRequest(ITmfDataRequest<T> request);
}
public TmfComponent(String name) {
fName = name;
- register();
+ TmfSignalManager.register(this);
}
// ------------------------------------------------------------------------
// ITmfComponent
// ------------------------------------------------------------------------
- public String getName() {
- return fName;
- }
-
/* (non-Javadoc)
- * @see org.eclipse.linuxtools.tmf.component.ITmfComponent#register()
+ * @see org.eclipse.linuxtools.tmf.component.ITmfComponent#getName()
*/
- public void register() {
- TmfSignalManager.register(this);
+ public String getName() {
+ return fName;
}
/* (non-Javadoc)
- * @see org.eclipse.linuxtools.tmf.component.ITmfComponent#deregister()
+ * @see org.eclipse.linuxtools.tmf.component.ITmfComponent#dispose()
*/
- public void deregister() {
+ public void dispose() {
TmfSignalManager.deregister(this);
}
}
@Override
- public void register() {
- super.register();
- TmfProviderManager.register(fType, this);
- }
-
- @Override
- public void deregister() {
+ public void dispose() {
TmfProviderManager.deregister(fType, this);
fExecutor.stop();
- super.deregister();
+ super.dispose();
}
public int getQueueSize() {
// ITmfRequestHandler
// ------------------------------------------------------------------------
- public void sendRequest(final TmfDataRequest<T> request) {
+ public synchronized void sendRequest(final ITmfDataRequest<T> request) {
if (fSynchDepth > 0) {
// We are in coalescing mode: client should NEVER wait
protected Vector<TmfCoalescedDataRequest<T>> fPendingCoalescedRequests = new Vector<TmfCoalescedDataRequest<T>>();
- protected synchronized void newCoalescedDataRequest(TmfDataRequest<T> request) {
+ protected synchronized void newCoalescedDataRequest(ITmfDataRequest<T> request) {
TmfCoalescedDataRequest<T> coalescedRequest =
new TmfCoalescedDataRequest<T>(fType, request.getIndex(), request.getNbRequested(), request.getBlockize());
coalescedRequest.addRequest(request);
fPendingCoalescedRequests.add(coalescedRequest);
}
- protected synchronized void coalesceDataRequest(TmfDataRequest<T> request) {
+ protected synchronized void coalesceDataRequest(ITmfDataRequest<T> request) {
for (TmfCoalescedDataRequest<T> req : fPendingCoalescedRequests) {
if (req.isCompatible(request)) {
req.addRequest(request);
// Request processing
// ------------------------------------------------------------------------
- protected void queueRequest(final TmfDataRequest<T> request) {
+ protected void queueRequest(final ITmfDataRequest<T> request) {
// Process the request
Thread thread = new Thread() {
* @param request
* @return an application specific context; null if request can't be serviced
*/
- public abstract ITmfContext armRequest(TmfDataRequest<T> request);
+ public abstract ITmfContext armRequest(ITmfDataRequest<T> request);
/**
* Return the next piece of data based on the context supplied. The context
* @param data
* @return
*/
- public boolean isCompleted(TmfDataRequest<T> request, T data, int nbRead) {
+ public boolean isCompleted(ITmfDataRequest<T> request, T data, int nbRead) {
return request.isCompleted() || nbRead >= request.getNbRequested();
}
import org.eclipse.linuxtools.tmf.event.TmfEvent;
import org.eclipse.linuxtools.tmf.event.TmfTimestamp;
+import org.eclipse.linuxtools.tmf.request.ITmfDataRequest;
+import org.eclipse.linuxtools.tmf.request.ITmfEventRequest;
import org.eclipse.linuxtools.tmf.request.TmfCoalescedEventRequest;
-import org.eclipse.linuxtools.tmf.request.TmfDataRequest;
-import org.eclipse.linuxtools.tmf.request.TmfEventRequest;
/**
* <b><u>TmfEventProvider</u></b>
}
@Override
- public boolean isCompleted(TmfDataRequest<T> request, T data, int nbRead) {
+ public boolean isCompleted(ITmfDataRequest<T> request, T data, int nbRead) {
boolean dataRequestCompleted = super.isCompleted(request, data, nbRead);
- if (!dataRequestCompleted && request instanceof TmfEventRequest<?> && data != null) {
- TmfTimestamp endTime = ((TmfEventRequest<?>) request).getRange().getEndTime();
+ if (!dataRequestCompleted && request instanceof ITmfEventRequest<?> && data != null) {
+ TmfTimestamp endTime = ((ITmfEventRequest<?>) request).getRange().getEndTime();
return data.getTimestamp().compareTo(endTime, false) > 0;
}
return dataRequestCompleted;
}
@Override
- protected synchronized void newCoalescedDataRequest(TmfDataRequest<T> request) {
- if (request instanceof TmfEventRequest<?>) {
- TmfEventRequest<T> eventRequest = (TmfEventRequest<T>) request;
+ protected synchronized void newCoalescedDataRequest(ITmfDataRequest<T> request) {
+ if (request instanceof ITmfEventRequest<?>) {
+ ITmfEventRequest<T> eventRequest = (ITmfEventRequest<T>) request;
TmfCoalescedEventRequest<T> coalescedRequest =
new TmfCoalescedEventRequest<T>(fType, eventRequest.getRange(), eventRequest.getNbRequested(), eventRequest.getBlockize());
coalescedRequest.addRequest(eventRequest);
@Override
public int hashCode() {
- return fFieldId.hashCode();
+ int result = 17;
+ result = 37 * result + fFieldId.hashCode();
+ result = 37 * result + fValue.hashCode();
+ return result;
}
@Override
@Override
public boolean equals(Object other) {
+ if (other instanceof TmfEvent) {
+ return super.equals(other);
+ }
if (!(other instanceof TmfTraceEvent)) {
return false;
}
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.TmfDataRequest;
-import org.eclipse.linuxtools.tmf.request.TmfEventRequest;
+import org.eclipse.linuxtools.tmf.request.ITmfDataRequest;
+import org.eclipse.linuxtools.tmf.request.ITmfEventRequest;
import org.eclipse.linuxtools.tmf.signal.TmfRangeSynchSignal;
import org.eclipse.linuxtools.tmf.signal.TmfSignalHandler;
import org.eclipse.linuxtools.tmf.trace.ITmfContext;
*
*/
@Override
- public void deregister() {
+ public void dispose() {
fTraces = null;
fCheckpoints.clear();
setCurrentExperiment(null);
- super.deregister();
+ super.dispose();
}
private static void setCurrentExperiment(TmfExperiment<?> experiment) {
// ------------------------------------------------------------------------
@Override
- public ITmfContext armRequest(TmfDataRequest<T> request) {
- TmfTimestamp timestamp = (request instanceof TmfEventRequest<?>) ?
- ((TmfEventRequest<T>) request).getRange().getStartTime() : null;
-
+ public ITmfContext armRequest(ITmfDataRequest<T> request) {
+
+ TmfTimestamp timestamp = (request instanceof ITmfEventRequest<?>) ?
+ ((ITmfEventRequest<T>) request).getRange().getStartTime() : null;
+
+
TmfExperimentContext context = (timestamp != null) ?
seekEvent(timestamp) : seekEvent(request.getIndex());
return context;
+
+// TmfTimestamp timestamp = null;
+//
+// if (request instanceof TmfEventRequest<?> == true) {
+// timestamp = ((TmfEventRequest<T>) request).getRange().getStartTime();
+// }
+// else if (request instanceof TmfCoalescedEventRequest<?> == true) {
+// timestamp = ((TmfCoalescedEventRequest<?>)request).getRange().getStartTime();
+// }
+// else {
+// System.out.println("ERROR : request of unknown instance in armRequest(). Class is : " + request.getClass().toString() );
+// }
+
+
}
@SuppressWarnings("unchecked")
@Override
public TmfExperimentLocation clone() {
+ super.clone(); // To keep FindBugs happy
ITmfLocation<?>[] locations = (ITmfLocation<?>[]) getLocation();
ITmfLocation<?>[] clones = new ITmfLocation[locations.length];
for (int i = 0; i < locations.length; i++) {
/**
* @return request ID
*/
- public long getRequestId();
+ public int getRequestId();
/**
* @return the index of the first event requested
* To suspend the client thread until the request completes
* (or is canceled).
*/
- public void waitForCompletion();
+ public void waitForCompletion() throws InterruptedException;
// ------------------------------------------------------------------------
// Request state modifiers
// Attributes
// ------------------------------------------------------------------------
- protected Vector<TmfDataRequest<T>> fRequests = new Vector<TmfDataRequest<T>>();
+ protected Vector<ITmfDataRequest<T>> fRequests = new Vector<ITmfDataRequest<T>>();
// ------------------------------------------------------------------------
// Constructor
// Management
// ------------------------------------------------------------------------
- public void addRequest(TmfDataRequest<T> request) {
+ public void addRequest(ITmfDataRequest<T> request) {
fRequests.add(request);
}
- public boolean isCompatible(TmfDataRequest<T> request) {
+ public boolean isCompatible(ITmfDataRequest<T> request) {
- boolean ok = request.getIndex() == getIndex();;
+ boolean ok = request.getIndex() == getIndex();
ok &= request.getNbRequested() == getNbRequested();
ok &= request.getBlockize() == getBlockize();
@Override
public void handleData() {
- for (TmfDataRequest<T> request : fRequests) {
+ for (ITmfDataRequest<T> request : fRequests) {
request.setData(getData());
request.handleData();
}
}
@Override
- public void handleCompleted() {
- for (TmfDataRequest<T> request : fRequests) {
- request.handleCompleted();
+ public void done() {
+ for (ITmfDataRequest<T> request : fRequests) {
+ request.done();
}
+ super.done();
}
@Override
- public void handleSuccess() {
- for (TmfDataRequest<T> request : fRequests) {
- request.handleSuccess();
+ public void fail() {
+ for (ITmfDataRequest<T> request : fRequests) {
+ request.fail();
}
+ super.fail();
}
@Override
- public void handleFailure() {
- for (TmfDataRequest<T> request : fRequests) {
- request.handleFailure();
+ public void cancel() {
+ for (ITmfDataRequest<T> request : fRequests) {
+ request.cancel();
}
+ super.cancel();
}
- @Override
- public void handleCancel() {
- for (TmfDataRequest<T> request : fRequests) {
- request.handleCancel();
- }
- }
+ // ------------------------------------------------------------------------
+ // Object
+ // ------------------------------------------------------------------------
@Override
- public void done() {
- for (TmfDataRequest<T> request : fRequests) {
- request.done();
- }
+ // All requests have a unique id
+ public int hashCode() {
+ return super.hashCode();
}
@Override
- public void fail() {
- for (TmfDataRequest<T> request : fRequests) {
- request.fail();
- }
+ 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;
}
@Override
- public void cancel() {
- for (TmfDataRequest<T> request : fRequests) {
- request.cancel();
- }
+ public String toString() {
+ return "[TmfCoalescedDataRequest(" + getRequestId() + "," + getDataType().getSimpleName()
+ + "," + getIndex() + "," + getNbRequested() + "," + getBlockize() + ")]";
}
}
// ------------------------------------------------------------------------
@Override
- public boolean isCompatible(TmfDataRequest<T> request) {
- if (request instanceof TmfEventRequest<?>) {
+ public boolean isCompatible(ITmfDataRequest<T> request) {
+ if (request instanceof ITmfEventRequest<?>) {
boolean ok = getNbRequested() == request.getNbRequested();
ok &= getBlockize() == request.getBlockize();
- ok &= fRange.equals(((TmfEventRequest<T>) request).getRange());
+ ok &= fRange.equals(((ITmfEventRequest<T>) request).getRange());
return ok;
}
return false;
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() + ")]";
+ }
+
}
private final int fBlockSize; // The maximum number of events per chunk
private int fNbRead; // The number of reads so far
- private Object lock = new Object();
- private boolean fRequestCompleted = false;
- private boolean fRequestFailed = false;
- private boolean fRequestCanceled = false;
+ private final Object lock;
+ private boolean fRequestCompleted;
+ private boolean fRequestFailed;
+ private boolean fRequestCanceled;
private T[] fData; // Data object
// Constructors
// ------------------------------------------------------------------------
+ /**
+ * Resets the request counter (used for testing)
+ */
+ public static void reset() {
+ fRequestNumber = 0;
+ }
+
/**
* Default constructor
+ *
+ * @param dataType the requested data type
*/
public TmfDataRequest(Class<T> dataType) {
this(dataType, 0, ALL_DATA, DEFAULT_BLOCK_SIZE);
}
/**
- * @param nbRequested
+ * @param dataType the requested data type
+ * @param nbRequested the number of data items requested
*/
public TmfDataRequest(Class<T> dataType, int index) {
this(dataType, index, ALL_DATA, DEFAULT_BLOCK_SIZE);
}
/**
- * @param index
- * @param nbRequested
+ * @param dataType the requested data type
+ * @param index the index (rank) of the first event requested
+ * @param blockSize the number of data items per block
*/
public TmfDataRequest(Class<T> dataType, int index, int nbRequested) {
this(dataType, index, nbRequested, DEFAULT_BLOCK_SIZE);
}
/**
- * @param index
- * @param nbRequested
- * @param blockSize
+ * @param dataType the requested data type
+ * @param index the index (rank) of the first event requested
+ * @param nbRequested the number of data items requested
+ * @param blockSize the number of data items per block
*/
public TmfDataRequest(Class<T> dataType, int index, int nbRequested, int blockSize) {
fRequestId = fRequestNumber++;
fNbRequested = nbRequested;
fBlockSize = blockSize;
fNbRead = 0;
+ lock = new Object();
+ }
+
+ /**
+ * Copy constructor
+ */
+ @SuppressWarnings("unused")
+ private TmfDataRequest(TmfDataRequest<T> other) {
+ fRequestId = 0;
+ fDataType = null;
+ fIndex = 0;
+ fNbRequested = 0;
+ fBlockSize = 0;
+ fNbRead = 0;
+ lock = new Object();
}
// ------------------------------------------------------------------------
/**
* @return the request ID
*/
- public long getRequestId() {
+ public int getRequestId() {
return fRequestId;
}
/**
* @return the number of events read so far
*/
- public int getNbRead() {
+ public synchronized int getNbRead() {
return fNbRead;
}
*
* @throws InterruptedException
*/
- public void waitForCompletion() {
+ public void waitForCompletion() throws InterruptedException {
synchronized (lock) {
while (!fRequestCompleted)
- try {
- lock.wait();
- } catch (InterruptedException e) {
- e.printStackTrace();
- }
+ lock.wait();
}
}
// ------------------------------------------------------------------------
@Override
+ // All requests have a unique id
public int hashCode() {
- return fRequestId;
+ return getRequestId();
}
@Override
return false;
}
+ @Override
+ public String toString() {
+ return "[TmfDataRequest(" + fRequestId + "," + fDataType.getSimpleName()
+ + "," + fIndex + "," + fNbRequested + "," + fBlockSize + ")]";
+ }
+
}
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
// ------------------------------------------------------------------------
return fRange;
}
+ // ------------------------------------------------------------------------
+ // Object
+ // ------------------------------------------------------------------------
+
+ @Override
+ // All requests have a unique id
+ public int hashCode() {
+ return getRequestId();
+ }
+
+ @Override
+ public boolean equals(Object other) {
+ if (other instanceof TmfEventRequest<?>) {
+ TmfEventRequest<?> request = (TmfEventRequest<?>) other;
+ return super.equals(other) && request.fRange.equals(fRange);
+ }
+ return false;
+ }
+
+ @Override
+ public String toString() {
+ return "[TmfEventRequest(" + getRequestId() + "," + getDataType().getSimpleName()
+ + "," + getRange() + "," + getNbRequested() + "," + getBlockize() + ")]";
+ }
+
}
/**
* <b><u>TmfRequestExecutor</u></b>
*
- * Implement me. Please.
+ * A simple, straightforward request executor.
*/
public class TmfRequestExecutor implements Executor {
// Nothing to do
}
+ /**
+ * Stops the executor
+ */
public void stop() {
fExecutor.shutdown();
}
- public void execute(final Runnable request) {
+ /* (non-Javadoc)
+ * @see java.util.concurrent.Executor#execute(java.lang.Runnable)
+ */
+ public synchronized void execute(final Runnable request) {
fRequests.offer(new Runnable() {
public void run() {
try {
}
}
+ /**
+ * Executes the next pending request, if applicable.
+ */
protected synchronized void scheduleNext() {
if ((fRequest = fRequests.poll()) != null) {
fExecutor.execute(fRequest);
}
}
+ /**
+ * Queues the request and schedules it.
+ *
+ * @param request the request to service
+ */
public synchronized void queueRequest(Runnable request) {
fRequests.add(request);
scheduleNext();
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.ITmfDataRequest;
+import org.eclipse.linuxtools.tmf.request.ITmfEventRequest;
import org.eclipse.linuxtools.tmf.request.TmfCoalescedEventRequest;
-import org.eclipse.linuxtools.tmf.request.TmfDataRequest;
-import org.eclipse.linuxtools.tmf.request.TmfEventRequest;
/**
* <b><u>TmfTrace</u></b>
// ------------------------------------------------------------------------
@Override
- public ITmfContext armRequest(TmfDataRequest<T> request) {
- if (request instanceof TmfEventRequest<?>) {
- return seekEvent(((TmfEventRequest<T>) request).getRange().getStartTime());
+ public ITmfContext armRequest(ITmfDataRequest<T> request) {
+ if (request instanceof ITmfEventRequest<?>) {
+ return seekEvent(((ITmfEventRequest<T>) request).getRange().getStartTime());
}
if (request instanceof TmfCoalescedEventRequest<?>) {
return seekEvent(((TmfCoalescedEventRequest<T>) request).getRange().getStartTime());
projects / deliverable / tracecompass.git / commitdiff
