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

/*******************************************************************************
 * Copyright (c) 2009, 2010 Ericsson
 * 
 * All rights reserved. This program and the accompanying materials are
 * made available under the terms of the Eclipse Public License v1.0 which
 * accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 * 
 * Contributors:
 *   Francois Chouinard - Initial API and implementation
 *******************************************************************************/

package org.eclipse.linuxtools.tmf.tests.trace;

import java.io.File;
import java.io.IOException;
import java.net.URISyntaxException;
import java.net.URL;
import java.util.Vector;

import junit.framework.TestCase;

import org.eclipse.core.runtime.FileLocator;
import org.eclipse.core.runtime.Path;
import org.eclipse.linuxtools.tmf.component.TmfDataProvider;
import org.eclipse.linuxtools.tmf.component.TmfProviderManager;
import org.eclipse.linuxtools.tmf.event.TmfEvent;
import org.eclipse.linuxtools.tmf.event.TmfTimeRange;
import org.eclipse.linuxtools.tmf.event.TmfTimestamp;
import org.eclipse.linuxtools.tmf.request.TmfEventRequest;
import org.eclipse.linuxtools.tmf.tests.TmfCoreTestPlugin;
import org.eclipse.linuxtools.tmf.trace.TmfContext;
import org.eclipse.linuxtools.tmf.trace.TmfTraceStub;

/**
 * <b><u>TmfTraceTest</u></b>
 * <p>
 * TODO: Implement me. Please.
 */
public class TmfTraceTest extends TestCase {

    private static final String DIRECTORY   = "testfiles";
    private static final String TEST_STREAM = "M-Test-10K";
    private static final int    NB_EVENTS   = 10000;
    private static TmfTraceStub fTrace      = null;

    private static byte SCALE = (byte) -3;

    // ------------------------------------------------------------------------
    // Housekeeping
    // ------------------------------------------------------------------------

    private TmfTraceStub setupTrace(String path) {
    	if (fTrace == null) {
    		try {
    	        URL location = FileLocator.find(TmfCoreTestPlugin.getPlugin().getBundle(), new Path(path), null);
    			File test = new File(FileLocator.toFileURL(location).toURI());
    			TmfTraceStub trace = new TmfTraceStub(test.getPath(), 500, true);
    	        fTrace = trace;
    		} catch (URISyntaxException e) {
    			e.printStackTrace();
    		} catch (IOException e) {
    			e.printStackTrace();
    		}
    	}
    	return fTrace;
    }

    public TmfTraceTest(String name) throws Exception {
		super(name);
	}

	@Override
	protected void setUp() throws Exception {
		super.setUp();
		setupTrace(DIRECTORY + File.separator + TEST_STREAM);
	}

	@Override
	protected void tearDown() throws Exception {
		super.tearDown();
	}

    // ------------------------------------------------------------------------
    // Constructors
    // ------------------------------------------------------------------------

    public void testTmfTraceDefault() throws Exception {
		TmfTraceStub trace = null;
		try {
	        URL location = FileLocator.find(TmfCoreTestPlugin.getPlugin().getBundle(), new Path(DIRECTORY + File.separator + TEST_STREAM), null);
			File test = new File(FileLocator.toFileURL(location).toURI());
			trace = new TmfTraceStub(test.getPath(), true);
		} catch (URISyntaxException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}
		assertTrue("Open trace",     trace != null);
		assertEquals("getCacheSize", TmfTraceStub.DEFAULT_CACHE_SIZE, trace.getCacheSize());
        assertEquals("getTraceSize", NB_EVENTS, trace.getNbEvents());
    }

    public void testTmfTrace() throws Exception {
        assertEquals("getCacheSize",   500, fTrace.getCacheSize());
        assertEquals("getTraceSize",   NB_EVENTS, fTrace.getNbEvents());
        assertEquals("getRange-start", 1, fTrace.getTimeRange().getStartTime().getValue());
        assertEquals("getRange-end",   NB_EVENTS, fTrace.getTimeRange().getEndTime().getValue());
    }

    // ------------------------------------------------------------------------
    // seek
    // ------------------------------------------------------------------------

    public void testSeekOnCacheBoundary() throws Exception {
    	TmfContext context = fTrace.seekLocation(null);

    	context = fTrace.seekEvent(new TmfTimestamp(1, SCALE, 0));
    	TmfEvent event = fTrace.getNextEvent(context);
        assertEquals("Event timestamp", 1, event.getTimestamp().getValue());
        assertEquals("Event rank", 1, context.getRank());

    	context = fTrace.seekEvent(new TmfTimestamp(1001, SCALE, 0));
        event = fTrace.getNextEvent(context);
        assertEquals("Event timestamp", 1001, event.getTimestamp().getValue());
        assertEquals("Event rank", 1001, context.getRank());

    	context = fTrace.seekEvent(new TmfTimestamp(4001, SCALE, 0));
        event = fTrace.getNextEvent(context);
        assertEquals("Event timestamp", 4001, event.getTimestamp().getValue());
        assertEquals("Event rank", 4001, context.getRank());
    }

    public void testSeekNotOnCacheBoundary() throws Exception {
    	TmfContext context = fTrace.seekLocation(null);

    	context = fTrace.seekEvent(new TmfTimestamp(10, SCALE, 0));
    	TmfEvent event = fTrace.getNextEvent(context);
        assertEquals("Event timestamp", 10, event.getTimestamp().getValue());
        assertEquals("Event rank", 10, context.getRank());

    	context = fTrace.seekEvent(new TmfTimestamp(999, SCALE, 0));
        event = fTrace.getNextEvent(context);
        assertEquals("Event timestamp", 999, event.getTimestamp().getValue());
        assertEquals("Event rank", 999, context.getRank());

    	context = fTrace.seekEvent(new TmfTimestamp(1001, SCALE, 0));
        event = fTrace.getNextEvent(context);
        assertEquals("Event timestamp", 1001, event.getTimestamp().getValue());
        assertEquals("Event rank", 1001, context.getRank());

    	context = fTrace.seekEvent(new TmfTimestamp(4499, SCALE, 0));
        event = fTrace.getNextEvent(context);
        assertEquals("Event timestamp", 4499, event.getTimestamp().getValue());
        assertEquals("Event rank", 4499, context.getRank());
    }

    public void testSeekForEventOutOfBounds() throws Exception {
    	TmfContext context = fTrace.seekLocation(null);

    	// On lower bound, returns the first event (ts = 1)
    	context = fTrace.seekEvent(new TmfTimestamp(-1, SCALE, 0));
        TmfEvent event = fTrace.getNextEvent(context);
        assertEquals("Event timestamp", 1, event.getTimestamp().getValue());

        // On higher bound, returns null (no event)
    	context = fTrace.seekEvent(new TmfTimestamp(NB_EVENTS + 1, SCALE, 0));
        event = fTrace.getNextEvent(context);
        assertEquals("Event timestamp", null, event);
    }

    public void testSeekOnIndex() throws Exception {
    	TmfContext context = fTrace.seekLocation(null);

    	// On lower bound, returns the first event (ts = 1)
    	context = fTrace.seekEvent(0);
        TmfEvent event = fTrace.getNextEvent(context);
        assertEquals("Event timestamp", 1, event.getTimestamp().getValue());

        // On higher bound
    	context = fTrace.seekEvent(NB_EVENTS - 1);
        event = fTrace.getNextEvent(context);
        assertEquals("Event timestamp", NB_EVENTS, event.getTimestamp().getValue());

        // Above high bound
    	context = fTrace.seekEvent(NB_EVENTS);
        event = fTrace.getNextEvent(context);
        assertEquals("Event", null, event);
    }

    // ------------------------------------------------------------------------
    // getNextEvent
    // ------------------------------------------------------------------------

    public void testGetNextEvent() throws Exception {
    	TmfContext context = fTrace.seekLocation(null);

    	// On lower bound, returns the first event (ts = 0)
    	context = fTrace.seekEvent(new TmfTimestamp(0, SCALE, 0));
        TmfEvent event = fTrace.getNextEvent(context);
        assertEquals("Event timestamp", 1, event.getTimestamp().getValue());

        for (int i = 2; i < 20; i++) {
            event = fTrace.getNextEvent(context);
            assertEquals("Event timestamp", i, event.getTimestamp().getValue());
        }
    }

    // ------------------------------------------------------------------------
    // processRequest
    // ------------------------------------------------------------------------

    @SuppressWarnings("unchecked")
	public void testProcessRequestForNbEvents() throws Exception {
        final int BLOCK_SIZE = 100;
        final int NB_EVENTS  = 1000;
        final Vector<TmfEvent> requestedEvents = new Vector<TmfEvent>();

        TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BigBang, TmfTimestamp.BigCrunch);
        final TmfEventRequest<TmfEvent> request = new TmfEventRequest<TmfEvent>(TmfEvent.class, range, NB_EVENTS, BLOCK_SIZE) {
            @Override
            public void handleData() {
            	TmfEvent[] events = getData();
                for (TmfEvent e : events) {
                    requestedEvents.add(e);
                }
            }
        };
        TmfDataProvider<TmfEvent>[] providers = (TmfDataProvider<TmfEvent>[]) TmfProviderManager.getProviders(TmfEvent.class, TmfTraceStub.class);
        providers[0].processRequest(request, true);

        assertEquals("nbEvents", NB_EVENTS, requestedEvents.size());
        assertTrue("isCompleted",  request.isCompleted());
        assertFalse("isCancelled", request.isCancelled());

        // Ensure that we have distinct events.
        // Don't go overboard: we are not validating the stub! 
        for (int i = 0; i < NB_EVENTS; i++) {
            assertEquals("Distinct events", i+1, requestedEvents.get(i).getTimestamp().getValue());
        }
    }
    
    @SuppressWarnings("unchecked")
	public void testProcessRequestForAllEvents() throws Exception {
        final int BLOCK_SIZE =  1;
        final Vector<TmfEvent> requestedEvents = new Vector<TmfEvent>();

        TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BigBang, TmfTimestamp.BigCrunch);
        final TmfEventRequest<TmfEvent> request = new TmfEventRequest<TmfEvent>(TmfEvent.class, range, NB_EVENTS, BLOCK_SIZE) {
            @Override
            public void handleData() {
            	TmfEvent[] events = getData();
                for (TmfEvent e : events) {
                    requestedEvents.add(e);
                }
            }
        };
        TmfDataProvider<TmfEvent>[] providers = (TmfDataProvider<TmfEvent>[]) TmfProviderManager.getProviders(TmfEvent.class, TmfTraceStub.class);
        providers[0].processRequest(request, true);

        assertEquals("nbEvents", NB_EVENTS, requestedEvents.size());
        assertTrue("isCompleted",  request.isCompleted());
        assertFalse("isCancelled", request.isCancelled());

        // Ensure that we have distinct events.
        // Don't go overboard: we are not validating the stub! 
        for (int i = 0; i < NB_EVENTS; i++) {
            assertEquals("Distinct events", i+1, requestedEvents.get(i).getTimestamp().getValue());
        }
    }
    
    // ------------------------------------------------------------------------
    // cancel
    // ------------------------------------------------------------------------

    @SuppressWarnings("unchecked")
	public void testCancel() throws Exception {
        final Vector<TmfEvent> requestedEvents = new Vector<TmfEvent>();

        TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BigBang, TmfTimestamp.BigCrunch);
        final TmfEventRequest<TmfEvent> request = new TmfEventRequest<TmfEvent>(TmfEvent.class, range, NB_EVENTS, NB_EVENTS) {
            @Override
            public void handleData() {
            	TmfEvent[] events = getData();
                for (TmfEvent e : events) {
                    requestedEvents.add(e);
                }
                // Cancel request after the first chunk is received
                cancel();
            }
        };
        TmfDataProvider<TmfEvent>[] providers = (TmfDataProvider<TmfEvent>[]) TmfProviderManager.getProviders(TmfEvent.class, TmfTraceStub.class);
        providers[0].processRequest(request, true);

        assertEquals("nbEvents",  NB_EVENTS, requestedEvents.size());
        assertTrue("isCompleted", request.isCompleted());
        assertTrue("isCancelled", request.isCancelled());
    }

}
Commit	Line	Data
d18dd09b	1	/*******************************************************************************
e31e01e8	2	* Copyright (c) 2009, 2010 Ericsson
d18dd09b ASL	3	*
	4	* All rights reserved. This program and the accompanying materials are
	5	* made available under the terms of the Eclipse Public License v1.0 which
	6	* accompanies this distribution, and is available at
	7	* http://www.eclipse.org/legal/epl-v10.html
	8	*
	9	* Contributors:
	10	* Francois Chouinard - Initial API and implementation
	11	*******************************************************************************/
	12
	13	package org.eclipse.linuxtools.tmf.tests.trace;
	14
	15	import java.io.File;
e1ab8984 FC	16	import java.io.IOException;
	17	import java.net.URISyntaxException;
	18	import java.net.URL;
d18dd09b ASL	19	import java.util.Vector;
d18dd09b ASL	20
e1ab8984 FC	21	import junit.framework.TestCase;
	22
	23	import org.eclipse.core.runtime.FileLocator;
	24	import org.eclipse.core.runtime.Path;
fc6ccf6f	25	import org.eclipse.linuxtools.tmf.component.TmfDataProvider;
e31e01e8	26	import org.eclipse.linuxtools.tmf.component.TmfProviderManager;
d18dd09b ASL	27	import org.eclipse.linuxtools.tmf.event.TmfEvent;
	28	import org.eclipse.linuxtools.tmf.event.TmfTimeRange;
	29	import org.eclipse.linuxtools.tmf.event.TmfTimestamp;
e31e01e8	30	import org.eclipse.linuxtools.tmf.request.TmfEventRequest;
e1ab8984	31	import org.eclipse.linuxtools.tmf.tests.TmfCoreTestPlugin;
9f584e4c	32	import org.eclipse.linuxtools.tmf.trace.TmfContext;
d18dd09b ASL	33	import org.eclipse.linuxtools.tmf.trace.TmfTraceStub;
	34
	35	/**
	36	* <b><u>TmfTraceTest</u></b>
	37	* <p>
75828b1a	38	* TODO: Implement me. Please.
d18dd09b ASL	39	*/
	40	public class TmfTraceTest extends TestCase {
	41
d18dd09b	42	private static final String DIRECTORY = "testfiles";
75828b1a	43	private static final String TEST_STREAM = "M-Test-10K";
e31e01e8 FC	44	private static final int NB_EVENTS = 10000;
e31e01e8 FC	45	private static TmfTraceStub fTrace = null;
d18dd09b ASL	46
	47	private static byte SCALE = (byte) -3;
	48
e31e01e8	49	// ------------------------------------------------------------------------
d18dd09b	50	// Housekeeping
e31e01e8	51	// ------------------------------------------------------------------------
d18dd09b	52
e1ab8984 FC	53	private TmfTraceStub setupTrace(String path) {
	54	if (fTrace == null) {
	55	try {
	56	URL location = FileLocator.find(TmfCoreTestPlugin.getPlugin().getBundle(), new Path(path), null);
	57	File test = new File(FileLocator.toFileURL(location).toURI());
	58	TmfTraceStub trace = new TmfTraceStub(test.getPath(), 500, true);
	59	fTrace = trace;
	60	} catch (URISyntaxException e) {
	61	e.printStackTrace();
	62	} catch (IOException e) {
	63	e.printStackTrace();
	64	}
	65	}
	66	return fTrace;
	67	}
	68
	69	public TmfTraceTest(String name) throws Exception {
d18dd09b ASL	70	super(name);
	71	}
	72
	73	@Override
	74	protected void setUp() throws Exception {
75828b1a	75	super.setUp();
e1ab8984	76	setupTrace(DIRECTORY + File.separator + TEST_STREAM);
d18dd09b ASL	77	}
	78
	79	@Override
	80	protected void tearDown() throws Exception {
	81	super.tearDown();
d18dd09b ASL	82	}
d18dd09b ASL	83
e31e01e8	84	// ------------------------------------------------------------------------
d18dd09b	85	// Constructors
e31e01e8	86	// ------------------------------------------------------------------------
d18dd09b ASL	87
d18dd09b ASL	88	public void testTmfTraceDefault() throws Exception {
e1ab8984 FC	89	TmfTraceStub trace = null;
	90	try {
	91	URL location = FileLocator.find(TmfCoreTestPlugin.getPlugin().getBundle(), new Path(DIRECTORY + File.separator + TEST_STREAM), null);
	92	File test = new File(FileLocator.toFileURL(location).toURI());
	93	trace = new TmfTraceStub(test.getPath(), true);
	94	} catch (URISyntaxException e) {
	95	e.printStackTrace();
	96	} catch (IOException e) {
	97	e.printStackTrace();
	98	}
9f584e4c	99	assertTrue("Open trace", trace != null);
e1ab8984	100	assertEquals("getCacheSize", TmfTraceStub.DEFAULT_CACHE_SIZE, trace.getCacheSize());
e31e01e8	101	assertEquals("getTraceSize", NB_EVENTS, trace.getNbEvents());
d18dd09b ASL	102	}
	103
	104	public void testTmfTrace() throws Exception {
e31e01e8 FC	105	assertEquals("getCacheSize", 500, fTrace.getCacheSize());
	106	assertEquals("getTraceSize", NB_EVENTS, fTrace.getNbEvents());
	107	assertEquals("getRange-start", 1, fTrace.getTimeRange().getStartTime().getValue());
	108	assertEquals("getRange-end", NB_EVENTS, fTrace.getTimeRange().getEndTime().getValue());
d18dd09b ASL	109	}
d18dd09b ASL	110
e31e01e8	111	// ------------------------------------------------------------------------
75828b1a	112	// seek
e31e01e8	113	// ------------------------------------------------------------------------
d18dd09b	114
75828b1a	115	public void testSeekOnCacheBoundary() throws Exception {
9f584e4c	116	TmfContext context = fTrace.seekLocation(null);
d18dd09b	117
e31e01e8	118	context = fTrace.seekEvent(new TmfTimestamp(1, SCALE, 0));
75828b1a FC	119	TmfEvent event = fTrace.getNextEvent(context);
75828b1a FC	120	assertEquals("Event timestamp", 1, event.getTimestamp().getValue());
e31e01e8	121	assertEquals("Event rank", 1, context.getRank());
d18dd09b	122
e31e01e8	123	context = fTrace.seekEvent(new TmfTimestamp(1001, SCALE, 0));
75828b1a	124	event = fTrace.getNextEvent(context);
e31e01e8 FC	125	assertEquals("Event timestamp", 1001, event.getTimestamp().getValue());
e31e01e8 FC	126	assertEquals("Event rank", 1001, context.getRank());
d18dd09b	127
e31e01e8	128	context = fTrace.seekEvent(new TmfTimestamp(4001, SCALE, 0));
75828b1a	129	event = fTrace.getNextEvent(context);
e31e01e8 FC	130	assertEquals("Event timestamp", 4001, event.getTimestamp().getValue());
e31e01e8 FC	131	assertEquals("Event rank", 4001, context.getRank());
75828b1a	132	}
d18dd09b	133
75828b1a	134	public void testSeekNotOnCacheBoundary() throws Exception {
9f584e4c	135	TmfContext context = fTrace.seekLocation(null);
d18dd09b	136
e31e01e8	137	context = fTrace.seekEvent(new TmfTimestamp(10, SCALE, 0));
75828b1a	138	TmfEvent event = fTrace.getNextEvent(context);
e31e01e8 FC	139	assertEquals("Event timestamp", 10, event.getTimestamp().getValue());
e31e01e8 FC	140	assertEquals("Event rank", 10, context.getRank());
d18dd09b	141
75828b1a FC	142	context = fTrace.seekEvent(new TmfTimestamp(999, SCALE, 0));
	143	event = fTrace.getNextEvent(context);
	144	assertEquals("Event timestamp", 999, event.getTimestamp().getValue());
e31e01e8 FC	145	assertEquals("Event rank", 999, context.getRank());
	146
	147	context = fTrace.seekEvent(new TmfTimestamp(1001, SCALE, 0));
	148	event = fTrace.getNextEvent(context);
	149	assertEquals("Event timestamp", 1001, event.getTimestamp().getValue());
	150	assertEquals("Event rank", 1001, context.getRank());
d18dd09b	151
75828b1a FC	152	context = fTrace.seekEvent(new TmfTimestamp(4499, SCALE, 0));
	153	event = fTrace.getNextEvent(context);
	154	assertEquals("Event timestamp", 4499, event.getTimestamp().getValue());
e31e01e8	155	assertEquals("Event rank", 4499, context.getRank());
75828b1a	156	}
d18dd09b	157
75828b1a	158	public void testSeekForEventOutOfBounds() throws Exception {
9f584e4c	159	TmfContext context = fTrace.seekLocation(null);
d18dd09b	160
75828b1a FC	161	// On lower bound, returns the first event (ts = 1)
	162	context = fTrace.seekEvent(new TmfTimestamp(-1, SCALE, 0));
	163	TmfEvent event = fTrace.getNextEvent(context);
	164	assertEquals("Event timestamp", 1, event.getTimestamp().getValue());
	165
	166	// On higher bound, returns null (no event)
	167	context = fTrace.seekEvent(new TmfTimestamp(NB_EVENTS + 1, SCALE, 0));
	168	event = fTrace.getNextEvent(context);
	169	assertEquals("Event timestamp", null, event);
d18dd09b ASL	170	}
d18dd09b ASL	171
e31e01e8	172	public void testSeekOnIndex() throws Exception {
9f584e4c	173	TmfContext context = fTrace.seekLocation(null);
e31e01e8 FC	174
	175	// On lower bound, returns the first event (ts = 1)
	176	context = fTrace.seekEvent(0);
	177	TmfEvent event = fTrace.getNextEvent(context);
	178	assertEquals("Event timestamp", 1, event.getTimestamp().getValue());
	179
	180	// On higher bound
	181	context = fTrace.seekEvent(NB_EVENTS - 1);
	182	event = fTrace.getNextEvent(context);
	183	assertEquals("Event timestamp", NB_EVENTS, event.getTimestamp().getValue());
	184
	185	// Above high bound
	186	context = fTrace.seekEvent(NB_EVENTS);
	187	event = fTrace.getNextEvent(context);
	188	assertEquals("Event", null, event);
	189	}
	190
	191	// ------------------------------------------------------------------------
75828b1a	192	// getNextEvent
e31e01e8	193	// ------------------------------------------------------------------------
d18dd09b ASL	194
d18dd09b ASL	195	public void testGetNextEvent() throws Exception {
9f584e4c	196	TmfContext context = fTrace.seekLocation(null);
d18dd09b ASL	197
d18dd09b ASL	198	// On lower bound, returns the first event (ts = 0)
75828b1a	199	context = fTrace.seekEvent(new TmfTimestamp(0, SCALE, 0));
d18dd09b ASL	200	TmfEvent event = fTrace.getNextEvent(context);
	201	assertEquals("Event timestamp", 1, event.getTimestamp().getValue());
	202
	203	for (int i = 2; i < 20; i++) {
	204	event = fTrace.getNextEvent(context);
	205	assertEquals("Event timestamp", i, event.getTimestamp().getValue());
	206	}
	207	}
	208
e31e01e8	209	// ------------------------------------------------------------------------
d18dd09b	210	// processRequest
e31e01e8	211	// ------------------------------------------------------------------------
d18dd09b	212
e31e01e8 FC	213	@SuppressWarnings("unchecked")
e31e01e8 FC	214	public void testProcessRequestForNbEvents() throws Exception {
d18dd09b ASL	215	final int BLOCK_SIZE = 100;
	216	final int NB_EVENTS = 1000;
	217	final Vector<TmfEvent> requestedEvents = new Vector<TmfEvent>();
	218
	219	TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BigBang, TmfTimestamp.BigCrunch);
e31e01e8	220	final TmfEventRequest<TmfEvent> request = new TmfEventRequest<TmfEvent>(TmfEvent.class, range, NB_EVENTS, BLOCK_SIZE) {
d18dd09b ASL	221	@Override
	222	public void handleData() {
	223	TmfEvent[] events = getData();
	224	for (TmfEvent e : events) {
	225	requestedEvents.add(e);
	226	}
	227	}
	228	};
fc6ccf6f	229	TmfDataProvider<TmfEvent>[] providers = (TmfDataProvider<TmfEvent>[]) TmfProviderManager.getProviders(TmfEvent.class, TmfTraceStub.class);
e31e01e8	230	providers[0].processRequest(request, true);
d18dd09b ASL	231
	232	assertEquals("nbEvents", NB_EVENTS, requestedEvents.size());
	233	assertTrue("isCompleted", request.isCompleted());
	234	assertFalse("isCancelled", request.isCancelled());
	235
	236	// Ensure that we have distinct events.
	237	// Don't go overboard: we are not validating the stub!
	238	for (int i = 0; i < NB_EVENTS; i++) {
	239	assertEquals("Distinct events", i+1, requestedEvents.get(i).getTimestamp().getValue());
	240	}
	241	}
	242
e31e01e8 FC	243	@SuppressWarnings("unchecked")
e31e01e8 FC	244	public void testProcessRequestForAllEvents() throws Exception {
d18dd09b ASL	245	final int BLOCK_SIZE = 1;
	246	final Vector<TmfEvent> requestedEvents = new Vector<TmfEvent>();
	247
	248	TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BigBang, TmfTimestamp.BigCrunch);
e31e01e8	249	final TmfEventRequest<TmfEvent> request = new TmfEventRequest<TmfEvent>(TmfEvent.class, range, NB_EVENTS, BLOCK_SIZE) {
d18dd09b ASL	250	@Override
	251	public void handleData() {
	252	TmfEvent[] events = getData();
	253	for (TmfEvent e : events) {
	254	requestedEvents.add(e);
	255	}
	256	}
	257	};
fc6ccf6f	258	TmfDataProvider<TmfEvent>[] providers = (TmfDataProvider<TmfEvent>[]) TmfProviderManager.getProviders(TmfEvent.class, TmfTraceStub.class);
e31e01e8	259	providers[0].processRequest(request, true);
d18dd09b ASL	260
	261	assertEquals("nbEvents", NB_EVENTS, requestedEvents.size());
	262	assertTrue("isCompleted", request.isCompleted());
	263	assertFalse("isCancelled", request.isCancelled());
	264
	265	// Ensure that we have distinct events.
	266	// Don't go overboard: we are not validating the stub!
	267	for (int i = 0; i < NB_EVENTS; i++) {
	268	assertEquals("Distinct events", i+1, requestedEvents.get(i).getTimestamp().getValue());
	269	}
	270	}
	271
e31e01e8	272	// ------------------------------------------------------------------------
d18dd09b	273	// cancel
e31e01e8	274	// ------------------------------------------------------------------------
d18dd09b	275
e31e01e8 FC	276	@SuppressWarnings("unchecked")
e31e01e8 FC	277	public void testCancel() throws Exception {
d18dd09b ASL	278	final Vector<TmfEvent> requestedEvents = new Vector<TmfEvent>();
	279
	280	TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BigBang, TmfTimestamp.BigCrunch);
e31e01e8	281	final TmfEventRequest<TmfEvent> request = new TmfEventRequest<TmfEvent>(TmfEvent.class, range, NB_EVENTS, NB_EVENTS) {
d18dd09b ASL	282	@Override
	283	public void handleData() {
	284	TmfEvent[] events = getData();
	285	for (TmfEvent e : events) {
	286	requestedEvents.add(e);
	287	}
	288	// Cancel request after the first chunk is received
	289	cancel();
	290	}
	291	};
fc6ccf6f	292	TmfDataProvider<TmfEvent>[] providers = (TmfDataProvider<TmfEvent>[]) TmfProviderManager.getProviders(TmfEvent.class, TmfTraceStub.class);
e31e01e8	293	providers[0].processRequest(request, true);
d18dd09b ASL	294
	295	assertEquals("nbEvents", NB_EVENTS, requestedEvents.size());
	296	assertTrue("isCompleted", request.isCompleted());
	297	assertTrue("isCancelled", request.isCancelled());
	298	}
e31e01e8 FC	299
e31e01e8 FC	300	}