[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.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.
 */
@SuppressWarnings("nls")
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());

        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());

        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());

        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());

        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)]";
        String expected2 = "[TmfEventRequest(1,TmfEvent," + range2 + ",100)]";
        String expected3 = "[TmfEventRequest(2,TmfEvent," + range2 + ",200)]";
        String expected4 = "[TmfEventRequest(3,TmfEvent," + range2 + ",200)]";

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

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