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

import junit.framework.TestCase;

import org.eclipse.linuxtools.tmf.event.TmfEvent;
import org.eclipse.linuxtools.tmf.event.TmfEventReference;
import org.eclipse.linuxtools.tmf.event.TmfEventSource;
import org.eclipse.linuxtools.tmf.event.TmfEventType;
import org.eclipse.linuxtools.tmf.event.TmfTimeRange;
import org.eclipse.linuxtools.tmf.event.TmfTimestamp;
import org.eclipse.linuxtools.tmf.request.TmfDataRequest;
import org.eclipse.linuxtools.tmf.request.TmfEventRequest;
import org.eclipse.linuxtools.tmf.request.TmfEventRequestStub;

/**
 * <b><u>TmfEventRequestTest</u></b>
 * <p>
 * Test suite for the TmfEventRequest class.
 */
public class TmfEventRequestTest extends TestCase {

	// ------------------------------------------------------------------------
	// Variables
	// ------------------------------------------------------------------------

	private static TmfTimeRange range1 = new TmfTimeRange(TmfTimeRange.Eternity);
	private static TmfTimeRange range2 = new TmfTimeRange(new TmfTimestamp(), TmfTimestamp.BigCrunch);
	
	private static TmfEventRequest<TmfEvent> fRequest1;
	private static TmfEventRequest<TmfEvent> fRequest1b;
	private static TmfEventRequest<TmfEvent> fRequest1c;
	private static TmfEventRequest<TmfEvent> fRequest2;
	private static TmfEventRequest<TmfEvent> fRequest3;
	private static TmfEventRequest<TmfEvent> fRequest4;

	private static int fRequestCount;
	
	// ------------------------------------------------------------------------
	// Housekeeping
	// ------------------------------------------------------------------------

	public TmfEventRequestTest(String name) {
		super(name);
	}

	@Override
	protected void setUp() throws Exception {
		super.setUp();
		TmfDataRequest.reset();
		fRequest1  = new TmfEventRequestStub<TmfEvent>(TmfEvent.class, range1, 100, 200);
		fRequest2  = new TmfEventRequestStub<TmfEvent>(TmfEvent.class, range2, 100, 200);
		fRequest3  = new TmfEventRequestStub<TmfEvent>(TmfEvent.class, range2, 200, 200);
		fRequest4  = new TmfEventRequestStub<TmfEvent>(TmfEvent.class, range2, 200, 300);
		fRequest1b = new TmfEventRequestStub<TmfEvent>(TmfEvent.class, range1, 100, 200);
		fRequest1c = new TmfEventRequestStub<TmfEvent>(TmfEvent.class, range1, 100, 200);
		fRequestCount = fRequest1c.getRequestId() + 1;
	}

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

	private TmfEventRequest<TmfEvent> setupTestRequest(final boolean[] flags) {
		
		TmfEventRequest<TmfEvent> request = new TmfEventRequestStub<TmfEvent>(TmfEvent.class, new TmfTimeRange(TmfTimeRange.Eternity), 100, 200) {
		    @Override
			public void handleCompleted() {
		    	super.handleCompleted();
		    	flags[0] = true;
		    }
		    @Override
		    public void handleSuccess() {
		    	super.handleSuccess();
		    	flags[1] = true;
		    }
		    @Override
		    public void handleFailure() {
		    	super.handleFailure();
		    	flags[2] = true;
		    }
		    @Override
		    public void handleCancel() {
		    	super.handleCancel();
		    	flags[3] = true;
		    }
		};
		return request;
	}
	
	// ------------------------------------------------------------------------
	// Constructors
	// ------------------------------------------------------------------------

	public void testTmfEventRequest() {
        TmfEventRequest<TmfEvent> request = new TmfEventRequestStub<TmfEvent>(TmfEvent.class);

        assertEquals("getRequestId", fRequestCount++, request.getRequestId());
        assertEquals("getDataType",  TmfEvent.class, request.getDataType());

        assertEquals("StartTime", TmfTimestamp.BigBang,   request.getRange().getStartTime());
        assertEquals("EndTime",   TmfTimestamp.BigCrunch, request.getRange().getEndTime());

        assertEquals("getIndex", 0, request.getIndex());
        assertEquals("getNbRequestedEvents", TmfDataRequest.ALL_DATA, request.getNbRequested());
        assertEquals("getBlockize", TmfDataRequest.DEFAULT_BLOCK_SIZE, request.getBlockize());

        assertFalse("isCompleted", request.isCompleted());
        assertFalse("isFailed", request.isFailed());
        assertFalse("isCancelled", request.isCancelled());

        assertEquals("getNbRead", 0, request.getNbRead());
	}

	public void testTmfEventRequestTimeRange() {
        TmfTimeRange range = new TmfTimeRange(new TmfTimestamp(), TmfTimestamp.BigCrunch);
        TmfEventRequest<TmfEvent> request = new TmfEventRequestStub<TmfEvent>(TmfEvent.class, range);

        assertEquals("getRequestId", fRequestCount++, request.getRequestId());
        assertEquals("getDataType",  TmfEvent.class, request.getDataType());

        assertEquals("StartTime", new TmfTimestamp(), request.getRange().getStartTime());
        assertEquals("EndTime",   TmfTimestamp.BigCrunch, request.getRange().getEndTime());

        assertEquals("getIndex", 0, request.getIndex());
        assertEquals("getNbRequestedEvents", TmfDataRequest.ALL_DATA, request.getNbRequested());
        assertEquals("getBlockize", TmfDataRequest.DEFAULT_BLOCK_SIZE, request.getBlockize());

        assertFalse("isCompleted", request.isCompleted());
        assertFalse("isFailed", request.isFailed());
        assertFalse("isCancelled", request.isCancelled());

        assertEquals("getNbRead", 0, request.getNbRead());
	}

	public void testTmfEventRequestTimeRangeNbRequested() {
        TmfTimeRange range = new TmfTimeRange(new TmfTimestamp(), TmfTimestamp.BigCrunch);
        TmfEventRequest<TmfEvent> request = new TmfEventRequestStub<TmfEvent>(TmfEvent.class, range, 100);

        assertEquals("getRequestId", fRequestCount++, request.getRequestId());
        assertEquals("getDataType",  TmfEvent.class, request.getDataType());

        assertEquals("StartTime", new TmfTimestamp(), request.getRange().getStartTime());
        assertEquals("EndTime",   TmfTimestamp.BigCrunch, request.getRange().getEndTime());

        assertEquals("getIndex", 0, request.getIndex());
        assertEquals("getNbRequestedEvents", 100, request.getNbRequested());
        assertEquals("getBlockize", TmfDataRequest.DEFAULT_BLOCK_SIZE, request.getBlockize());

        assertFalse("isCompleted", request.isCompleted());
        assertFalse("isFailed", request.isFailed());
        assertFalse("isCancelled", request.isCancelled());

        assertEquals("getNbRead", 0, request.getNbRead());
	}

	public void testTmfEventRequestTimeRangeNbRequestedBlocksize() {
        TmfTimeRange range = new TmfTimeRange(new TmfTimestamp(), TmfTimestamp.BigCrunch);
        TmfEventRequest<TmfEvent> request = new TmfEventRequestStub<TmfEvent>(TmfEvent.class, range, 100, 200);

        assertEquals("getRequestId", fRequestCount++, request.getRequestId());
        assertEquals("getDataType",  TmfEvent.class, request.getDataType());

        assertEquals("StartTime", new TmfTimestamp(), request.getRange().getStartTime());
        assertEquals("EndTime",   TmfTimestamp.BigCrunch, request.getRange().getEndTime());

        assertEquals("getIndex", 0, request.getIndex());
        assertEquals("getNbRequestedEvents", 100, request.getNbRequested());
        assertEquals("getBlockize", 200, request.getBlockize());

        assertFalse("isCompleted", request.isCompleted());
        assertFalse("isFailed", request.isFailed());
        assertFalse("isCancelled", request.isCancelled());

        assertEquals("getNbRead", 0, request.getNbRead());
	}

	// ------------------------------------------------------------------------
	// equals
	// ------------------------------------------------------------------------

	public void testEqualsReflexivity() throws Exception {
        assertTrue("equals", fRequest1.equals(fRequest1));
        assertTrue("equals", fRequest2.equals(fRequest2));

        assertFalse("equals", fRequest1.equals(fRequest2));
        assertFalse("equals", fRequest2.equals(fRequest1));
	}

	public void testEqualsSymmetry() throws Exception {
        assertTrue("equals", fRequest1.equals(fRequest1b));
        assertTrue("equals", fRequest1b.equals(fRequest1));

        assertFalse("equals", fRequest1.equals(fRequest3));
        assertFalse("equals", fRequest2.equals(fRequest3));
        assertFalse("equals", fRequest3.equals(fRequest1));
        assertFalse("equals", fRequest3.equals(fRequest2));
	}
	
	public void testEqualsTransivity() throws Exception {
        assertTrue("equals", fRequest1.equals(fRequest1b));
        assertTrue("equals", fRequest1b.equals(fRequest1c));
        assertTrue("equals", fRequest1.equals(fRequest1c));
	}
	
	public void testEqualsNull() throws Exception {
        assertFalse("equals", fRequest1.equals(null));
        assertFalse("equals", fRequest2.equals(null));
	}

	// ------------------------------------------------------------------------
	// hashCode
	// ------------------------------------------------------------------------

	public void testHashCode() throws Exception {
        assertTrue("hashCode", fRequest1.hashCode() == fRequest1.hashCode());
        assertTrue("hashCode", fRequest2.hashCode() == fRequest2.hashCode());
		assertTrue("hashCode", fRequest1.hashCode() != fRequest2.hashCode());
	}
	
	// ------------------------------------------------------------------------
	// toString
	// ------------------------------------------------------------------------

	public void testToString() {
        String expected1 = "[TmfEventRequest(0,TmfEvent," + range1 + ",100,200)]";
        String expected2 = "[TmfEventRequest(1,TmfEvent," + range2 + ",100,200)]";
        String expected3 = "[TmfEventRequest(2,TmfEvent," + range2 + ",200,200)]";
        String expected4 = "[TmfEventRequest(3,TmfEvent," + range2 + ",200,300)]";

        assertEquals("toString", expected1, fRequest1.toString());
        assertEquals("toString", expected2, fRequest2.toString());
        assertEquals("toString", expected3, fRequest3.toString());
        assertEquals("toString", expected4, fRequest4.toString());
	}

	// ------------------------------------------------------------------------
	// setData/getData
	// ------------------------------------------------------------------------

	public void testSetData() {
		// Initialize the data
		int nbEvents = 10;
		TmfEvent[] events = new TmfEvent[nbEvents];
		for (int i = 0; i < nbEvents; i++) {
			events[i] = new TmfEvent(new TmfTimestamp(i), new TmfEventSource(),
					new TmfEventType(), new TmfEventReference());
		}

		fRequest1.setData(events);
		assertEquals("setData", nbEvents, fRequest1.getNbRead());

		TmfEvent[] eventsRead = fRequest1.getData();
		assertEquals("getData", nbEvents, eventsRead.length);

		for (int i = 0; i < nbEvents; i++) {
			assertEquals("getData", i, eventsRead[i].getTimestamp().getValue());
		}
	}

	// ------------------------------------------------------------------------
	// done
	// ------------------------------------------------------------------------

	public void testDone() {
		
		final boolean[] flags = new boolean[4];
		TmfEventRequest<TmfEvent> request = setupTestRequest(flags);
		request.done();

		assertTrue ("isCompleted", request.isCompleted());
		assertFalse("isFailed",    request.isFailed());
		assertFalse("isCancelled", request.isCancelled());

		assertTrue ("handleCompleted", flags[0]);
		assertTrue ("handleSuccess",   flags[1]);
		assertFalse("handleFailure",   flags[2]);
		assertFalse("handleCancel",    flags[3]);
	}

	// ------------------------------------------------------------------------
	// fail
	// ------------------------------------------------------------------------

	public void testFail() {
		
		final boolean[] flags = new boolean[4];
		TmfEventRequest<TmfEvent> request = setupTestRequest(flags);
		request.fail();

		assertTrue ("isCompleted", request.isCompleted());
		assertTrue ("isFailed",    request.isFailed());
		assertFalse("isCancelled", request.isCancelled());

		assertTrue ("handleCompleted", flags[0]);
		assertFalse("handleSuccess",   flags[1]);
		assertTrue ("handleFailure",   flags[2]);
		assertFalse("handleCancel",    flags[3]);
	}

	// ------------------------------------------------------------------------
	// cancel
	// ------------------------------------------------------------------------

	public void testCancel() {

		final boolean[] flags = new boolean[4];
		TmfEventRequest<TmfEvent> request = setupTestRequest(flags);
		request.cancel();

		assertTrue ("isCompleted", request.isCompleted());
		assertFalse("isFailed",    request.isFailed());
		assertTrue ("isCancelled", request.isCancelled());

		assertTrue ("handleCompleted", flags[0]);
		assertFalse("handleSuccess",   flags[1]);
		assertFalse("handleFailure",   flags[2]);
		assertTrue ("handleCancel",    flags[3]);
	}

	// ------------------------------------------------------------------------
	// waitForCompletion
	// ------------------------------------------------------------------------

}
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.request;
	14
	15	import junit.framework.TestCase;
	16
	17	import org.eclipse.linuxtools.tmf.event.TmfEvent;
2fb2eb37 FC	18	import org.eclipse.linuxtools.tmf.event.TmfEventReference;
	19	import org.eclipse.linuxtools.tmf.event.TmfEventSource;
	20	import org.eclipse.linuxtools.tmf.event.TmfEventType;
d18dd09b ASL	21	import org.eclipse.linuxtools.tmf.event.TmfTimeRange;
	22	import org.eclipse.linuxtools.tmf.event.TmfTimestamp;
	23	import org.eclipse.linuxtools.tmf.request.TmfDataRequest;
	24	import org.eclipse.linuxtools.tmf.request.TmfEventRequest;
951d134a	25	import org.eclipse.linuxtools.tmf.request.TmfEventRequestStub;
d18dd09b ASL	26
	27	/**
	28	* <b><u>TmfEventRequestTest</u></b>
	29	* <p>
2fb2eb37	30	* Test suite for the TmfEventRequest class.
d18dd09b ASL	31	*/
	32	public class TmfEventRequestTest extends TestCase {
	33
2fb2eb37 FC	34	// ------------------------------------------------------------------------
	35	// Variables
	36	// ------------------------------------------------------------------------
	37
	38	private static TmfTimeRange range1 = new TmfTimeRange(TmfTimeRange.Eternity);
	39	private static TmfTimeRange range2 = new TmfTimeRange(new TmfTimestamp(), TmfTimestamp.BigCrunch);
	40
	41	private static TmfEventRequest<TmfEvent> fRequest1;
	42	private static TmfEventRequest<TmfEvent> fRequest1b;
	43	private static TmfEventRequest<TmfEvent> fRequest1c;
	44	private static TmfEventRequest<TmfEvent> fRequest2;
	45	private static TmfEventRequest<TmfEvent> fRequest3;
	46	private static TmfEventRequest<TmfEvent> fRequest4;
	47
	48	private static int fRequestCount;
	49
d18dd09b ASL	50	// ------------------------------------------------------------------------
	51	// Housekeeping
	52	// ------------------------------------------------------------------------
	53
	54	public TmfEventRequestTest(String name) {
	55	super(name);
	56	}
	57
	58	@Override
	59	protected void setUp() throws Exception {
	60	super.setUp();
2fb2eb37 FC	61	TmfDataRequest.reset();
	62	fRequest1 = new TmfEventRequestStub<TmfEvent>(TmfEvent.class, range1, 100, 200);
	63	fRequest2 = new TmfEventRequestStub<TmfEvent>(TmfEvent.class, range2, 100, 200);
	64	fRequest3 = new TmfEventRequestStub<TmfEvent>(TmfEvent.class, range2, 200, 200);
	65	fRequest4 = new TmfEventRequestStub<TmfEvent>(TmfEvent.class, range2, 200, 300);
	66	fRequest1b = new TmfEventRequestStub<TmfEvent>(TmfEvent.class, range1, 100, 200);
	67	fRequest1c = new TmfEventRequestStub<TmfEvent>(TmfEvent.class, range1, 100, 200);
	68	fRequestCount = fRequest1c.getRequestId() + 1;
d18dd09b ASL	69	}
	70
	71	@Override
	72	protected void tearDown() throws Exception {
	73	super.tearDown();
	74	}
	75
2fb2eb37 FC	76	private TmfEventRequest<TmfEvent> setupTestRequest(final boolean[] flags) {
	77
	78	TmfEventRequest<TmfEvent> request = new TmfEventRequestStub<TmfEvent>(TmfEvent.class, new TmfTimeRange(TmfTimeRange.Eternity), 100, 200) {
	79	@Override
	80	public void handleCompleted() {
	81	super.handleCompleted();
	82	flags[0] = true;
	83	}
	84	@Override
	85	public void handleSuccess() {
	86	super.handleSuccess();
	87	flags[1] = true;
	88	}
	89	@Override
	90	public void handleFailure() {
	91	super.handleFailure();
	92	flags[2] = true;
	93	}
	94	@Override
	95	public void handleCancel() {
	96	super.handleCancel();
	97	flags[3] = true;
	98	}
	99	};
	100	return request;
	101	}
	102
d18dd09b ASL	103	// ------------------------------------------------------------------------
	104	// Constructors
	105	// ------------------------------------------------------------------------
	106
951d134a FC	107	public void testTmfEventRequest() {
951d134a FC	108	TmfEventRequest<TmfEvent> request = new TmfEventRequestStub<TmfEvent>(TmfEvent.class);
d18dd09b	109
2fb2eb37 FC	110	assertEquals("getRequestId", fRequestCount++, request.getRequestId());
	111	assertEquals("getDataType", TmfEvent.class, request.getDataType());
	112
d18dd09b ASL	113	assertEquals("StartTime", TmfTimestamp.BigBang, request.getRange().getStartTime());
	114	assertEquals("EndTime", TmfTimestamp.BigCrunch, request.getRange().getEndTime());
	115
2fb2eb37	116	assertEquals("getIndex", 0, request.getIndex());
d18dd09b ASL	117	assertEquals("getNbRequestedEvents", TmfDataRequest.ALL_DATA, request.getNbRequested());
d18dd09b ASL	118	assertEquals("getBlockize", TmfDataRequest.DEFAULT_BLOCK_SIZE, request.getBlockize());
2fb2eb37 FC	119
	120	assertFalse("isCompleted", request.isCompleted());
	121	assertFalse("isFailed", request.isFailed());
	122	assertFalse("isCancelled", request.isCancelled());
	123
	124	assertEquals("getNbRead", 0, request.getNbRead());
d18dd09b ASL	125	}
d18dd09b ASL	126
951d134a	127	public void testTmfEventRequestTimeRange() {
d18dd09b	128	TmfTimeRange range = new TmfTimeRange(new TmfTimestamp(), TmfTimestamp.BigCrunch);
951d134a	129	TmfEventRequest<TmfEvent> request = new TmfEventRequestStub<TmfEvent>(TmfEvent.class, range);
d18dd09b	130
2fb2eb37 FC	131	assertEquals("getRequestId", fRequestCount++, request.getRequestId());
	132	assertEquals("getDataType", TmfEvent.class, request.getDataType());
	133
	134	assertEquals("StartTime", new TmfTimestamp(), request.getRange().getStartTime());
	135	assertEquals("EndTime", TmfTimestamp.BigCrunch, request.getRange().getEndTime());
d18dd09b	136
2fb2eb37	137	assertEquals("getIndex", 0, request.getIndex());
d18dd09b ASL	138	assertEquals("getNbRequestedEvents", TmfDataRequest.ALL_DATA, request.getNbRequested());
d18dd09b ASL	139	assertEquals("getBlockize", TmfDataRequest.DEFAULT_BLOCK_SIZE, request.getBlockize());
2fb2eb37 FC	140
	141	assertFalse("isCompleted", request.isCompleted());
	142	assertFalse("isFailed", request.isFailed());
	143	assertFalse("isCancelled", request.isCancelled());
	144
	145	assertEquals("getNbRead", 0, request.getNbRead());
d18dd09b ASL	146	}
d18dd09b ASL	147
951d134a	148	public void testTmfEventRequestTimeRangeNbRequested() {
d18dd09b	149	TmfTimeRange range = new TmfTimeRange(new TmfTimestamp(), TmfTimestamp.BigCrunch);
951d134a	150	TmfEventRequest<TmfEvent> request = new TmfEventRequestStub<TmfEvent>(TmfEvent.class, range, 100);
d18dd09b	151
2fb2eb37 FC	152	assertEquals("getRequestId", fRequestCount++, request.getRequestId());
	153	assertEquals("getDataType", TmfEvent.class, request.getDataType());
	154
	155	assertEquals("StartTime", new TmfTimestamp(), request.getRange().getStartTime());
	156	assertEquals("EndTime", TmfTimestamp.BigCrunch, request.getRange().getEndTime());
d18dd09b	157
2fb2eb37	158	assertEquals("getIndex", 0, request.getIndex());
d18dd09b ASL	159	assertEquals("getNbRequestedEvents", 100, request.getNbRequested());
d18dd09b ASL	160	assertEquals("getBlockize", TmfDataRequest.DEFAULT_BLOCK_SIZE, request.getBlockize());
2fb2eb37 FC	161
	162	assertFalse("isCompleted", request.isCompleted());
	163	assertFalse("isFailed", request.isFailed());
	164	assertFalse("isCancelled", request.isCancelled());
	165
	166	assertEquals("getNbRead", 0, request.getNbRead());
d18dd09b ASL	167	}
d18dd09b ASL	168
951d134a	169	public void testTmfEventRequestTimeRangeNbRequestedBlocksize() {
d18dd09b	170	TmfTimeRange range = new TmfTimeRange(new TmfTimestamp(), TmfTimestamp.BigCrunch);
951d134a	171	TmfEventRequest<TmfEvent> request = new TmfEventRequestStub<TmfEvent>(TmfEvent.class, range, 100, 200);
d18dd09b	172
2fb2eb37 FC	173	assertEquals("getRequestId", fRequestCount++, request.getRequestId());
2fb2eb37 FC	174	assertEquals("getDataType", TmfEvent.class, request.getDataType());
d18dd09b	175
2fb2eb37 FC	176	assertEquals("StartTime", new TmfTimestamp(), request.getRange().getStartTime());
	177	assertEquals("EndTime", TmfTimestamp.BigCrunch, request.getRange().getEndTime());
	178
	179	assertEquals("getIndex", 0, request.getIndex());
d18dd09b	180	assertEquals("getNbRequestedEvents", 100, request.getNbRequested());
2fb2eb37 FC	181	assertEquals("getBlockize", 200, request.getBlockize());
	182
	183	assertFalse("isCompleted", request.isCompleted());
	184	assertFalse("isFailed", request.isFailed());
	185	assertFalse("isCancelled", request.isCancelled());
	186
	187	assertEquals("getNbRead", 0, request.getNbRead());
d18dd09b ASL	188	}
d18dd09b ASL	189
951d134a FC	190	// ------------------------------------------------------------------------
	191	// equals
	192	// ------------------------------------------------------------------------
	193
2fb2eb37 FC	194	public void testEqualsReflexivity() throws Exception {
	195	assertTrue("equals", fRequest1.equals(fRequest1));
	196	assertTrue("equals", fRequest2.equals(fRequest2));
	197
	198	assertFalse("equals", fRequest1.equals(fRequest2));
	199	assertFalse("equals", fRequest2.equals(fRequest1));
	200	}
	201
	202	public void testEqualsSymmetry() throws Exception {
	203	assertTrue("equals", fRequest1.equals(fRequest1b));
	204	assertTrue("equals", fRequest1b.equals(fRequest1));
	205
	206	assertFalse("equals", fRequest1.equals(fRequest3));
	207	assertFalse("equals", fRequest2.equals(fRequest3));
	208	assertFalse("equals", fRequest3.equals(fRequest1));
	209	assertFalse("equals", fRequest3.equals(fRequest2));
	210	}
	211
	212	public void testEqualsTransivity() throws Exception {
	213	assertTrue("equals", fRequest1.equals(fRequest1b));
	214	assertTrue("equals", fRequest1b.equals(fRequest1c));
	215	assertTrue("equals", fRequest1.equals(fRequest1c));
	216	}
	217
2fb2eb37 FC	218	public void testEqualsNull() throws Exception {
	219	assertFalse("equals", fRequest1.equals(null));
	220	assertFalse("equals", fRequest2.equals(null));
	221	}
	222
	223	// ------------------------------------------------------------------------
	224	// hashCode
	225	// ------------------------------------------------------------------------
	226
	227	public void testHashCode() throws Exception {
	228	assertTrue("hashCode", fRequest1.hashCode() == fRequest1.hashCode());
	229	assertTrue("hashCode", fRequest2.hashCode() == fRequest2.hashCode());
	230	assertTrue("hashCode", fRequest1.hashCode() != fRequest2.hashCode());
	231	}
	232
	233	// ------------------------------------------------------------------------
	234	// toString
	235	// ------------------------------------------------------------------------
951d134a	236
2fb2eb37 FC	237	public void testToString() {
	238	String expected1 = "[TmfEventRequest(0,TmfEvent," + range1 + ",100,200)]";
	239	String expected2 = "[TmfEventRequest(1,TmfEvent," + range2 + ",100,200)]";
	240	String expected3 = "[TmfEventRequest(2,TmfEvent," + range2 + ",200,200)]";
	241	String expected4 = "[TmfEventRequest(3,TmfEvent," + range2 + ",200,300)]";
	242
	243	assertEquals("toString", expected1, fRequest1.toString());
	244	assertEquals("toString", expected2, fRequest2.toString());
	245	assertEquals("toString", expected3, fRequest3.toString());
	246	assertEquals("toString", expected4, fRequest4.toString());
951d134a FC	247	}
951d134a FC	248
2fb2eb37 FC	249	// ------------------------------------------------------------------------
	250	// setData/getData
	251	// ------------------------------------------------------------------------
	252
	253	public void testSetData() {
	254	// Initialize the data
	255	int nbEvents = 10;
	256	TmfEvent[] events = new TmfEvent[nbEvents];
	257	for (int i = 0; i < nbEvents; i++) {
	258	events[i] = new TmfEvent(new TmfTimestamp(i), new TmfEventSource(),
	259	new TmfEventType(), new TmfEventReference());
	260	}
951d134a	261
2fb2eb37 FC	262	fRequest1.setData(events);
2fb2eb37 FC	263	assertEquals("setData", nbEvents, fRequest1.getNbRead());
951d134a	264
2fb2eb37 FC	265	TmfEvent[] eventsRead = fRequest1.getData();
2fb2eb37 FC	266	assertEquals("getData", nbEvents, eventsRead.length);
951d134a	267
2fb2eb37 FC	268	for (int i = 0; i < nbEvents; i++) {
	269	assertEquals("getData", i, eventsRead[i].getTimestamp().getValue());
	270	}
951d134a FC	271	}
951d134a FC	272
2fb2eb37 FC	273	// ------------------------------------------------------------------------
	274	// done
	275	// ------------------------------------------------------------------------
	276
	277	public void testDone() {
	278
	279	final boolean[] flags = new boolean[4];
	280	TmfEventRequest<TmfEvent> request = setupTestRequest(flags);
	281	request.done();
951d134a	282
2fb2eb37 FC	283	assertTrue ("isCompleted", request.isCompleted());
	284	assertFalse("isFailed", request.isFailed());
	285	assertFalse("isCancelled", request.isCancelled());
951d134a	286
2fb2eb37 FC	287	assertTrue ("handleCompleted", flags[0]);
	288	assertTrue ("handleSuccess", flags[1]);
	289	assertFalse("handleFailure", flags[2]);
	290	assertFalse("handleCancel", flags[3]);
951d134a FC	291	}
951d134a FC	292
2fb2eb37 FC	293	// ------------------------------------------------------------------------
	294	// fail
	295	// ------------------------------------------------------------------------
	296
	297	public void testFail() {
	298
	299	final boolean[] flags = new boolean[4];
	300	TmfEventRequest<TmfEvent> request = setupTestRequest(flags);
	301	request.fail();
	302
	303	assertTrue ("isCompleted", request.isCompleted());
	304	assertTrue ("isFailed", request.isFailed());
	305	assertFalse("isCancelled", request.isCancelled());
	306
	307	assertTrue ("handleCompleted", flags[0]);
	308	assertFalse("handleSuccess", flags[1]);
	309	assertTrue ("handleFailure", flags[2]);
	310	assertFalse("handleCancel", flags[3]);
	311	}
	312
	313	// ------------------------------------------------------------------------
	314	// cancel
	315	// ------------------------------------------------------------------------
	316
	317	public void testCancel() {
	318
	319	final boolean[] flags = new boolean[4];
	320	TmfEventRequest<TmfEvent> request = setupTestRequest(flags);
	321	request.cancel();
	322
	323	assertTrue ("isCompleted", request.isCompleted());
	324	assertFalse("isFailed", request.isFailed());
	325	assertTrue ("isCancelled", request.isCancelled());
	326
	327	assertTrue ("handleCompleted", flags[0]);
	328	assertFalse("handleSuccess", flags[1]);
	329	assertFalse("handleFailure", flags[2]);
	330	assertTrue ("handleCancel", flags[3]);
	331	}
	332
	333	// ------------------------------------------------------------------------
	334	// waitForCompletion
	335	// ------------------------------------------------------------------------
	336
d18dd09b	337	}