[deliverable/tracecompass.git] / org.eclipse.linuxtools.tmf.tests / src / org / eclipse / linuxtools / tmf / tests / component / TmfEventProviderTest.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.component;

import java.io.IOException;
import java.util.Vector;

import junit.framework.TestCase;

import org.eclipse.linuxtools.tmf.component.ITmfDataProvider;
import org.eclipse.linuxtools.tmf.component.TmfEventProviderStub;
import org.eclipse.linuxtools.tmf.component.TmfProviderManager;
import org.eclipse.linuxtools.tmf.component.TmfSyntheticEventProviderStub;
import org.eclipse.linuxtools.tmf.event.TmfEvent;
import org.eclipse.linuxtools.tmf.event.TmfSyntheticEventStub;
import org.eclipse.linuxtools.tmf.event.TmfTimeRange;
import org.eclipse.linuxtools.tmf.event.TmfTimestamp;
import org.eclipse.linuxtools.tmf.request.TmfEventRequest;
import org.eclipse.linuxtools.tmf.signal.TmfEndSynchSignal;
import org.eclipse.linuxtools.tmf.signal.TmfStartSynchSignal;
import org.eclipse.linuxtools.tmf.trace.TmfTraceStub;

/**
 * <b><u>TmfClientTest</u></b>
 * <p>
 * Test suite for the TmfEventProvider class.
 */
@SuppressWarnings("nls")
public class TmfEventProviderTest extends TestCase {

	TmfEventProviderStub fEventProvider;
	TmfSyntheticEventProviderStub fSyntheticEventProvider;

	public TmfEventProviderTest(String name) throws IOException {
		super(name);
	}

	@Override
	protected void setUp() throws Exception {
		super.setUp();
		fEventProvider = new TmfEventProviderStub();
		fSyntheticEventProvider = new TmfSyntheticEventProviderStub();
	}

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

	// ------------------------------------------------------------------------
	// getProviders (more a sanity check than a test)
	// ------------------------------------------------------------------------

	@SuppressWarnings("unchecked")
	public void testGetProviders() {

		// There should be 2 TmfEvent providers: a TmfTraceStub and a TmfEventProviderStub
		ITmfDataProvider<TmfEvent>[] eventProviders = (ITmfDataProvider<TmfEvent>[]) TmfProviderManager.getProviders(TmfEvent.class);
		assertEquals("getProviders", 2, eventProviders.length);

		eventProviders = (ITmfDataProvider<TmfEvent>[]) TmfProviderManager.getProviders(TmfEvent.class, TmfTraceStub.class);
		assertEquals("getProviders", 1, eventProviders.length);

		eventProviders = (ITmfDataProvider<TmfEvent>[]) TmfProviderManager.getProviders(TmfEvent.class, TmfEventProviderStub.class);
		assertEquals("getProviders", 1, eventProviders.length);

		// There should be 1 TmfSyntheticEventStub provider
		eventProviders = (ITmfDataProvider<TmfEvent>[]) TmfProviderManager.getProviders(TmfSyntheticEventStub.class);
		assertEquals("getProviders", 1, eventProviders.length);
	}

	// ------------------------------------------------------------------------
	// getSyntheticEvent
	// ------------------------------------------------------------------------

	@SuppressWarnings("unchecked")
	public void testGetPlainEvents() {

        final int BLOCK_SIZE = 100;
        final int NB_EVENTS  = 1000;
        final Vector<TmfEvent> requestedEvents = new Vector<TmfEvent>();

        // Get the TmfSyntheticEventStub provider
		ITmfDataProvider<TmfEvent>[] eventProviders = (ITmfDataProvider<TmfEvent>[]) TmfProviderManager.getProviders(TmfEvent.class, TmfEventProviderStub.class);
		ITmfDataProvider<TmfEvent> provider = eventProviders[0];

        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 event) {
        	super.handleData(event);
        		requestedEvents.add(event);
        	}
        };
        
        provider.sendRequest(request);
        try {
			request.waitForCompletion();
	        assertEquals("nbEvents", NB_EVENTS, requestedEvents.size());
	        assertTrue("isCompleted",  request.isCompleted());
	        assertFalse("isCancelled", request.isCancelled());

	        // Make 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());
	        }
		} catch (InterruptedException e) {
			fail();
		}
	}

	@SuppressWarnings("unchecked")
	public void testCancelRequests() {

	    final int BLOCK_SIZE = 100;
	    final int NB_EVENTS  = 1000;
	    final int NUMBER_EVENTS_BEFORE_CANCEL_REQ1 = 10;
	    final int NUMBER_EVENTS_BEFORE_CANCEL_REQ2 = 800;
	    
	    final Vector<TmfEvent> requestedEventsReq1 = new Vector<TmfEvent>();
	    final Vector<TmfEvent> requestedEventsReq2 = new Vector<TmfEvent>();

	    // Get the TmfSyntheticEventStub provider
	    ITmfDataProvider<TmfEvent>[] eventProviders = (ITmfDataProvider<TmfEvent>[]) TmfProviderManager.getProviders(TmfEvent.class, TmfEventProviderStub.class);
	    ITmfDataProvider<TmfEvent> provider = eventProviders[0];

	    TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BigBang, TmfTimestamp.BigCrunch);
	    
	    // Create first request
	    final TmfEventRequest<TmfEvent> request1 =
	        new TmfEventRequest<TmfEvent>(TmfEvent.class, range, NB_EVENTS, BLOCK_SIZE) {
	        @Override
	        public void handleData(TmfEvent event) {
	            super.handleData(event);
	            requestedEventsReq1.add(event);

	            // cancel sub request
	            if (getNbRead() == NUMBER_EVENTS_BEFORE_CANCEL_REQ1) {
	                cancel();
	            }
	        }
	    };

	    // Synchronize requests
	    ((TmfEventProviderStub) provider).startSynch(new TmfStartSynchSignal(0));
	    
	    // Additionally, notify provider for up-coming requests
	    provider.notifyPendingRequest(true);
	    
	    // Call sendRequest, which will create a coalescing request, but it doesn't send request1 yet
	    provider.sendRequest(request1);
	    
	    // Check if request1 is not running yet.
	    assertFalse("isRunning", request1.isRunning());
	    
	    // Create second request
	    final TmfEventRequest<TmfEvent> request2 =
	        new TmfEventRequest<TmfEvent>(TmfEvent.class, range, NB_EVENTS, BLOCK_SIZE) {
	        @Override
	        public void handleData(TmfEvent event) {
	            super.handleData(event);
                requestedEventsReq2.add(event);

                // cancel sub request which will cancel also main request
	            if (getNbRead() == NUMBER_EVENTS_BEFORE_CANCEL_REQ2) {
	                cancel();
	            }
	        }
	    };

	    // Call sendRequest, which will create a coalescing request, but it doesn't send request2 yet
        provider.sendRequest(request2);

        // Check if request1/2 is not running yet.
        assertFalse("isRunning",  request1.isRunning());
        assertFalse("isRunning",  request2.isRunning());
        
        // Send end synch signal, however requests won't be sent 
        ((TmfEventProviderStub) provider).endSynch(new TmfEndSynchSignal(0));

        // Check if request1/2 is not running yet.
        assertFalse("isRunning",  request1.isRunning());
        assertFalse("isRunning",  request2.isRunning());

        // Finally, trigger sending of requests 
        provider.notifyPendingRequest(false);
        
	    try {
	        
	        // Wait till requests start
	        request1.waitForStart();
	        request2.waitForStart();

	        // Check if request1/2 are running.
	        assertTrue("isRunning",  request1.isRunning());
	        assertTrue("isRunning",  request2.isRunning());

	        request1.waitForCompletion();

	        // Check if request2 is still running
            assertTrue("isRunning",  request2.isRunning());

	        // Verify result (request1)
            assertEquals("nbEvents", NUMBER_EVENTS_BEFORE_CANCEL_REQ1, requestedEventsReq1.size());
	        assertTrue("isCompleted",  request1.isCompleted());
	        assertTrue("isCancelled",  request1.isCancelled());
	        
	        request2.waitForCompletion();
	        
  	        // Verify result (request2)
	        assertEquals("nbEvents", NUMBER_EVENTS_BEFORE_CANCEL_REQ2, requestedEventsReq2.size());
	        assertTrue("isCompleted",  request2.isCompleted());
	        assertTrue("isCancelled",  request2.isCancelled());

	    } catch (InterruptedException e) {
	        fail();
	    }
	}
	
	@SuppressWarnings("unchecked")
	private void getSyntheticData(final TmfTimeRange range, final int nbEvents, final int blockSize) throws InterruptedException {

        final Vector<TmfSyntheticEventStub> requestedEvents = new Vector<TmfSyntheticEventStub>();

        // Get the event provider
		ITmfDataProvider<TmfSyntheticEventStub>[] eventProviders = (ITmfDataProvider<TmfSyntheticEventStub>[]) TmfProviderManager.getProviders(TmfSyntheticEventStub.class);
		ITmfDataProvider<TmfSyntheticEventStub> provider = eventProviders[0];

        final TmfEventRequest<TmfSyntheticEventStub> request =
        	new TmfEventRequest<TmfSyntheticEventStub>(TmfSyntheticEventStub.class, range, nbEvents, blockSize) {
        		@Override
        		public void handleData(TmfSyntheticEventStub event) {
            		super.handleData(event);
        			requestedEvents.add(event);
        		}
        	};
        provider.sendRequest(request);

        request.waitForCompletion();
	    if (nbEvents != -1)
	       	assertEquals("nbEvents", nbEvents, requestedEvents.size());
	    assertTrue("isCompleted", request.isCompleted());
	    assertFalse("isCancelled", request.isCancelled());

	    // For each base event, the stub will queue 2 identical synthetic events
	    // Ensure that the events are queued properly.
	    // Don't go overboard: we are not validating the stub!
	    for (int i = 0; i < (nbEvents / 2); i++) {
	        assertEquals("Distinct events", i+1, requestedEvents.get(2 * i + 0).getTimestamp().getValue());
	        assertEquals("Distinct events", i+1, requestedEvents.get(2 * i + 1).getTimestamp().getValue());
	    }
	}

	// The following tests are the same but for the size of the requested blocks
	// with regards to the size of the TmfSyntheticEventProviderStub block
    public void testGetSyntheticEvents_EqualBlockSizes() {
        TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BigBang, TmfTimestamp.BigCrunch);
		try {
			getSyntheticData(range, 1000, TmfSyntheticEventProviderStub.BLOCK_SIZE);
		} catch (InterruptedException e) {
			fail();
		}
	}

	public void testGetSyntheticEvents_SmallerBlock() {
        TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BigBang, TmfTimestamp.BigCrunch);
		try {
			getSyntheticData(range, 1000, TmfSyntheticEventProviderStub.BLOCK_SIZE / 2);
		} catch (InterruptedException e) {
			fail();
		}
	}

	public void testGetSyntheticEvents_LargerBlock() {
        TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BigBang, TmfTimestamp.BigCrunch);
		try {
			getSyntheticData(range, 1000, TmfSyntheticEventProviderStub.BLOCK_SIZE * 2);
		} catch (InterruptedException e) {
			fail();
		}
	}

	public void testGetSyntheticEvents_TimeRange() {
		TmfTimestamp start = new TmfTimestamp(   1, (byte) -3, 0);
		TmfTimestamp end   = new TmfTimestamp(1000, (byte) -3, 0);
        TmfTimeRange range = new TmfTimeRange(start, end);
		try {
			getSyntheticData(range, -1, TmfSyntheticEventProviderStub.BLOCK_SIZE);
		} catch (InterruptedException e) {
			fail();
		}
	}

	public void testGetSyntheticEvents_WeirdTimeRange1() {
		TmfTimestamp start = TmfTimestamp.BigBang;
		TmfTimestamp end   = TmfTimestamp.Zero; // new TmfTimestamp(0, (byte) -3, 0);
        TmfTimeRange range = new TmfTimeRange(start, end);
		try {
			getSyntheticData(range, -1, TmfSyntheticEventProviderStub.BLOCK_SIZE);
		} catch (InterruptedException e) {
			fail();
		}
	}

	public void testGetSyntheticEvents_WeirdTimeRange2() {
		TmfTimestamp start = TmfTimestamp.Zero; // new TmfTimestamp(0, (byte) -3, 0);
		TmfTimestamp end   = TmfTimestamp.BigCrunch;
        TmfTimeRange range = new TmfTimeRange(start, end);
		try {
			getSyntheticData(range, -1, TmfSyntheticEventProviderStub.BLOCK_SIZE);
		} catch (InterruptedException e) {
			fail();
		}
	}

	// ------------------------------------------------------------------------
	// getProviders (more a sanity check than a test)
	// ------------------------------------------------------------------------

	@SuppressWarnings("unchecked")
	public void testGetProviders2() {

		// There should be 2 TmfEvent providers: a TmfTraceStub and a TmfEventProviderStub
		ITmfDataProvider<TmfEvent>[] eventProviders = (ITmfDataProvider<TmfEvent>[]) TmfProviderManager.getProviders(TmfEvent.class);
		assertEquals("getProviders", 2, eventProviders.length);

		eventProviders = (ITmfDataProvider<TmfEvent>[]) TmfProviderManager.getProviders(TmfEvent.class, TmfTraceStub.class);
		assertEquals("getProviders", 1, eventProviders.length);

		eventProviders = (ITmfDataProvider<TmfEvent>[]) TmfProviderManager.getProviders(TmfEvent.class, TmfEventProviderStub.class);
		assertEquals("getProviders", 1, eventProviders.length);

		// There should be 1 TmfSyntheticEventStub provider
		eventProviders = (ITmfDataProvider<TmfEvent>[]) TmfProviderManager.getProviders(TmfSyntheticEventStub.class);
		assertEquals("getProviders", 1, eventProviders.length);
	}

}
Commit	Line	Data
d18dd09b ASL	1	/*******************************************************************************
	2	* Copyright (c) 2009, 2010 Ericsson
	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.component;
	14
	15	import java.io.IOException;
	16	import java.util.Vector;
	17
	18	import junit.framework.TestCase;
	19
	20	import org.eclipse.linuxtools.tmf.component.ITmfDataProvider;
	21	import org.eclipse.linuxtools.tmf.component.TmfEventProviderStub;
	22	import org.eclipse.linuxtools.tmf.component.TmfProviderManager;
	23	import org.eclipse.linuxtools.tmf.component.TmfSyntheticEventProviderStub;
	24	import org.eclipse.linuxtools.tmf.event.TmfEvent;
	25	import org.eclipse.linuxtools.tmf.event.TmfSyntheticEventStub;
	26	import org.eclipse.linuxtools.tmf.event.TmfTimeRange;
	27	import org.eclipse.linuxtools.tmf.event.TmfTimestamp;
	28	import org.eclipse.linuxtools.tmf.request.TmfEventRequest;
c1c69938 FC	29	import org.eclipse.linuxtools.tmf.signal.TmfEndSynchSignal;
c1c69938 FC	30	import org.eclipse.linuxtools.tmf.signal.TmfStartSynchSignal;
d18dd09b ASL	31	import org.eclipse.linuxtools.tmf.trace.TmfTraceStub;
	32
	33	/**
	34	* <b><u>TmfClientTest</u></b>
	35	* <p>
ff4ed569	36	* Test suite for the TmfEventProvider class.
d18dd09b	37	*/
3b38ea61	38	@SuppressWarnings("nls")
d18dd09b ASL	39	public class TmfEventProviderTest extends TestCase {
	40
	41	TmfEventProviderStub fEventProvider;
	42	TmfSyntheticEventProviderStub fSyntheticEventProvider;
	43
	44	public TmfEventProviderTest(String name) throws IOException {
	45	super(name);
	46	}
	47
	48	@Override
	49	protected void setUp() throws Exception {
	50	super.setUp();
	51	fEventProvider = new TmfEventProviderStub();
	52	fSyntheticEventProvider = new TmfSyntheticEventProviderStub();
	53	}
	54
	55	@Override
	56	protected void tearDown() throws Exception {
	57	super.tearDown();
2fb2eb37 FC	58	fEventProvider.dispose();
2fb2eb37 FC	59	fSyntheticEventProvider.dispose();
d18dd09b ASL	60	}
	61
	62	// ------------------------------------------------------------------------
	63	// getProviders (more a sanity check than a test)
	64	// ------------------------------------------------------------------------
	65
	66	@SuppressWarnings("unchecked")
	67	public void testGetProviders() {
	68
	69	// There should be 2 TmfEvent providers: a TmfTraceStub and a TmfEventProviderStub
	70	ITmfDataProvider<TmfEvent>[] eventProviders = (ITmfDataProvider<TmfEvent>[]) TmfProviderManager.getProviders(TmfEvent.class);
ff4ed569	71	assertEquals("getProviders", 2, eventProviders.length);
d18dd09b ASL	72
d18dd09b ASL	73	eventProviders = (ITmfDataProvider<TmfEvent>[]) TmfProviderManager.getProviders(TmfEvent.class, TmfTraceStub.class);
ff4ed569	74	assertEquals("getProviders", 1, eventProviders.length);
d18dd09b ASL	75
d18dd09b ASL	76	eventProviders = (ITmfDataProvider<TmfEvent>[]) TmfProviderManager.getProviders(TmfEvent.class, TmfEventProviderStub.class);
ff4ed569	77	assertEquals("getProviders", 1, eventProviders.length);
d18dd09b ASL	78
	79	// There should be 1 TmfSyntheticEventStub provider
	80	eventProviders = (ITmfDataProvider<TmfEvent>[]) TmfProviderManager.getProviders(TmfSyntheticEventStub.class);
ff4ed569	81	assertEquals("getProviders", 1, eventProviders.length);
d18dd09b ASL	82	}
	83
	84	// ------------------------------------------------------------------------
	85	// getSyntheticEvent
	86	// ------------------------------------------------------------------------
	87
	88	@SuppressWarnings("unchecked")
cb866e08	89	public void testGetPlainEvents() {
d18dd09b ASL	90
	91	final int BLOCK_SIZE = 100;
	92	final int NB_EVENTS = 1000;
	93	final Vector<TmfEvent> requestedEvents = new Vector<TmfEvent>();
	94
	95	// Get the TmfSyntheticEventStub provider
	96	ITmfDataProvider<TmfEvent>[] eventProviders = (ITmfDataProvider<TmfEvent>[]) TmfProviderManager.getProviders(TmfEvent.class, TmfEventProviderStub.class);
	97	ITmfDataProvider<TmfEvent> provider = eventProviders[0];
	98
	99	TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BigBang, TmfTimestamp.BigCrunch);
	100	final TmfEventRequest<TmfEvent> request =
	101	new TmfEventRequest<TmfEvent>(TmfEvent.class, range, NB_EVENTS, BLOCK_SIZE) {
f9673903 FC	102	@Override
	103	public void handleData(TmfEvent event) {
	104	super.handleData(event);
	105	requestedEvents.add(event);
	106	}
	107	};
c1c69938	108
d18dd09b	109	provider.sendRequest(request);
cb866e08 FC	110	try {
	111	request.waitForCompletion();
	112	assertEquals("nbEvents", NB_EVENTS, requestedEvents.size());
	113	assertTrue("isCompleted", request.isCompleted());
	114	assertFalse("isCancelled", request.isCancelled());
	115
	116	// Make that we have distinct events.
	117	// Don't go overboard: we are not validating the stub!
	118	for (int i = 0; i < NB_EVENTS; i++) {
	119	assertEquals("Distinct events", i+1, requestedEvents.get(i).getTimestamp().getValue());
	120	}
	121	} catch (InterruptedException e) {
	122	fail();
	123	}
d18dd09b ASL	124	}
d18dd09b ASL	125
c1c69938 FC	126	@SuppressWarnings("unchecked")
	127	public void testCancelRequests() {
	128
	129	final int BLOCK_SIZE = 100;
	130	final int NB_EVENTS = 1000;
	131	final int NUMBER_EVENTS_BEFORE_CANCEL_REQ1 = 10;
	132	final int NUMBER_EVENTS_BEFORE_CANCEL_REQ2 = 800;
	133
	134	final Vector<TmfEvent> requestedEventsReq1 = new Vector<TmfEvent>();
	135	final Vector<TmfEvent> requestedEventsReq2 = new Vector<TmfEvent>();
	136
	137	// Get the TmfSyntheticEventStub provider
	138	ITmfDataProvider<TmfEvent>[] eventProviders = (ITmfDataProvider<TmfEvent>[]) TmfProviderManager.getProviders(TmfEvent.class, TmfEventProviderStub.class);
	139	ITmfDataProvider<TmfEvent> provider = eventProviders[0];
	140
	141	TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BigBang, TmfTimestamp.BigCrunch);
	142
	143	// Create first request
	144	final TmfEventRequest<TmfEvent> request1 =
	145	new TmfEventRequest<TmfEvent>(TmfEvent.class, range, NB_EVENTS, BLOCK_SIZE) {
	146	@Override
	147	public void handleData(TmfEvent event) {
	148	super.handleData(event);
	149	requestedEventsReq1.add(event);
	150
	151	// cancel sub request
	152	if (getNbRead() == NUMBER_EVENTS_BEFORE_CANCEL_REQ1) {
	153	cancel();
	154	}
	155	}
	156	};
	157
	158	// Synchronize requests
	159	((TmfEventProviderStub) provider).startSynch(new TmfStartSynchSignal(0));
	160
	161	// Additionally, notify provider for up-coming requests
	162	provider.notifyPendingRequest(true);
	163
	164	// Call sendRequest, which will create a coalescing request, but it doesn't send request1 yet
	165	provider.sendRequest(request1);
	166
	167	// Check if request1 is not running yet.
	168	assertFalse("isRunning", request1.isRunning());
	169
	170	// Create second request
	171	final TmfEventRequest<TmfEvent> request2 =
	172	new TmfEventRequest<TmfEvent>(TmfEvent.class, range, NB_EVENTS, BLOCK_SIZE) {
	173	@Override
	174	public void handleData(TmfEvent event) {
	175	super.handleData(event);
	176	requestedEventsReq2.add(event);
	177
	178	// cancel sub request which will cancel also main request
	179	if (getNbRead() == NUMBER_EVENTS_BEFORE_CANCEL_REQ2) {
	180	cancel();
	181	}
	182	}
	183	};
	184
	185	// Call sendRequest, which will create a coalescing request, but it doesn't send request2 yet
	186	provider.sendRequest(request2);
	187
	188	// Check if request1/2 is not running yet.
	189	assertFalse("isRunning", request1.isRunning());
190	assertFalse("isRunning", request2.isRunning());
191
192	// Send end synch signal, however requests won't be sent
193	((TmfEventProviderStub) provider).endSynch(new TmfEndSynchSignal(0));
194
195	// Check if request1/2 is not running yet.
196	assertFalse("isRunning", request1.isRunning());
197	assertFalse("isRunning", request2.isRunning());
198
199	// Finally, trigger sending of requests
200	provider.notifyPendingRequest(false);
201
202	try {
203
204	// Wait till requests start
205	request1.waitForStart();
206	request2.waitForStart();
207
208	// Check if request1/2 are running.
209	assertTrue("isRunning", request1.isRunning());
210	assertTrue("isRunning", request2.isRunning());
211
212	request1.waitForCompletion();
213
214	// Check if request2 is still running
215	assertTrue("isRunning", request2.isRunning());
216
217	// Verify result (request1)
218	assertEquals("nbEvents", NUMBER_EVENTS_BEFORE_CANCEL_REQ1, requestedEventsReq1.size());
219	assertTrue("isCompleted", request1.isCompleted());
220	assertTrue("isCancelled", request1.isCancelled());
221
222	request2.waitForCompletion();
223
224	// Verify result (request2)
225	assertEquals("nbEvents", NUMBER_EVENTS_BEFORE_CANCEL_REQ2, requestedEventsReq2.size());
226	assertTrue("isCompleted", request2.isCompleted());
227	assertTrue("isCancelled", request2.isCancelled());
228
229	} catch (InterruptedException e) {
230	fail();
231	}
232	}
233
d18dd09b	234	@SuppressWarnings("unchecked")
2fb2eb37	235	private void getSyntheticData(final TmfTimeRange range, final int nbEvents, final int blockSize) throws InterruptedException {
d18dd09b ASL	236
	237	final Vector<TmfSyntheticEventStub> requestedEvents = new Vector<TmfSyntheticEventStub>();
	238
	239	// Get the event provider
	240	ITmfDataProvider<TmfSyntheticEventStub>[] eventProviders = (ITmfDataProvider<TmfSyntheticEventStub>[]) TmfProviderManager.getProviders(TmfSyntheticEventStub.class);
	241	ITmfDataProvider<TmfSyntheticEventStub> provider = eventProviders[0];
	242
	243	final TmfEventRequest<TmfSyntheticEventStub> request =
	244	new TmfEventRequest<TmfSyntheticEventStub>(TmfSyntheticEventStub.class, range, nbEvents, blockSize) {
f9673903 FC	245	@Override
	246	public void handleData(TmfSyntheticEventStub event) {
	247	super.handleData(event);
	248	requestedEvents.add(event);
	249	}
d18dd09b ASL	250	};
d18dd09b ASL	251	provider.sendRequest(request);
d18dd09b	252
cb866e08 FC	253	request.waitForCompletion();
	254	if (nbEvents != -1)
	255	assertEquals("nbEvents", nbEvents, requestedEvents.size());
	256	assertTrue("isCompleted", request.isCompleted());
	257	assertFalse("isCancelled", request.isCancelled());
	258
	259	// For each base event, the stub will queue 2 identical synthetic events
	260	// Ensure that the events are queued properly.
	261	// Don't go overboard: we are not validating the stub!
	262	for (int i = 0; i < (nbEvents / 2); i++) {
	263	assertEquals("Distinct events", i+1, requestedEvents.get(2 * i + 0).getTimestamp().getValue());
	264	assertEquals("Distinct events", i+1, requestedEvents.get(2 * i + 1).getTimestamp().getValue());
	265	}
d18dd09b ASL	266	}
	267
	268	// The following tests are the same but for the size of the requested blocks
	269	// with regards to the size of the TmfSyntheticEventProviderStub block
cb866e08	270	public void testGetSyntheticEvents_EqualBlockSizes() {
d18dd09b	271	TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BigBang, TmfTimestamp.BigCrunch);
cb866e08 FC	272	try {
	273	getSyntheticData(range, 1000, TmfSyntheticEventProviderStub.BLOCK_SIZE);
	274	} catch (InterruptedException e) {
	275	fail();
	276	}
d18dd09b ASL	277	}
d18dd09b ASL	278
cb866e08	279	public void testGetSyntheticEvents_SmallerBlock() {
d18dd09b	280	TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BigBang, TmfTimestamp.BigCrunch);
cb866e08 FC	281	try {
	282	getSyntheticData(range, 1000, TmfSyntheticEventProviderStub.BLOCK_SIZE / 2);
	283	} catch (InterruptedException e) {
	284	fail();
	285	}
d18dd09b ASL	286	}
d18dd09b ASL	287
cb866e08	288	public void testGetSyntheticEvents_LargerBlock() {
d18dd09b	289	TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BigBang, TmfTimestamp.BigCrunch);
cb866e08 FC	290	try {
	291	getSyntheticData(range, 1000, TmfSyntheticEventProviderStub.BLOCK_SIZE * 2);
	292	} catch (InterruptedException e) {
	293	fail();
	294	}
d18dd09b ASL	295	}
d18dd09b ASL	296
cb866e08	297	public void testGetSyntheticEvents_TimeRange() {
d18dd09b ASL	298	TmfTimestamp start = new TmfTimestamp( 1, (byte) -3, 0);
	299	TmfTimestamp end = new TmfTimestamp(1000, (byte) -3, 0);
	300	TmfTimeRange range = new TmfTimeRange(start, end);
cb866e08 FC	301	try {
	302	getSyntheticData(range, -1, TmfSyntheticEventProviderStub.BLOCK_SIZE);
	303	} catch (InterruptedException e) {
	304	fail();
	305	}
d18dd09b ASL	306	}
d18dd09b ASL	307
cb866e08	308	public void testGetSyntheticEvents_WeirdTimeRange1() {
d18dd09b	309	TmfTimestamp start = TmfTimestamp.BigBang;
9b635e61	310	TmfTimestamp end = TmfTimestamp.Zero; // new TmfTimestamp(0, (byte) -3, 0);
d18dd09b	311	TmfTimeRange range = new TmfTimeRange(start, end);
cb866e08 FC	312	try {
	313	getSyntheticData(range, -1, TmfSyntheticEventProviderStub.BLOCK_SIZE);
	314	} catch (InterruptedException e) {
	315	fail();
	316	}
d18dd09b ASL	317	}
d18dd09b ASL	318
cb866e08	319	public void testGetSyntheticEvents_WeirdTimeRange2() {
9b635e61	320	TmfTimestamp start = TmfTimestamp.Zero; // new TmfTimestamp(0, (byte) -3, 0);
d18dd09b ASL	321	TmfTimestamp end = TmfTimestamp.BigCrunch;
d18dd09b ASL	322	TmfTimeRange range = new TmfTimeRange(start, end);
cb866e08 FC	323	try {
	324	getSyntheticData(range, -1, TmfSyntheticEventProviderStub.BLOCK_SIZE);
	325	} catch (InterruptedException e) {
	326	fail();
	327	}
d18dd09b ASL	328	}
	329
	330	// ------------------------------------------------------------------------
	331	// getProviders (more a sanity check than a test)
	332	// ------------------------------------------------------------------------
	333
	334	@SuppressWarnings("unchecked")
	335	public void testGetProviders2() {
	336
	337	// There should be 2 TmfEvent providers: a TmfTraceStub and a TmfEventProviderStub
	338	ITmfDataProvider<TmfEvent>[] eventProviders = (ITmfDataProvider<TmfEvent>[]) TmfProviderManager.getProviders(TmfEvent.class);
ff4ed569	339	assertEquals("getProviders", 2, eventProviders.length);
d18dd09b ASL	340
d18dd09b ASL	341	eventProviders = (ITmfDataProvider<TmfEvent>[]) TmfProviderManager.getProviders(TmfEvent.class, TmfTraceStub.class);
ff4ed569	342	assertEquals("getProviders", 1, eventProviders.length);
d18dd09b ASL	343
d18dd09b ASL	344	eventProviders = (ITmfDataProvider<TmfEvent>[]) TmfProviderManager.getProviders(TmfEvent.class, TmfEventProviderStub.class);
ff4ed569	345	assertEquals("getProviders", 1, eventProviders.length);
d18dd09b ASL	346
	347	// There should be 1 TmfSyntheticEventStub provider
	348	eventProviders = (ITmfDataProvider<TmfEvent>[]) TmfProviderManager.getProviders(TmfSyntheticEventStub.class);
ff4ed569	349	assertEquals("getProviders", 1, eventProviders.length);
d18dd09b ASL	350	}
	351
	352	}