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

import junit.framework.TestCase;

import org.eclipse.linuxtools.tmf.core.event.TmfEvent;
import org.eclipse.linuxtools.tmf.core.request.TmfDataRequest;
import org.eclipse.linuxtools.tmf.tests.stubs.request.TmfDataRequestStub;

/**
 * <b><u>TmfDataRequestTest</u></b>
 * <p>
 * Test suite for the TmfDataRequest class.
 */
@SuppressWarnings({"nls","javadoc"})
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
	// ------------------------------------------------------------------------

    /**
     * @param name the test name
     */
	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 static 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());

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

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

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

        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 = "[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());
	}

	// ------------------------------------------------------------------------
	// 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
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
6c13869b FC	17	import org.eclipse.linuxtools.tmf.core.event.TmfEvent;
6c13869b FC	18	import org.eclipse.linuxtools.tmf.core.request.TmfDataRequest;
4918b8f2	19	import org.eclipse.linuxtools.tmf.tests.stubs.request.TmfDataRequestStub;
d18dd09b ASL	20
	21	/**
	22	* <b><u>TmfDataRequestTest</u></b>
	23	* <p>
2fb2eb37	24	* Test suite for the TmfDataRequest class.
d18dd09b	25	*/
54a7a54c	26	@SuppressWarnings({"nls","javadoc"})
d18dd09b ASL	27	public class TmfDataRequestTest extends TestCase {
d18dd09b ASL	28
e31e01e8	29	// ------------------------------------------------------------------------
2fb2eb37 FC	30	// Variables
	31	// ------------------------------------------------------------------------
	32
	33	private static TmfDataRequest<TmfEvent> fRequest1;
	34	private static TmfDataRequest<TmfEvent> fRequest1b;
	35	private static TmfDataRequest<TmfEvent> fRequest1c;
	36	private static TmfDataRequest<TmfEvent> fRequest2;
	37	private static TmfDataRequest<TmfEvent> fRequest3;
	38	private static TmfDataRequest<TmfEvent> fRequest4;
	39
	40	private static int fRequestCount;
9b749023	41
2fb2eb37	42	// ------------------------------------------------------------------------
d18dd09b	43	// Housekeeping
e31e01e8	44	// ------------------------------------------------------------------------
d18dd09b	45
54a7a54c FC	46	/**
	47	* @param name the test name
	48	*/
d18dd09b ASL	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
9b749023 AM	71	private static TmfDataRequest<TmfEvent> setupTestRequest(final boolean[] flags) {
9b749023 AM	72
2fb2eb37 FC	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	}
9b749023	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());
2fb2eb37 FC	110
	111	assertFalse("isCompleted", request.isCompleted());
	112	assertFalse("isFailed", request.isFailed());
	113	assertFalse("isCancelled", request.isCancelled());
	114
	115	assertEquals("getNbRead", 0, request.getNbRead());
d18dd09b ASL	116	}
d18dd09b ASL	117
e31e01e8	118	public void testTmfDataRequestIndex() {
951d134a	119	TmfDataRequest<TmfEvent> request = new TmfDataRequestStub<TmfEvent>(TmfEvent.class, 10);
d18dd09b	120
2fb2eb37 FC	121	assertEquals("getRequestId", fRequestCount++, request.getRequestId());
	122	assertEquals("getDataType", TmfEvent.class, request.getDataType());
	123
	124	assertEquals("getIndex", 10, request.getIndex());
e31e01e8	125	assertEquals("getNbRequestedEvents", TmfDataRequest.ALL_DATA, request.getNbRequested());
2fb2eb37 FC	126
	127	assertFalse("isCompleted", request.isCompleted());
	128	assertFalse("isFailed", request.isFailed());
	129	assertFalse("isCancelled", request.isCancelled());
	130
	131	assertEquals("getNbRead", 0, request.getNbRead());
d18dd09b ASL	132	}
d18dd09b ASL	133
e31e01e8	134	public void testTmfDataRequestIndexNbRequested() {
951d134a	135	TmfDataRequest<TmfEvent> request = new TmfDataRequestStub<TmfEvent>(TmfEvent.class, 10, 100);
d18dd09b	136
2fb2eb37 FC	137	assertEquals("getRequestId", fRequestCount++, request.getRequestId());
	138	assertEquals("getDataType", TmfEvent.class, request.getDataType());
	139
	140	assertEquals("getIndex", 10, request.getIndex());
e31e01e8	141	assertEquals("getNbRequestedEvents", 100, request.getNbRequested());
2fb2eb37 FC	142
	143	assertFalse("isCompleted", request.isCompleted());
	144	assertFalse("isFailed", request.isFailed());
	145	assertFalse("isCancelled", request.isCancelled());
	146
	147	assertEquals("getNbRead", 0, request.getNbRead());
d18dd09b ASL	148	}
d18dd09b ASL	149
e31e01e8	150	public void testTmfDataRequestIndexNbEventsBlocksize() {
951d134a	151	TmfDataRequest<TmfEvent> request = new TmfDataRequestStub<TmfEvent>(TmfEvent.class, 10, 100, 200);
d18dd09b	152
2fb2eb37 FC	153	assertEquals("getRequestId", fRequestCount++, request.getRequestId());
	154	assertEquals("getDataType", TmfEvent.class, request.getDataType());
	155
	156	assertEquals("getIndex", 10, request.getIndex());
e31e01e8	157	assertEquals("getNbRequestedEvents", 100, request.getNbRequested());
2fb2eb37 FC	158
	159	assertFalse("isCompleted", request.isCompleted());
	160	assertFalse("isFailed", request.isFailed());
	161	assertFalse("isCancelled", request.isCancelled());
	162
	163	assertEquals("getNbRead", 0, request.getNbRead());
d18dd09b ASL	164	}
d18dd09b ASL	165
951d134a FC	166	// ------------------------------------------------------------------------
	167	// equals
	168	// ------------------------------------------------------------------------
	169
54a7a54c	170	public void testEqualsReflexivity() {
2fb2eb37 FC	171	assertTrue("equals", fRequest1.equals(fRequest1));
	172	assertTrue("equals", fRequest2.equals(fRequest2));
	173
	174	assertFalse("equals", fRequest1.equals(fRequest2));
	175	assertFalse("equals", fRequest2.equals(fRequest1));
	176	}
	177
54a7a54c	178	public void testEqualsSymmetry() {
2fb2eb37 FC	179	assertTrue("equals", fRequest1.equals(fRequest1b));
	180	assertTrue("equals", fRequest1b.equals(fRequest1));
	181
	182	assertFalse("equals", fRequest1.equals(fRequest3));
	183	assertFalse("equals", fRequest2.equals(fRequest3));
	184	assertFalse("equals", fRequest3.equals(fRequest1));
	185	assertFalse("equals", fRequest3.equals(fRequest2));
	186	}
9b749023	187
54a7a54c	188	public void testEqualsTransivity() {
2fb2eb37 FC	189	assertTrue("equals", fRequest1.equals(fRequest1b));
	190	assertTrue("equals", fRequest1b.equals(fRequest1c));
	191	assertTrue("equals", fRequest1.equals(fRequest1c));
	192	}
9b749023	193
54a7a54c	194	public void testEqualsNull() {
2fb2eb37 FC	195	assertFalse("equals", fRequest1.equals(null));
	196	assertFalse("equals", fRequest2.equals(null));
	197	}
	198
	199	// ------------------------------------------------------------------------
	200	// hashCode
	201	// ------------------------------------------------------------------------
	202
54a7a54c	203	public void testHashCode() {
2fb2eb37 FC	204	assertTrue("hashCode", fRequest1.hashCode() == fRequest1.hashCode());
	205	assertTrue("hashCode", fRequest2.hashCode() == fRequest2.hashCode());
	206	assertTrue("hashCode", fRequest1.hashCode() != fRequest2.hashCode());
	207	}
9b749023	208
2fb2eb37 FC	209	// ------------------------------------------------------------------------
	210	// toString
	211	// ------------------------------------------------------------------------
	212
	213	public void testToString() {
8016d660 FC	214	String expected1 = "[TmfDataRequest(0,TmfEvent,10,100,200)]";
	215	String expected2 = "[TmfDataRequest(1,TmfEvent,20,100,200)]";
	216	String expected3 = "[TmfDataRequest(2,TmfEvent,20,200,200)]";
	217	String expected4 = "[TmfDataRequest(3,TmfEvent,20,200,300)]";
2fb2eb37 FC	218
	219	assertEquals("toString", expected1, fRequest1.toString());
	220	assertEquals("toString", expected2, fRequest2.toString());
	221	assertEquals("toString", expected3, fRequest3.toString());
	222	assertEquals("toString", expected4, fRequest4.toString());
	223	}
	224
2fb2eb37 FC	225	// ------------------------------------------------------------------------
	226	// done
	227	// ------------------------------------------------------------------------
	228
	229	public void testDone() {
9b749023	230
2fb2eb37 FC	231	final boolean[] flags = new boolean[4];
	232	TmfDataRequest<TmfEvent> request = setupTestRequest(flags);
	233	request.done();
	234
	235	assertTrue ("isCompleted", request.isCompleted());
	236	assertFalse("isFailed", request.isFailed());
	237	assertFalse("isCancelled", request.isCancelled());
951d134a	238
2fb2eb37 FC	239	assertTrue ("handleCompleted", flags[0]);
	240	assertTrue ("handleSuccess", flags[1]);
	241	assertFalse("handleFailure", flags[2]);
	242	assertFalse("handleCancel", flags[3]);
951d134a FC	243	}
951d134a FC	244
2fb2eb37 FC	245	// ------------------------------------------------------------------------
	246	// fail
	247	// ------------------------------------------------------------------------
951d134a	248
2fb2eb37	249	public void testFail() {
9b749023	250
2fb2eb37 FC	251	final boolean[] flags = new boolean[4];
	252	TmfDataRequest<TmfEvent> request = setupTestRequest(flags);
	253	request.fail();
951d134a	254
2fb2eb37 FC	255	assertTrue ("isCompleted", request.isCompleted());
	256	assertTrue ("isFailed", request.isFailed());
	257	assertFalse("isCancelled", request.isCancelled());
	258
	259	assertTrue ("handleCompleted", flags[0]);
	260	assertFalse("handleSuccess", flags[1]);
	261	assertTrue ("handleFailure", flags[2]);
	262	assertFalse("handleCancel", flags[3]);
951d134a FC	263	}
951d134a FC	264
2fb2eb37 FC	265	// ------------------------------------------------------------------------
	266	// cancel
	267	// ------------------------------------------------------------------------
	268
	269	public void testCancel() {
	270
	271	final boolean[] flags = new boolean[4];
	272	TmfDataRequest<TmfEvent> request = setupTestRequest(flags);
	273	request.cancel();
	274
	275	assertTrue ("isCompleted", request.isCompleted());
	276	assertFalse("isFailed", request.isFailed());
	277	assertTrue ("isCancelled", request.isCancelled());
951d134a	278
2fb2eb37 FC	279	assertTrue ("handleCompleted", flags[0]);
	280	assertFalse("handleSuccess", flags[1]);
	281	assertFalse("handleFailure", flags[2]);
	282	assertTrue ("handleCancel", flags[3]);
951d134a FC	283	}
951d134a FC	284
2fb2eb37 FC	285	// ------------------------------------------------------------------------
	286	// waitForCompletion
	287	// ------------------------------------------------------------------------
	288
9b749023	289	}