[deliverable/tracecompass.git] / org.eclipse.linuxtools.tmf.tests / src / org / eclipse / linuxtools / tmf / tests / request / TmfDataRequestTest.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.TmfTimestamp;
import org.eclipse.linuxtools.tmf.request.TmfDataRequest;
import org.eclipse.linuxtools.tmf.request.TmfDataRequestStub;

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

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

	private static TmfDataRequest<TmfEvent> fRequest1;
	private static TmfDataRequest<TmfEvent> fRequest1b;
	private static TmfDataRequest<TmfEvent> fRequest1c;
	private static TmfDataRequest<TmfEvent> fRequest2;
	private static TmfDataRequest<TmfEvent> fRequest3;
	private static TmfDataRequest<TmfEvent> fRequest4;

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

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

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

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

	private TmfDataRequest<TmfEvent> setupTestRequest(final boolean[] flags) {
		
		TmfDataRequest<TmfEvent> request = new TmfDataRequestStub<TmfEvent>(TmfEvent.class, 10, 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 testTmfDataRequest() {
        TmfDataRequest<TmfEvent> request = new TmfDataRequestStub<TmfEvent>(TmfEvent.class);

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

        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 testTmfDataRequestIndex() {
        TmfDataRequest<TmfEvent> request = new TmfDataRequestStub<TmfEvent>(TmfEvent.class, 10);

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

        assertEquals("getIndex", 10, 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 testTmfDataRequestIndexNbRequested() {
        TmfDataRequest<TmfEvent> request = new TmfDataRequestStub<TmfEvent>(TmfEvent.class, 10, 100);

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

        assertEquals("getIndex", 10, 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 testTmfDataRequestIndexNbEventsBlocksize() {
        TmfDataRequest<TmfEvent> request = new TmfDataRequestStub<TmfEvent>(TmfEvent.class, 10, 100, 200);

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

        assertEquals("getIndex", 10, 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 = "[TmfDataRequest(0,TmfEvent,10,100,200)]";
        String expected2 = "[TmfDataRequest(1,TmfEvent,20,100,200)]";
        String expected3 = "[TmfDataRequest(2,TmfEvent,20,200,200)]";
        String expected4 = "[TmfDataRequest(3,TmfEvent,20,200,300)]";

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