import org.eclipse.linuxtools.internal.tmf.core.component.TmfProviderManager;
import org.eclipse.linuxtools.tmf.core.component.ITmfDataProvider;
import org.eclipse.linuxtools.tmf.core.event.ITmfEvent;
-import org.eclipse.linuxtools.tmf.core.event.TmfEvent;
import org.eclipse.linuxtools.tmf.core.event.TmfTimeRange;
import org.eclipse.linuxtools.tmf.core.event.TmfTimestamp;
import org.eclipse.linuxtools.tmf.core.request.TmfEventRequest;
// There should be 2 TmfEvent providers: a TmfTraceStub and a
// TmfEventProviderStub
- ITmfDataProvider[] eventProviders = TmfProviderManager.getProviders(TmfEvent.class);
+ ITmfDataProvider[] eventProviders = TmfProviderManager.getProviders(ITmfEvent.class);
assertEquals("getProviders", 2, eventProviders.length);
- eventProviders = TmfProviderManager.getProviders(TmfEvent.class, TmfTraceStub.class);
+ eventProviders = TmfProviderManager.getProviders(ITmfEvent.class, TmfTraceStub.class);
assertEquals("getProviders", 1, eventProviders.length);
- eventProviders = TmfProviderManager.getProviders(TmfEvent.class, TmfEventProviderStub.class);
+ eventProviders = TmfProviderManager.getProviders(ITmfEvent.class, TmfEventProviderStub.class);
assertEquals("getProviders", 1, eventProviders.length);
// There should be 1 TmfSyntheticEventStub provider
final Vector<ITmfEvent> requestedEvents = new Vector<ITmfEvent>();
// Get the TmfSyntheticEventStub provider
- ITmfDataProvider[] eventProviders = TmfProviderManager.getProviders(TmfEvent.class,
+ ITmfDataProvider[] eventProviders = TmfProviderManager.getProviders(ITmfEvent.class,
TmfEventProviderStub.class);
ITmfDataProvider provider = eventProviders[0];
TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BIG_BANG, TmfTimestamp.BIG_CRUNCH);
- final TmfEventRequest request = new TmfEventRequest(TmfEvent.class, range, NB_EVENTS, BLOCK_SIZE) {
+ final TmfEventRequest request = new TmfEventRequest(ITmfEvent.class, range, NB_EVENTS, BLOCK_SIZE) {
@Override
public void handleData(ITmfEvent event) {
super.handleData(event);
final Vector<ITmfEvent> requestedEventsReq2 = new Vector<ITmfEvent>();
// Get the TmfSyntheticEventStub provider
- ITmfDataProvider[] eventProviders = TmfProviderManager.getProviders(TmfEvent.class,
+ ITmfDataProvider[] eventProviders = TmfProviderManager.getProviders(ITmfEvent.class,
TmfEventProviderStub.class);
ITmfDataProvider provider = eventProviders[0];
TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BIG_BANG, TmfTimestamp.BIG_CRUNCH);
// Create first request
- final TmfEventRequest request1 = new TmfEventRequest(TmfEvent.class, range, NB_EVENTS, BLOCK_SIZE) {
+ final TmfEventRequest request1 = new TmfEventRequest(ITmfEvent.class, range, NB_EVENTS, BLOCK_SIZE) {
@Override
public void handleData(ITmfEvent event) {
super.handleData(event);
assertFalse("isRunning", request1.isRunning());
// Create second request
- final TmfEventRequest request2 = new TmfEventRequest(TmfEvent.class, range, NB_EVENTS, BLOCK_SIZE) {
+ final TmfEventRequest request2 = new TmfEventRequest(ITmfEvent.class, range, NB_EVENTS, BLOCK_SIZE) {
@Override
public void handleData(ITmfEvent event) {
super.handleData(event);
// There should be 2 TmfEvent providers: a TmfTraceStub and a
// TmfEventProviderStub
- ITmfDataProvider[] eventProviders = TmfProviderManager.getProviders(TmfEvent.class);
+ ITmfDataProvider[] eventProviders = TmfProviderManager.getProviders(ITmfEvent.class);
assertEquals("getProviders", 2, eventProviders.length);
- eventProviders = TmfProviderManager.getProviders(TmfEvent.class, TmfTraceStub.class);
+ eventProviders = TmfProviderManager.getProviders(ITmfEvent.class, TmfTraceStub.class);
assertEquals("getProviders", 1, eventProviders.length);
- eventProviders = TmfProviderManager.getProviders(TmfEvent.class, TmfEventProviderStub.class);
+ eventProviders = TmfProviderManager.getProviders(ITmfEvent.class, TmfEventProviderStub.class);
assertEquals("getProviders", 1, eventProviders.length);
// There should be 1 TmfSyntheticEventStub provider
// ------------------------------------------------------------------------
private class TestProvider1 extends TmfDataProvider {
- public TestProvider1(Class<TmfEvent> type) {
+ public TestProvider1(Class<ITmfEvent> type) {
super("TestProvider1", type);
}
@Override
return null;
}
@Override
- public TmfEvent getNext(ITmfContext context) {
+ public ITmfEvent getNext(ITmfContext context) {
return null;
}
@Override
}
private class TestProvider2 extends TmfDataProvider {
- public TestProvider2(Class<TmfEvent> type) {
+ public TestProvider2(Class<ITmfEvent> type) {
super("TestProvider2", type);
}
@Override
return null;
}
@Override
- public TmfEvent getNext(ITmfContext context) {
+ public ITmfEvent getNext(ITmfContext context) {
return null;
}
@Override
*
*/
public void testRegister_0() {
- TmfDataProvider[] providers = TmfProviderManager.getProviders(TmfEvent.class);
+ TmfDataProvider[] providers = TmfProviderManager.getProviders(ITmfEvent.class);
assertEquals("getProviders", 0, providers.length);
- providers = TmfProviderManager.getProviders(TmfEvent.class, TestProvider1.class);
+ providers = TmfProviderManager.getProviders(ITmfEvent.class, TestProvider1.class);
assertEquals("getProviders", 0, providers.length);
}
public void testRegister_Unregister_1() {
// Register a single provider
- TestProvider1 testProvider1 = new TestProvider1(TmfEvent.class);
+ TestProvider1 testProvider1 = new TestProvider1(ITmfEvent.class);
- TmfDataProvider[] providers = TmfProviderManager.getProviders(TmfEvent.class);
+ TmfDataProvider[] providers = TmfProviderManager.getProviders(ITmfEvent.class);
assertEquals("getProviders", 1, providers.length);
assertEquals("getProviders", testProvider1, providers[0]);
- providers = TmfProviderManager.getProviders(TmfEvent.class, TestProvider1.class);
+ providers = TmfProviderManager.getProviders(ITmfEvent.class, TestProvider1.class);
assertEquals("getProviders", 1, providers.length);
assertEquals("getProviders", testProvider1, providers[0]);
// Unregister it
testProvider1.dispose();
- providers = TmfProviderManager.getProviders(TmfEvent.class);
+ providers = TmfProviderManager.getProviders(ITmfEvent.class);
assertEquals("getProviders", 0, providers.length);
- providers = TmfProviderManager.getProviders(TmfEvent.class, TestProvider1.class);
+ providers = TmfProviderManager.getProviders(ITmfEvent.class, TestProvider1.class);
assertEquals("getProviders", 0, providers.length);
}
public void testRegister_Unregister_2() {
// Register 2 providers, same data type
- TestProvider1 testProvider1 = new TestProvider1(TmfEvent.class);
- TestProvider2 testProvider2 = new TestProvider2(TmfEvent.class);
+ TestProvider1 testProvider1 = new TestProvider1(ITmfEvent.class);
+ TestProvider2 testProvider2 = new TestProvider2(ITmfEvent.class);
- TmfDataProvider[] providers = TmfProviderManager.getProviders(TmfEvent.class);
+ TmfDataProvider[] providers = TmfProviderManager.getProviders(ITmfEvent.class);
assertEquals("getProviders", 2, providers.length);
assertTrue(providers.length == 2);
if (providers[0] == testProvider1) {
assertEquals("getProviders", testProvider1, providers[1]);
}
- providers = TmfProviderManager.getProviders(TmfEvent.class, TestProvider1.class);
+ providers = TmfProviderManager.getProviders(ITmfEvent.class, TestProvider1.class);
assertEquals("getProviders", 1, providers.length);
assertEquals("getProviders", testProvider1, providers[0]);
- providers = TmfProviderManager.getProviders(TmfEvent.class, TestProvider2.class);
+ providers = TmfProviderManager.getProviders(ITmfEvent.class, TestProvider2.class);
assertEquals("getProviders", 1, providers.length);
assertEquals("getProviders", testProvider2, providers[0]);
// Remove one
testProvider1.dispose();
- providers = TmfProviderManager.getProviders(TmfEvent.class);
+ providers = TmfProviderManager.getProviders(ITmfEvent.class);
assertEquals("getProviders", 1, providers.length);
assertEquals("getProviders", testProvider2, providers[0]);
- providers = TmfProviderManager.getProviders(TmfEvent.class, TestProvider1.class);
+ providers = TmfProviderManager.getProviders(ITmfEvent.class, TestProvider1.class);
assertEquals("getProviders", 0, providers.length);
- providers = TmfProviderManager.getProviders(TmfEvent.class, TestProvider2.class);
+ providers = TmfProviderManager.getProviders(ITmfEvent.class, TestProvider2.class);
assertEquals("getProviders", 1, providers.length);
assertEquals("getProviders", testProvider2, providers[0]);
// Remove the other
testProvider2.dispose();
- providers = TmfProviderManager.getProviders(TmfEvent.class);
+ providers = TmfProviderManager.getProviders(ITmfEvent.class);
assertEquals("getProviders", 0, providers.length);
- providers = TmfProviderManager.getProviders(TmfEvent.class, TestProvider1.class);
+ providers = TmfProviderManager.getProviders(ITmfEvent.class, TestProvider1.class);
assertEquals("getProviders", 0, providers.length);
- providers = TmfProviderManager.getProviders(TmfEvent.class, TestProvider2.class);
+ providers = TmfProviderManager.getProviders(ITmfEvent.class, TestProvider2.class);
assertEquals("getProviders", 0, providers.length);
}
public void testRegister_Unregister_3() {
// Register 3 providers, mixed data types
- TestProvider1 testProvider1 = new TestProvider1(TmfEvent.class);
- TestProvider2 testProvider2 = new TestProvider2(TmfEvent.class);
+ TestProvider1 testProvider1 = new TestProvider1(ITmfEvent.class);
+ TestProvider2 testProvider2 = new TestProvider2(ITmfEvent.class);
TestProvider3 testProvider3 = new TestProvider3(TmfEvent3.class);
- TmfDataProvider[] providers = TmfProviderManager.getProviders(TmfEvent.class);
+ TmfDataProvider[] providers = TmfProviderManager.getProviders(ITmfEvent.class);
assertEquals("getProviders", 2, providers.length);
if (providers[0] == testProvider1) {
assertEquals("getProviders", testProvider2, providers[1]);
assertEquals("getProviders", 1, providers3.length);
assertEquals("getProviders", testProvider3, providers3[0]);
- providers = TmfProviderManager.getProviders(TmfEvent.class, TestProvider1.class);
+ providers = TmfProviderManager.getProviders(ITmfEvent.class, TestProvider1.class);
assertEquals("getProviders", 1, providers.length);
assertEquals("getProviders", testProvider1, providers[0]);
- providers = TmfProviderManager.getProviders(TmfEvent.class, TestProvider2.class);
+ providers = TmfProviderManager.getProviders(ITmfEvent.class, TestProvider2.class);
assertEquals("getProviders", 1, providers.length);
assertEquals("getProviders", testProvider2, providers[0]);
// Remove one
testProvider1.dispose();
- providers = TmfProviderManager.getProviders(TmfEvent.class);
+ providers = TmfProviderManager.getProviders(ITmfEvent.class);
assertEquals("getProviders", 1, providers.length);
assertEquals("getProviders", testProvider2, providers[0]);
- providers = TmfProviderManager.getProviders(TmfEvent.class, TestProvider1.class);
+ providers = TmfProviderManager.getProviders(ITmfEvent.class, TestProvider1.class);
assertEquals("getProviders", 0, providers.length);
- providers = TmfProviderManager.getProviders(TmfEvent.class, TestProvider2.class);
+ providers = TmfProviderManager.getProviders(ITmfEvent.class, TestProvider2.class);
assertEquals("getProviders", 1, providers.length);
assertEquals("getProviders", testProvider2, providers[0]);
// Remove another one
testProvider2.dispose();
- providers = TmfProviderManager.getProviders(TmfEvent.class);
+ providers = TmfProviderManager.getProviders(ITmfEvent.class);
assertEquals("getProviders", 0, providers.length);
- providers = TmfProviderManager.getProviders(TmfEvent.class, TestProvider1.class);
+ providers = TmfProviderManager.getProviders(ITmfEvent.class, TestProvider1.class);
assertEquals("getProviders", 0, providers.length);
- providers = TmfProviderManager.getProviders(TmfEvent.class, TestProvider2.class);
+ providers = TmfProviderManager.getProviders(ITmfEvent.class, TestProvider2.class);
assertEquals("getProviders", 0, providers.length);
providers3 = TmfProviderManager.getProviders(TmfEvent3.class);
// Remove the last one
testProvider3.dispose();
- providers = TmfProviderManager.getProviders(TmfEvent.class);
+ providers = TmfProviderManager.getProviders(ITmfEvent.class);
assertEquals("getProviders", 0, providers.length);
- providers = TmfProviderManager.getProviders(TmfEvent.class, TestProvider1.class);
+ providers = TmfProviderManager.getProviders(ITmfEvent.class, TestProvider1.class);
assertEquals("getProviders", 0, providers.length);
- providers = TmfProviderManager.getProviders(TmfEvent.class, TestProvider2.class);
+ providers = TmfProviderManager.getProviders(ITmfEvent.class, TestProvider2.class);
assertEquals("getProviders", 0, providers.length);
providers3 = TmfProviderManager.getProviders(TmfEvent3.class);
public void testGetProvider() {
// Register 3 providers, mixed data types
- TestProvider1 testProvider1 = new TestProvider1(TmfEvent.class);
- TestProvider2 testProvider2 = new TestProvider2(TmfEvent.class);
+ TestProvider1 testProvider1 = new TestProvider1(ITmfEvent.class);
+ TestProvider2 testProvider2 = new TestProvider2(ITmfEvent.class);
TestProvider3 testProvider3 = new TestProvider3(TmfEvent3.class);
- TmfDataProvider[] providers = TmfProviderManager.getProviders(TmfEvent.class, null);
+ TmfDataProvider[] providers = TmfProviderManager.getProviders(ITmfEvent.class, null);
assertEquals("getProviders", 2, providers.length);
if (providers[0] == testProvider1) {
assertEquals("getProviders", testProvider2, providers[1]);
*
*/
public void testNoRankConstructor() {
- final TmfEvent event = new TmfEvent(null, fTimestamp1, fSource, fType, fContent1, fReference1);
+ final ITmfEvent event = new TmfEvent(null, fTimestamp1, fSource, fType, fContent1, fReference1);
assertNull("getTrace", event.getTrace());
assertEquals("getRank", ITmfContext.UNKNOWN_RANK, event.getRank());
assertEquals("getTimestamp", fTimestamp1, event.getTimestamp());
*/
public void testConstructorWithTrace() {
final ITmfTrace trace = openTrace();
- final TmfEvent event = new TmfEvent(trace, 0, fTimestamp1, fSource, fType, fContent1, fReference1);
+ final ITmfEvent event = new TmfEvent(trace, 0, fTimestamp1, fSource, fType, fContent1, fReference1);
assertNotNull("getTrace", event.getTrace());
assertEquals("getRank", 0, event.getRank());
assertEquals("getTimestamp", fTimestamp1, event.getTimestamp());
*
*/
public void testTmfEventCopy() {
- final TmfEvent event = new TmfEvent(fEvent1);
+ final ITmfEvent event = new TmfEvent(fEvent1);
assertNull("getTrace", event.getTrace());
assertEquals("getRank", 0, event.getRank());
assertEquals("getTimestamp", fTimestamp1, event.getTimestamp());
assertEquals("setReference", fReference1, event.getReference());
}
- // ------------------------------------------------------------------------
- // clone
- // ------------------------------------------------------------------------
-
- private static class MyEvent extends TmfEvent {
-
- @Override
- public boolean equals(final Object other) {
- return super.equals(other);
- }
- @Override
- public MyEvent clone() {
- return (MyEvent) super.clone();
- }
- }
-
- /**
- *
- */
- public void testClone1() {
- final ITmfEvent clone = fEvent1.clone();
-
- assertTrue("clone", fEvent1.clone().equals(fEvent1));
- assertTrue("clone", clone.clone().equals(clone));
-
- assertEquals("clone", fEvent1, clone);
- assertEquals("clone", clone, fEvent1);
- }
-
- /**
- *
- */
- public void testClone2() {
- final TmfEvent event = new MyEvent();
- final TmfEvent clone = event.clone();
-
- assertTrue("clone", event.clone().equals(event));
- assertTrue("clone", clone.clone().equals(clone));
-
- assertEquals("clone", event, clone);
- assertEquals("clone", clone, event);
- }
-
// ------------------------------------------------------------------------
// hashCode
// ------------------------------------------------------------------------
*
*/
public void testHashCode() {
- TmfEvent event1 = new TmfEvent();
- TmfEvent event2 = new TmfEvent();
+ ITmfEvent event1 = new TmfEvent();
+ ITmfEvent event2 = new TmfEvent();
assertTrue("hashCode", event1.hashCode() == event2.hashCode());
final ITmfTrace trace = openTrace();
event1 = new TmfEvent(trace, 0, fTimestamp1, fSource, fType, fContent1, fReference1);
event2 = new TmfEvent(trace, 1, fTimestamp2, fSource, fType, fContent2, fReference2);
- final TmfEvent event1b = new TmfEvent(event1);
- final TmfEvent event2b = new TmfEvent(event2);
+ final ITmfEvent event1b = new TmfEvent(event1);
+ final ITmfEvent event2b = new TmfEvent(event2);
assertTrue("hashCode", event1.hashCode() == event1b.hashCode());
assertTrue("hashCode", event2.hashCode() == event2b.hashCode());
*
*/
public void testEqualsSymmetry() {
- final TmfEvent event1 = new TmfEvent(fEvent1);
- final TmfEvent event2 = new TmfEvent(fEvent2);
+ final ITmfEvent event1 = new TmfEvent(fEvent1);
+ final ITmfEvent event2 = new TmfEvent(fEvent2);
assertTrue("equals", event1.equals(fEvent1));
assertTrue("equals", fEvent1.equals(event1));
*
*/
public void testEqualsTransivity() {
- final TmfEvent event1 = new TmfEvent(fEvent1);
- final TmfEvent event2 = new TmfEvent(fEvent1);
- final TmfEvent event3 = new TmfEvent(fEvent1);
+ final ITmfEvent event1 = new TmfEvent(fEvent1);
+ final ITmfEvent event2 = new TmfEvent(fEvent1);
+ final ITmfEvent event3 = new TmfEvent(fEvent1);
assertTrue("equals", event1.equals(event2));
assertTrue("equals", event2.equals(event3));
final ITmfTrace trace1 = openTrace();
final ITmfTrace trace2 = openTrace();
- final TmfEvent event1 = new TmfEvent(trace1, 0, fTimestamp1, fSource, fType, fContent1, fReference1);
- TmfEvent event2 = new TmfEvent(trace1, 0, fTimestamp1, fSource, fType, fContent1, fReference1);
+ final ITmfEvent event1 = new TmfEvent(trace1, 0, fTimestamp1, fSource, fType, fContent1, fReference1);
+ ITmfEvent event2 = new TmfEvent(trace1, 0, fTimestamp1, fSource, fType, fContent1, fReference1);
assertTrue("equals", event1.equals(event2));
assertTrue("equals", event2.equals(event1));
*
*/
public void testNonEqualRanks() {
- final TmfEvent event1 = new TmfEvent(null, 0, fTimestamp1, fSource, fType, fContent1, fReference1);
- TmfEvent event2 = new TmfEvent(null, 0, fTimestamp1, fSource, fType, fContent1, fReference1);
+ final ITmfEvent event1 = new TmfEvent(null, 0, fTimestamp1, fSource, fType, fContent1, fReference1);
+ ITmfEvent event2 = new TmfEvent(null, 0, fTimestamp1, fSource, fType, fContent1, fReference1);
assertTrue("equals", event1.equals(event2));
assertTrue("equals", event2.equals(event1));
*
*/
public void testNonEqualTimestamps() {
- final TmfEvent event1 = new TmfEvent(null, 0, fTimestamp1, fSource, fType, fContent1, fReference1);
- TmfEvent event2 = new TmfEvent(null, 0, fTimestamp1, fSource, fType, fContent1, fReference1);
+ final ITmfEvent event1 = new TmfEvent(null, 0, fTimestamp1, fSource, fType, fContent1, fReference1);
+ ITmfEvent event2 = new TmfEvent(null, 0, fTimestamp1, fSource, fType, fContent1, fReference1);
assertTrue("equals", event1.equals(event2));
assertTrue("equals", event2.equals(event1));
*
*/
public void testNonEqualSources() {
- final TmfEvent event1 = new TmfEvent(null, 0, fTimestamp1, fSource, fType, fContent1, fReference1);
- TmfEvent event2 = new TmfEvent(null, 0, fTimestamp1, fSource, fType, fContent1, fReference1);
+ final ITmfEvent event1 = new TmfEvent(null, 0, fTimestamp1, fSource, fType, fContent1, fReference1);
+ ITmfEvent event2 = new TmfEvent(null, 0, fTimestamp1, fSource, fType, fContent1, fReference1);
assertTrue("equals", event1.equals(event2));
assertTrue("equals", event2.equals(event1));
*
*/
public void testNonEqualTypes() {
- final TmfEvent event1 = new TmfEvent(null, 0, fTimestamp1, fSource, fType, fContent1, fReference1);
- TmfEvent event2 = new TmfEvent(null, 0, fTimestamp1, fSource, fType, fContent1, fReference1);
+ final ITmfEvent event1 = new TmfEvent(null, 0, fTimestamp1, fSource, fType, fContent1, fReference1);
+ ITmfEvent event2 = new TmfEvent(null, 0, fTimestamp1, fSource, fType, fContent1, fReference1);
assertTrue("equals", event1.equals(event2));
assertTrue("equals", event2.equals(event1));
*
*/
public void testNonEqualContents() {
- final TmfEvent event1 = new TmfEvent(null, 0, fTimestamp1, fSource, fType, fContent1, fReference1);
- TmfEvent event2 = new TmfEvent(null, 0, fTimestamp1, fSource, fType, fContent1, fReference1);
+ final ITmfEvent event1 = new TmfEvent(null, 0, fTimestamp1, fSource, fType, fContent1, fReference1);
+ ITmfEvent event2 = new TmfEvent(null, 0, fTimestamp1, fSource, fType, fContent1, fReference1);
assertTrue("equals", event1.equals(event2));
assertTrue("equals", event2.equals(event1));
*
*/
public void testNonEqualReferences() {
- final TmfEvent event1 = new TmfEvent(null, 0, fTimestamp1, fSource, fType, fContent1, fReference1);
- TmfEvent event2 = new TmfEvent(null, 0, fTimestamp1, fSource, fType, fContent1, fReference1);
+ final ITmfEvent event1 = new TmfEvent(null, 0, fTimestamp1, fSource, fType, fContent1, fReference1);
+ ITmfEvent event2 = new TmfEvent(null, 0, fTimestamp1, fSource, fType, fContent1, fReference1);
assertTrue("equals", event1.equals(event2));
assertTrue("equals", event2.equals(event1));
import org.eclipse.linuxtools.internal.tmf.core.request.TmfCoalescedDataRequest;
import org.eclipse.linuxtools.tmf.core.event.ITmfEvent;
-import org.eclipse.linuxtools.tmf.core.event.TmfEvent;
import org.eclipse.linuxtools.tmf.core.request.TmfDataRequest;
import org.eclipse.linuxtools.tmf.tests.stubs.request.TmfDataRequestStub;
public void setUp() throws Exception {
super.setUp();
TmfDataRequest.reset();
- fRequest1 = new TmfCoalescedDataRequest(TmfEvent.class, 10, 100, 200);
- fRequest2 = new TmfCoalescedDataRequest(TmfEvent.class, 20, 100, 200);
- fRequest3 = new TmfCoalescedDataRequest(TmfEvent.class, 20, 200, 200);
- fRequest4 = new TmfCoalescedDataRequest(TmfEvent.class, 20, 200, 300);
+ fRequest1 = new TmfCoalescedDataRequest(ITmfEvent.class, 10, 100, 200);
+ fRequest2 = new TmfCoalescedDataRequest(ITmfEvent.class, 20, 100, 200);
+ fRequest3 = new TmfCoalescedDataRequest(ITmfEvent.class, 20, 200, 200);
+ fRequest4 = new TmfCoalescedDataRequest(ITmfEvent.class, 20, 200, 300);
- fRequest1b = new TmfCoalescedDataRequest(TmfEvent.class, 10, 100, 200);
- fRequest1c = new TmfCoalescedDataRequest(TmfEvent.class, 10, 100, 200);
+ fRequest1b = new TmfCoalescedDataRequest(ITmfEvent.class, 10, 100, 200);
+ fRequest1c = new TmfCoalescedDataRequest(ITmfEvent.class, 10, 100, 200);
fRequestCount = fRequest1c.getRequestId() + 1;
}
private static TmfCoalescedDataRequest setupTestRequest(final boolean[] flags) {
- TmfCoalescedDataRequest request = new TmfCoalescedDataRequest(TmfEvent.class, 10, 100, 200) {
+ TmfCoalescedDataRequest request = new TmfCoalescedDataRequest(ITmfEvent.class, 10, 100, 200) {
@Override
public void handleCompleted() {
super.handleCompleted();
// ------------------------------------------------------------------------
public void testTmfCoalescedDataRequest() {
- TmfCoalescedDataRequest request = new TmfCoalescedDataRequest(TmfEvent.class);
+ TmfCoalescedDataRequest request = new TmfCoalescedDataRequest(ITmfEvent.class);
assertEquals("getRequestId", fRequestCount++, request.getRequestId());
assertEquals("getDataType", ITmfEvent.class, request.getDataType());
}
public void testTmfCoalescedDataRequestIndex() {
- TmfCoalescedDataRequest request = new TmfCoalescedDataRequest(TmfEvent.class, 10);
+ TmfCoalescedDataRequest request = new TmfCoalescedDataRequest(ITmfEvent.class, 10);
assertEquals("getRequestId", fRequestCount++, request.getRequestId());
assertEquals("getDataType", ITmfEvent.class, request.getDataType());
}
public void testTmfCoalescedDataRequestIndexNbRequested() {
- TmfCoalescedDataRequest request = new TmfCoalescedDataRequest(TmfEvent.class, 10, 100);
+ TmfCoalescedDataRequest request = new TmfCoalescedDataRequest(ITmfEvent.class, 10, 100);
assertEquals("getRequestId", fRequestCount++, request.getRequestId());
assertEquals("getDataType", ITmfEvent.class, request.getDataType());
}
public void testTmfCoalescedDataRequestIndexNbEventsBlocksize() {
- TmfCoalescedDataRequest request = new TmfCoalescedDataRequest(TmfEvent.class, 10, 100, 200);
+ TmfCoalescedDataRequest request = new TmfCoalescedDataRequest(ITmfEvent.class, 10, 100, 200);
assertEquals("getRequestId", fRequestCount++, request.getRequestId());
assertEquals("getDataType", ITmfEvent.class, request.getDataType());
assertEquals("toString", expected2, fRequest2.toString());
assertEquals("toString", expected3, fRequest3.toString());
assertEquals("toString", expected4, fRequest4.toString());
- }
+ }
- // ------------------------------------------------------------------------
- // isCompatible
- // ------------------------------------------------------------------------
+ // ------------------------------------------------------------------------
+ // isCompatible
+ // ------------------------------------------------------------------------
- public void testIsCompatible() {
- TmfCoalescedDataRequest coalescedRequest = new TmfCoalescedDataRequest(TmfEvent.class, 10, 100, 200);
- TmfDataRequest request1 = new TmfDataRequestStub(TmfEvent.class, 10, 100, 200);
- TmfDataRequest request2 = new TmfDataRequestStub(TmfEvent.class, 5, 100, 200);
- TmfDataRequest request3 = new TmfDataRequestStub(TmfEvent.class, 5, 4, 200);
- TmfDataRequest request4 = new TmfDataRequestStub(TmfEvent.class, 5, 5, 200);
- TmfDataRequest request5 = new TmfDataRequestStub(TmfEvent.class, 15, 100, 200);
- TmfDataRequest request6 = new TmfDataRequestStub(TmfEvent.class, 100, 100, 200);
- TmfDataRequest request7 = new TmfDataRequestStub(TmfEvent.class, 110, 100, 200);
- TmfDataRequest request8 = new TmfDataRequestStub(TmfEvent.class, 111, 100, 200);
+ public void testIsCompatible() {
+ TmfCoalescedDataRequest coalescedRequest = new TmfCoalescedDataRequest(ITmfEvent.class, 10, 100, 200);
+ TmfDataRequest request1 = new TmfDataRequestStub(ITmfEvent.class, 10, 100, 200);
+ TmfDataRequest request2 = new TmfDataRequestStub(ITmfEvent.class, 5, 100, 200);
+ TmfDataRequest request3 = new TmfDataRequestStub(ITmfEvent.class, 5, 4, 200);
+ TmfDataRequest request4 = new TmfDataRequestStub(ITmfEvent.class, 5, 5, 200);
+ TmfDataRequest request5 = new TmfDataRequestStub(ITmfEvent.class, 15, 100, 200);
+ TmfDataRequest request6 = new TmfDataRequestStub(ITmfEvent.class, 100, 100, 200);
+ TmfDataRequest request7 = new TmfDataRequestStub(ITmfEvent.class, 110, 100, 200);
+ TmfDataRequest request8 = new TmfDataRequestStub(ITmfEvent.class, 111, 100, 200);
assertTrue("isCompatible", coalescedRequest.isCompatible(request1));
assertTrue("isCompatible", coalescedRequest.isCompatible(request2));
assertTrue("isCompatible", coalescedRequest.isCompatible(request7));
assertTrue("isCompatible", coalescedRequest.isCompatible(request8));
- TmfDataRequest request9 = new TmfDataRequestStub(TmfEvent.class, 5, 3, 200);
- TmfDataRequest request10 = new TmfDataRequestStub(TmfEvent.class, 112, 100, 200);
+ TmfDataRequest request9 = new TmfDataRequestStub(ITmfEvent.class, 5, 3, 200);
+ TmfDataRequest request10 = new TmfDataRequestStub(ITmfEvent.class, 112, 100, 200);
assertFalse("isCompatible", coalescedRequest.isCompatible(request9));
assertFalse("isCompatible", coalescedRequest.isCompatible(request10));
- }
+ }
// ------------------------------------------------------------------------
// addRequest
// ------------------------------------------------------------------------
public void testAddRequest1() {
- TmfCoalescedDataRequest coalescedRequest = new TmfCoalescedDataRequest(TmfEvent.class, 10, 100, 200);
- TmfDataRequest request = new TmfDataRequestStub(TmfEvent.class, 10, 100, 200);
+ TmfCoalescedDataRequest coalescedRequest = new TmfCoalescedDataRequest(ITmfEvent.class, 10, 100, 200);
+ TmfDataRequest request = new TmfDataRequestStub(ITmfEvent.class, 10, 100, 200);
assertTrue("isCompatible", coalescedRequest.isCompatible(request));
coalescedRequest.addRequest(request);
}
public void testAddRequest2() {
- TmfCoalescedDataRequest coalescedRequest = new TmfCoalescedDataRequest(TmfEvent.class, 10, 100, 200);
- TmfDataRequest request = new TmfDataRequestStub(TmfEvent.class, 5, 100, 200);
+ TmfCoalescedDataRequest coalescedRequest = new TmfCoalescedDataRequest(ITmfEvent.class, 10, 100, 200);
+ TmfDataRequest request = new TmfDataRequestStub(ITmfEvent.class, 5, 100, 200);
assertTrue("isCompatible", coalescedRequest.isCompatible(request));
coalescedRequest.addRequest(request);
}
public void testAddRequest3() {
- TmfCoalescedDataRequest coalescedRequest = new TmfCoalescedDataRequest(TmfEvent.class, 10, 100, 200);
- TmfDataRequest request = new TmfDataRequestStub(TmfEvent.class, 5, 4, 200);
+ TmfCoalescedDataRequest coalescedRequest = new TmfCoalescedDataRequest(ITmfEvent.class, 10, 100, 200);
+ TmfDataRequest request = new TmfDataRequestStub(ITmfEvent.class, 5, 4, 200);
assertTrue("isCompatible", coalescedRequest.isCompatible(request));
coalescedRequest.addRequest(request);
}
public void testAddRequest4() {
- TmfCoalescedDataRequest coalescedRequest = new TmfCoalescedDataRequest(TmfEvent.class, 10, 100, 200);
- TmfDataRequest request = new TmfDataRequestStub(TmfEvent.class, 5, 5, 200);
+ TmfCoalescedDataRequest coalescedRequest = new TmfCoalescedDataRequest(ITmfEvent.class, 10, 100, 200);
+ TmfDataRequest request = new TmfDataRequestStub(ITmfEvent.class, 5, 5, 200);
assertTrue("isCompatible", coalescedRequest.isCompatible(request));
coalescedRequest.addRequest(request);
}
public void testAddRequest5() {
- TmfCoalescedDataRequest coalescedRequest = new TmfCoalescedDataRequest(TmfEvent.class, 10, 100, 200);
- TmfDataRequest request = new TmfDataRequestStub(TmfEvent.class, 15, 100, 200);
+ TmfCoalescedDataRequest coalescedRequest = new TmfCoalescedDataRequest(ITmfEvent.class, 10, 100, 200);
+ TmfDataRequest request = new TmfDataRequestStub(ITmfEvent.class, 15, 100, 200);
assertTrue("isCompatible", coalescedRequest.isCompatible(request));
coalescedRequest.addRequest(request);
}
public void testAddRequest6() {
- TmfCoalescedDataRequest coalescedRequest = new TmfCoalescedDataRequest(TmfEvent.class, 10, 100, 200);
- TmfDataRequest request = new TmfDataRequestStub(TmfEvent.class, 100, 100, 200);
+ TmfCoalescedDataRequest coalescedRequest = new TmfCoalescedDataRequest(ITmfEvent.class, 10, 100, 200);
+ TmfDataRequest request = new TmfDataRequestStub(ITmfEvent.class, 100, 100, 200);
assertTrue("isCompatible", coalescedRequest.isCompatible(request));
coalescedRequest.addRequest(request);
}
public void testAddRequest7() {
- TmfCoalescedDataRequest coalescedRequest = new TmfCoalescedDataRequest(TmfEvent.class, 10, 100, 200);
- TmfDataRequest request = new TmfDataRequestStub(TmfEvent.class, 110, 100, 200);
+ TmfCoalescedDataRequest coalescedRequest = new TmfCoalescedDataRequest(ITmfEvent.class, 10, 100, 200);
+ TmfDataRequest request = new TmfDataRequestStub(ITmfEvent.class, 110, 100, 200);
assertTrue("isCompatible", coalescedRequest.isCompatible(request));
coalescedRequest.addRequest(request);
}
public void testAddRequest8() {
- TmfCoalescedDataRequest coalescedRequest = new TmfCoalescedDataRequest(TmfEvent.class, 10, 100, 200);
- TmfDataRequest request = new TmfDataRequestStub(TmfEvent.class, 111, 100, 200);
+ TmfCoalescedDataRequest coalescedRequest = new TmfCoalescedDataRequest(ITmfEvent.class, 10, 100, 200);
+ TmfDataRequest request = new TmfDataRequestStub(ITmfEvent.class, 111, 100, 200);
assertTrue("isCompatible", coalescedRequest.isCompatible(request));
coalescedRequest.addRequest(request);
// ------------------------------------------------------------------------
// done
- // ------------------------------------------------------------------------
+ // ------------------------------------------------------------------------
- public void testDone() {
+ public void testDone() {
- // Test request
- final boolean[] crFlags = new boolean[4];
- TmfCoalescedDataRequest request = setupTestRequest(crFlags);
- TmfDataRequest subRequest1 = new TmfDataRequestStub(TmfEvent.class, 10, 100, 200);
- TmfDataRequest subRequest2 = new TmfDataRequestStub(TmfEvent.class, 10, 100, 200);
- request.addRequest(subRequest1);
- request.addRequest(subRequest2);
+ // Test request
+ final boolean[] crFlags = new boolean[4];
+ TmfCoalescedDataRequest request = setupTestRequest(crFlags);
+ TmfDataRequest subRequest1 = new TmfDataRequestStub(ITmfEvent.class, 10, 100, 200);
+ TmfDataRequest subRequest2 = new TmfDataRequestStub(ITmfEvent.class, 10, 100, 200);
+ request.addRequest(subRequest1);
+ request.addRequest(subRequest2);
request.done();
final boolean[] crFlags = new boolean[4];
TmfCoalescedDataRequest request = setupTestRequest(crFlags);
- TmfDataRequest subRequest1 = new TmfDataRequestStub(TmfEvent.class, 10, 100, 200);
- TmfDataRequest subRequest2 = new TmfDataRequestStub(TmfEvent.class, 10, 100, 200);
+ TmfDataRequest subRequest1 = new TmfDataRequestStub(ITmfEvent.class, 10, 100, 200);
+ TmfDataRequest subRequest2 = new TmfDataRequestStub(ITmfEvent.class, 10, 100, 200);
request.addRequest(subRequest1);
request.addRequest(subRequest2);
final boolean[] crFlags = new boolean[4];
TmfCoalescedDataRequest request = setupTestRequest(crFlags);
- TmfDataRequest subRequest1 = new TmfDataRequestStub(TmfEvent.class, 10, 100, 200);
- TmfDataRequest subRequest2 = new TmfDataRequestStub(TmfEvent.class, 10, 100, 200);
+ TmfDataRequest subRequest1 = new TmfDataRequestStub(ITmfEvent.class, 10, 100, 200);
+ TmfDataRequest subRequest2 = new TmfDataRequestStub(ITmfEvent.class, 10, 100, 200);
request.addRequest(subRequest1);
request.addRequest(subRequest2);
public void testCancelSubRequests() {
- final boolean[] crFlags = new boolean[4];
- TmfCoalescedDataRequest request = setupTestRequest(crFlags);
- TmfDataRequest subRequest1 = new TmfDataRequestStub(TmfEvent.class, 10, 100, 200);
- TmfDataRequest subRequest2 = new TmfDataRequestStub(TmfEvent.class, 10, 100, 200);
- request.addRequest(subRequest1);
- request.addRequest(subRequest2);
-
- subRequest1.cancel();
-
- // Validate the first coalesced request
- assertTrue ("isCompleted", subRequest1.isCompleted());
- assertFalse("isFailed", subRequest1.isFailed());
- assertTrue ("isCancelled", subRequest1.isCancelled());
-
- // Validate the coalescing request
- assertFalse("isCompleted", request.isCompleted());
- assertFalse("isFailed", request.isFailed());
- assertFalse("isCancelled", request.isCancelled());
-
- // Cancel second sub-request
- subRequest2.cancel();
-
- // Validate the second coalesced request
- assertTrue ("isCompleted", subRequest2.isCompleted());
- assertFalse("isFailed", subRequest2.isFailed());
- assertTrue ("isCancelled", subRequest2.isCancelled());
-
- // Validate the coalescing request
- assertTrue ("isCompleted", request.isCompleted());
- assertFalse("isFailed", request.isFailed());
- assertTrue ("isCancelled", request.isCancelled());
-
- // Finalize coalescing request -
- // Note: No need to check "request.isCancelled()" since it was verified above
- request.cancel();
-
- assertTrue ("handleCompleted", crFlags[0]);
- assertFalse("handleSuccess", crFlags[1]);
- assertFalse("handleFailure", crFlags[2]);
- assertTrue ("handleCancel", crFlags[3]);
- }
+ final boolean[] crFlags = new boolean[4];
+ TmfCoalescedDataRequest request = setupTestRequest(crFlags);
+ TmfDataRequest subRequest1 = new TmfDataRequestStub(ITmfEvent.class, 10, 100, 200);
+ TmfDataRequest subRequest2 = new TmfDataRequestStub(ITmfEvent.class, 10, 100, 200);
+ request.addRequest(subRequest1);
+ request.addRequest(subRequest2);
+
+ subRequest1.cancel();
+
+ // Validate the first coalesced request
+ assertTrue ("isCompleted", subRequest1.isCompleted());
+ assertFalse("isFailed", subRequest1.isFailed());
+ assertTrue ("isCancelled", subRequest1.isCancelled());
+
+ // Validate the coalescing request
+ assertFalse("isCompleted", request.isCompleted());
+ assertFalse("isFailed", request.isFailed());
+ assertFalse("isCancelled", request.isCancelled());
+
+ // Cancel second sub-request
+ subRequest2.cancel();
+
+ // Validate the second coalesced request
+ assertTrue ("isCompleted", subRequest2.isCompleted());
+ assertFalse("isFailed", subRequest2.isFailed());
+ assertTrue("isCancelled", subRequest2.isCancelled());
+
+ // Validate the coalescing request
+ assertTrue("isCompleted", request.isCompleted());
+ assertFalse("isFailed", request.isFailed());
+ assertTrue("isCancelled", request.isCancelled());
+
+ // Finalize coalescing request -
+ // Note: No need to check "request.isCancelled()" since it was verified
+ // above
+ request.cancel();
+
+ assertTrue("handleCompleted", crFlags[0]);
+ assertFalse("handleSuccess", crFlags[1]);
+ assertFalse("handleFailure", crFlags[2]);
+ assertTrue("handleCancel", crFlags[3]);
+ }
}
import org.eclipse.linuxtools.internal.tmf.core.request.TmfCoalescedEventRequest;
import org.eclipse.linuxtools.tmf.core.component.ITmfDataProvider;
import org.eclipse.linuxtools.tmf.core.event.ITmfEvent;
-import org.eclipse.linuxtools.tmf.core.event.TmfEvent;
import org.eclipse.linuxtools.tmf.core.event.TmfTimeRange;
import org.eclipse.linuxtools.tmf.core.event.TmfTimestamp;
import org.eclipse.linuxtools.tmf.core.exceptions.TmfTraceException;
public void setUp() throws Exception {
super.setUp();
TmfDataRequest.reset();
- fRequest1 = new TmfCoalescedEventRequest(TmfEvent.class, range1, 100, 200);
- fRequest2 = new TmfCoalescedEventRequest(TmfEvent.class, range2, 100, 200);
- fRequest3 = new TmfCoalescedEventRequest(TmfEvent.class, range2, 200, 200);
- fRequest4 = new TmfCoalescedEventRequest(TmfEvent.class, range2, 200, 300);
+ fRequest1 = new TmfCoalescedEventRequest(ITmfEvent.class, range1, 100, 200);
+ fRequest2 = new TmfCoalescedEventRequest(ITmfEvent.class, range2, 100, 200);
+ fRequest3 = new TmfCoalescedEventRequest(ITmfEvent.class, range2, 200, 200);
+ fRequest4 = new TmfCoalescedEventRequest(ITmfEvent.class, range2, 200, 300);
- fRequest1b = new TmfCoalescedEventRequest(TmfEvent.class, range1, 100, 200);
- fRequest1c = new TmfCoalescedEventRequest(TmfEvent.class, range1, 100, 200);
+ fRequest1b = new TmfCoalescedEventRequest(ITmfEvent.class, range1, 100, 200);
+ fRequest1c = new TmfCoalescedEventRequest(ITmfEvent.class, range1, 100, 200);
fRequestCount = fRequest1c.getRequestId() + 1;
}
private TmfCoalescedEventRequest setupTestRequest(final boolean[] flags) {
- TmfCoalescedEventRequest request = new TmfCoalescedEventRequest(TmfEvent.class, range1, 100, 200) {
+ TmfCoalescedEventRequest request = new TmfCoalescedEventRequest(ITmfEvent.class, range1, 100, 200) {
@Override
public void handleCompleted() {
super.handleCompleted();
// ------------------------------------------------------------------------
public void testTmfCoalescedEventRequest() {
- TmfCoalescedEventRequest request = new TmfCoalescedEventRequest(TmfEvent.class);
+ TmfCoalescedEventRequest request = new TmfCoalescedEventRequest(ITmfEvent.class);
assertEquals("getRequestId", fRequestCount++, request.getRequestId());
assertEquals("getDataType", ITmfEvent.class, request.getDataType());
}
public void testTmfCoalescedEventRequestIndex() {
- TmfCoalescedEventRequest request = new TmfCoalescedEventRequest(TmfEvent.class, range1);
+ TmfCoalescedEventRequest request = new TmfCoalescedEventRequest(ITmfEvent.class, range1);
assertEquals("getRequestId", fRequestCount++, request.getRequestId());
assertEquals("getDataType", ITmfEvent.class, request.getDataType());
}
public void testTmfCoalescedEventRequestIndexNbRequested() {
- TmfCoalescedEventRequest request = new TmfCoalescedEventRequest(TmfEvent.class, range1, 100);
+ TmfCoalescedEventRequest request = new TmfCoalescedEventRequest(ITmfEvent.class, range1, 100);
assertEquals("getRequestId", fRequestCount++, request.getRequestId());
assertEquals("getDataType", ITmfEvent.class, request.getDataType());
}
public void testTmfCoalescedEventRequestIndexNbEventsBlocksize() {
- TmfCoalescedEventRequest request = new TmfCoalescedEventRequest(TmfEvent.class, range1, 100, 200);
+ TmfCoalescedEventRequest request = new TmfCoalescedEventRequest(ITmfEvent.class, range1, 100, 200);
assertEquals("getRequestId", fRequestCount++, request.getRequestId());
assertEquals("getDataType", ITmfEvent.class, request.getDataType());
@SuppressWarnings("hiding")
public void testIsCompatible() {
- TmfCoalescedEventRequest coalescedRequest = new TmfCoalescedEventRequest(TmfEvent.class, range1, 100, 200);
- TmfEventRequest request1 = new TmfEventRequestStub(TmfEvent.class, range1, 100, 200);
- TmfEventRequest request2 = new TmfEventRequestStub(TmfEvent.class, range2, 100, 200);
- TmfEventRequest request3 = new TmfEventRequestStub(TmfEvent.class, range1, 101, 200);
+ TmfCoalescedEventRequest coalescedRequest = new TmfCoalescedEventRequest(ITmfEvent.class, range1, 100, 200);
+ TmfEventRequest request1 = new TmfEventRequestStub(ITmfEvent.class, range1, 100, 200);
+ TmfEventRequest request2 = new TmfEventRequestStub(ITmfEvent.class, range2, 100, 200);
+ TmfEventRequest request3 = new TmfEventRequestStub(ITmfEvent.class, range1, 101, 200);
assertTrue("isCompatible", coalescedRequest.isCompatible(request1));
assertTrue("isCompatible", coalescedRequest.isCompatible(request2));
@SuppressWarnings("hiding")
public void testAddEvent1() {
- TmfCoalescedEventRequest coalescedRequest = new TmfCoalescedEventRequest(TmfEvent.class, range1, 0, 2147483647, 200, ExecutionType.FOREGROUND);
- TmfEventRequest request1 = new TmfEventRequestStub(TmfEvent.class, range1, 0, 2147483647, 200);
- TmfEventRequest request2 = new TmfEventRequestStub(TmfEvent.class, range1, 1, 2147483647, 200);
+ TmfCoalescedEventRequest coalescedRequest = new TmfCoalescedEventRequest(ITmfEvent.class, range1, 0, 2147483647, 200, ExecutionType.FOREGROUND);
+ TmfEventRequest request1 = new TmfEventRequestStub(ITmfEvent.class, range1, 0, 2147483647, 200);
+ TmfEventRequest request2 = new TmfEventRequestStub(ITmfEvent.class, range1, 1, 2147483647, 200);
assertTrue("isCompatible", coalescedRequest.isCompatible(request1));
assertTrue("isCompatible", coalescedRequest.isCompatible(request2));
@SuppressWarnings("hiding")
public void testAddEvent2() {
- TmfCoalescedEventRequest coalescedRequest = new TmfCoalescedEventRequest(TmfEvent.class, range1, 1, 2147483647, 200, ExecutionType.FOREGROUND);
- TmfEventRequest request1 = new TmfEventRequestStub(TmfEvent.class, range1, 1, 2147483647, 200);
- TmfEventRequest request2 = new TmfEventRequestStub(TmfEvent.class, range1, 0, 2147483647, 200);
+ TmfCoalescedEventRequest coalescedRequest = new TmfCoalescedEventRequest(ITmfEvent.class, range1, 1, 2147483647, 200, ExecutionType.FOREGROUND);
+ TmfEventRequest request1 = new TmfEventRequestStub(ITmfEvent.class, range1, 1, 2147483647, 200);
+ TmfEventRequest request2 = new TmfEventRequestStub(ITmfEvent.class, range1, 0, 2147483647, 200);
assertTrue("isCompatible", coalescedRequest.isCompatible(request1));
assertTrue("isCompatible", coalescedRequest.isCompatible(request2));
// Test request
final boolean[] crFlags = new boolean[4];
TmfCoalescedEventRequest request = setupTestRequest(crFlags);
- TmfEventRequest subRequest1 = new TmfEventRequestStub(TmfEvent.class, range1, 100, 200);
- TmfEventRequest subRequest2 = new TmfEventRequestStub(TmfEvent.class, range1, 100, 200);
+ TmfEventRequest subRequest1 = new TmfEventRequestStub(ITmfEvent.class, range1, 100, 200);
+ TmfEventRequest subRequest2 = new TmfEventRequestStub(ITmfEvent.class, range1, 100, 200);
request.addRequest(subRequest1);
request.addRequest(subRequest2);
final boolean[] crFlags = new boolean[4];
TmfCoalescedEventRequest request = setupTestRequest(crFlags);
- TmfEventRequest subRequest1 = new TmfEventRequestStub(TmfEvent.class, range1, 100, 200);
- TmfEventRequest subRequest2 = new TmfEventRequestStub(TmfEvent.class, range1, 100, 200);
+ TmfEventRequest subRequest1 = new TmfEventRequestStub(ITmfEvent.class, range1, 100, 200);
+ TmfEventRequest subRequest2 = new TmfEventRequestStub(ITmfEvent.class, range1, 100, 200);
request.addRequest(subRequest1);
request.addRequest(subRequest2);
final boolean[] crFlags = new boolean[4];
TmfCoalescedEventRequest request = setupTestRequest(crFlags);
- TmfEventRequest subRequest1 = new TmfEventRequestStub(TmfEvent.class, range1, 100, 200);
- TmfEventRequest subRequest2 = new TmfEventRequestStub(TmfEvent.class, range1, 100, 200);
+ TmfEventRequest subRequest1 = new TmfEventRequestStub(ITmfEvent.class, range1, 100, 200);
+ TmfEventRequest subRequest2 = new TmfEventRequestStub(ITmfEvent.class, range1, 100, 200);
request.addRequest(subRequest1);
request.addRequest(subRequest2);
final long REQUEST_OFFSET = 1000;
requestedEvents1 = new Vector<ITmfEvent>();
- request1 = new TmfEventRequest(TmfEvent.class, range, signal.fIndex, NB_EVENTS, BLOCK_SIZE) {
+ request1 = new TmfEventRequest(ITmfEvent.class, range, signal.fIndex, NB_EVENTS, BLOCK_SIZE) {
int nbRead = 0;
@Override
public void handleData(ITmfEvent event) {
};
requestedEvents2 = new Vector<ITmfEvent>();
- request2 = new TmfEventRequest(TmfEvent.class, range, signal.fIndex + REQUEST_OFFSET, NB_EVENTS, BLOCK_SIZE) {
+ request2 = new TmfEventRequest(ITmfEvent.class, range, signal.fIndex + REQUEST_OFFSET, NB_EVENTS, BLOCK_SIZE) {
@Override
public void handleData(ITmfEvent event) {
super.handleData(event);
};
requestedEvents3 = new Vector<ITmfEvent>();
- request3 = new TmfEventRequest(TmfEvent.class, range, signal.fIndex + 2 * REQUEST_OFFSET, NB_EVENTS, BLOCK_SIZE) {
+ request3 = new TmfEventRequest(ITmfEvent.class, range, signal.fIndex + 2 * REQUEST_OFFSET, NB_EVENTS, BLOCK_SIZE) {
@Override
public void handleData(ITmfEvent event) {
super.handleData(event);
}
};
- providers = TmfProviderManager.getProviders(TmfEvent.class, TmfTraceStub.class);
+ providers = TmfProviderManager.getProviders(ITmfEvent.class, TmfTraceStub.class);
providers[0].sendRequest(request1);
providers[0].sendRequest(request2);
providers[0].sendRequest(request3);
import junit.framework.TestCase;
-import org.eclipse.linuxtools.tmf.core.event.TmfEvent;
+import org.eclipse.linuxtools.tmf.core.event.ITmfEvent;
import org.eclipse.linuxtools.tmf.core.request.TmfDataRequest;
import org.eclipse.linuxtools.tmf.tests.stubs.request.TmfDataRequestStub;
protected void setUp() throws Exception {
super.setUp();
TmfDataRequest.reset();
- fRequest1 = new TmfDataRequestStub(TmfEvent.class, 10, 100, 200);
- fRequest2 = new TmfDataRequestStub(TmfEvent.class, 20, 100, 200);
- fRequest3 = new TmfDataRequestStub(TmfEvent.class, 20, 200, 200);
- fRequest4 = new TmfDataRequestStub(TmfEvent.class, 20, 200, 300);
- fRequest1b = new TmfDataRequestStub(TmfEvent.class, 10, 100, 200);
- fRequest1c = new TmfDataRequestStub(TmfEvent.class, 10, 100, 200);
+ fRequest1 = new TmfDataRequestStub(ITmfEvent.class, 10, 100, 200);
+ fRequest2 = new TmfDataRequestStub(ITmfEvent.class, 20, 100, 200);
+ fRequest3 = new TmfDataRequestStub(ITmfEvent.class, 20, 200, 200);
+ fRequest4 = new TmfDataRequestStub(ITmfEvent.class, 20, 200, 300);
+ fRequest1b = new TmfDataRequestStub(ITmfEvent.class, 10, 100, 200);
+ fRequest1c = new TmfDataRequestStub(ITmfEvent.class, 10, 100, 200);
fRequestCount = fRequest1c.getRequestId() + 1;
}
private static TmfDataRequest setupTestRequest(final boolean[] flags) {
- TmfDataRequest request = new TmfDataRequestStub(TmfEvent.class, 10, 100, 200) {
+ TmfDataRequest request = new TmfDataRequestStub(ITmfEvent.class, 10, 100, 200) {
@Override
public void handleCompleted() {
super.handleCompleted();
// ------------------------------------------------------------------------
public void testTmfDataRequest() {
- TmfDataRequest request = new TmfDataRequestStub(TmfEvent.class);
+ TmfDataRequest request = new TmfDataRequestStub(ITmfEvent.class);
assertEquals("getRequestId", fRequestCount++, request.getRequestId());
- assertEquals("getDataType", TmfEvent.class, request.getDataType());
+ assertEquals("getDataType", ITmfEvent.class, request.getDataType());
assertEquals("getIndex", 0, request.getIndex());
assertEquals("getNbRequestedEvents", TmfDataRequest.ALL_DATA, request.getNbRequested());
}
public void testTmfDataRequestIndex() {
- TmfDataRequest request = new TmfDataRequestStub(TmfEvent.class, 10);
+ TmfDataRequest request = new TmfDataRequestStub(ITmfEvent.class, 10);
assertEquals("getRequestId", fRequestCount++, request.getRequestId());
- assertEquals("getDataType", TmfEvent.class, request.getDataType());
+ assertEquals("getDataType", ITmfEvent.class, request.getDataType());
assertEquals("getIndex", 10, request.getIndex());
assertEquals("getNbRequestedEvents", TmfDataRequest.ALL_DATA, request.getNbRequested());
}
public void testTmfDataRequestIndexNbRequested() {
- TmfDataRequest request = new TmfDataRequestStub(TmfEvent.class, 10, 100);
+ TmfDataRequest request = new TmfDataRequestStub(ITmfEvent.class, 10, 100);
assertEquals("getRequestId", fRequestCount++, request.getRequestId());
- assertEquals("getDataType", TmfEvent.class, request.getDataType());
+ assertEquals("getDataType", ITmfEvent.class, request.getDataType());
assertEquals("getIndex", 10, request.getIndex());
assertEquals("getNbRequestedEvents", 100, request.getNbRequested());
}
public void testTmfDataRequestIndexNbEventsBlocksize() {
- TmfDataRequest request = new TmfDataRequestStub(TmfEvent.class, 10, 100, 200);
+ TmfDataRequest request = new TmfDataRequestStub(ITmfEvent.class, 10, 100, 200);
assertEquals("getRequestId", fRequestCount++, request.getRequestId());
- assertEquals("getDataType", TmfEvent.class, request.getDataType());
+ assertEquals("getDataType", ITmfEvent.class, request.getDataType());
assertEquals("getIndex", 10, request.getIndex());
assertEquals("getNbRequestedEvents", 100, request.getNbRequested());
// ------------------------------------------------------------------------
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)]";
+ String expected1 = "[TmfDataRequest(0,ITmfEvent,10,100,200)]";
+ String expected2 = "[TmfDataRequest(1,ITmfEvent,20,100,200)]";
+ String expected3 = "[TmfDataRequest(2,ITmfEvent,20,200,200)]";
+ String expected4 = "[TmfDataRequest(3,ITmfEvent,20,200,300)]";
assertEquals("toString", expected1, fRequest1.toString());
assertEquals("toString", expected2, fRequest2.toString());
import junit.framework.TestCase;
-import org.eclipse.linuxtools.tmf.core.event.TmfEvent;
+import org.eclipse.linuxtools.tmf.core.event.ITmfEvent;
import org.eclipse.linuxtools.tmf.core.event.TmfTimeRange;
import org.eclipse.linuxtools.tmf.core.event.TmfTimestamp;
import org.eclipse.linuxtools.tmf.core.request.TmfDataRequest;
protected void setUp() throws Exception {
super.setUp();
TmfDataRequest.reset();
- fRequest1 = new TmfEventRequestStub(TmfEvent.class, range1, 100, 200);
- fRequest2 = new TmfEventRequestStub(TmfEvent.class, range2, 100, 200);
- fRequest3 = new TmfEventRequestStub(TmfEvent.class, range2, 200, 200);
- fRequest4 = new TmfEventRequestStub(TmfEvent.class, range2, 200, 300);
- fRequest1b = new TmfEventRequestStub(TmfEvent.class, range1, 100, 200);
- fRequest1c = new TmfEventRequestStub(TmfEvent.class, range1, 100, 200);
+ fRequest1 = new TmfEventRequestStub(ITmfEvent.class, range1, 100, 200);
+ fRequest2 = new TmfEventRequestStub(ITmfEvent.class, range2, 100, 200);
+ fRequest3 = new TmfEventRequestStub(ITmfEvent.class, range2, 200, 200);
+ fRequest4 = new TmfEventRequestStub(ITmfEvent.class, range2, 200, 300);
+ fRequest1b = new TmfEventRequestStub(ITmfEvent.class, range1, 100, 200);
+ fRequest1c = new TmfEventRequestStub(ITmfEvent.class, range1, 100, 200);
fRequestCount = fRequest1c.getRequestId() + 1;
}
private static TmfEventRequest setupTestRequest(final boolean[] flags) {
- TmfEventRequest request = new TmfEventRequestStub(TmfEvent.class, new TmfTimeRange(TmfTimeRange.ETERNITY), 100, 200) {
+ TmfEventRequest request = new TmfEventRequestStub(ITmfEvent.class, new TmfTimeRange(TmfTimeRange.ETERNITY), 100, 200) {
@Override
public void handleCompleted() {
super.handleCompleted();
// ------------------------------------------------------------------------
public void testTmfEventRequest() {
- TmfEventRequest request = new TmfEventRequestStub(TmfEvent.class);
+ TmfEventRequest request = new TmfEventRequestStub(ITmfEvent.class);
assertEquals("getRequestId", fRequestCount++, request.getRequestId());
- assertEquals("getDataType", TmfEvent.class, request.getDataType());
+ assertEquals("getDataType", ITmfEvent.class, request.getDataType());
assertEquals("StartTime", TmfTimestamp.BIG_BANG, request.getRange().getStartTime());
assertEquals("EndTime", TmfTimestamp.BIG_CRUNCH, request.getRange().getEndTime());
public void testTmfEventRequestTimeRange() {
TmfTimeRange range = new TmfTimeRange(new TmfTimestamp(), TmfTimestamp.BIG_CRUNCH);
- TmfEventRequest request = new TmfEventRequestStub(TmfEvent.class, range);
+ TmfEventRequest request = new TmfEventRequestStub(ITmfEvent.class, range);
assertEquals("getRequestId", fRequestCount++, request.getRequestId());
- assertEquals("getDataType", TmfEvent.class, request.getDataType());
+ assertEquals("getDataType", ITmfEvent.class, request.getDataType());
assertEquals("StartTime", new TmfTimestamp(), request.getRange().getStartTime());
assertEquals("EndTime", TmfTimestamp.BIG_CRUNCH, request.getRange().getEndTime());
public void testTmfEventRequestTimeRangeNbRequested() {
TmfTimeRange range = new TmfTimeRange(new TmfTimestamp(), TmfTimestamp.BIG_CRUNCH);
- TmfEventRequest request = new TmfEventRequestStub(TmfEvent.class, range, 100);
+ TmfEventRequest request = new TmfEventRequestStub(ITmfEvent.class, range, 100);
assertEquals("getRequestId", fRequestCount++, request.getRequestId());
- assertEquals("getDataType", TmfEvent.class, request.getDataType());
+ assertEquals("getDataType", ITmfEvent.class, request.getDataType());
assertEquals("StartTime", new TmfTimestamp(), request.getRange().getStartTime());
assertEquals("EndTime", TmfTimestamp.BIG_CRUNCH, request.getRange().getEndTime());
public void testTmfEventRequestTimeRangeNbRequestedBlocksize() {
TmfTimeRange range = new TmfTimeRange(new TmfTimestamp(), TmfTimestamp.BIG_CRUNCH);
- TmfEventRequest request = new TmfEventRequestStub(TmfEvent.class, range, 100, 200);
+ TmfEventRequest request = new TmfEventRequestStub(ITmfEvent.class, range, 100, 200);
assertEquals("getRequestId", fRequestCount++, request.getRequestId());
- assertEquals("getDataType", TmfEvent.class, request.getDataType());
+ assertEquals("getDataType", ITmfEvent.class, request.getDataType());
assertEquals("StartTime", new TmfTimestamp(), request.getRange().getStartTime());
assertEquals("EndTime", TmfTimestamp.BIG_CRUNCH, request.getRange().getEndTime());
// ------------------------------------------------------------------------
public void testToString() {
- String expected1 = "[TmfEventRequest(0,TmfEvent," + range1 + ",0,100,200)]";
- String expected2 = "[TmfEventRequest(1,TmfEvent," + range2 + ",0,100,200)]";
- String expected3 = "[TmfEventRequest(2,TmfEvent," + range2 + ",0,200,200)]";
- String expected4 = "[TmfEventRequest(3,TmfEvent," + range2 + ",0,200,300)]";
+ String expected1 = "[TmfEventRequest(0,ITmfEvent," + range1 + ",0,100,200)]";
+ String expected2 = "[TmfEventRequest(1,ITmfEvent," + range2 + ",0,100,200)]";
+ String expected3 = "[TmfEventRequest(2,ITmfEvent," + range2 + ",0,200,200)]";
+ String expected4 = "[TmfEventRequest(3,ITmfEvent," + range2 + ",0,200,300)]";
assertEquals("toString", expected1, fRequest1.toString());
assertEquals("toString", expected2, fRequest2.toString());
import org.eclipse.linuxtools.internal.tmf.core.trace.TmfExperimentContext;
import org.eclipse.linuxtools.internal.tmf.core.trace.TmfExperimentLocation;
import org.eclipse.linuxtools.tmf.core.event.ITmfEvent;
-import org.eclipse.linuxtools.tmf.core.event.TmfEvent;
import org.eclipse.linuxtools.tmf.core.event.TmfTimeRange;
import org.eclipse.linuxtools.tmf.core.event.TmfTimestamp;
import org.eclipse.linuxtools.tmf.core.exceptions.TmfTraceException;
public void testSimpleTmfExperimentConstructor() {
- TmfExperiment experiment = new TmfExperiment(TmfEvent.class, EXPERIMENT, fTestTraces);
+ TmfExperiment experiment = new TmfExperiment(ITmfEvent.class, EXPERIMENT, fTestTraces);
assertEquals("GetId", EXPERIMENT, experiment.getName());
assertEquals("GetCacheSize", TmfExperiment.DEFAULT_INDEX_PAGE_SIZE, experiment.getCacheSize());
experiment.dispose();
- experiment = new TmfExperiment(TmfEvent.class, EXPERIMENT, null);
+ experiment = new TmfExperiment(ITmfEvent.class, EXPERIMENT, null);
experiment.dispose();
}
}
public void testSeekNoTrace() {
- TmfExperiment experiment = new TmfExperiment(TmfEvent.class, EXPERIMENT, null);
+ TmfExperiment experiment = new TmfExperiment(ITmfEvent.class, EXPERIMENT, null);
ITmfContext context = experiment.seekEvent((TmfExperimentLocation) null);
assertNull("seekEvent", context);
experiment.dispose();
final Vector<ITmfEvent> requestedEvents = new Vector<ITmfEvent>();
final TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BIG_BANG, TmfTimestamp.BIG_CRUNCH);
- final TmfEventRequest request = new TmfEventRequest(TmfEvent.class, range, nbEvents, blockSize) {
+ final TmfEventRequest request = new TmfEventRequest(ITmfEvent.class, range, nbEvents, blockSize) {
@Override
public void handleData(final ITmfEvent event) {
super.handleData(event);
final Vector<ITmfEvent> requestedEvents = new Vector<ITmfEvent>();
final TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BIG_BANG, TmfTimestamp.BIG_CRUNCH);
- final TmfEventRequest request = new TmfEventRequest(TmfEvent.class, range, nbEvents, blockSize) {
+ final TmfEventRequest request = new TmfEventRequest(ITmfEvent.class, range, nbEvents, blockSize) {
@Override
public void handleData(final ITmfEvent event) {
super.handleData(event);
final long nbExpectedEvents = NB_EVENTS;
final TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BIG_BANG, TmfTimestamp.BIG_CRUNCH);
- final TmfEventRequest request = new TmfEventRequest(TmfEvent.class, range, nbEvents, blockSize) {
+ final TmfEventRequest request = new TmfEventRequest(ITmfEvent.class, range, nbEvents, blockSize) {
@Override
public void handleData(final ITmfEvent event) {
super.handleData(event);
final Vector<ITmfEvent> requestedEvents = new Vector<ITmfEvent>();
final TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BIG_BANG, TmfTimestamp.BIG_CRUNCH);
- final TmfEventRequest request = new TmfEventRequest(TmfEvent.class, range, nbEvents, blockSize) {
+ final TmfEventRequest request = new TmfEventRequest(ITmfEvent.class, range, nbEvents, blockSize) {
int nbRead = 0;
@Override
public void handleData(final ITmfEvent event) {
import org.eclipse.linuxtools.internal.tmf.core.trace.TmfExperimentContext;
import org.eclipse.linuxtools.tmf.core.event.ITmfEvent;
import org.eclipse.linuxtools.tmf.core.event.ITmfTimestamp;
-import org.eclipse.linuxtools.tmf.core.event.TmfEvent;
import org.eclipse.linuxtools.tmf.core.event.TmfTimeRange;
import org.eclipse.linuxtools.tmf.core.event.TmfTimestamp;
import org.eclipse.linuxtools.tmf.core.exceptions.TmfTraceException;
final Vector<ITmfEvent> requestedEvents = new Vector<ITmfEvent>();
final TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BIG_BANG, TmfTimestamp.BIG_CRUNCH);
- final TmfEventRequest request = new TmfEventRequest(TmfEvent.class, range, nbEvents, blockSize) {
+ final TmfEventRequest request = new TmfEventRequest(ITmfEvent.class, range, nbEvents, blockSize) {
@Override
public void handleData(final ITmfEvent event) {
super.handleData(event);
final Vector<ITmfEvent> requestedEvents = new Vector<ITmfEvent>();
final TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BIG_BANG, TmfTimestamp.BIG_CRUNCH);
- final TmfEventRequest request = new TmfEventRequest(TmfEvent.class, range, nbEvents, blockSize) {
+ final TmfEventRequest request = new TmfEventRequest(ITmfEvent.class, range, nbEvents, blockSize) {
@Override
public void handleData(final ITmfEvent event) {
super.handleData(event);
final long nbExpectedEvents = NB_EVENTS;
final TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BIG_BANG, TmfTimestamp.BIG_CRUNCH);
- final TmfEventRequest request = new TmfEventRequest(TmfEvent.class, range, nbEvents, blockSize) {
+ final TmfEventRequest request = new TmfEventRequest(ITmfEvent.class, range, nbEvents, blockSize) {
@Override
public void handleData(final ITmfEvent event) {
super.handleData(event);
final Vector<ITmfEvent> requestedEvents = new Vector<ITmfEvent>();
final TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BIG_BANG, TmfTimestamp.BIG_CRUNCH);
- final TmfEventRequest request = new TmfEventRequest(TmfEvent.class, range, nbEvents, blockSize) {
+ final TmfEventRequest request = new TmfEventRequest(ITmfEvent.class, range, nbEvents, blockSize) {
int nbRead = 0;
@Override
public void handleData(final ITmfEvent event) {
// ------------------------------------------------------------------------
// getInitialRangeOffset, getCurrentRange, getCurrentTime
// ------------------------------------------------------------------------
+
public void testDefaultCurrentTimeValues() {
// reset to default initial range offset
((TmfTraceStub)fTraces[0]).setInitialRangeOffset(null);
import org.eclipse.linuxtools.tmf.core.component.ITmfDataProvider;
import org.eclipse.linuxtools.tmf.core.event.ITmfEvent;
import org.eclipse.linuxtools.tmf.core.event.ITmfTimestamp;
-import org.eclipse.linuxtools.tmf.core.event.TmfEvent;
import org.eclipse.linuxtools.tmf.core.event.TmfTimeRange;
import org.eclipse.linuxtools.tmf.core.event.TmfTimestamp;
import org.eclipse.linuxtools.tmf.core.exceptions.TmfTraceException;
}
assertFalse ("Open trace", trace == null);
- assertEquals("getType", TmfEvent.class, trace.getType());
+ assertEquals("getType", ITmfEvent.class, trace.getType());
assertNull ("getResource", trace.getResource());
assertEquals("getPath", testfile.toURI().getPath(), trace.getPath());
assertEquals("getCacheSize", ITmfTrace.DEFAULT_TRACE_CACHE_SIZE, trace.getCacheSize());
}
assertFalse ("Open trace", trace == null);
- assertEquals("getType", TmfEvent.class, trace.getType());
+ assertEquals("getType", ITmfEvent.class, trace.getType());
assertNull ("getResource", trace.getResource());
assertEquals("getPath", testfile.toURI().getPath(), trace.getPath());
assertEquals("getCacheSize", ITmfTrace.DEFAULT_TRACE_CACHE_SIZE, trace.getCacheSize());
fail("IOException");
}
- assertEquals("getType", TmfEvent.class, trace.getType());
+ assertEquals("getType", ITmfEvent.class, trace.getType());
assertNull ("getResource", trace.getResource());
assertEquals("getPath", testfile.toURI().getPath(), trace.getPath());
assertEquals("getCacheSize", BLOCK_SIZE, trace.getCacheSize());
}
assertFalse ("Open trace", trace == null);
- assertEquals("getType", TmfEvent.class, trace.getType());
+ assertEquals("getType", ITmfEvent.class, trace.getType());
assertNull ("getResource", trace.getResource());
assertEquals("getPath", testfile.toURI().getPath(), trace.getPath());
assertEquals("getCacheSize", BLOCK_SIZE, trace.getCacheSize());
}
assertFalse ("Open trace", trace == null);
- assertEquals("getType", TmfEvent.class, trace.getType());
+ assertEquals("getType", ITmfEvent.class, trace.getType());
assertNull ("getResource", trace.getResource());
assertEquals("getPath", testfile.toURI().getPath(), trace.getPath());
assertEquals("getCacheSize", BLOCK_SIZE, trace.getCacheSize());
}
assertFalse ("Open trace", trace == null);
- assertEquals("getType", TmfEvent.class, trace.getType());
+ assertEquals("getType", ITmfEvent.class, trace.getType());
assertNull ("getResource", trace.getResource());
assertEquals("getPath", testfile.toURI().getPath(), trace.getPath());
assertEquals("getCacheSize", BLOCK_SIZE, trace.getCacheSize());
final TmfTraceStub trace = new TmfTraceStub();
try {
- trace.initialize(null, null, TmfEvent.class);
+ trace.initialize(null, null, ITmfEvent.class);
fail("TmfTrace.initialize() - no exception thrown");
} catch (TmfTraceException e) {
// Success
// Path == trace name
String path = "TraceName";
try {
- trace.initialize(null, path, TmfEvent.class);
+ trace.initialize(null, path, ITmfEvent.class);
} catch (Exception e) {
fail("TmfTrace.initialize() - Exception thrown");
}
- assertEquals("getType", TmfEvent.class, trace.getType());
+ assertEquals("getType", ITmfEvent.class, trace.getType());
assertNull ("getResource", trace.getResource());
assertEquals("getPath", path, trace.getPath());
assertEquals("getCacheSize", ITmfTrace.DEFAULT_TRACE_CACHE_SIZE, trace.getCacheSize());
String name = "TraceName";
String path = "/my/trace/path/" + name;
try {
- trace.initialize(null, path, TmfEvent.class);
+ trace.initialize(null, path, ITmfEvent.class);
} catch (Exception e) {
fail("TmfTrace.initialize() - Exception thrown");
}
- assertEquals("getType", TmfEvent.class, trace.getType());
+ assertEquals("getType", ITmfEvent.class, trace.getType());
assertNull ("getResource", trace.getResource());
assertEquals("getPath", path, trace.getPath());
assertEquals("getCacheSize", ITmfTrace.DEFAULT_TRACE_CACHE_SIZE, trace.getCacheSize());
assertTrue("validate", trace.validate(null, testfile.getPath()));
// InitTrace and wait for indexing completion...
- trace.initTrace(null, testfile.toURI().getPath(), TmfEvent.class);
+ trace.initTrace(null, testfile.toURI().getPath(), ITmfEvent.class);
trace.indexTrace();
int nbSecs = 0;
while (trace.getNbEvents() < NB_EVENTS && nbSecs < 10) {
fail("indexing");
}
- assertEquals("getType", TmfEvent.class, trace.getType());
+ assertEquals("getType", ITmfEvent.class, trace.getType());
assertNull ("getResource", trace.getResource());
assertEquals("getCacheSize", ITmfTrace.DEFAULT_TRACE_CACHE_SIZE, trace.getCacheSize());
assertEquals("getStreamingInterval", 0, trace.getStreamingInterval());
final Vector<ITmfEvent> requestedEvents = new Vector<ITmfEvent>();
final TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BIG_BANG, TmfTimestamp.BIG_CRUNCH);
- final TmfEventRequest request = new TmfEventRequest(TmfEvent.class, range, NB_EVENTS, BLOCK_SIZE) {
+ final TmfEventRequest request = new TmfEventRequest(ITmfEvent.class, range, NB_EVENTS, BLOCK_SIZE) {
@Override
public void handleData(final ITmfEvent event) {
super.handleData(event);
requestedEvents.add(event);
}
};
- final ITmfDataProvider[] providers = TmfProviderManager.getProviders(TmfEvent.class, TmfTraceStub.class);
+ final ITmfDataProvider[] providers = TmfProviderManager.getProviders(ITmfEvent.class, TmfTraceStub.class);
providers[0].sendRequest(request);
request.waitForCompletion();
final Vector<ITmfEvent> requestedEvents = new Vector<ITmfEvent>();
final TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BIG_BANG, TmfTimestamp.BIG_CRUNCH);
- final TmfEventRequest request = new TmfEventRequest(TmfEvent.class, range, NB_EVENTS, BLOCK_SIZE) {
+ final TmfEventRequest request = new TmfEventRequest(ITmfEvent.class, range, NB_EVENTS, BLOCK_SIZE) {
@Override
public void handleData(final ITmfEvent event) {
super.handleData(event);
requestedEvents.add(event);
}
};
- final ITmfDataProvider[] providers = TmfProviderManager.getProviders(TmfEvent.class, TmfTraceStub.class);
+ final ITmfDataProvider[] providers = TmfProviderManager.getProviders(ITmfEvent.class, TmfTraceStub.class);
providers[0].sendRequest(request);
request.waitForCompletion();
final Vector<ITmfEvent> requestedEvents = new Vector<ITmfEvent>();
final TmfTimeRange range = new TmfTimeRange(new TmfTimestamp(startTime, SCALE), TmfTimestamp.BIG_CRUNCH);
- final TmfEventRequest request = new TmfEventRequest(TmfEvent.class, range, NB_EVENTS, BLOCK_SIZE) {
+ final TmfEventRequest request = new TmfEventRequest(ITmfEvent.class, range, NB_EVENTS, BLOCK_SIZE) {
@Override
public void handleData(final ITmfEvent event) {
super.handleData(event);
requestedEvents.add(event);
}
};
- final ITmfDataProvider[] providers = TmfProviderManager.getProviders(TmfEvent.class, TmfTraceStub.class);
+ final ITmfDataProvider[] providers = TmfProviderManager.getProviders(ITmfEvent.class, TmfTraceStub.class);
providers[0].sendRequest(request);
request.waitForCompletion();
final Vector<ITmfEvent> requestedEvents = new Vector<ITmfEvent>();
final TmfTimeRange range = new TmfTimeRange(new TmfTimestamp(startTime, SCALE), TmfTimestamp.BIG_CRUNCH);
- final TmfEventRequest request = new TmfEventRequest(TmfEvent.class, range, startIndex, NB_EVENTS, BLOCK_SIZE) {
+ final TmfEventRequest request = new TmfEventRequest(ITmfEvent.class, range, startIndex, NB_EVENTS, BLOCK_SIZE) {
@Override
public void handleData(final ITmfEvent event) {
super.handleData(event);
requestedEvents.add(event);
}
};
- final ITmfDataProvider[] providers = TmfProviderManager.getProviders(TmfEvent.class, TmfTraceStub.class);
+ final ITmfDataProvider[] providers = TmfProviderManager.getProviders(ITmfEvent.class, TmfTraceStub.class);
providers[0].sendRequest(request);
request.waitForCompletion();
final int NB_EVENTS = 1000;
final Vector<ITmfEvent> requestedEvents = new Vector<ITmfEvent>();
- final TmfDataRequest request = new TmfDataRequest(TmfEvent.class, startIndex, NB_EVENTS) {
+ final TmfDataRequest request = new TmfDataRequest(ITmfEvent.class, startIndex, NB_EVENTS) {
@Override
public void handleData(final ITmfEvent event) {
super.handleData(event);
requestedEvents.add(event);
}
};
- final ITmfDataProvider[] providers = TmfProviderManager.getProviders(TmfEvent.class, TmfTraceStub.class);
+ final ITmfDataProvider[] providers = TmfProviderManager.getProviders(ITmfEvent.class, TmfTraceStub.class);
providers[0].sendRequest(request);
request.waitForCompletion();
final Vector<ITmfEvent> requestedEvents = new Vector<ITmfEvent>();
final TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BIG_BANG, TmfTimestamp.BIG_CRUNCH);
- final TmfEventRequest request = new TmfEventRequest(TmfEvent.class, range, NB_EVENTS, BLOCK_SIZE) {
+ final TmfEventRequest request = new TmfEventRequest(ITmfEvent.class, range, NB_EVENTS, BLOCK_SIZE) {
int nbRead = 0;
@Override
public void handleData(final ITmfEvent event) {
}
}
};
- final ITmfDataProvider[] providers = TmfProviderManager.getProviders(TmfEvent.class, TmfTraceStub.class);
+ final ITmfDataProvider[] providers = TmfProviderManager.getProviders(ITmfEvent.class, TmfTraceStub.class);
providers[0].sendRequest(request);
request.waitForCompletion();
public void testDefaultTmfTraceStub() {
assertFalse ("Open trace", fTrace == null);
- assertEquals("getType", TmfEvent.class, fTrace.getType());
+ assertEquals("getType", ITmfEvent.class, fTrace.getType());
assertNull ("getResource", fTrace.getResource());
assertEquals("getCacheSize", BLOCK_SIZE, fTrace.getCacheSize());
assertEquals("getStreamingInterval", 0, fTrace.getStreamingInterval());
import junit.framework.TestCase;
+import org.eclipse.linuxtools.tmf.core.event.ITmfEvent;
import org.eclipse.linuxtools.tmf.core.event.ITmfEventField;
import org.eclipse.linuxtools.tmf.core.event.ITmfEventType;
import org.eclipse.linuxtools.tmf.core.event.TmfEvent;
private final TmfEventType fType = new TmfEventType(fContext, fTypeId, TmfEventField.makeRoot(fLabels));
private final String fReference = "Some reference";
- private final TmfEvent fEvent1;
- private final TmfEvent fEvent2;
+ private final ITmfEvent fEvent1;
+ private final ITmfEvent fEvent2;
private final TmfEventField fContent1;
private final TmfEventField fContent2;
import junit.framework.TestCase;
+import org.eclipse.linuxtools.tmf.core.event.ITmfEvent;
import org.eclipse.linuxtools.tmf.core.event.ITmfEventField;
import org.eclipse.linuxtools.tmf.core.event.ITmfEventType;
import org.eclipse.linuxtools.tmf.core.event.TmfEvent;
private final TmfEventType fType = new TmfEventType(fContext, fTypeId, TmfEventField.makeRoot(fLabels));
private final String fReference = "Some reference";
- private final TmfEvent fEvent1;
+ private final ITmfEvent fEvent1;
private final TmfEventField fContent1;
public TmfSyncSequenceDiagramEventTest () {
import org.eclipse.core.runtime.Path;
import org.eclipse.linuxtools.tmf.core.component.TmfDataProvider;
import org.eclipse.linuxtools.tmf.core.event.ITmfEvent;
-import org.eclipse.linuxtools.tmf.core.event.TmfEvent;
import org.eclipse.linuxtools.tmf.core.exceptions.TmfTraceException;
import org.eclipse.linuxtools.tmf.core.request.ITmfDataRequest;
import org.eclipse.linuxtools.tmf.core.request.ITmfEventRequest;
private TmfTraceStub fTrace;
public TmfDataProviderStub(final String path) throws IOException {
- super("TmfDataProviderStub", TmfEvent.class);
+ super("TmfDataProviderStub", ITmfEvent.class);
final URL location = FileLocator.find(TmfCoreTestPlugin.getDefault().getBundle(), new Path(path), null);
try {
final File test = new File(FileLocator.toFileURL(location).toURI());
import org.eclipse.core.runtime.Path;
import org.eclipse.linuxtools.tmf.core.component.TmfEventProvider;
import org.eclipse.linuxtools.tmf.core.event.ITmfEvent;
-import org.eclipse.linuxtools.tmf.core.event.TmfEvent;
import org.eclipse.linuxtools.tmf.core.exceptions.TmfTraceException;
import org.eclipse.linuxtools.tmf.core.request.ITmfDataRequest;
import org.eclipse.linuxtools.tmf.core.request.ITmfEventRequest;
private TmfTraceStub fTrace;
public TmfEventProviderStub(final String path) throws IOException {
- super(path, TmfEvent.class);
+ super(path, ITmfEvent.class);
final URL location = FileLocator.find(TmfCoreTestPlugin.getDefault().getBundle(), new Path(path), null);
try {
final File test = new File(FileLocator.toFileURL(location).toURI());
import org.eclipse.linuxtools.tmf.core.component.ITmfDataProvider;
import org.eclipse.linuxtools.tmf.core.component.TmfEventProvider;
import org.eclipse.linuxtools.tmf.core.event.ITmfEvent;
-import org.eclipse.linuxtools.tmf.core.event.TmfEvent;
import org.eclipse.linuxtools.tmf.core.event.TmfTimeRange;
import org.eclipse.linuxtools.tmf.core.request.ITmfDataRequest;
import org.eclipse.linuxtools.tmf.core.request.ITmfEventRequest;
public ITmfContext armRequest(final ITmfDataRequest request) {
// Get the TmfSyntheticEventStub provider
- final ITmfDataProvider[] eventProviders = TmfProviderManager.getProviders(TmfEvent.class, TmfEventProviderStub.class);
+ final ITmfDataProvider[] eventProviders = TmfProviderManager.getProviders(ITmfEvent.class, TmfEventProviderStub.class);
final ITmfDataProvider provider = eventProviders[0];
// make sure we have the right type of request
final TmfEventRequest eventRequest = (TmfEventRequest) request;
final TmfTimeRange range = eventRequest.getRange();
final TmfEventRequest subRequest =
- new TmfEventRequest(TmfEvent.class, range, NB_EVENTS, BLOCK_SIZE) {
+ new TmfEventRequest(ITmfEvent.class, range, NB_EVENTS, BLOCK_SIZE) {
@Override
public void handleData(final ITmfEvent event) {
super.handleData(event);
package org.eclipse.linuxtools.tmf.tests.stubs.trace;
-import org.eclipse.linuxtools.tmf.core.event.TmfEvent;
+import org.eclipse.linuxtools.tmf.core.event.ITmfEvent;
import org.eclipse.linuxtools.tmf.core.trace.ITmfContext;
import org.eclipse.linuxtools.tmf.core.trace.ITmfLocation;
import org.eclipse.linuxtools.tmf.core.trace.TmfContext;
}
@Override
- public TmfEvent parseEvent(final ITmfContext context) {
+ public ITmfEvent parseEvent(final ITmfContext context) {
return null;
}
import java.io.RandomAccessFile;
import java.util.Vector;
+import org.eclipse.linuxtools.tmf.core.event.ITmfEvent;
import org.eclipse.linuxtools.tmf.core.event.ITmfEventField;
import org.eclipse.linuxtools.tmf.core.event.TmfEvent;
import org.eclipse.linuxtools.tmf.core.event.TmfEventField;
static final String typePrefix = "Type-";
@Override
- public TmfEvent parseEvent(final ITmfContext context) {
+ public ITmfEvent parseEvent(final ITmfContext context) {
if (! (fEventStream instanceof TmfTraceStub)) {
return null;
content.append("]");
final TmfEventField root = new TmfEventField(ITmfEventField.ROOT_FIELD_ID, content.toString());
- final TmfEvent event = new TmfEvent(fEventStream,
+ final ITmfEvent event = new TmfEvent(fEventStream,
new TmfTimestamp(ts, -3, 0), // millisecs
source, fTypes[typeIndex], root, reference.toString());
return event;
package org.eclipse.linuxtools.tmf.tests.stubs.trace;
-import org.eclipse.linuxtools.tmf.core.event.TmfEvent;
+import org.eclipse.linuxtools.tmf.core.event.ITmfEvent;
import org.eclipse.linuxtools.tmf.core.trace.ITmfTrace;
import org.eclipse.linuxtools.tmf.core.trace.TmfExperiment;
public class TmfExperimentStub extends TmfExperiment {
public TmfExperimentStub(String name, ITmfTrace[] traces, int blockSize) {
- super(TmfEvent.class, name, traces, blockSize);
+ super(ITmfEvent.class, name, traces, blockSize);
setIndexer(new TmfIndexerStub(this, blockSize));
}
import org.eclipse.core.resources.IResource;
import org.eclipse.linuxtools.tmf.core.event.ITmfEvent;
import org.eclipse.linuxtools.tmf.core.event.ITmfTimestamp;
-import org.eclipse.linuxtools.tmf.core.event.TmfEvent;
import org.eclipse.linuxtools.tmf.core.event.TmfTimeRange;
import org.eclipse.linuxtools.tmf.core.exceptions.TmfTraceException;
import org.eclipse.linuxtools.tmf.core.trace.ITmfContext;
* @throws FileNotFoundException
*/
public TmfTraceStub(final String path, final int cacheSize, final long interval) throws TmfTraceException {
- super(null, TmfEvent.class, path, cacheSize, interval);
+ super(null, ITmfEvent.class, path, cacheSize, interval);
try {
fTrace = new RandomAccessFile(path, "r");
} catch (FileNotFoundException e) {
* @throws FileNotFoundException
*/
public TmfTraceStub(final String path, final int cacheSize, final boolean waitForCompletion) throws TmfTraceException {
- super(null, TmfEvent.class, path, cacheSize);
+ super(null, ITmfEvent.class, path, cacheSize);
try {
fTrace = new RandomAccessFile(path, "r");
} catch (FileNotFoundException e) {
* @throws FileNotFoundException
*/
public TmfTraceStub(final IResource resource, final String path, final int cacheSize, final boolean waitForCompletion) throws TmfTraceException {
- super(resource, TmfEvent.class, path, cacheSize);
+ super(resource, ITmfEvent.class, path, cacheSize);
try {
fTrace = new RandomAccessFile(path, "r");
} catch (FileNotFoundException e) {
*/
public TmfTraceStub(final String path, final int cacheSize, final boolean waitForCompletion,
final ITmfEventParser parser, final ITmfTraceIndexer indexer) throws TmfTraceException {
- super(null, TmfEvent.class, path, cacheSize, 0, indexer);
+ super(null, ITmfEvent.class, path, cacheSize, 0, indexer);
try {
fTrace = new RandomAccessFile(path, "r");
} catch (FileNotFoundException e) {
import org.eclipse.jface.viewers.ColumnLabelProvider;
import org.eclipse.jface.viewers.ViewerComparator;
+import org.eclipse.linuxtools.tmf.core.event.ITmfEvent;
import org.eclipse.linuxtools.tmf.core.event.ITmfEventField;
import org.eclipse.linuxtools.tmf.core.event.TmfEvent;
import org.eclipse.linuxtools.tmf.core.event.TmfEventField;
private final String fReference = "Some reference";
- private final TmfEvent fEvent1;
- private final TmfEvent fEvent2;
- private final TmfEvent fEvent3;
+ private final ITmfEvent fEvent1;
+ private final ITmfEvent fEvent2;
+ private final ITmfEvent fEvent3;
private final TmfEventField fContent1;
private final TmfEventField fContent2;
import junit.framework.TestCase;
+import org.eclipse.linuxtools.tmf.core.event.ITmfEvent;
import org.eclipse.linuxtools.tmf.core.event.ITmfEventField;
import org.eclipse.linuxtools.tmf.core.event.TmfEvent;
import org.eclipse.linuxtools.tmf.core.event.TmfEventField;
private final String fReference = "Some reference";
- private final TmfEvent fEvent1;
- private final TmfEvent fEvent2;
- private final TmfEvent fEvent3;
+ private final ITmfEvent fEvent1;
+ private final ITmfEvent fEvent2;
+ private final ITmfEvent fEvent3;
private final TmfEventField fContent1;
private final TmfEventField fContent2;
import junit.framework.TestCase;
+import org.eclipse.linuxtools.tmf.core.event.ITmfEvent;
import org.eclipse.linuxtools.tmf.core.event.ITmfEventField;
import org.eclipse.linuxtools.tmf.core.event.TmfEvent;
import org.eclipse.linuxtools.tmf.core.event.TmfEventField;
private final String fReference = "Some reference";
- private final TmfEvent fEvent1;
- private final TmfEvent fEvent2;
+ private final ITmfEvent fEvent1;
+ private final ITmfEvent fEvent2;
private final TmfEventField fContent1;
private final TmfEventField fContent2;
import org.eclipse.core.runtime.FileLocator;
import org.eclipse.core.runtime.Path;
import org.eclipse.core.runtime.jobs.Job;
-import org.eclipse.linuxtools.tmf.core.event.TmfEvent;
+import org.eclipse.linuxtools.tmf.core.event.ITmfEvent;
import org.eclipse.linuxtools.tmf.core.exceptions.TmfTraceException;
import org.eclipse.linuxtools.tmf.core.signal.TmfTraceClosedSignal;
import org.eclipse.linuxtools.tmf.core.signal.TmfTraceSelectedSignal;
final ITmfTrace traces[] = new ITmfTrace[1];
traces[0] = fTrace;
- fExperiment = new TmfExperiment(TmfEvent.class, "TestExperiment", traces); //$NON-NLS-1$
+ fExperiment = new TmfExperiment(ITmfEvent.class, "TestExperiment", traces); //$NON-NLS-1$
fTrace.broadcast(new TmfTraceSelectedSignal(this, fExperiment));
if (wait) {
while (fExperiment.getNbEvents() == 0) {
import java.io.IOException;
import java.io.RandomAccessFile;
+import org.eclipse.linuxtools.tmf.core.event.ITmfEvent;
import org.eclipse.linuxtools.tmf.core.event.ITmfEventField;
import org.eclipse.linuxtools.tmf.core.event.TmfEvent;
import org.eclipse.linuxtools.tmf.core.event.TmfEventField;
@Override
@SuppressWarnings({ "nls" })
- public TmfEvent parseEvent(ITmfContext context) {
+ public ITmfEvent parseEvent(ITmfContext context) {
if (! (fEventStream instanceof TmfTraceStub)) {
return null;
}
fields[2] = new TmfEventField("signal", signal);
ITmfEventField tmfContent = new TmfEventField(ITmfEventField.ROOT_FIELD_ID, content, fields);
- TmfEvent tmfEvent = new TmfEvent(fEventStream, new TmfTimestamp(ts, -9), source, tmfEventType, tmfContent, reference);
+ ITmfEvent tmfEvent = new TmfEvent(fEventStream, new TmfTimestamp(ts, -9), source, tmfEventType, tmfContent, reference);
return tmfEvent;
} catch (final EOFException e) {
projects / deliverable / tracecompass.git / commitdiff
