X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=org.eclipse.linuxtools.tmf.core.tests%2Fsrc%2Forg%2Feclipse%2Flinuxtools%2Ftmf%2Fcore%2Ftests%2Frequest%2FTmfCoalescedDataRequestTest.java;h=6869cc84765b4a4e48cf041b14f336b109bc7ed9;hb=f4d1e5914d2d0ff9ec37c11ea445dfef9149b59b;hp=fcfbdcfe737cfa5cc494858368cf8cf751b42dbc;hpb=bb0f342ed784cd96b30eba578a2aef5abc4e3e01;p=deliverable%2Ftracecompass.git diff --git a/org.eclipse.linuxtools.tmf.core.tests/src/org/eclipse/linuxtools/tmf/core/tests/request/TmfCoalescedDataRequestTest.java b/org.eclipse.linuxtools.tmf.core.tests/src/org/eclipse/linuxtools/tmf/core/tests/request/TmfCoalescedDataRequestTest.java index fcfbdcfe73..6869cc8476 100644 --- a/org.eclipse.linuxtools.tmf.core.tests/src/org/eclipse/linuxtools/tmf/core/tests/request/TmfCoalescedDataRequestTest.java +++ b/org.eclipse.linuxtools.tmf.core.tests/src/org/eclipse/linuxtools/tmf/core/tests/request/TmfCoalescedDataRequestTest.java @@ -1,5 +1,5 @@ /******************************************************************************* - * Copyright (c) 2009, 2010, 2012 Ericsson + * Copyright (c) 2009, 2013 Ericsson * * All rights reserved. This program and the accompanying materials are * made available under the terms of the Eclipse Public License v1.0 which @@ -9,153 +9,101 @@ * Contributors: * Francois Chouinard - Initial API and implementation * Francois Chouinard - Added tests to check offsets + * Alexandre Montplaisir - Port to JUnit4 *******************************************************************************/ package org.eclipse.linuxtools.tmf.core.tests.request; -import junit.framework.TestCase; +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertTrue; import org.eclipse.linuxtools.internal.tmf.core.request.TmfCoalescedDataRequest; import org.eclipse.linuxtools.tmf.core.event.ITmfEvent; -import org.eclipse.linuxtools.tmf.core.event.TmfEvent; import org.eclipse.linuxtools.tmf.core.request.TmfDataRequest; +import org.eclipse.linuxtools.tmf.core.request.ITmfDataRequest.ExecutionType; import org.eclipse.linuxtools.tmf.tests.stubs.request.TmfDataRequestStub; +import org.junit.Before; +import org.junit.Test; /** * Test suite for the TmfCoalescedDataRequest class. */ -@SuppressWarnings({"nls","javadoc"}) -public class TmfCoalescedDataRequestTest extends TestCase { - - // ------------------------------------------------------------------------ - // Variables - // ------------------------------------------------------------------------ - - private TmfCoalescedDataRequest fRequest1; - private TmfCoalescedDataRequest fRequest2; - private TmfCoalescedDataRequest fRequest3; - private TmfCoalescedDataRequest fRequest4; - - private TmfCoalescedDataRequest fRequest1b; - private TmfCoalescedDataRequest fRequest1c; - - private int fRequestCount; - - // ------------------------------------------------------------------------ - // Housekeeping - // ------------------------------------------------------------------------ - - /** - * @param name the test name - */ - public TmfCoalescedDataRequestTest(final String name) { - super(name); - } - - @Override - public void setUp() throws Exception { - super.setUp(); - TmfDataRequest.reset(); - fRequest1 = new TmfCoalescedDataRequest(TmfEvent.class, 10, 100, 200); - fRequest2 = new TmfCoalescedDataRequest(TmfEvent.class, 20, 100, 200); - fRequest3 = new TmfCoalescedDataRequest(TmfEvent.class, 20, 200, 200); - fRequest4 = new TmfCoalescedDataRequest(TmfEvent.class, 20, 200, 300); - - fRequest1b = new TmfCoalescedDataRequest(TmfEvent.class, 10, 100, 200); - fRequest1c = new TmfCoalescedDataRequest(TmfEvent.class, 10, 100, 200); - - fRequestCount = fRequest1c.getRequestId() + 1; - } - - @Override - public void tearDown() throws Exception { - super.tearDown(); - } - - private static TmfCoalescedDataRequest setupTestRequest(final boolean[] flags) { - - TmfCoalescedDataRequest request = new TmfCoalescedDataRequest(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 request = new TmfCoalescedDataRequest(TmfEvent.class); +@SuppressWarnings("javadoc") +public class TmfCoalescedDataRequestTest { - assertEquals("getRequestId", fRequestCount++, request.getRequestId()); - assertEquals("getDataType", ITmfEvent.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()); - } + // ------------------------------------------------------------------------ + // Variables + // ------------------------------------------------------------------------ - public void testTmfCoalescedDataRequestIndex() { - TmfCoalescedDataRequest request = new TmfCoalescedDataRequest(TmfEvent.class, 10); + private TmfCoalescedDataRequest fRequest1; + private TmfCoalescedDataRequest fRequest2; + private TmfCoalescedDataRequest fRequest3; + private TmfCoalescedDataRequest fRequest4; - assertEquals("getRequestId", fRequestCount++, request.getRequestId()); - assertEquals("getDataType", ITmfEvent.class, request.getDataType()); + private TmfCoalescedDataRequest fRequest1b; + private TmfCoalescedDataRequest fRequest1c; - assertEquals("getIndex", 10, request.getIndex()); - assertEquals("getNbRequestedEvents", TmfDataRequest.ALL_DATA, request.getNbRequested()); + private int fRequestCount; - assertFalse("isCompleted", request.isCompleted()); - assertFalse("isFailed", request.isFailed()); - assertFalse("isCancelled", request.isCancelled()); - - assertEquals("getNbRead", 0, request.getNbRead()); - } + // ------------------------------------------------------------------------ + // Housekeeping + // ------------------------------------------------------------------------ - public void testTmfCoalescedDataRequestIndexNbRequested() { - TmfCoalescedDataRequest request = new TmfCoalescedDataRequest(TmfEvent.class, 10, 100); + @Before + public void setUp() { + TmfDataRequest.reset(); + fRequest1 = new TmfCoalescedDataRequest(ITmfEvent.class, 10, 100, ExecutionType.FOREGROUND); + fRequest2 = new TmfCoalescedDataRequest(ITmfEvent.class, 20, 100, ExecutionType.FOREGROUND); + fRequest3 = new TmfCoalescedDataRequest(ITmfEvent.class, 20, 200, ExecutionType.FOREGROUND); + fRequest4 = new TmfCoalescedDataRequest(ITmfEvent.class, 20, 200, ExecutionType.FOREGROUND); - assertEquals("getRequestId", fRequestCount++, request.getRequestId()); - assertEquals("getDataType", ITmfEvent.class, request.getDataType()); + fRequest1b = new TmfCoalescedDataRequest(ITmfEvent.class, 10, 100, ExecutionType.FOREGROUND); + fRequest1c = new TmfCoalescedDataRequest(ITmfEvent.class, 10, 100, ExecutionType.FOREGROUND); - assertEquals("getIndex", 10, request.getIndex()); - assertEquals("getNbRequestedEvents", 100, request.getNbRequested()); + fRequestCount = fRequest1c.getRequestId() + 1; + } - assertFalse("isCompleted", request.isCompleted()); - assertFalse("isFailed", request.isFailed()); - assertFalse("isCancelled", request.isCancelled()); + private static TmfCoalescedDataRequest setupTestRequest(final boolean[] flags) { + + TmfCoalescedDataRequest request = new TmfCoalescedDataRequest(ITmfEvent.class, 10, 100, ExecutionType.FOREGROUND) { + @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; + } - assertEquals("getNbRead", 0, request.getNbRead()); - } + // ------------------------------------------------------------------------ + // Constructor + // ------------------------------------------------------------------------ - public void testTmfCoalescedDataRequestIndexNbEventsBlocksize() { - TmfCoalescedDataRequest request = new TmfCoalescedDataRequest(TmfEvent.class, 10, 100, 200); + @Test + public void testTmfCoalescedDataRequestIndexNbEventsBlocksize() { + TmfCoalescedDataRequest request = new TmfCoalescedDataRequest(ITmfEvent.class, 10, 100, ExecutionType.FOREGROUND); assertEquals("getRequestId", fRequestCount++, request.getRequestId()); - assertEquals("getDataType", ITmfEvent.class, request.getDataType()); + assertEquals("getDataType", ITmfEvent.class, request.getDataType()); assertEquals("getIndex", 10, request.getIndex()); assertEquals("getNbRequestedEvents", 100, request.getNbRequested()); @@ -165,21 +113,23 @@ public class TmfCoalescedDataRequestTest extends TestCase { assertFalse("isCancelled", request.isCancelled()); assertEquals("getNbRead", 0, request.getNbRead()); - } + } - // ------------------------------------------------------------------------ - // equals - // ------------------------------------------------------------------------ + // ------------------------------------------------------------------------ + // equals + // ------------------------------------------------------------------------ - public void testEqualsReflexivity() { + @Test + 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() { + @Test + public void testEqualsSymmetry() { assertTrue("equals", fRequest1.equals(fRequest1b)); assertTrue("equals", fRequest1b.equals(fRequest1)); @@ -187,59 +137,64 @@ public class TmfCoalescedDataRequestTest extends TestCase { assertFalse("equals", fRequest2.equals(fRequest3)); assertFalse("equals", fRequest3.equals(fRequest1)); assertFalse("equals", fRequest3.equals(fRequest2)); - } + } - public void testEqualsTransivity() { + @Test + public void testEqualsTransivity() { assertTrue("equals", fRequest1.equals(fRequest1b)); assertTrue("equals", fRequest1b.equals(fRequest1c)); assertTrue("equals", fRequest1.equals(fRequest1c)); - } + } - public void testEqualsNull() { + @Test + public void testEqualsNull() { assertFalse("equals", fRequest1.equals(null)); assertFalse("equals", fRequest2.equals(null)); - } + } - // ------------------------------------------------------------------------ - // hashCode - // ------------------------------------------------------------------------ + // ------------------------------------------------------------------------ + // hashCode + // ------------------------------------------------------------------------ - public void testHashCode() { + @Test + public void testHashCode() { assertTrue("hashCode", fRequest1.hashCode() == fRequest1.hashCode()); assertTrue("hashCode", fRequest2.hashCode() == fRequest2.hashCode()); - assertTrue("hashCode", fRequest1.hashCode() != fRequest2.hashCode()); - } + assertTrue("hashCode", fRequest1.hashCode() != fRequest2.hashCode()); + } - // ------------------------------------------------------------------------ - // toString - // ------------------------------------------------------------------------ + // ------------------------------------------------------------------------ + // toString + // ------------------------------------------------------------------------ - public void testToString() { - String expected1 = "[TmfCoalescedDataRequest(0,ITmfEvent,10,100,200)]"; - String expected2 = "[TmfCoalescedDataRequest(1,ITmfEvent,20,100,200)]"; - String expected3 = "[TmfCoalescedDataRequest(2,ITmfEvent,20,200,200)]"; - String expected4 = "[TmfCoalescedDataRequest(3,ITmfEvent,20,200,300)]"; + @Test + public void testToString() { + String expected1 = "[TmfCoalescedDataRequest(0,ITmfEvent,FOREGROUND,10,100, [])]"; + String expected2 = "[TmfCoalescedDataRequest(1,ITmfEvent,FOREGROUND,20,100, [])]"; + String expected3 = "[TmfCoalescedDataRequest(2,ITmfEvent,FOREGROUND,20,200, [])]"; + String expected4 = "[TmfCoalescedDataRequest(3,ITmfEvent,FOREGROUND,20,200, [])]"; 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 coalescedRequest = new TmfCoalescedDataRequest(TmfEvent.class, 10, 100, 200); - TmfDataRequest request1 = new TmfDataRequestStub(TmfEvent.class, 10, 100, 200); - TmfDataRequest request2 = new TmfDataRequestStub(TmfEvent.class, 5, 100, 200); - TmfDataRequest request3 = new TmfDataRequestStub(TmfEvent.class, 5, 4, 200); - TmfDataRequest request4 = new TmfDataRequestStub(TmfEvent.class, 5, 5, 200); - TmfDataRequest request5 = new TmfDataRequestStub(TmfEvent.class, 15, 100, 200); - TmfDataRequest request6 = new TmfDataRequestStub(TmfEvent.class, 100, 100, 200); - TmfDataRequest request7 = new TmfDataRequestStub(TmfEvent.class, 110, 100, 200); - TmfDataRequest request8 = new TmfDataRequestStub(TmfEvent.class, 111, 100, 200); + } + + // ------------------------------------------------------------------------ + // isCompatible + // ------------------------------------------------------------------------ + + @Test + public void testIsCompatible() { + TmfCoalescedDataRequest coalescedRequest = new TmfCoalescedDataRequest(ITmfEvent.class, 10, 100, ExecutionType.FOREGROUND); + TmfDataRequest request1 = new TmfDataRequestStub(ITmfEvent.class, 10, 100); + TmfDataRequest request2 = new TmfDataRequestStub(ITmfEvent.class, 5, 100); + TmfDataRequest request3 = new TmfDataRequestStub(ITmfEvent.class, 5, 4); + TmfDataRequest request4 = new TmfDataRequestStub(ITmfEvent.class, 5, 5); + TmfDataRequest request5 = new TmfDataRequestStub(ITmfEvent.class, 15, 100); + TmfDataRequest request6 = new TmfDataRequestStub(ITmfEvent.class, 100, 100); + TmfDataRequest request7 = new TmfDataRequestStub(ITmfEvent.class, 110, 100); + TmfDataRequest request8 = new TmfDataRequestStub(ITmfEvent.class, 111, 100); assertTrue("isCompatible", coalescedRequest.isCompatible(request1)); assertTrue("isCompatible", coalescedRequest.isCompatible(request2)); @@ -250,261 +205,261 @@ public class TmfCoalescedDataRequestTest extends TestCase { assertTrue("isCompatible", coalescedRequest.isCompatible(request7)); assertTrue("isCompatible", coalescedRequest.isCompatible(request8)); - TmfDataRequest request9 = new TmfDataRequestStub(TmfEvent.class, 5, 3, 200); - TmfDataRequest request10 = new TmfDataRequestStub(TmfEvent.class, 112, 100, 200); + TmfDataRequest request9 = new TmfDataRequestStub(ITmfEvent.class, 5, 3); + TmfDataRequest request10 = new TmfDataRequestStub(ITmfEvent.class, 112, 100); assertFalse("isCompatible", coalescedRequest.isCompatible(request9)); assertFalse("isCompatible", coalescedRequest.isCompatible(request10)); - } + } // ------------------------------------------------------------------------ // addRequest // ------------------------------------------------------------------------ + @Test public void testAddRequest1() { - TmfCoalescedDataRequest coalescedRequest = new TmfCoalescedDataRequest(TmfEvent.class, 10, 100, 200); - TmfDataRequest request = new TmfDataRequestStub(TmfEvent.class, 10, 100, 200); + TmfCoalescedDataRequest coalescedRequest = new TmfCoalescedDataRequest(ITmfEvent.class, 10, 100, ExecutionType.FOREGROUND); + TmfDataRequest request = new TmfDataRequestStub(ITmfEvent.class, 10, 100); assertTrue("isCompatible", coalescedRequest.isCompatible(request)); coalescedRequest.addRequest(request); - assertEquals("addRequest", 10, coalescedRequest.getIndex()); + assertEquals("addRequest", 10, coalescedRequest.getIndex()); assertEquals("addRequest", 100, coalescedRequest.getNbRequested()); - assertEquals("addRequest", 200, coalescedRequest.getBlockSize()); } + @Test public void testAddRequest2() { - TmfCoalescedDataRequest coalescedRequest = new TmfCoalescedDataRequest(TmfEvent.class, 10, 100, 200); - TmfDataRequest request = new TmfDataRequestStub(TmfEvent.class, 5, 100, 200); + TmfCoalescedDataRequest coalescedRequest = new TmfCoalescedDataRequest(ITmfEvent.class, 10, 100, ExecutionType.FOREGROUND); + TmfDataRequest request = new TmfDataRequestStub(ITmfEvent.class, 5, 100); assertTrue("isCompatible", coalescedRequest.isCompatible(request)); coalescedRequest.addRequest(request); - assertEquals("addRequest", 5, coalescedRequest.getIndex()); + assertEquals("addRequest", 5, coalescedRequest.getIndex()); assertEquals("addRequest", 105, coalescedRequest.getNbRequested()); - assertEquals("addRequest", 200, coalescedRequest.getBlockSize()); } + @Test public void testAddRequest3() { - TmfCoalescedDataRequest coalescedRequest = new TmfCoalescedDataRequest(TmfEvent.class, 10, 100, 200); - TmfDataRequest request = new TmfDataRequestStub(TmfEvent.class, 5, 4, 200); + TmfCoalescedDataRequest coalescedRequest = new TmfCoalescedDataRequest(ITmfEvent.class, 10, 100, ExecutionType.FOREGROUND); + TmfDataRequest request = new TmfDataRequestStub(ITmfEvent.class, 5, 4); assertTrue("isCompatible", coalescedRequest.isCompatible(request)); coalescedRequest.addRequest(request); - assertEquals("addRequest", 5, coalescedRequest.getIndex()); + assertEquals("addRequest", 5, coalescedRequest.getIndex()); assertEquals("addRequest", 105, coalescedRequest.getNbRequested()); - assertEquals("addRequest", 200, coalescedRequest.getBlockSize()); } + @Test public void testAddRequest4() { - TmfCoalescedDataRequest coalescedRequest = new TmfCoalescedDataRequest(TmfEvent.class, 10, 100, 200); - TmfDataRequest request = new TmfDataRequestStub(TmfEvent.class, 5, 5, 200); + TmfCoalescedDataRequest coalescedRequest = new TmfCoalescedDataRequest(ITmfEvent.class, 10, 100, ExecutionType.FOREGROUND); + TmfDataRequest request = new TmfDataRequestStub(ITmfEvent.class, 5, 5); assertTrue("isCompatible", coalescedRequest.isCompatible(request)); coalescedRequest.addRequest(request); - assertEquals("addRequest", 5, coalescedRequest.getIndex()); + assertEquals("addRequest", 5, coalescedRequest.getIndex()); assertEquals("addRequest", 105, coalescedRequest.getNbRequested()); - assertEquals("addRequest", 200, coalescedRequest.getBlockSize()); } + @Test public void testAddRequest5() { - TmfCoalescedDataRequest coalescedRequest = new TmfCoalescedDataRequest(TmfEvent.class, 10, 100, 200); - TmfDataRequest request = new TmfDataRequestStub(TmfEvent.class, 15, 100, 200); + TmfCoalescedDataRequest coalescedRequest = new TmfCoalescedDataRequest(ITmfEvent.class, 10, 100, ExecutionType.FOREGROUND); + TmfDataRequest request = new TmfDataRequestStub(ITmfEvent.class, 15, 100); assertTrue("isCompatible", coalescedRequest.isCompatible(request)); coalescedRequest.addRequest(request); - assertEquals("addRequest", 10, coalescedRequest.getIndex()); + assertEquals("addRequest", 10, coalescedRequest.getIndex()); assertEquals("addRequest", 105, coalescedRequest.getNbRequested()); - assertEquals("addRequest", 200, coalescedRequest.getBlockSize()); } + @Test public void testAddRequest6() { - TmfCoalescedDataRequest coalescedRequest = new TmfCoalescedDataRequest(TmfEvent.class, 10, 100, 200); - TmfDataRequest request = new TmfDataRequestStub(TmfEvent.class, 100, 100, 200); + TmfCoalescedDataRequest coalescedRequest = new TmfCoalescedDataRequest(ITmfEvent.class, 10, 100, ExecutionType.FOREGROUND); + TmfDataRequest request = new TmfDataRequestStub(ITmfEvent.class, 100, 100); assertTrue("isCompatible", coalescedRequest.isCompatible(request)); coalescedRequest.addRequest(request); - assertEquals("addRequest", 10, coalescedRequest.getIndex()); + assertEquals("addRequest", 10, coalescedRequest.getIndex()); assertEquals("addRequest", 190, coalescedRequest.getNbRequested()); - assertEquals("addRequest", 200, coalescedRequest.getBlockSize()); } + @Test public void testAddRequest7() { - TmfCoalescedDataRequest coalescedRequest = new TmfCoalescedDataRequest(TmfEvent.class, 10, 100, 200); - TmfDataRequest request = new TmfDataRequestStub(TmfEvent.class, 110, 100, 200); + TmfCoalescedDataRequest coalescedRequest = new TmfCoalescedDataRequest(ITmfEvent.class, 10, 100, ExecutionType.FOREGROUND); + TmfDataRequest request = new TmfDataRequestStub(ITmfEvent.class, 110, 100); assertTrue("isCompatible", coalescedRequest.isCompatible(request)); coalescedRequest.addRequest(request); - assertEquals("addRequest", 10, coalescedRequest.getIndex()); + assertEquals("addRequest", 10, coalescedRequest.getIndex()); assertEquals("addRequest", 200, coalescedRequest.getNbRequested()); - assertEquals("addRequest", 200, coalescedRequest.getBlockSize()); } + @Test public void testAddRequest8() { - TmfCoalescedDataRequest coalescedRequest = new TmfCoalescedDataRequest(TmfEvent.class, 10, 100, 200); - TmfDataRequest request = new TmfDataRequestStub(TmfEvent.class, 111, 100, 200); + TmfCoalescedDataRequest coalescedRequest = new TmfCoalescedDataRequest(ITmfEvent.class, 10, 100, ExecutionType.FOREGROUND); + TmfDataRequest request = new TmfDataRequestStub(ITmfEvent.class, 111, 100); assertTrue("isCompatible", coalescedRequest.isCompatible(request)); coalescedRequest.addRequest(request); - assertEquals("addRequest", 10, coalescedRequest.getIndex()); + assertEquals("addRequest", 10, coalescedRequest.getIndex()); assertEquals("addRequest", 201, coalescedRequest.getNbRequested()); - assertEquals("addRequest", 200, coalescedRequest.getBlockSize()); } - // ------------------------------------------------------------------------ - // done - // ------------------------------------------------------------------------ - - public void testDone() { - - // Test request - final boolean[] crFlags = new boolean[4]; - TmfCoalescedDataRequest request = setupTestRequest(crFlags); - TmfDataRequest subRequest1 = new TmfDataRequestStub(TmfEvent.class, 10, 100, 200); - TmfDataRequest subRequest2 = new TmfDataRequestStub(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 request = setupTestRequest(crFlags); - TmfDataRequest subRequest1 = new TmfDataRequestStub(TmfEvent.class, 10, 100, 200); - TmfDataRequest subRequest2 = new TmfDataRequestStub(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 request = setupTestRequest(crFlags); - TmfDataRequest subRequest1 = new TmfDataRequestStub(TmfEvent.class, 10, 100, 200); - TmfDataRequest subRequest2 = new TmfDataRequestStub(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 - // ------------------------------------------------------------------------ + // ------------------------------------------------------------------------ + // done + // ------------------------------------------------------------------------ + + @Test + public void testDone() { + // Test request + final boolean[] crFlags = new boolean[4]; + TmfCoalescedDataRequest request = setupTestRequest(crFlags); + TmfDataRequest subRequest1 = new TmfDataRequestStub(ITmfEvent.class, 10, 100); + TmfDataRequest subRequest2 = new TmfDataRequestStub(ITmfEvent.class, 10, 100); + 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 + // ------------------------------------------------------------------------ + + @Test + public void testFail() { + final boolean[] crFlags = new boolean[4]; + TmfCoalescedDataRequest request = setupTestRequest(crFlags); + TmfDataRequest subRequest1 = new TmfDataRequestStub(ITmfEvent.class, 10, 100); + TmfDataRequest subRequest2 = new TmfDataRequestStub(ITmfEvent.class, 10, 100); + 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 + // ------------------------------------------------------------------------ + + @Test + public void testCancel() { + final boolean[] crFlags = new boolean[4]; + TmfCoalescedDataRequest request = setupTestRequest(crFlags); + TmfDataRequest subRequest1 = new TmfDataRequestStub(ITmfEvent.class, 10, 100); + TmfDataRequest subRequest2 = new TmfDataRequestStub(ITmfEvent.class, 10, 100); + 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 + // ------------------------------------------------------------------------ + + @Test public void testCancelSubRequests() { + final boolean[] crFlags = new boolean[4]; + TmfCoalescedDataRequest request = setupTestRequest(crFlags); + TmfDataRequest subRequest1 = new TmfDataRequestStub(ITmfEvent.class, 10, 100); + TmfDataRequest subRequest2 = new TmfDataRequestStub(ITmfEvent.class, 10, 100); + 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()); - final boolean[] crFlags = new boolean[4]; - TmfCoalescedDataRequest request = setupTestRequest(crFlags); - TmfDataRequest subRequest1 = new TmfDataRequestStub(TmfEvent.class, 10, 100, 200); - TmfDataRequest subRequest2 = new TmfDataRequestStub(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]); - } + // 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]); + } }