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

import junit.framework.TestCase;

import org.eclipse.linuxtools.tmf.core.event.ITmfEvent;
import org.eclipse.linuxtools.tmf.core.event.TmfTimeRange;
import org.eclipse.linuxtools.tmf.core.event.TmfTimestamp;
import org.eclipse.linuxtools.tmf.core.request.TmfDataRequest;
import org.eclipse.linuxtools.tmf.core.request.TmfEventRequest;
import org.eclipse.linuxtools.tmf.tests.stubs.request.TmfEventRequestStub;

/**
 * <b><u>TmfEventRequestTest</u></b>
 * <p>
 * Test suite for the TmfEventRequest class.
 */
@SuppressWarnings({"nls","javadoc"})
public class TmfEventRequestTest extends TestCase {

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

	private static TmfTimeRange range1 = new TmfTimeRange(TmfTimeRange.ETERNITY);
	private static TmfTimeRange range2 = new TmfTimeRange(new TmfTimestamp(), TmfTimestamp.BIG_CRUNCH);

	private static TmfEventRequest fRequest1;
	private static TmfEventRequest fRequest1b;
	private static TmfEventRequest fRequest1c;
	private static TmfEventRequest fRequest2;
	private static TmfEventRequest fRequest3;
	private static TmfEventRequest fRequest4;

	private static int fRequestCount;

	// ------------------------------------------------------------------------
	// Housekeeping
	// ------------------------------------------------------------------------

    /**
     * @param name the test name
     */
    public TmfEventRequestTest(final String name) {
		super(name);
	}

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

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

	private static TmfEventRequest setupTestRequest(final boolean[] flags) {

		TmfEventRequest request = new TmfEventRequestStub(ITmfEvent.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 request = new TmfEventRequestStub(ITmfEvent.class);

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

        assertEquals("StartTime", TmfTimestamp.BIG_BANG,   request.getRange().getStartTime());
        assertEquals("EndTime",   TmfTimestamp.BIG_CRUNCH, 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.BIG_CRUNCH);
        TmfEventRequest request = new TmfEventRequestStub(ITmfEvent.class, range);

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

        assertEquals("StartTime", new TmfTimestamp(), request.getRange().getStartTime());
        assertEquals("EndTime",   TmfTimestamp.BIG_CRUNCH, 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.BIG_CRUNCH);
        TmfEventRequest request = new TmfEventRequestStub(ITmfEvent.class, range, 100);

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

        assertEquals("StartTime", new TmfTimestamp(), request.getRange().getStartTime());
        assertEquals("EndTime",   TmfTimestamp.BIG_CRUNCH, 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.BIG_CRUNCH);
        TmfEventRequest request = new TmfEventRequestStub(ITmfEvent.class, range, 100, 200);

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

        assertEquals("StartTime", new TmfTimestamp(), request.getRange().getStartTime());
        assertEquals("EndTime",   TmfTimestamp.BIG_CRUNCH, 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() {
        assertTrue("equals", fRequest1.equals(fRequest1));
        assertTrue("equals", fRequest2.equals(fRequest2));

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

	public void testEqualsSymmetry() {
        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() {
        assertTrue("equals", fRequest1.equals(fRequest1b));
        assertTrue("equals", fRequest1b.equals(fRequest1c));
        assertTrue("equals", fRequest1.equals(fRequest1c));
	}

	public void testEqualsNull() {
        assertFalse("equals", fRequest1.equals(null));
        assertFalse("equals", fRequest2.equals(null));
	}

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

	public void testHashCode() {
        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,ITmfEvent," + range1 + ",0,100,200)]";
        String expected2 = "[TmfEventRequest(1,ITmfEvent," + range2 + ",0,100,200)]";
        String expected3 = "[TmfEventRequest(2,ITmfEvent," + range2 + ",0,200,200)]";
        String expected4 = "[TmfEventRequest(3,ITmfEvent," + range2 + ",0,200,300)]";

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