org.eclipse.linuxtools.tmf.core.tests/src/org/eclipse/linuxtools/tmf/core/tests/request/TmfDataRequestTest.java

   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.core.tests.request;
  14
  15 import junit.framework.TestCase;
  16
  17 import org.eclipse.linuxtools.tmf.core.event.TmfEvent;
  18 import org.eclipse.linuxtools.tmf.core.request.TmfDataRequest;
  19 import org.eclipse.linuxtools.tmf.tests.stubs.request.TmfDataRequestStub;
  20
  21 /**
  22  * <b><u>TmfDataRequestTest</u></b>
  23  * <p>
  24  * Test suite for the TmfDataRequest class.
  25  */
  26 @SuppressWarnings({"nls","javadoc"})
  27 public class TmfDataRequestTest extends TestCase {
  28
  29         // ------------------------------------------------------------------------
  30         // Variables
  31         // ------------------------------------------------------------------------
  32
  33         private static TmfDataRequest fRequest1;
  34         private static TmfDataRequest fRequest1b;
  35         private static TmfDataRequest fRequest1c;
  36         private static TmfDataRequest fRequest2;
  37         private static TmfDataRequest fRequest3;
  38         private static TmfDataRequest fRequest4;
  39
  40         private static int fRequestCount;
  41
  42     // ------------------------------------------------------------------------
  43         // Housekeeping
  44         // ------------------------------------------------------------------------
  45
  46     /**
  47      * @param name the test name
  48      */
  49         public TmfDataRequestTest(String name) {
  50                 super(name);
  51         }
  52
  53         @Override
  54         protected void setUp() throws Exception {
  55                 super.setUp();
  56                 TmfDataRequest.reset();
  57                 fRequest1  = new TmfDataRequestStub(TmfEvent.class, 10, 100, 200);
  58                 fRequest2  = new TmfDataRequestStub(TmfEvent.class, 20, 100, 200);
  59                 fRequest3  = new TmfDataRequestStub(TmfEvent.class, 20, 200, 200);
  60                 fRequest4  = new TmfDataRequestStub(TmfEvent.class, 20, 200, 300);
  61         fRequest1b = new TmfDataRequestStub(TmfEvent.class, 10, 100, 200);
  62                 fRequest1c = new TmfDataRequestStub(TmfEvent.class, 10, 100, 200);
  63                 fRequestCount = fRequest1c.getRequestId() + 1;
  64         }
  65
  66         @Override
  67         protected void tearDown() throws Exception {
  68                 super.tearDown();
  69         }
  70
  71         private static TmfDataRequest setupTestRequest(final boolean[] flags) {
  72
  73                 TmfDataRequest request = new TmfDataRequestStub(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         }
  97
  98         // ------------------------------------------------------------------------
  99         // Constructors
 100         // ------------------------------------------------------------------------
 101
 102         public void testTmfDataRequest() {
 103         TmfDataRequest request = new TmfDataRequestStub(TmfEvent.class);
 104
 105         assertEquals("getRequestId", fRequestCount++, request.getRequestId());
 106         assertEquals("getDataType",  TmfEvent.class, request.getDataType());
 107
 108         assertEquals("getIndex", 0, request.getIndex());
 109         assertEquals("getNbRequestedEvents", TmfDataRequest.ALL_DATA, request.getNbRequested());
 110
 111         assertFalse("isCompleted", request.isCompleted());
 112         assertFalse("isFailed", request.isFailed());
 113         assertFalse("isCancelled", request.isCancelled());
 114
 115         assertEquals("getNbRead", 0, request.getNbRead());
 116         }
 117
 118         public void testTmfDataRequestIndex() {
 119         TmfDataRequest request = new TmfDataRequestStub(TmfEvent.class, 10);
 120
 121         assertEquals("getRequestId", fRequestCount++, request.getRequestId());
 122         assertEquals("getDataType",  TmfEvent.class, request.getDataType());
 123
 124         assertEquals("getIndex", 10, request.getIndex());
 125         assertEquals("getNbRequestedEvents", TmfDataRequest.ALL_DATA, request.getNbRequested());
 126
 127         assertFalse("isCompleted", request.isCompleted());
 128         assertFalse("isFailed", request.isFailed());
 129         assertFalse("isCancelled", request.isCancelled());
 130
 131         assertEquals("getNbRead", 0, request.getNbRead());
 132         }
 133
 134         public void testTmfDataRequestIndexNbRequested() {
 135         TmfDataRequest request = new TmfDataRequestStub(TmfEvent.class, 10, 100);
 136
 137         assertEquals("getRequestId", fRequestCount++, request.getRequestId());
 138         assertEquals("getDataType",  TmfEvent.class, request.getDataType());
 139
 140         assertEquals("getIndex", 10, request.getIndex());
 141         assertEquals("getNbRequestedEvents", 100, request.getNbRequested());
 142
 143         assertFalse("isCompleted", request.isCompleted());
 144         assertFalse("isFailed", request.isFailed());
 145         assertFalse("isCancelled", request.isCancelled());
 146
 147         assertEquals("getNbRead", 0, request.getNbRead());
 148         }
 149
 150         public void testTmfDataRequestIndexNbEventsBlocksize() {
 151         TmfDataRequest request = new TmfDataRequestStub(TmfEvent.class, 10, 100, 200);
 152
 153         assertEquals("getRequestId", fRequestCount++, request.getRequestId());
 154         assertEquals("getDataType",  TmfEvent.class, request.getDataType());
 155
 156         assertEquals("getIndex", 10, request.getIndex());
 157         assertEquals("getNbRequestedEvents", 100, request.getNbRequested());
 158
 159         assertFalse("isCompleted", request.isCompleted());
 160         assertFalse("isFailed", request.isFailed());
 161         assertFalse("isCancelled", request.isCancelled());
 162
 163         assertEquals("getNbRead", 0, request.getNbRead());
 164         }
 165
 166         // ------------------------------------------------------------------------
 167         // equals
 168         // ------------------------------------------------------------------------
 169
 170         public void testEqualsReflexivity() {
 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
 178         public void testEqualsSymmetry() {
 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         }
 187
 188         public void testEqualsTransivity() {
 189         assertTrue("equals", fRequest1.equals(fRequest1b));
 190         assertTrue("equals", fRequest1b.equals(fRequest1c));
 191         assertTrue("equals", fRequest1.equals(fRequest1c));
 192         }
 193
 194         public void testEqualsNull() {
 195         assertFalse("equals", fRequest1.equals(null));
 196         assertFalse("equals", fRequest2.equals(null));
 197         }
 198
 199         // ------------------------------------------------------------------------
 200         // hashCode
 201         // ------------------------------------------------------------------------
 202
 203         public void testHashCode() {
 204         assertTrue("hashCode", fRequest1.hashCode() == fRequest1.hashCode());
 205         assertTrue("hashCode", fRequest2.hashCode() == fRequest2.hashCode());
 206                 assertTrue("hashCode", fRequest1.hashCode() != fRequest2.hashCode());
 207         }
 208
 209         // ------------------------------------------------------------------------
 210         // toString
 211         // ------------------------------------------------------------------------
 212
 213         public void testToString() {
 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)]";
 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
 225         // ------------------------------------------------------------------------
 226         // done
 227         // ------------------------------------------------------------------------
 228
 229         public void testDone() {
 230
 231                 final boolean[] flags = new boolean[4];
 232                 TmfDataRequest request = setupTestRequest(flags);
 233                 request.done();
 234
 235                 assertTrue ("isCompleted", request.isCompleted());
 236                 assertFalse("isFailed",    request.isFailed());
 237                 assertFalse("isCancelled", request.isCancelled());
 238
 239                 assertTrue ("handleCompleted", flags[0]);
 240                 assertTrue ("handleSuccess",   flags[1]);
 241                 assertFalse("handleFailure",   flags[2]);
 242                 assertFalse("handleCancel",    flags[3]);
 243         }
 244
 245         // ------------------------------------------------------------------------
 246         // fail
 247         // ------------------------------------------------------------------------
 248
 249         public void testFail() {
 250
 251                 final boolean[] flags = new boolean[4];
 252                 TmfDataRequest request = setupTestRequest(flags);
 253                 request.fail();
 254
 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]);
 263         }
 264
 265         // ------------------------------------------------------------------------
 266         // cancel
 267         // ------------------------------------------------------------------------
 268
 269         public void testCancel() {
 270
 271                 final boolean[] flags = new boolean[4];
 272                 TmfDataRequest request = setupTestRequest(flags);
 273                 request.cancel();
 274
 275                 assertTrue ("isCompleted", request.isCompleted());
 276                 assertFalse("isFailed",    request.isFailed());
 277                 assertTrue ("isCancelled", request.isCancelled());
 278
 279                 assertTrue ("handleCompleted", flags[0]);
 280                 assertFalse("handleSuccess",   flags[1]);
 281                 assertFalse("handleFailure",   flags[2]);
 282                 assertTrue ("handleCancel",    flags[3]);
 283         }
 284
 285         // ------------------------------------------------------------------------
 286         // waitForCompletion
 287         // ------------------------------------------------------------------------
 288
 289 }