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

   1 /*******************************************************************************
   2  * Copyright (c) 2009, 2010, 2012 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  *   Francois Chouinard - Added tests to check offsets
  12  *******************************************************************************/
  13
  14 package org.eclipse.linuxtools.tmf.core.tests.request;
  15
  16 import junit.framework.TestCase;
  17
  18 import org.eclipse.linuxtools.internal.tmf.core.request.TmfCoalescedDataRequest;
  19 import org.eclipse.linuxtools.tmf.core.event.ITmfEvent;
  20 import org.eclipse.linuxtools.tmf.core.event.TmfEvent;
  21 import org.eclipse.linuxtools.tmf.core.request.TmfDataRequest;
  22 import org.eclipse.linuxtools.tmf.tests.stubs.request.TmfDataRequestStub;
  23
  24 /**
  25  * Test suite for the TmfCoalescedDataRequest class.
  26  */
  27 @SuppressWarnings({"nls","javadoc"})
  28 public class TmfCoalescedDataRequestTest extends TestCase {
  29
  30         // ------------------------------------------------------------------------
  31         // Variables
  32         // ------------------------------------------------------------------------
  33
  34         private TmfCoalescedDataRequest fRequest1;
  35         private TmfCoalescedDataRequest fRequest2;
  36         private TmfCoalescedDataRequest fRequest3;
  37         private TmfCoalescedDataRequest fRequest4;
  38
  39         private TmfCoalescedDataRequest fRequest1b;
  40         private TmfCoalescedDataRequest fRequest1c;
  41
  42         private int fRequestCount;
  43
  44         // ------------------------------------------------------------------------
  45         // Housekeeping
  46         // ------------------------------------------------------------------------
  47
  48         /**
  49          * @param name the test name
  50          */
  51         public TmfCoalescedDataRequestTest(final String name) {
  52                 super(name);
  53         }
  54
  55     @Override
  56         public void setUp() throws Exception {
  57                 super.setUp();
  58                 TmfDataRequest.reset();
  59                 fRequest1  = new TmfCoalescedDataRequest(TmfEvent.class, 10, 100, 200);
  60                 fRequest2  = new TmfCoalescedDataRequest(TmfEvent.class, 20, 100, 200);
  61                 fRequest3  = new TmfCoalescedDataRequest(TmfEvent.class, 20, 200, 200);
  62                 fRequest4  = new TmfCoalescedDataRequest(TmfEvent.class, 20, 200, 300);
  63
  64                 fRequest1b = new TmfCoalescedDataRequest(TmfEvent.class, 10, 100, 200);
  65                 fRequest1c = new TmfCoalescedDataRequest(TmfEvent.class, 10, 100, 200);
  66
  67                 fRequestCount = fRequest1c.getRequestId() + 1;
  68         }
  69
  70         @Override
  71         public void tearDown() throws Exception {
  72                 super.tearDown();
  73         }
  74
  75         private static TmfCoalescedDataRequest setupTestRequest(final boolean[] flags) {
  76
  77                 TmfCoalescedDataRequest request = new TmfCoalescedDataRequest(TmfEvent.class, 10, 100, 200) {
  78                     @Override
  79                         public void handleCompleted() {
  80                         super.handleCompleted();
  81                         flags[0] = true;
  82                     }
  83                     @Override
  84                     public void handleSuccess() {
  85                         super.handleSuccess();
  86                         flags[1] = true;
  87                     }
  88                     @Override
  89                     public void handleFailure() {
  90                         super.handleFailure();
  91                         flags[2] = true;
  92                     }
  93                     @Override
  94                     public void handleCancel() {
  95                         super.handleCancel();
  96                         flags[3] = true;
  97                     }
  98                 };
  99                 return request;
 100         }
 101
 102         // ------------------------------------------------------------------------
 103         // Constructors
 104         // ------------------------------------------------------------------------
 105
 106         public void testTmfCoalescedDataRequest() {
 107                 TmfCoalescedDataRequest request = new TmfCoalescedDataRequest(TmfEvent.class);
 108
 109         assertEquals("getRequestId", fRequestCount++, request.getRequestId());
 110         assertEquals("getDataType",  ITmfEvent.class, request.getDataType());
 111
 112         assertEquals("getIndex", 0, request.getIndex());
 113         assertEquals("getNbRequestedEvents", TmfDataRequest.ALL_DATA, request.getNbRequested());
 114
 115         assertFalse("isCompleted", request.isCompleted());
 116         assertFalse("isFailed", request.isFailed());
 117         assertFalse("isCancelled", request.isCancelled());
 118
 119         assertEquals("getNbRead", 0, request.getNbRead());
 120         }
 121
 122         public void testTmfCoalescedDataRequestIndex() {
 123                 TmfCoalescedDataRequest request = new TmfCoalescedDataRequest(TmfEvent.class, 10);
 124
 125         assertEquals("getRequestId", fRequestCount++, request.getRequestId());
 126         assertEquals("getDataType",  ITmfEvent.class, request.getDataType());
 127
 128         assertEquals("getIndex", 10, request.getIndex());
 129         assertEquals("getNbRequestedEvents", TmfDataRequest.ALL_DATA, request.getNbRequested());
 130
 131         assertFalse("isCompleted", request.isCompleted());
 132         assertFalse("isFailed", request.isFailed());
 133         assertFalse("isCancelled", request.isCancelled());
 134
 135         assertEquals("getNbRead", 0, request.getNbRead());
 136         }
 137
 138         public void testTmfCoalescedDataRequestIndexNbRequested() {
 139                 TmfCoalescedDataRequest request = new TmfCoalescedDataRequest(TmfEvent.class, 10, 100);
 140
 141         assertEquals("getRequestId", fRequestCount++, request.getRequestId());
 142         assertEquals("getDataType",  ITmfEvent.class, request.getDataType());
 143
 144         assertEquals("getIndex", 10, request.getIndex());
 145         assertEquals("getNbRequestedEvents", 100, request.getNbRequested());
 146
 147         assertFalse("isCompleted", request.isCompleted());
 148         assertFalse("isFailed", request.isFailed());
 149         assertFalse("isCancelled", request.isCancelled());
 150
 151         assertEquals("getNbRead", 0, request.getNbRead());
 152         }
 153
 154         public void testTmfCoalescedDataRequestIndexNbEventsBlocksize() {
 155                 TmfCoalescedDataRequest request = new TmfCoalescedDataRequest(TmfEvent.class, 10, 100, 200);
 156
 157         assertEquals("getRequestId", fRequestCount++, request.getRequestId());
 158         assertEquals("getDataType",  ITmfEvent.class, request.getDataType());
 159
 160         assertEquals("getIndex", 10, request.getIndex());
 161         assertEquals("getNbRequestedEvents", 100, request.getNbRequested());
 162
 163         assertFalse("isCompleted", request.isCompleted());
 164         assertFalse("isFailed", request.isFailed());
 165         assertFalse("isCancelled", request.isCancelled());
 166
 167         assertEquals("getNbRead", 0, request.getNbRead());
 168         }
 169
 170         // ------------------------------------------------------------------------
 171         // equals
 172         // ------------------------------------------------------------------------
 173
 174         public void testEqualsReflexivity() {
 175         assertTrue("equals", fRequest1.equals(fRequest1));
 176         assertTrue("equals", fRequest2.equals(fRequest2));
 177
 178         assertFalse("equals", fRequest1.equals(fRequest2));
 179         assertFalse("equals", fRequest2.equals(fRequest1));
 180         }
 181
 182         public void testEqualsSymmetry() {
 183         assertTrue("equals", fRequest1.equals(fRequest1b));
 184         assertTrue("equals", fRequest1b.equals(fRequest1));
 185
 186         assertFalse("equals", fRequest1.equals(fRequest3));
 187         assertFalse("equals", fRequest2.equals(fRequest3));
 188         assertFalse("equals", fRequest3.equals(fRequest1));
 189         assertFalse("equals", fRequest3.equals(fRequest2));
 190         }
 191
 192         public void testEqualsTransivity() {
 193         assertTrue("equals", fRequest1.equals(fRequest1b));
 194         assertTrue("equals", fRequest1b.equals(fRequest1c));
 195         assertTrue("equals", fRequest1.equals(fRequest1c));
 196         }
 197
 198         public void testEqualsNull() {
 199         assertFalse("equals", fRequest1.equals(null));
 200         assertFalse("equals", fRequest2.equals(null));
 201         }
 202
 203         // ------------------------------------------------------------------------
 204         // hashCode
 205         // ------------------------------------------------------------------------
 206
 207         public void testHashCode() {
 208         assertTrue("hashCode", fRequest1.hashCode() == fRequest1.hashCode());
 209         assertTrue("hashCode", fRequest2.hashCode() == fRequest2.hashCode());
 210                 assertTrue("hashCode", fRequest1.hashCode() != fRequest2.hashCode());
 211         }
 212
 213         // ------------------------------------------------------------------------
 214         // toString
 215         // ------------------------------------------------------------------------
 216
 217         public void testToString() {
 218         String expected1 = "[TmfCoalescedDataRequest(0,ITmfEvent,10,100,200)]";
 219         String expected2 = "[TmfCoalescedDataRequest(1,ITmfEvent,20,100,200)]";
 220         String expected3 = "[TmfCoalescedDataRequest(2,ITmfEvent,20,200,200)]";
 221         String expected4 = "[TmfCoalescedDataRequest(3,ITmfEvent,20,200,300)]";
 222
 223         assertEquals("toString", expected1, fRequest1.toString());
 224         assertEquals("toString", expected2, fRequest2.toString());
 225         assertEquals("toString", expected3, fRequest3.toString());
 226         assertEquals("toString", expected4, fRequest4.toString());
 227         }
 228
 229         // ------------------------------------------------------------------------
 230         // isCompatible
 231         // ------------------------------------------------------------------------
 232
 233         public void testIsCompatible() {
 234                 TmfCoalescedDataRequest coalescedRequest = new TmfCoalescedDataRequest(TmfEvent.class, 10, 100, 200);
 235         TmfDataRequest request1 = new TmfDataRequestStub(TmfEvent.class,  10, 100, 200);
 236                 TmfDataRequest request2 = new TmfDataRequestStub(TmfEvent.class,   5, 100, 200);
 237         TmfDataRequest request3 = new TmfDataRequestStub(TmfEvent.class,   5,   4, 200);
 238         TmfDataRequest request4 = new TmfDataRequestStub(TmfEvent.class,   5,   5, 200);
 239         TmfDataRequest request5 = new TmfDataRequestStub(TmfEvent.class,  15, 100, 200);
 240         TmfDataRequest request6 = new TmfDataRequestStub(TmfEvent.class, 100, 100, 200);
 241         TmfDataRequest request7 = new TmfDataRequestStub(TmfEvent.class, 110, 100, 200);
 242         TmfDataRequest request8 = new TmfDataRequestStub(TmfEvent.class, 111, 100, 200);
 243
 244         assertTrue("isCompatible", coalescedRequest.isCompatible(request1));
 245         assertTrue("isCompatible", coalescedRequest.isCompatible(request2));
 246         assertTrue("isCompatible", coalescedRequest.isCompatible(request3));
 247         assertTrue("isCompatible", coalescedRequest.isCompatible(request4));
 248         assertTrue("isCompatible", coalescedRequest.isCompatible(request5));
 249         assertTrue("isCompatible", coalescedRequest.isCompatible(request6));
 250         assertTrue("isCompatible", coalescedRequest.isCompatible(request7));
 251         assertTrue("isCompatible", coalescedRequest.isCompatible(request8));
 252
 253         TmfDataRequest request9  = new TmfDataRequestStub(TmfEvent.class,   5,   3, 200);
 254         TmfDataRequest request10 = new TmfDataRequestStub(TmfEvent.class, 112, 100, 200);
 255
 256         assertFalse("isCompatible", coalescedRequest.isCompatible(request9));
 257         assertFalse("isCompatible", coalescedRequest.isCompatible(request10));
 258         }
 259
 260     // ------------------------------------------------------------------------
 261     // addRequest
 262     // ------------------------------------------------------------------------
 263
 264     public void testAddRequest1() {
 265         TmfCoalescedDataRequest coalescedRequest = new TmfCoalescedDataRequest(TmfEvent.class, 10, 100, 200);
 266         TmfDataRequest request = new TmfDataRequestStub(TmfEvent.class, 10, 100, 200);
 267
 268         assertTrue("isCompatible", coalescedRequest.isCompatible(request));
 269         coalescedRequest.addRequest(request);
 270         assertEquals("addRequest",  10, coalescedRequest.getIndex());
 271         assertEquals("addRequest", 100, coalescedRequest.getNbRequested());
 272         assertEquals("addRequest", 200, coalescedRequest.getBlockSize());
 273     }
 274
 275     public void testAddRequest2() {
 276         TmfCoalescedDataRequest coalescedRequest = new TmfCoalescedDataRequest(TmfEvent.class, 10, 100, 200);
 277         TmfDataRequest request = new TmfDataRequestStub(TmfEvent.class, 5, 100, 200);
 278
 279         assertTrue("isCompatible", coalescedRequest.isCompatible(request));
 280         coalescedRequest.addRequest(request);
 281         assertEquals("addRequest",   5, coalescedRequest.getIndex());
 282         assertEquals("addRequest", 105, coalescedRequest.getNbRequested());
 283         assertEquals("addRequest", 200, coalescedRequest.getBlockSize());
 284     }
 285
 286     public void testAddRequest3() {
 287         TmfCoalescedDataRequest coalescedRequest = new TmfCoalescedDataRequest(TmfEvent.class, 10, 100, 200);
 288         TmfDataRequest request = new TmfDataRequestStub(TmfEvent.class, 5, 4, 200);
 289
 290         assertTrue("isCompatible", coalescedRequest.isCompatible(request));
 291         coalescedRequest.addRequest(request);
 292         assertEquals("addRequest",   5, coalescedRequest.getIndex());
 293         assertEquals("addRequest", 105, coalescedRequest.getNbRequested());
 294         assertEquals("addRequest", 200, coalescedRequest.getBlockSize());
 295     }
 296
 297     public void testAddRequest4() {
 298         TmfCoalescedDataRequest coalescedRequest = new TmfCoalescedDataRequest(TmfEvent.class, 10, 100, 200);
 299         TmfDataRequest request = new TmfDataRequestStub(TmfEvent.class, 5, 5, 200);
 300
 301         assertTrue("isCompatible", coalescedRequest.isCompatible(request));
 302         coalescedRequest.addRequest(request);
 303         assertEquals("addRequest",   5, coalescedRequest.getIndex());
 304         assertEquals("addRequest", 105, coalescedRequest.getNbRequested());
 305         assertEquals("addRequest", 200, coalescedRequest.getBlockSize());
 306     }
 307
 308     public void testAddRequest5() {
 309         TmfCoalescedDataRequest coalescedRequest = new TmfCoalescedDataRequest(TmfEvent.class, 10, 100, 200);
 310         TmfDataRequest request = new TmfDataRequestStub(TmfEvent.class,  15, 100, 200);
 311
 312         assertTrue("isCompatible", coalescedRequest.isCompatible(request));
 313         coalescedRequest.addRequest(request);
 314         assertEquals("addRequest",  10, coalescedRequest.getIndex());
 315         assertEquals("addRequest", 105, coalescedRequest.getNbRequested());
 316         assertEquals("addRequest", 200, coalescedRequest.getBlockSize());
 317     }
 318
 319     public void testAddRequest6() {
 320         TmfCoalescedDataRequest coalescedRequest = new TmfCoalescedDataRequest(TmfEvent.class, 10, 100, 200);
 321         TmfDataRequest request = new TmfDataRequestStub(TmfEvent.class, 100, 100, 200);
 322
 323         assertTrue("isCompatible", coalescedRequest.isCompatible(request));
 324         coalescedRequest.addRequest(request);
 325         assertEquals("addRequest",  10, coalescedRequest.getIndex());
 326         assertEquals("addRequest", 190, coalescedRequest.getNbRequested());
 327         assertEquals("addRequest", 200, coalescedRequest.getBlockSize());
 328     }
 329
 330     public void testAddRequest7() {
 331         TmfCoalescedDataRequest coalescedRequest = new TmfCoalescedDataRequest(TmfEvent.class, 10, 100, 200);
 332         TmfDataRequest request = new TmfDataRequestStub(TmfEvent.class, 110, 100, 200);
 333
 334         assertTrue("isCompatible", coalescedRequest.isCompatible(request));
 335         coalescedRequest.addRequest(request);
 336         assertEquals("addRequest",  10, coalescedRequest.getIndex());
 337         assertEquals("addRequest", 200, coalescedRequest.getNbRequested());
 338         assertEquals("addRequest", 200, coalescedRequest.getBlockSize());
 339     }
 340
 341     public void testAddRequest8() {
 342         TmfCoalescedDataRequest coalescedRequest = new TmfCoalescedDataRequest(TmfEvent.class, 10, 100, 200);
 343         TmfDataRequest request = new TmfDataRequestStub(TmfEvent.class, 111, 100, 200);
 344
 345         assertTrue("isCompatible", coalescedRequest.isCompatible(request));
 346         coalescedRequest.addRequest(request);
 347         assertEquals("addRequest",  10, coalescedRequest.getIndex());
 348         assertEquals("addRequest", 201, coalescedRequest.getNbRequested());
 349         assertEquals("addRequest", 200, coalescedRequest.getBlockSize());
 350     }
 351
 352         // ------------------------------------------------------------------------
 353         // done
 354         // ------------------------------------------------------------------------
 355
 356         public void testDone() {
 357
 358                 // Test request
 359                 final boolean[] crFlags = new boolean[4];
 360                 TmfCoalescedDataRequest request = setupTestRequest(crFlags);
 361                 TmfDataRequest subRequest1 = new TmfDataRequestStub(TmfEvent.class, 10, 100, 200);
 362                 TmfDataRequest subRequest2 = new TmfDataRequestStub(TmfEvent.class, 10, 100, 200);
 363                 request.addRequest(subRequest1);
 364                 request.addRequest(subRequest2);
 365
 366                 request.done();
 367
 368                 // Validate the coalescing request
 369                 assertTrue ("isCompleted", request.isCompleted());
 370                 assertFalse("isFailed",    request.isFailed());
 371                 assertFalse("isCancelled", request.isCancelled());
 372
 373                 assertTrue ("handleCompleted", crFlags[0]);
 374                 assertTrue ("handleSuccess",   crFlags[1]);
 375                 assertFalse("handleFailure",   crFlags[2]);
 376                 assertFalse("handleCancel",    crFlags[3]);
 377
 378                 // Validate the first coalesced request
 379                 assertTrue ("isCompleted", subRequest1.isCompleted());
 380                 assertFalse("isFailed",    subRequest1.isFailed());
 381                 assertFalse("isCancelled", subRequest1.isCancelled());
 382
 383                 // Validate the second coalesced request
 384                 assertTrue ("isCompleted", subRequest2.isCompleted());
 385                 assertFalse("isFailed",    subRequest2.isFailed());
 386                 assertFalse("isCancelled", subRequest2.isCancelled());
 387         }
 388
 389         // ------------------------------------------------------------------------
 390         // fail
 391         // ------------------------------------------------------------------------
 392
 393         public void testFail() {
 394
 395                 final boolean[] crFlags = new boolean[4];
 396                 TmfCoalescedDataRequest request = setupTestRequest(crFlags);
 397                 TmfDataRequest subRequest1 = new TmfDataRequestStub(TmfEvent.class, 10, 100, 200);
 398                 TmfDataRequest subRequest2 = new TmfDataRequestStub(TmfEvent.class, 10, 100, 200);
 399                 request.addRequest(subRequest1);
 400                 request.addRequest(subRequest2);
 401
 402                 request.fail();
 403
 404                 // Validate the coalescing request
 405                 assertTrue ("isCompleted", request.isCompleted());
 406                 assertTrue ("isFailed",    request.isFailed());
 407                 assertFalse("isCancelled", request.isCancelled());
 408
 409                 assertTrue ("handleCompleted", crFlags[0]);
 410                 assertFalse("handleSuccess",   crFlags[1]);
 411                 assertTrue ("handleFailure",   crFlags[2]);
 412                 assertFalse("handleCancel",    crFlags[3]);
 413
 414                 // Validate the first coalesced request
 415                 assertTrue ("isCompleted", subRequest1.isCompleted());
 416                 assertTrue ("isFailed",    subRequest1.isFailed());
 417                 assertFalse("isCancelled", subRequest1.isCancelled());
 418
 419                 // Validate the second coalesced request
 420                 assertTrue ("isCompleted", subRequest2.isCompleted());
 421                 assertTrue ("isFailed",    subRequest2.isFailed());
 422                 assertFalse("isCancelled", subRequest2.isCancelled());
 423         }
 424
 425         // ------------------------------------------------------------------------
 426         // cancel
 427         // ------------------------------------------------------------------------
 428
 429         public void testCancel() {
 430
 431                 final boolean[] crFlags = new boolean[4];
 432                 TmfCoalescedDataRequest request = setupTestRequest(crFlags);
 433                 TmfDataRequest subRequest1 = new TmfDataRequestStub(TmfEvent.class, 10, 100, 200);
 434                 TmfDataRequest subRequest2 = new TmfDataRequestStub(TmfEvent.class, 10, 100, 200);
 435                 request.addRequest(subRequest1);
 436                 request.addRequest(subRequest2);
 437
 438                 request.cancel();
 439
 440                 // Validate the coalescing request
 441                 assertTrue ("isCompleted", request.isCompleted());
 442                 assertFalse("isFailed",    request.isFailed());
 443                 assertTrue ("isCancelled", request.isCancelled());
 444
 445                 assertTrue ("handleCompleted", crFlags[0]);
 446                 assertFalse("handleSuccess",   crFlags[1]);
 447                 assertFalse("handleFailure",   crFlags[2]);
 448                 assertTrue ("handleCancel",    crFlags[3]);
 449
 450                 // Validate the first coalesced request
 451                 assertTrue ("isCompleted", subRequest1.isCompleted());
 452                 assertFalse("isFailed",    subRequest1.isFailed());
 453                 assertTrue ("isCancelled", subRequest1.isCancelled());
 454
 455                 // Validate the second coalesced request
 456                 assertTrue ("isCompleted", subRequest2.isCompleted());
 457                 assertFalse("isFailed",    subRequest2.isFailed());
 458                 assertTrue ("isCancelled", subRequest2.isCancelled());
 459         }
 460
 461
 462         // ------------------------------------------------------------------------
 463         // cancel sub-requests
 464         // ------------------------------------------------------------------------
 465
 466     public void testCancelSubRequests() {
 467
 468                 final boolean[] crFlags = new boolean[4];
 469                 TmfCoalescedDataRequest request = setupTestRequest(crFlags);
 470                 TmfDataRequest subRequest1 = new TmfDataRequestStub(TmfEvent.class, 10, 100, 200);
 471                 TmfDataRequest subRequest2 = new TmfDataRequestStub(TmfEvent.class, 10, 100, 200);
 472                 request.addRequest(subRequest1);
 473                 request.addRequest(subRequest2);
 474
 475                 subRequest1.cancel();
 476
 477                 // Validate the first coalesced request
 478                 assertTrue ("isCompleted", subRequest1.isCompleted());
 479                 assertFalse("isFailed",    subRequest1.isFailed());
 480                 assertTrue ("isCancelled", subRequest1.isCancelled());
 481
 482                 // Validate the coalescing request
 483                 assertFalse("isCompleted", request.isCompleted());
 484                 assertFalse("isFailed",     request.isFailed());
 485                 assertFalse("isCancelled", request.isCancelled());
 486
 487                 // Cancel second sub-request
 488                 subRequest2.cancel();
 489
 490                 // Validate the second coalesced request
 491                 assertTrue ("isCompleted", subRequest2.isCompleted());
 492                 assertFalse("isFailed",    subRequest2.isFailed());
 493                 assertTrue ("isCancelled", subRequest2.isCancelled());
 494
 495                 // Validate the coalescing request
 496                 assertTrue ("isCompleted", request.isCompleted());
 497                 assertFalse("isFailed",    request.isFailed());
 498                 assertTrue ("isCancelled", request.isCancelled());
 499
 500                 // Finalize coalescing request -
 501                 // Note: No need to check "request.isCancelled()" since it was verified above
 502             request.cancel();
 503
 504                 assertTrue ("handleCompleted", crFlags[0]);
 505                 assertFalse("handleSuccess",   crFlags[1]);
 506                 assertFalse("handleFailure",   crFlags[2]);
 507                 assertTrue ("handleCancel",    crFlags[3]);
 508             }
 509
 510 }