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