/**
* Test suite for the TmfExperiment class (multiple traces).
*/
-@SuppressWarnings("nls")
+@SuppressWarnings({"nls","javadoc"})
public class TmfMultiTraceExperimentTest extends TestCase {
// ------------------------------------------------------------------------
private static int NB_EVENTS = 20000;
private static int BLOCK_SIZE = 1000;
- private static ITmfTrace<TmfEvent>[] fTraces;
- private static TmfExperimentStub<TmfEvent> fExperiment;
+ private static ITmfTrace[] fTraces;
+ private static TmfExperimentStub fExperiment;
private static byte SCALE = (byte) -3;
// Housekeeping
// ------------------------------------------------------------------------
- @SuppressWarnings("unchecked")
- private synchronized static ITmfTrace<?>[] setupTrace(final String path1, final String path2) {
+ private synchronized static ITmfTrace[] setupTrace(final String path1, final String path2) {
if (fTraces == null) {
fTraces = new ITmfTrace[2];
try {
return fTraces;
}
- public TmfMultiTraceExperimentTest(final String name) throws Exception {
+ /**
+ * @param name the test name
+ */
+ public TmfMultiTraceExperimentTest(final String name) {
super(name);
}
super.setUp();
setupTrace(DIRECTORY + File.separator + TEST_STREAM1, DIRECTORY + File.separator + TEST_STREAM2);
if (fExperiment == null) {
- fExperiment = new TmfExperimentStub<TmfEvent>(EXPERIMENT, fTraces, BLOCK_SIZE);
+ fExperiment = new TmfExperimentStub(EXPERIMENT, fTraces, BLOCK_SIZE);
fExperiment.getIndexer().buildIndex(0, TmfTimeRange.ETERNITY, true);
}
}
// seekEvent on rank
// ------------------------------------------------------------------------
- public void testSeekRankOnCacheBoundary() throws Exception {
+ public void testSeekRankOnCacheBoundary() {
long cacheSize = fExperiment.getCacheSize();
assertEquals("Context rank", 4 * cacheSize + 1, context.getRank());
}
- public void testSeekRankNotOnCacheBoundary() throws Exception {
+ public void testSeekRankNotOnCacheBoundary() {
long cacheSize = fExperiment.getCacheSize();
assertEquals("Context rank", 4501, context.getRank());
}
- public void testSeekRankOutOfScope() throws Exception {
+ public void testSeekRankOutOfScope() {
// Position trace at beginning
ITmfContext context = fExperiment.seekEvent(-1);
// seekEvent on timestamp
// ------------------------------------------------------------------------
- public void testSeekTimestampOnCacheBoundary() throws Exception {
+ public void testSeekTimestampOnCacheBoundary() {
long cacheSize = fExperiment.getCacheSize();
assertEquals("Context rank", 4 * cacheSize + 1, context.getRank());
}
- public void testSeekTimestampNotOnCacheBoundary() throws Exception {
+ public void testSeekTimestampNotOnCacheBoundary() {
// Position trace at event rank 1 (TS = 2)
ITmfContext context = fExperiment.seekEvent(new TmfTimestamp(2, SCALE, 0));
assertEquals("Context rank", 4501, context.getRank());
}
- public void testSeekTimestampOutOfScope() throws Exception {
+ public void testSeekTimestampOutOfScope() {
// Position trace at beginning
ITmfContext context = fExperiment.seekEvent(new TmfTimestamp(-1, SCALE, 0));
// seekEvent by location (context rank is undefined)
// ------------------------------------------------------------------------
- public void testSeekLocationOnCacheBoundary() throws Exception {
+ public void testSeekLocationOnCacheBoundary() {
long cacheSize = fExperiment.getCacheSize();
assertEquals("Event timestamp", 4 * cacheSize + 2, event.getTimestamp().getValue());
}
- public void testSeekLocationNotOnCacheBoundary() throws Exception {
+ public void testSeekLocationNotOnCacheBoundary() {
long cacheSize = fExperiment.getCacheSize();
assertEquals("Event timestamp", 4502, event.getTimestamp().getValue());
}
- public void testSeekLocationOutOfScope() throws Exception {
+ public void testSeekLocationOutOfScope() {
// Position trace at beginning
- ITmfContext context = fExperiment.seekEvent((ITmfLocation<?>) null);
+ ITmfContext context = fExperiment.seekEvent((ITmfLocation) null);
ITmfEvent event = fExperiment.getNext(context);
assertEquals("Event timestamp", 1, event.getTimestamp().getValue());
// getNext - updates the context
// ------------------------------------------------------------------------
- private void validateContextRanks(ITmfContext context) {
+ private static void validateContextRanks(ITmfContext context) {
assertTrue("Experiment context type", context instanceof TmfExperimentContext);
TmfExperimentContext ctx = (TmfExperimentContext) context;
assertEquals("Experiment context rank", expRank, ctx.getRank());
}
- public void testGetNextAfteSeekingOnTS_1() throws Exception {
+ public void testGetNextAfteSeekingOnTS_1() {
final long INITIAL_TS = 1;
final int NB_READS = 20;
validateContextRanks(context);
}
- public void testGetNextAfteSeekingOnTS_2() throws Exception {
+ public void testGetNextAfteSeekingOnTS_2() {
final long INITIAL_TS = 2;
final int NB_READS = 20;
validateContextRanks(context);
}
- public void testGetNextAfteSeekingOnTS_3() throws Exception {
+ public void testGetNextAfteSeekingOnTS_3() {
final long INITIAL_TS = 500;
final int NB_READS = 20;
validateContextRanks(context);
}
- public void testGetNextAfterSeekingOnRank_1() throws Exception {
+ public void testGetNextAfterSeekingOnRank_1() {
final long INITIAL_RANK = 0L;
final int NB_READS = 20;
validateContextRanks(context);
}
- public void testGetNextAfterSeekingOnRank_2() throws Exception {
+ public void testGetNextAfterSeekingOnRank_2() {
final long INITIAL_RANK = 1L;
final int NB_READS = 20;
validateContextRanks(context);
}
- public void testGetNextAfterSeekingOnRank_3() throws Exception {
+ public void testGetNextAfterSeekingOnRank_3() {
final long INITIAL_RANK = 500L;
final int NB_READS = 20;
validateContextRanks(context);
}
- public void testGetNextAfterSeekingOnLocation_1() throws Exception {
+ public void testGetNextAfterSeekingOnLocation_1() {
- final ITmfLocation<?> INITIAL_LOC = null;
+ final ITmfLocation INITIAL_LOC = null;
final long INITIAL_TS = 1;
final int NB_READS = 20;
validateContextRanks(context);
}
- public void testGetNextAfterSeekingOnLocation_2() throws Exception {
+ public void testGetNextAfterSeekingOnLocation_2() {
- final ITmfLocation<?> INITIAL_LOC = fExperiment.seekEvent(1L).getLocation();
+ final ITmfLocation INITIAL_LOC = fExperiment.seekEvent(1L).getLocation();
final long INITIAL_TS = 2;
final int NB_READS = 20;
validateContextRanks(context);
}
- public void testGetNextAfterSeekingOnLocation_3() throws Exception {
+ public void testGetNextAfterSeekingOnLocation_3() {
- final ITmfLocation<?> INITIAL_LOC = fExperiment.seekEvent(500L).getLocation();
+ final ITmfLocation INITIAL_LOC = fExperiment.seekEvent(500L).getLocation();
final long INITIAL_TS = 501;
final int NB_READS = 20;
validateContextRanks(context);
}
- public void testGetNextLocation() throws Exception {
+ public void testGetNextLocation() {
ITmfContext context1 = fExperiment.seekEvent(0);
fExperiment.getNext(context1);
- ITmfLocation<?> location = context1.getLocation().clone();
+ ITmfLocation location = context1.getLocation().clone();
ITmfEvent event1 = fExperiment.getNext(context1);
ITmfContext context2 = fExperiment.seekEvent(location);
ITmfEvent event2 = fExperiment.getNext(context2);
assertEquals("Event timestamp", event1.getTimestamp().getValue(), event2.getTimestamp().getValue());
}
- public void testGetNextEndLocation() throws Exception {
+ public void testGetNextEndLocation() {
ITmfContext context1 = fExperiment.seekEvent(fExperiment.getNbEvents() - 1);
fExperiment.getNext(context1);
- ITmfLocation<?> location = context1.getLocation().clone();
+ ITmfLocation location = context1.getLocation().clone();
ITmfContext context2 = fExperiment.seekEvent(location);
ITmfEvent event = fExperiment.getNext(context2);
assertNull("Event", event);
// processRequest
// ------------------------------------------------------------------------
- public void testProcessRequestForNbEvents() throws Exception {
+ public void testProcessRequestForNbEvents() throws InterruptedException {
final int blockSize = 100;
final int nbEvents = 1000;
- final Vector<TmfEvent> requestedEvents = new Vector<TmfEvent>();
+ final Vector<ITmfEvent> requestedEvents = new Vector<ITmfEvent>();
final TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BIG_BANG, TmfTimestamp.BIG_CRUNCH);
- final TmfEventRequest<TmfEvent> request = new TmfEventRequest<TmfEvent>(TmfEvent.class, range, nbEvents, blockSize) {
+ final TmfEventRequest request = new TmfEventRequest(TmfEvent.class, range, nbEvents, blockSize) {
@Override
- public void handleData(final TmfEvent event) {
+ public void handleData(final ITmfEvent event) {
super.handleData(event);
requestedEvents.add(event);
}
}
}
- public void testProcessRequestForNbEvents2() throws Exception {
+ public void testProcessRequestForNbEvents2() throws InterruptedException {
final int blockSize = 2 * NB_EVENTS;
final int nbEvents = 1000;
- final Vector<TmfEvent> requestedEvents = new Vector<TmfEvent>();
+ final Vector<ITmfEvent> requestedEvents = new Vector<ITmfEvent>();
final TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BIG_BANG, TmfTimestamp.BIG_CRUNCH);
- final TmfEventRequest<TmfEvent> request = new TmfEventRequest<TmfEvent>(TmfEvent.class, range, nbEvents, blockSize) {
+ final TmfEventRequest request = new TmfEventRequest(TmfEvent.class, range, nbEvents, blockSize) {
@Override
- public void handleData(final TmfEvent event) {
+ public void handleData(final ITmfEvent event) {
super.handleData(event);
requestedEvents.add(event);
}
}
}
- public void testProcessRequestForAllEvents() throws Exception {
+ public void testProcessRequestForAllEvents() throws InterruptedException {
final int nbEvents = TmfDataRequest.ALL_DATA;
final int blockSize = 1;
- final Vector<TmfEvent> requestedEvents = new Vector<TmfEvent>();
+ final Vector<ITmfEvent> requestedEvents = new Vector<ITmfEvent>();
final long nbExpectedEvents = NB_EVENTS;
final TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BIG_BANG, TmfTimestamp.BIG_CRUNCH);
- final TmfEventRequest<TmfEvent> request = new TmfEventRequest<TmfEvent>(TmfEvent.class, range, nbEvents, blockSize) {
+ final TmfEventRequest request = new TmfEventRequest(TmfEvent.class, range, nbEvents, blockSize) {
@Override
- public void handleData(final TmfEvent event) {
+ public void handleData(final ITmfEvent event) {
super.handleData(event);
requestedEvents.add(event);
}
// cancel
// ------------------------------------------------------------------------
- public void testCancel() throws Exception {
+ public void testCancel() throws InterruptedException {
final int nbEvents = NB_EVENTS;
final int blockSize = BLOCK_SIZE;
- final Vector<TmfEvent> requestedEvents = new Vector<TmfEvent>();
+ final Vector<ITmfEvent> requestedEvents = new Vector<ITmfEvent>();
final TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BIG_BANG, TmfTimestamp.BIG_CRUNCH);
- final TmfEventRequest<TmfEvent> request = new TmfEventRequest<TmfEvent>(TmfEvent.class, range, nbEvents, blockSize) {
+ final TmfEventRequest request = new TmfEventRequest(TmfEvent.class, range, nbEvents, blockSize) {
int nbRead = 0;
@Override
- public void handleData(final TmfEvent event) {
+ public void handleData(final ITmfEvent event) {
super.handleData(event);
requestedEvents.add(event);
if (++nbRead == blockSize) {
// getTimestamp
// ------------------------------------------------------------------------
- public void testGetTimestamp() throws Exception {
+ public void testGetTimestamp() {
assertEquals("getTimestamp", new TmfTimestamp( 1, (byte) -3), fExperiment.getTimestamp( 0));
assertEquals("getTimestamp", new TmfTimestamp( 2, (byte) -3), fExperiment.getTimestamp( 1));
assertEquals("getTimestamp", new TmfTimestamp( 11, (byte) -3), fExperiment.getTimestamp( 10));