[deliverable/tracecompass.git] / org.eclipse.linuxtools.tmf.tests / src / org / eclipse / linuxtools / tmf / tests / request / TmfCoalescedDataRequestTest.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.TmfCoalescedDataRequest;
import org.eclipse.linuxtools.tmf.request.TmfDataRequest;
import org.eclipse.linuxtools.tmf.request.TmfDataRequestStub;

/**
 * <b><u>TmfCoalescedDataRequestTest</u></b>
 * <p>
 * Test suite for the TmfCoalescedDataRequest class.
 */
@SuppressWarnings("nls")
public class TmfCoalescedDataRequestTest extends TestCase {

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

	private static TmfCoalescedDataRequest<TmfEvent> fRequest1;
	private static TmfCoalescedDataRequest<TmfEvent> fRequest2;
	private static TmfCoalescedDataRequest<TmfEvent> fRequest3;
	private static TmfCoalescedDataRequest<TmfEvent> fRequest4;

	private static TmfCoalescedDataRequest<TmfEvent> fRequest1b;
	private static TmfCoalescedDataRequest<TmfEvent> fRequest1c;

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

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

	@Override
	public void setUp() throws Exception {
		super.setUp();
		TmfDataRequest.reset();
		fRequest1  = new TmfCoalescedDataRequest<TmfEvent>(TmfEvent.class, 10, 100, 200);
		fRequest2  = new TmfCoalescedDataRequest<TmfEvent>(TmfEvent.class, 20, 100, 200);
		fRequest3  = new TmfCoalescedDataRequest<TmfEvent>(TmfEvent.class, 20, 200, 200);
		fRequest4  = new TmfCoalescedDataRequest<TmfEvent>(TmfEvent.class, 20, 200, 300);

		fRequest1b = new TmfCoalescedDataRequest<TmfEvent>(TmfEvent.class, 10, 100, 200);
		fRequest1c = new TmfCoalescedDataRequest<TmfEvent>(TmfEvent.class, 10, 100, 200);

		fRequestCount = fRequest1c.getRequestId() + 1;
	}

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

	private TmfCoalescedDataRequest<TmfEvent> setupTestRequest(final boolean[] flags) {
		
		TmfCoalescedDataRequest<TmfEvent> request = new TmfCoalescedDataRequest<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 testTmfCoalescedDataRequest() {
		TmfCoalescedDataRequest<TmfEvent> request = new TmfCoalescedDataRequest<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 testTmfCoalescedDataRequestIndex() {
		TmfCoalescedDataRequest<TmfEvent> request = new TmfCoalescedDataRequest<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 testTmfCoalescedDataRequestIndexNbRequested() {
		TmfCoalescedDataRequest<TmfEvent> request = new TmfCoalescedDataRequest<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 testTmfCoalescedDataRequestIndexNbEventsBlocksize() {
		TmfCoalescedDataRequest<TmfEvent> request = new TmfCoalescedDataRequest<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 = "[TmfCoalescedDataRequest(0,TmfEvent,10,100,200)]";
        String expected2 = "[TmfCoalescedDataRequest(1,TmfEvent,20,100,200)]";
        String expected3 = "[TmfCoalescedDataRequest(2,TmfEvent,20,200,200)]";
        String expected4 = "[TmfCoalescedDataRequest(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());
	}

	// ------------------------------------------------------------------------
	// isCompatible
	// ------------------------------------------------------------------------

	public void testIsCompatible() {
		TmfCoalescedDataRequest<TmfEvent> coalescedRequest = new TmfCoalescedDataRequest<TmfEvent>(TmfEvent.class, 10, 100, 200);
		TmfDataRequest<TmfEvent> request1 = new TmfDataRequestStub<TmfEvent>(TmfEvent.class, 10, 100, 200);
		TmfDataRequest<TmfEvent> request2 = new TmfDataRequestStub<TmfEvent>(TmfEvent.class, 11, 100, 200);
		TmfDataRequest<TmfEvent> request3 = new TmfDataRequestStub<TmfEvent>(TmfEvent.class, 10, 101, 200);

        assertTrue ("isCompatible", coalescedRequest.isCompatible(request1));
        assertFalse("isCompatible", coalescedRequest.isCompatible(request2));
        assertFalse("isCompatible", coalescedRequest.isCompatible(request3));
	}

	// ------------------------------------------------------------------------
	// done
	// ------------------------------------------------------------------------

	public void testDone() {
		
		// Test request
		final boolean[] crFlags = new boolean[4];
		TmfCoalescedDataRequest<TmfEvent> request = setupTestRequest(crFlags);
		TmfDataRequest<TmfEvent> subRequest1 = new TmfDataRequestStub<TmfEvent>(TmfEvent.class, 10, 100, 200);
		TmfDataRequest<TmfEvent> subRequest2 = new TmfDataRequestStub<TmfEvent>(TmfEvent.class, 10, 100, 200);
		request.addRequest(subRequest1);
		request.addRequest(subRequest2);

		request.done();

		// Validate the coalescing request
		assertTrue ("isCompleted", request.isCompleted());
		assertFalse("isFailed",    request.isFailed());
		assertFalse("isCancelled", request.isCancelled());

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

		// Validate the first coalesced request
		assertTrue ("isCompleted", subRequest1.isCompleted());
		assertFalse("isFailed",    subRequest1.isFailed());
		assertFalse("isCancelled", subRequest1.isCancelled());

		// Validate the second coalesced request
		assertTrue ("isCompleted", subRequest2.isCompleted());
		assertFalse("isFailed",    subRequest2.isFailed());
		assertFalse("isCancelled", subRequest2.isCancelled());
	}

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

	public void testFail() {
		
		final boolean[] crFlags = new boolean[4];
		TmfCoalescedDataRequest<TmfEvent> request = setupTestRequest(crFlags);
		TmfDataRequest<TmfEvent> subRequest1 = new TmfDataRequestStub<TmfEvent>(TmfEvent.class, 10, 100, 200);
		TmfDataRequest<TmfEvent> subRequest2 = new TmfDataRequestStub<TmfEvent>(TmfEvent.class, 10, 100, 200);
		request.addRequest(subRequest1);
		request.addRequest(subRequest2);

		request.fail();

		// Validate the coalescing request
		assertTrue ("isCompleted", request.isCompleted());
		assertTrue ("isFailed",    request.isFailed());
		assertFalse("isCancelled", request.isCancelled());

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

		// Validate the first coalesced request
		assertTrue ("isCompleted", subRequest1.isCompleted());
		assertTrue ("isFailed",    subRequest1.isFailed());
		assertFalse("isCancelled", subRequest1.isCancelled());

		// Validate the second coalesced request
		assertTrue ("isCompleted", subRequest2.isCompleted());
		assertTrue ("isFailed",    subRequest2.isFailed());
		assertFalse("isCancelled", subRequest2.isCancelled());
	}

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

	public void testCancel() {

		final boolean[] crFlags = new boolean[4];
		TmfCoalescedDataRequest<TmfEvent> request = setupTestRequest(crFlags);
		TmfDataRequest<TmfEvent> subRequest1 = new TmfDataRequestStub<TmfEvent>(TmfEvent.class, 10, 100, 200);
		TmfDataRequest<TmfEvent> subRequest2 = new TmfDataRequestStub<TmfEvent>(TmfEvent.class, 10, 100, 200);
		request.addRequest(subRequest1);
		request.addRequest(subRequest2);

		request.cancel();

		// Validate the coalescing request
		assertTrue ("isCompleted", request.isCompleted());
		assertFalse("isFailed",    request.isFailed());
		assertTrue ("isCancelled", request.isCancelled());

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

		// Validate the first coalesced request
		assertTrue ("isCompleted", subRequest1.isCompleted());
		assertFalse("isFailed",    subRequest1.isFailed());
		assertTrue ("isCancelled", subRequest1.isCancelled());

		// Validate the second coalesced request
		assertTrue ("isCompleted", subRequest2.isCompleted());
		assertFalse("isFailed",    subRequest2.isFailed());
		assertTrue ("isCancelled", subRequest2.isCancelled());
	}

	
	// ------------------------------------------------------------------------
	// cancel sub-requests
	// ------------------------------------------------------------------------

    public void testCancelSubRequests() {

	        final boolean[] crFlags = new boolean[4];
	        TmfCoalescedDataRequest<TmfEvent> request = setupTestRequest(crFlags);
	        TmfDataRequest<TmfEvent> subRequest1 = new TmfDataRequestStub<TmfEvent>(TmfEvent.class, 10, 100, 200);
	        TmfDataRequest<TmfEvent> subRequest2 = new TmfDataRequestStub<TmfEvent>(TmfEvent.class, 10, 100, 200);
	        request.addRequest(subRequest1);
	        request.addRequest(subRequest2);

	        subRequest1.cancel();

	        // Validate the first coalesced request
	        assertTrue ("isCompleted", subRequest1.isCompleted());
	        assertFalse("isFailed",    subRequest1.isFailed());
	        assertTrue ("isCancelled", subRequest1.isCancelled());

	        // Validate the coalescing request
	        assertFalse("isCompleted", request.isCompleted());
	        assertFalse("isFailed",     request.isFailed());
	        assertFalse("isCancelled", request.isCancelled());  

	        // Cancel second sub-request
	        subRequest2.cancel();

	        // Validate the second coalesced request
	        assertTrue ("isCompleted", subRequest2.isCompleted());
	        assertFalse("isFailed",    subRequest2.isFailed());
	        assertTrue ("isCancelled", subRequest2.isCancelled());

	        // Validate the coalescing request
	        assertTrue ("isCompleted", request.isCompleted());
	        assertFalse("isFailed",    request.isFailed());
	        assertTrue ("isCancelled", request.isCancelled());

	        // Finalize coalescing request - 
	        // Note: No need to check "request.isCancelled()" since it was verified above
            request.cancel();

	        assertTrue ("handleCompleted", crFlags[0]);
	        assertFalse("handleSuccess",   crFlags[1]);
	        assertFalse("handleFailure",   crFlags[2]);
	        assertTrue ("handleCancel",   crFlags[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
	16	import junit.framework.TestCase;
	17
	18	import org.eclipse.linuxtools.tmf.event.TmfEvent;
d18dd09b ASL	19	import org.eclipse.linuxtools.tmf.request.TmfCoalescedDataRequest;
	20	import org.eclipse.linuxtools.tmf.request.TmfDataRequest;
	21	import org.eclipse.linuxtools.tmf.request.TmfDataRequestStub;
	22
	23	/**
	24	* <b><u>TmfCoalescedDataRequestTest</u></b>
	25	* <p>
2fb2eb37	26	* Test suite for the TmfCoalescedDataRequest class.
d18dd09b	27	*/
3b38ea61	28	@SuppressWarnings("nls")
d18dd09b ASL	29	public class TmfCoalescedDataRequestTest extends TestCase {
d18dd09b ASL	30
2fb2eb37 FC	31	// ------------------------------------------------------------------------
	32	// Variables
	33	// ------------------------------------------------------------------------
	34
	35	private static TmfCoalescedDataRequest<TmfEvent> fRequest1;
	36	private static TmfCoalescedDataRequest<TmfEvent> fRequest2;
	37	private static TmfCoalescedDataRequest<TmfEvent> fRequest3;
	38	private static TmfCoalescedDataRequest<TmfEvent> fRequest4;
	39
	40	private static TmfCoalescedDataRequest<TmfEvent> fRequest1b;
	41	private static TmfCoalescedDataRequest<TmfEvent> fRequest1c;
	42
	43	private static int fRequestCount;
	44
d18dd09b ASL	45	// ------------------------------------------------------------------------
	46	// Housekeeping
	47	// ------------------------------------------------------------------------
	48
	49	public TmfCoalescedDataRequestTest(String name) {
	50	super(name);
	51	}
	52
	53	@Override
	54	public void setUp() throws Exception {
2fb2eb37 FC	55	super.setUp();
	56	TmfDataRequest.reset();
	57	fRequest1 = new TmfCoalescedDataRequest<TmfEvent>(TmfEvent.class, 10, 100, 200);
	58	fRequest2 = new TmfCoalescedDataRequest<TmfEvent>(TmfEvent.class, 20, 100, 200);
	59	fRequest3 = new TmfCoalescedDataRequest<TmfEvent>(TmfEvent.class, 20, 200, 200);
	60	fRequest4 = new TmfCoalescedDataRequest<TmfEvent>(TmfEvent.class, 20, 200, 300);
	61
	62	fRequest1b = new TmfCoalescedDataRequest<TmfEvent>(TmfEvent.class, 10, 100, 200);
	63	fRequest1c = new TmfCoalescedDataRequest<TmfEvent>(TmfEvent.class, 10, 100, 200);
	64
	65	fRequestCount = fRequest1c.getRequestId() + 1;
d18dd09b ASL	66	}
	67
	68	@Override
	69	public void tearDown() throws Exception {
2fb2eb37	70	super.tearDown();
d18dd09b ASL	71	}
d18dd09b ASL	72
2fb2eb37 FC	73	private TmfCoalescedDataRequest<TmfEvent> setupTestRequest(final boolean[] flags) {
	74
	75	TmfCoalescedDataRequest<TmfEvent> request = new TmfCoalescedDataRequest<TmfEvent>(TmfEvent.class, 10, 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
	104	public void testTmfCoalescedDataRequest() {
	105	TmfCoalescedDataRequest<TmfEvent> request = new TmfCoalescedDataRequest<TmfEvent>(TmfEvent.class);
	106
2fb2eb37 FC	107	assertEquals("getRequestId", fRequestCount++, request.getRequestId());
	108	assertEquals("getDataType", TmfEvent.class, request.getDataType());
	109
	110	assertEquals("getIndex", 0, request.getIndex());
d18dd09b	111	assertEquals("getNbRequestedEvents", TmfDataRequest.ALL_DATA, request.getNbRequested());
2fb2eb37 FC	112
	113	assertFalse("isCompleted", request.isCompleted());
	114	assertFalse("isFailed", request.isFailed());
	115	assertFalse("isCancelled", request.isCancelled());
	116
	117	assertEquals("getNbRead", 0, request.getNbRead());
d18dd09b ASL	118	}
	119
	120	public void testTmfCoalescedDataRequestIndex() {
	121	TmfCoalescedDataRequest<TmfEvent> request = new TmfCoalescedDataRequest<TmfEvent>(TmfEvent.class, 10);
	122
2fb2eb37 FC	123	assertEquals("getRequestId", fRequestCount++, request.getRequestId());
	124	assertEquals("getDataType", TmfEvent.class, request.getDataType());
	125
	126	assertEquals("getIndex", 10, request.getIndex());
d18dd09b	127	assertEquals("getNbRequestedEvents", TmfDataRequest.ALL_DATA, request.getNbRequested());
2fb2eb37 FC	128
	129	assertFalse("isCompleted", request.isCompleted());
	130	assertFalse("isFailed", request.isFailed());
	131	assertFalse("isCancelled", request.isCancelled());
	132
	133	assertEquals("getNbRead", 0, request.getNbRead());
d18dd09b ASL	134	}
	135
	136	public void testTmfCoalescedDataRequestIndexNbRequested() {
	137	TmfCoalescedDataRequest<TmfEvent> request = new TmfCoalescedDataRequest<TmfEvent>(TmfEvent.class, 10, 100);
	138
2fb2eb37 FC	139	assertEquals("getRequestId", fRequestCount++, request.getRequestId());
	140	assertEquals("getDataType", TmfEvent.class, request.getDataType());
	141
	142	assertEquals("getIndex", 10, request.getIndex());
d18dd09b	143	assertEquals("getNbRequestedEvents", 100, request.getNbRequested());
2fb2eb37 FC	144
	145	assertFalse("isCompleted", request.isCompleted());
	146	assertFalse("isFailed", request.isFailed());
	147	assertFalse("isCancelled", request.isCancelled());
	148
	149	assertEquals("getNbRead", 0, request.getNbRead());
d18dd09b ASL	150	}
	151
	152	public void testTmfCoalescedDataRequestIndexNbEventsBlocksize() {
	153	TmfCoalescedDataRequest<TmfEvent> request = new TmfCoalescedDataRequest<TmfEvent>(TmfEvent.class, 10, 100, 200);
	154
2fb2eb37 FC	155	assertEquals("getRequestId", fRequestCount++, request.getRequestId());
	156	assertEquals("getDataType", TmfEvent.class, request.getDataType());
	157
	158	assertEquals("getIndex", 10, request.getIndex());
d18dd09b	159	assertEquals("getNbRequestedEvents", 100, request.getNbRequested());
2fb2eb37 FC	160
	161	assertFalse("isCompleted", request.isCompleted());
	162	assertFalse("isFailed", request.isFailed());
	163	assertFalse("isCancelled", request.isCancelled());
	164
	165	assertEquals("getNbRead", 0, request.getNbRead());
	166	}
	167
	168	// ------------------------------------------------------------------------
	169	// equals
	170	// ------------------------------------------------------------------------
	171
	172	public void testEqualsReflexivity() throws Exception {
	173	assertTrue("equals", fRequest1.equals(fRequest1));
	174	assertTrue("equals", fRequest2.equals(fRequest2));
	175
	176	assertFalse("equals", fRequest1.equals(fRequest2));
	177	assertFalse("equals", fRequest2.equals(fRequest1));
	178	}
	179
	180	public void testEqualsSymmetry() throws Exception {
	181	assertTrue("equals", fRequest1.equals(fRequest1b));
	182	assertTrue("equals", fRequest1b.equals(fRequest1));
	183
	184	assertFalse("equals", fRequest1.equals(fRequest3));
	185	assertFalse("equals", fRequest2.equals(fRequest3));
	186	assertFalse("equals", fRequest3.equals(fRequest1));
	187	assertFalse("equals", fRequest3.equals(fRequest2));
	188	}
	189
	190	public void testEqualsTransivity() throws Exception {
	191	assertTrue("equals", fRequest1.equals(fRequest1b));
	192	assertTrue("equals", fRequest1b.equals(fRequest1c));
	193	assertTrue("equals", fRequest1.equals(fRequest1c));
	194	}
	195
2fb2eb37 FC	196	public void testEqualsNull() throws Exception {
	197	assertFalse("equals", fRequest1.equals(null));
	198	assertFalse("equals", fRequest2.equals(null));
	199	}
	200
	201	// ------------------------------------------------------------------------
	202	// hashCode
	203	// ------------------------------------------------------------------------
	204
	205	public void testHashCode() throws Exception {
	206	assertTrue("hashCode", fRequest1.hashCode() == fRequest1.hashCode());
	207	assertTrue("hashCode", fRequest2.hashCode() == fRequest2.hashCode());
	208	assertTrue("hashCode", fRequest1.hashCode() != fRequest2.hashCode());
	209	}
	210
	211	// ------------------------------------------------------------------------
	212	// toString
	213	// ------------------------------------------------------------------------
	214
	215	public void testToString() {
8016d660 FC	216	String expected1 = "[TmfCoalescedDataRequest(0,TmfEvent,10,100,200)]";
	217	String expected2 = "[TmfCoalescedDataRequest(1,TmfEvent,20,100,200)]";
	218	String expected3 = "[TmfCoalescedDataRequest(2,TmfEvent,20,200,200)]";
	219	String expected4 = "[TmfCoalescedDataRequest(3,TmfEvent,20,200,300)]";
2fb2eb37 FC	220
	221	assertEquals("toString", expected1, fRequest1.toString());
	222	assertEquals("toString", expected2, fRequest2.toString());
	223	assertEquals("toString", expected3, fRequest3.toString());
	224	assertEquals("toString", expected4, fRequest4.toString());
d18dd09b ASL	225	}
	226
	227	// ------------------------------------------------------------------------
	228	// isCompatible
	229	// ------------------------------------------------------------------------
	230
	231	public void testIsCompatible() {
	232	TmfCoalescedDataRequest<TmfEvent> coalescedRequest = new TmfCoalescedDataRequest<TmfEvent>(TmfEvent.class, 10, 100, 200);
	233	TmfDataRequest<TmfEvent> request1 = new TmfDataRequestStub<TmfEvent>(TmfEvent.class, 10, 100, 200);
	234	TmfDataRequest<TmfEvent> request2 = new TmfDataRequestStub<TmfEvent>(TmfEvent.class, 11, 100, 200);
	235	TmfDataRequest<TmfEvent> request3 = new TmfDataRequestStub<TmfEvent>(TmfEvent.class, 10, 101, 200);
d18dd09b ASL	236
	237	assertTrue ("isCompatible", coalescedRequest.isCompatible(request1));
	238	assertFalse("isCompatible", coalescedRequest.isCompatible(request2));
	239	assertFalse("isCompatible", coalescedRequest.isCompatible(request3));
2fb2eb37 FC	240	}
	241
	242	// ------------------------------------------------------------------------
	243	// done
	244	// ------------------------------------------------------------------------
	245
	246	public void testDone() {
	247
	248	// Test request
	249	final boolean[] crFlags = new boolean[4];
	250	TmfCoalescedDataRequest<TmfEvent> request = setupTestRequest(crFlags);
	251	TmfDataRequest<TmfEvent> subRequest1 = new TmfDataRequestStub<TmfEvent>(TmfEvent.class, 10, 100, 200);
	252	TmfDataRequest<TmfEvent> subRequest2 = new TmfDataRequestStub<TmfEvent>(TmfEvent.class, 10, 100, 200);
	253	request.addRequest(subRequest1);
	254	request.addRequest(subRequest2);
	255
	256	request.done();
	257
	258	// Validate the coalescing request
	259	assertTrue ("isCompleted", request.isCompleted());
	260	assertFalse("isFailed", request.isFailed());
	261	assertFalse("isCancelled", request.isCancelled());
	262
	263	assertTrue ("handleCompleted", crFlags[0]);
	264	assertTrue ("handleSuccess", crFlags[1]);
	265	assertFalse("handleFailure", crFlags[2]);
	266	assertFalse("handleCancel", crFlags[3]);
	267
	268	// Validate the first coalesced request
	269	assertTrue ("isCompleted", subRequest1.isCompleted());
	270	assertFalse("isFailed", subRequest1.isFailed());
	271	assertFalse("isCancelled", subRequest1.isCancelled());
	272
	273	// Validate the second coalesced request
	274	assertTrue ("isCompleted", subRequest2.isCompleted());
	275	assertFalse("isFailed", subRequest2.isFailed());
	276	assertFalse("isCancelled", subRequest2.isCancelled());
	277	}
	278
	279	// ------------------------------------------------------------------------
	280	// fail
	281	// ------------------------------------------------------------------------
	282
	283	public void testFail() {
	284
	285	final boolean[] crFlags = new boolean[4];
	286	TmfCoalescedDataRequest<TmfEvent> request = setupTestRequest(crFlags);
	287	TmfDataRequest<TmfEvent> subRequest1 = new TmfDataRequestStub<TmfEvent>(TmfEvent.class, 10, 100, 200);
	288	TmfDataRequest<TmfEvent> subRequest2 = new TmfDataRequestStub<TmfEvent>(TmfEvent.class, 10, 100, 200);
	289	request.addRequest(subRequest1);
	290	request.addRequest(subRequest2);
	291
	292	request.fail();
	293
	294	// Validate the coalescing request
	295	assertTrue ("isCompleted", request.isCompleted());
	296	assertTrue ("isFailed", request.isFailed());
	297	assertFalse("isCancelled", request.isCancelled());
	298
	299	assertTrue ("handleCompleted", crFlags[0]);
	300	assertFalse("handleSuccess", crFlags[1]);
	301	assertTrue ("handleFailure", crFlags[2]);
	302	assertFalse("handleCancel", crFlags[3]);
	303
304	// Validate the first coalesced request
305	assertTrue ("isCompleted", subRequest1.isCompleted());
306	assertTrue ("isFailed", subRequest1.isFailed());
307	assertFalse("isCancelled", subRequest1.isCancelled());
308
309	// Validate the second coalesced request
310	assertTrue ("isCompleted", subRequest2.isCompleted());
311	assertTrue ("isFailed", subRequest2.isFailed());
312	assertFalse("isCancelled", subRequest2.isCancelled());
313	}
314
315	// ------------------------------------------------------------------------
316	// cancel
317	// ------------------------------------------------------------------------
318
319	public void testCancel() {
320
321	final boolean[] crFlags = new boolean[4];
322	TmfCoalescedDataRequest<TmfEvent> request = setupTestRequest(crFlags);
323	TmfDataRequest<TmfEvent> subRequest1 = new TmfDataRequestStub<TmfEvent>(TmfEvent.class, 10, 100, 200);
324	TmfDataRequest<TmfEvent> subRequest2 = new TmfDataRequestStub<TmfEvent>(TmfEvent.class, 10, 100, 200);
325	request.addRequest(subRequest1);
326	request.addRequest(subRequest2);
327
328	request.cancel();
329
330	// Validate the coalescing request
331	assertTrue ("isCompleted", request.isCompleted());
332	assertFalse("isFailed", request.isFailed());
333	assertTrue ("isCancelled", request.isCancelled());
334
335	assertTrue ("handleCompleted", crFlags[0]);
336	assertFalse("handleSuccess", crFlags[1]);
337	assertFalse("handleFailure", crFlags[2]);
338	assertTrue ("handleCancel", crFlags[3]);
339
340	// Validate the first coalesced request
341	assertTrue ("isCompleted", subRequest1.isCompleted());
342	assertFalse("isFailed", subRequest1.isFailed());
343	assertTrue ("isCancelled", subRequest1.isCancelled());
344
345	// Validate the second coalesced request
346	assertTrue ("isCompleted", subRequest2.isCompleted());
347	assertFalse("isFailed", subRequest2.isFailed());
348	assertTrue ("isCancelled", subRequest2.isCancelled());
349	}
350
c1c69938 FC	351
	352	// ------------------------------------------------------------------------
	353	// cancel sub-requests
	354	// ------------------------------------------------------------------------
	355
	356	public void testCancelSubRequests() {
	357
	358	final boolean[] crFlags = new boolean[4];
	359	TmfCoalescedDataRequest<TmfEvent> request = setupTestRequest(crFlags);
	360	TmfDataRequest<TmfEvent> subRequest1 = new TmfDataRequestStub<TmfEvent>(TmfEvent.class, 10, 100, 200);
	361	TmfDataRequest<TmfEvent> subRequest2 = new TmfDataRequestStub<TmfEvent>(TmfEvent.class, 10, 100, 200);
	362	request.addRequest(subRequest1);
	363	request.addRequest(subRequest2);
	364
	365	subRequest1.cancel();
	366
	367	// Validate the first coalesced request
	368	assertTrue ("isCompleted", subRequest1.isCompleted());
	369	assertFalse("isFailed", subRequest1.isFailed());
	370	assertTrue ("isCancelled", subRequest1.isCancelled());
	371
	372	// Validate the coalescing request
	373	assertFalse("isCompleted", request.isCompleted());
	374	assertFalse("isFailed", request.isFailed());
	375	assertFalse("isCancelled", request.isCancelled());
	376
	377	// Cancel second sub-request
	378	subRequest2.cancel();
	379
	380	// Validate the second coalesced request
	381	assertTrue ("isCompleted", subRequest2.isCompleted());
	382	assertFalse("isFailed", subRequest2.isFailed());
	383	assertTrue ("isCancelled", subRequest2.isCancelled());
	384
	385	// Validate the coalescing request
	386	assertTrue ("isCompleted", request.isCompleted());
	387	assertFalse("isFailed", request.isFailed());
	388	assertTrue ("isCancelled", request.isCancelled());
	389
	390	// Finalize coalescing request -
	391	// Note: No need to check "request.isCancelled()" since it was verified above
	392	request.cancel();
	393
	394	assertTrue ("handleCompleted", crFlags[0]);
	395	assertFalse("handleSuccess", crFlags[1]);
	396	assertFalse("handleFailure", crFlags[2]);
	397	assertTrue ("handleCancel", crFlags[3]);
	398	}
	399
2fb2eb37 FC	400	// ------------------------------------------------------------------------
	401	// waitForCompletion
	402	// ------------------------------------------------------------------------
	403
d18dd09b	404	}