[deliverable/tracecompass.git] / org.eclipse.linuxtools.tmf.tests / src / org / eclipse / linuxtools / tmf / tests / request / TmfDataRequestTest.java

/*******************************************************************************
 * Copyright (c) 2009, 2010 Ericsson
 * 
 * All rights reserved. This program and the accompanying materials are
 * made available under the terms of the Eclipse Public License v1.0 which
 * accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 * 
 * Contributors:
 *   Francois Chouinard - Initial API and implementation
 *******************************************************************************/

package org.eclipse.linuxtools.tmf.tests.request;

import junit.framework.TestCase;

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

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

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

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

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

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

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

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

	private TmfDataRequest<TmfEvent> setupTestRequest(final boolean[] flags) {
		
		TmfDataRequest<TmfEvent> request = new TmfDataRequestStub<TmfEvent>(TmfEvent.class, 10, 100, 200) {
		    @Override
			public void handleCompleted() {
		    	super.handleCompleted();
		    	flags[0] = true;
		    }
		    @Override
		    public void handleSuccess() {
		    	super.handleSuccess();
		    	flags[1] = true;
		    }
		    @Override
		    public void handleFailure() {
		    	super.handleFailure();
		    	flags[2] = true;
		    }
		    @Override
		    public void handleCancel() {
		    	super.handleCancel();
		    	flags[3] = true;
		    }
		};
		return request;
	}
	
	// ------------------------------------------------------------------------
	// Constructors
	// ------------------------------------------------------------------------

	public void testTmfDataRequest() {
        TmfDataRequest<TmfEvent> request = new TmfDataRequestStub<TmfEvent>(TmfEvent.class);

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

        assertEquals("getIndex", 0, request.getIndex());
        assertEquals("getNbRequestedEvents", TmfDataRequest.ALL_DATA, request.getNbRequested());

        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() throws Exception {
        assertTrue("equals", fRequest1.equals(fRequest1));
        assertTrue("equals", fRequest2.equals(fRequest2));

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

	public void testEqualsSymmetry() throws Exception {
        assertTrue("equals", fRequest1.equals(fRequest1b));
        assertTrue("equals", fRequest1b.equals(fRequest1));

        assertFalse("equals", fRequest1.equals(fRequest3));
        assertFalse("equals", fRequest2.equals(fRequest3));
        assertFalse("equals", fRequest3.equals(fRequest1));
        assertFalse("equals", fRequest3.equals(fRequest2));
	}
	
	public void testEqualsTransivity() throws Exception {
        assertTrue("equals", fRequest1.equals(fRequest1b));
        assertTrue("equals", fRequest1b.equals(fRequest1c));
        assertTrue("equals", fRequest1.equals(fRequest1c));
	}
	
	public void testEqualsNull() throws Exception {
        assertFalse("equals", fRequest1.equals(null));
        assertFalse("equals", fRequest2.equals(null));
	}

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

	public void testHashCode() throws Exception {
        assertTrue("hashCode", fRequest1.hashCode() == fRequest1.hashCode());
        assertTrue("hashCode", fRequest2.hashCode() == fRequest2.hashCode());
		assertTrue("hashCode", fRequest1.hashCode() != fRequest2.hashCode());
	}
	
	// ------------------------------------------------------------------------
	// toString
	// ------------------------------------------------------------------------

	public void testToString() {
        String expected1 = "[TmfDataRequest(0,TmfEvent,10,100)]";
        String expected2 = "[TmfDataRequest(1,TmfEvent,20,100)]";
        String expected3 = "[TmfDataRequest(2,TmfEvent,20,200)]";
        String expected4 = "[TmfDataRequest(3,TmfEvent,20,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];
		TmfDataRequest<TmfEvent> request = setupTestRequest(flags);
		request.done();

		assertTrue ("isCompleted", request.isCompleted());
		assertFalse("isFailed",    request.isFailed());
		assertFalse("isCancelled", request.isCancelled());

		assertTrue ("handleCompleted", flags[0]);
		assertTrue ("handleSuccess",   flags[1]);
		assertFalse("handleFailure",   flags[2]);
		assertFalse("handleCancel",    flags[3]);
	}

	// ------------------------------------------------------------------------
	// fail
	// ------------------------------------------------------------------------

	public void testFail() {
		
		final boolean[] flags = new boolean[4];
		TmfDataRequest<TmfEvent> request = setupTestRequest(flags);
		request.fail();

		assertTrue ("isCompleted", request.isCompleted());
		assertTrue ("isFailed",    request.isFailed());
		assertFalse("isCancelled", request.isCancelled());

		assertTrue ("handleCompleted", flags[0]);
		assertFalse("handleSuccess",   flags[1]);
		assertTrue ("handleFailure",   flags[2]);
		assertFalse("handleCancel",    flags[3]);
	}

	// ------------------------------------------------------------------------
	// cancel
	// ------------------------------------------------------------------------

	public void testCancel() {

		final boolean[] flags = new boolean[4];
		TmfDataRequest<TmfEvent> request = setupTestRequest(flags);
		request.cancel();

		assertTrue ("isCompleted", request.isCompleted());
		assertFalse("isFailed",    request.isFailed());
		assertTrue ("isCancelled", request.isCancelled());

		assertTrue ("handleCompleted", flags[0]);
		assertFalse("handleSuccess",   flags[1]);
		assertFalse("handleFailure",   flags[2]);
		assertTrue ("handleCancel",    flags[3]);
	}

	// ------------------------------------------------------------------------
	// waitForCompletion
	// ------------------------------------------------------------------------

}
Commit	Line	Data
d18dd09b	1	/*******************************************************************************
e31e01e8	2	* Copyright (c) 2009, 2010 Ericsson
d18dd09b ASL	3	*
	4	* All rights reserved. This program and the accompanying materials are
	5	* made available under the terms of the Eclipse Public License v1.0 which
	6	* accompanies this distribution, and is available at
	7	* http://www.eclipse.org/legal/epl-v10.html
	8	*
	9	* Contributors:
	10	* Francois Chouinard - Initial API and implementation
	11	*******************************************************************************/
	12
	13	package org.eclipse.linuxtools.tmf.tests.request;
	14
	15	import junit.framework.TestCase;
	16
	17	import org.eclipse.linuxtools.tmf.event.TmfEvent;
d18dd09b	18	import org.eclipse.linuxtools.tmf.request.TmfDataRequest;
951d134a	19	import org.eclipse.linuxtools.tmf.request.TmfDataRequestStub;
d18dd09b ASL	20
	21	/**
	22	* <b><u>TmfDataRequestTest</u></b>
	23	* <p>
2fb2eb37	24	* Test suite for the TmfDataRequest class.
d18dd09b ASL	25	*/
	26	public class TmfDataRequestTest extends TestCase {
	27
e31e01e8	28	// ------------------------------------------------------------------------
2fb2eb37 FC	29	// Variables
	30	// ------------------------------------------------------------------------
	31
	32	private static TmfDataRequest<TmfEvent> fRequest1;
	33	private static TmfDataRequest<TmfEvent> fRequest1b;
	34	private static TmfDataRequest<TmfEvent> fRequest1c;
	35	private static TmfDataRequest<TmfEvent> fRequest2;
	36	private static TmfDataRequest<TmfEvent> fRequest3;
	37	private static TmfDataRequest<TmfEvent> fRequest4;
	38
	39	private static int fRequestCount;
	40
	41	// ------------------------------------------------------------------------
d18dd09b	42	// Housekeeping
e31e01e8	43	// ------------------------------------------------------------------------
d18dd09b ASL	44
	45	public TmfDataRequestTest(String name) {
	46	super(name);
	47	}
	48
	49	@Override
	50	protected void setUp() throws Exception {
	51	super.setUp();
2fb2eb37 FC	52	TmfDataRequest.reset();
	53	fRequest1 = new TmfDataRequestStub<TmfEvent>(TmfEvent.class, 10, 100, 200);
	54	fRequest2 = new TmfDataRequestStub<TmfEvent>(TmfEvent.class, 20, 100, 200);
	55	fRequest3 = new TmfDataRequestStub<TmfEvent>(TmfEvent.class, 20, 200, 200);
	56	fRequest4 = new TmfDataRequestStub<TmfEvent>(TmfEvent.class, 20, 200, 300);
	57	fRequest1b = new TmfDataRequestStub<TmfEvent>(TmfEvent.class, 10, 100, 200);
	58	fRequest1c = new TmfDataRequestStub<TmfEvent>(TmfEvent.class, 10, 100, 200);
	59	fRequestCount = fRequest1c.getRequestId() + 1;
d18dd09b ASL	60	}
	61
	62	@Override
	63	protected void tearDown() throws Exception {
	64	super.tearDown();
	65	}
	66
2fb2eb37 FC	67	private TmfDataRequest<TmfEvent> setupTestRequest(final boolean[] flags) {
	68
	69	TmfDataRequest<TmfEvent> request = new TmfDataRequestStub<TmfEvent>(TmfEvent.class, 10, 100, 200) {
	70	@Override
	71	public void handleCompleted() {
	72	super.handleCompleted();
	73	flags[0] = true;
	74	}
	75	@Override
	76	public void handleSuccess() {
	77	super.handleSuccess();
	78	flags[1] = true;
	79	}
	80	@Override
	81	public void handleFailure() {
	82	super.handleFailure();
	83	flags[2] = true;
	84	}
	85	@Override
	86	public void handleCancel() {
	87	super.handleCancel();
	88	flags[3] = true;
	89	}
	90	};
	91	return request;
	92	}
	93
e31e01e8	94	// ------------------------------------------------------------------------
d18dd09b	95	// Constructors
e31e01e8	96	// ------------------------------------------------------------------------
d18dd09b	97
e31e01e8	98	public void testTmfDataRequest() {
951d134a	99	TmfDataRequest<TmfEvent> request = new TmfDataRequestStub<TmfEvent>(TmfEvent.class);
d18dd09b	100
2fb2eb37 FC	101	assertEquals("getRequestId", fRequestCount++, request.getRequestId());
	102	assertEquals("getDataType", TmfEvent.class, request.getDataType());
	103
	104	assertEquals("getIndex", 0, request.getIndex());
e31e01e8	105	assertEquals("getNbRequestedEvents", TmfDataRequest.ALL_DATA, request.getNbRequested());
2fb2eb37 FC	106
	107	assertFalse("isCompleted", request.isCompleted());
	108	assertFalse("isFailed", request.isFailed());
	109	assertFalse("isCancelled", request.isCancelled());
	110
	111	assertEquals("getNbRead", 0, request.getNbRead());
d18dd09b ASL	112	}
d18dd09b ASL	113
e31e01e8	114	public void testTmfDataRequestIndex() {
951d134a	115	TmfDataRequest<TmfEvent> request = new TmfDataRequestStub<TmfEvent>(TmfEvent.class, 10);
d18dd09b	116
2fb2eb37 FC	117	assertEquals("getRequestId", fRequestCount++, request.getRequestId());
	118	assertEquals("getDataType", TmfEvent.class, request.getDataType());
	119
	120	assertEquals("getIndex", 10, request.getIndex());
e31e01e8	121	assertEquals("getNbRequestedEvents", TmfDataRequest.ALL_DATA, request.getNbRequested());
2fb2eb37 FC	122
	123	assertFalse("isCompleted", request.isCompleted());
	124	assertFalse("isFailed", request.isFailed());
	125	assertFalse("isCancelled", request.isCancelled());
	126
	127	assertEquals("getNbRead", 0, request.getNbRead());
d18dd09b ASL	128	}
d18dd09b ASL	129
e31e01e8	130	public void testTmfDataRequestIndexNbRequested() {
951d134a	131	TmfDataRequest<TmfEvent> request = new TmfDataRequestStub<TmfEvent>(TmfEvent.class, 10, 100);
d18dd09b	132
2fb2eb37 FC	133	assertEquals("getRequestId", fRequestCount++, request.getRequestId());
	134	assertEquals("getDataType", TmfEvent.class, request.getDataType());
	135
	136	assertEquals("getIndex", 10, request.getIndex());
e31e01e8	137	assertEquals("getNbRequestedEvents", 100, request.getNbRequested());
2fb2eb37 FC	138
	139	assertFalse("isCompleted", request.isCompleted());
	140	assertFalse("isFailed", request.isFailed());
	141	assertFalse("isCancelled", request.isCancelled());
	142
	143	assertEquals("getNbRead", 0, request.getNbRead());
d18dd09b ASL	144	}
d18dd09b ASL	145
e31e01e8	146	public void testTmfDataRequestIndexNbEventsBlocksize() {
951d134a	147	TmfDataRequest<TmfEvent> request = new TmfDataRequestStub<TmfEvent>(TmfEvent.class, 10, 100, 200);
d18dd09b	148
2fb2eb37 FC	149	assertEquals("getRequestId", fRequestCount++, request.getRequestId());
	150	assertEquals("getDataType", TmfEvent.class, request.getDataType());
	151
	152	assertEquals("getIndex", 10, request.getIndex());
e31e01e8	153	assertEquals("getNbRequestedEvents", 100, request.getNbRequested());
2fb2eb37 FC	154
	155	assertFalse("isCompleted", request.isCompleted());
	156	assertFalse("isFailed", request.isFailed());
	157	assertFalse("isCancelled", request.isCancelled());
	158
	159	assertEquals("getNbRead", 0, request.getNbRead());
d18dd09b ASL	160	}
d18dd09b ASL	161
951d134a FC	162	// ------------------------------------------------------------------------
	163	// equals
	164	// ------------------------------------------------------------------------
	165
2fb2eb37 FC	166	public void testEqualsReflexivity() throws Exception {
	167	assertTrue("equals", fRequest1.equals(fRequest1));
	168	assertTrue("equals", fRequest2.equals(fRequest2));
	169
	170	assertFalse("equals", fRequest1.equals(fRequest2));
	171	assertFalse("equals", fRequest2.equals(fRequest1));
	172	}
	173
	174	public void testEqualsSymmetry() throws Exception {
	175	assertTrue("equals", fRequest1.equals(fRequest1b));
	176	assertTrue("equals", fRequest1b.equals(fRequest1));
	177
	178	assertFalse("equals", fRequest1.equals(fRequest3));
	179	assertFalse("equals", fRequest2.equals(fRequest3));
	180	assertFalse("equals", fRequest3.equals(fRequest1));
	181	assertFalse("equals", fRequest3.equals(fRequest2));
	182	}
	183
	184	public void testEqualsTransivity() throws Exception {
	185	assertTrue("equals", fRequest1.equals(fRequest1b));
	186	assertTrue("equals", fRequest1b.equals(fRequest1c));
	187	assertTrue("equals", fRequest1.equals(fRequest1c));
	188	}
	189
2fb2eb37 FC	190	public void testEqualsNull() throws Exception {
	191	assertFalse("equals", fRequest1.equals(null));
	192	assertFalse("equals", fRequest2.equals(null));
	193	}
	194
	195	// ------------------------------------------------------------------------
	196	// hashCode
	197	// ------------------------------------------------------------------------
	198
	199	public void testHashCode() throws Exception {
	200	assertTrue("hashCode", fRequest1.hashCode() == fRequest1.hashCode());
	201	assertTrue("hashCode", fRequest2.hashCode() == fRequest2.hashCode());
	202	assertTrue("hashCode", fRequest1.hashCode() != fRequest2.hashCode());
	203	}
	204
	205	// ------------------------------------------------------------------------
	206	// toString
	207	// ------------------------------------------------------------------------
	208
	209	public void testToString() {
f9673903 FC	210	String expected1 = "[TmfDataRequest(0,TmfEvent,10,100)]";
	211	String expected2 = "[TmfDataRequest(1,TmfEvent,20,100)]";
	212	String expected3 = "[TmfDataRequest(2,TmfEvent,20,200)]";
	213	String expected4 = "[TmfDataRequest(3,TmfEvent,20,200)]";
2fb2eb37 FC	214
	215	assertEquals("toString", expected1, fRequest1.toString());
	216	assertEquals("toString", expected2, fRequest2.toString());
	217	assertEquals("toString", expected3, fRequest3.toString());
	218	assertEquals("toString", expected4, fRequest4.toString());
	219	}
	220
2fb2eb37 FC	221	// ------------------------------------------------------------------------
	222	// done
	223	// ------------------------------------------------------------------------
	224
	225	public void testDone() {
	226
	227	final boolean[] flags = new boolean[4];
	228	TmfDataRequest<TmfEvent> request = setupTestRequest(flags);
	229	request.done();
	230
	231	assertTrue ("isCompleted", request.isCompleted());
	232	assertFalse("isFailed", request.isFailed());
	233	assertFalse("isCancelled", request.isCancelled());
951d134a	234
2fb2eb37 FC	235	assertTrue ("handleCompleted", flags[0]);
	236	assertTrue ("handleSuccess", flags[1]);
	237	assertFalse("handleFailure", flags[2]);
	238	assertFalse("handleCancel", flags[3]);
951d134a FC	239	}
951d134a FC	240
2fb2eb37 FC	241	// ------------------------------------------------------------------------
	242	// fail
	243	// ------------------------------------------------------------------------
951d134a	244
2fb2eb37 FC	245	public void testFail() {
	246
	247	final boolean[] flags = new boolean[4];
	248	TmfDataRequest<TmfEvent> request = setupTestRequest(flags);
	249	request.fail();
951d134a	250
2fb2eb37 FC	251	assertTrue ("isCompleted", request.isCompleted());
	252	assertTrue ("isFailed", request.isFailed());
	253	assertFalse("isCancelled", request.isCancelled());
	254
	255	assertTrue ("handleCompleted", flags[0]);
	256	assertFalse("handleSuccess", flags[1]);
	257	assertTrue ("handleFailure", flags[2]);
	258	assertFalse("handleCancel", flags[3]);
951d134a FC	259	}
951d134a FC	260
2fb2eb37 FC	261	// ------------------------------------------------------------------------
	262	// cancel
	263	// ------------------------------------------------------------------------
	264
	265	public void testCancel() {
	266
	267	final boolean[] flags = new boolean[4];
	268	TmfDataRequest<TmfEvent> request = setupTestRequest(flags);
	269	request.cancel();
	270
	271	assertTrue ("isCompleted", request.isCompleted());
	272	assertFalse("isFailed", request.isFailed());
	273	assertTrue ("isCancelled", request.isCancelled());
951d134a	274
2fb2eb37 FC	275	assertTrue ("handleCompleted", flags[0]);
	276	assertFalse("handleSuccess", flags[1]);
	277	assertFalse("handleFailure", flags[2]);
	278	assertTrue ("handleCancel", flags[3]);
951d134a FC	279	}
951d134a FC	280
2fb2eb37 FC	281	// ------------------------------------------------------------------------
	282	// waitForCompletion
	283	// ------------------------------------------------------------------------
	284
e31e01e8	285	}