1 /*******************************************************************************
2 * Copyright (c) 2012 Ericsson
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
10 * Francois Chouinard - Initial API and implementation
11 *******************************************************************************/
13 package org
.eclipse
.linuxtools
.tmf
.core
.tests
.request
;
15 import java
.util
.ArrayList
;
16 import java
.util
.Collection
;
18 import junit
.framework
.TestCase
;
20 import org
.eclipse
.core
.runtime
.IStatus
;
21 import org
.eclipse
.linuxtools
.tmf
.core
.event
.TmfTimeRange
;
22 import org
.eclipse
.linuxtools
.tmf
.core
.event
.TmfTimestamp
;
23 import org
.eclipse
.linuxtools
.tmf
.core
.filter
.ITmfFilter
;
24 import org
.eclipse
.linuxtools
.tmf
.core
.request
.ITmfRequest
;
25 import org
.eclipse
.linuxtools
.tmf
.core
.request
.ITmfRequest
.TmfRequestPriority
;
26 import org
.eclipse
.linuxtools
.tmf
.core
.request
.ITmfRequest
.TmfRequestState
;
27 import org
.eclipse
.linuxtools
.tmf
.core
.request
.TmfBlockFilter
;
28 import org
.eclipse
.linuxtools
.tmf
.core
.request
.TmfRangeFilter
;
29 import org
.eclipse
.linuxtools
.tmf
.tests
.stubs
.request
.TmfRequestStub
;
30 import org
.junit
.Test
;
33 * <b><u>TmfRequestTest</u></b>
35 * Test suite for the TmfRequest class.
37 @SuppressWarnings({"nls","javadoc"})
38 public class TmfRequestTest
extends TestCase
{
40 // ------------------------------------------------------------------------
42 // ------------------------------------------------------------------------
44 private static final TmfRequestPriority NORMAL
= TmfRequestPriority
.NORMAL
;
45 private static final TmfRequestPriority HIGH
= TmfRequestPriority
.HIGH
;
47 private static final long ALL_EVENTS
= ITmfRequest
.ALL_EVENTS
;
49 private static final TmfTimeRange ETERNITY
= TmfTimeRange
.ETERNITY
;
50 private static final TmfTimeRange EPOCH
= new TmfTimeRange(TmfTimestamp
.ZERO
, TmfTimestamp
.BIG_BANG
);
52 private static final TmfRequestState PENDING
= TmfRequestState
.PENDING
;
53 private static final TmfRequestState RUNNING
= TmfRequestState
.RUNNING
;
54 private static final TmfRequestState COMPLETED
= TmfRequestState
.COMPLETED
;
56 // ------------------------------------------------------------------------
58 // ------------------------------------------------------------------------
60 private ITmfRequest fRequest1
;
61 private ITmfRequest fRequest1b
;
62 private ITmfRequest fRequest1c
;
64 private ITmfRequest fRequest2
;
66 private static int fLastRequestId
;
68 // ------------------------------------------------------------------------
70 // ------------------------------------------------------------------------
73 * @param name the test name
75 public TmfRequestTest(String name
) {
80 protected void setUp() throws Exception
{
82 fRequest1
= new TmfRequestStub();
83 fRequest1b
= new TmfRequestStub();
84 fRequest1c
= new TmfRequestStub();
85 fRequest2
= new TmfRequestStub(HIGH
);
86 fLastRequestId
= fRequest2
.getRequestId();
90 protected void tearDown() throws Exception
{
94 private static ITmfRequest
setupDummyRequest(final boolean[] flags
) {
96 ITmfRequest request
= new TmfRequestStub(10, 100) {
98 public synchronized void handleCompleted() {
99 super.handleCompleted();
104 public void handleSuccess() {
105 super.handleSuccess();
110 public void handleFailure() {
111 super.handleFailure();
116 public void handleCancel() {
117 super.handleCancel();
121 fLastRequestId
= request
.getRequestId();
125 // ------------------------------------------------------------------------
127 // ------------------------------------------------------------------------
130 public void testTmfRequest() {
131 ITmfRequest request
= new TmfRequestStub();
134 assertEquals("getRequestId", fLastRequestId
, request
.getRequestId());
135 assertEquals("getRequestPriority", NORMAL
, request
.getRequestPriority());
136 assertEquals("getTimeRange", ETERNITY
, request
.getTimeRange());
137 assertEquals("getNbRequested", ALL_EVENTS
, request
.getNbRequested());
138 assertEquals("getStartIndex", 0, request
.getStartIndex());
139 assertEquals("getEventFilters", TmfBlockFilter
.ALL_EVENTS
, request
.getEventFilter(TmfBlockFilter
.class));
140 assertEquals("getEventFilters", TmfRangeFilter
.ALL_EVENTS
, request
.getEventFilter(TmfRangeFilter
.class));
141 assertNull("getParent", request
.getParent());
143 assertEquals("getNbEventsRead", 0, request
.getNbEventsRead());
144 assertEquals("getState", PENDING
, request
.getState());
145 assertFalse("isRunning", request
.isRunning());
146 assertFalse("isCompleted", request
.isCompleted());
148 assertNull("getStatus", request
.getStatus());
149 assertFalse("isOK", request
.isOK());
150 assertFalse("isFailed", request
.isFailed());
151 assertFalse("isCancelled", request
.isCancelled());
155 public void testTmfRequestPriority() {
157 // 1. Normal priority
158 ITmfRequest request
= new TmfRequestStub(TmfRequestPriority
.NORMAL
);
161 assertEquals("getRequestId", fLastRequestId
, request
.getRequestId());
162 assertEquals("getRequestPriority", NORMAL
, request
.getRequestPriority());
163 assertEquals("getTimeRange", ETERNITY
, request
.getTimeRange());
164 assertEquals("getNbRequested", ALL_EVENTS
, request
.getNbRequested());
165 assertEquals("getStartIndex", 0, request
.getStartIndex());
167 assertEquals("getNbEventsRead", 0, request
.getNbEventsRead());
168 assertEquals("getState", PENDING
, request
.getState());
169 assertFalse("isRunning", request
.isRunning());
170 assertFalse("isCompleted", request
.isCompleted());
172 assertNull("getStatus", request
.getStatus());
173 assertFalse("isOK", request
.isOK());
174 assertFalse("isFailed", request
.isFailed());
175 assertFalse("isCancelled", request
.isCancelled());
178 request
= new TmfRequestStub(TmfRequestPriority
.HIGH
);
181 assertEquals("getRequestId", fLastRequestId
, request
.getRequestId());
182 assertEquals("getRequestPriority", HIGH
, request
.getRequestPriority());
183 assertEquals("getTimeRange", ETERNITY
, request
.getTimeRange());
184 assertEquals("getNbRequested", ALL_EVENTS
, request
.getNbRequested());
185 assertEquals("getStartIndex", 0, request
.getStartIndex());
187 assertEquals("getNbEventsRead", 0, request
.getNbEventsRead());
188 assertEquals("getState", PENDING
, request
.getState());
189 assertFalse("isRunning", request
.isRunning());
190 assertFalse("isCompleted", request
.isCompleted());
192 assertNull("getStatus", request
.getStatus());
193 assertFalse("isOK", request
.isOK());
194 assertFalse("isFailed", request
.isFailed());
195 assertFalse("isCancelled", request
.isCancelled());
199 public void testTmfRequestTimeRange() {
202 ITmfRequest request
= new TmfRequestStub(ETERNITY
);
205 assertEquals("getRequestId", fLastRequestId
, request
.getRequestId());
206 assertEquals("getRequestPriority", NORMAL
, request
.getRequestPriority());
207 assertEquals("getTimeRange", ETERNITY
, request
.getTimeRange());
208 assertEquals("getNbRequested", ALL_EVENTS
, request
.getNbRequested());
209 assertEquals("getStartIndex", 0, request
.getStartIndex());
211 assertEquals("getNbEventsRead", 0, request
.getNbEventsRead());
212 assertEquals("getState", PENDING
, request
.getState());
213 assertFalse("isRunning", request
.isRunning());
214 assertFalse("isCompleted", request
.isCompleted());
216 assertNull("getStatus", request
.getStatus());
217 assertFalse("isOK", request
.isOK());
218 assertFalse("isFailed", request
.isFailed());
219 assertFalse("isCancelled", request
.isCancelled());
221 // 2. Since the epoch
222 request
= new TmfRequestStub(EPOCH
);
225 assertEquals("getRequestId", fLastRequestId
, request
.getRequestId());
226 assertEquals("getRequestPriority", NORMAL
, request
.getRequestPriority());
227 assertEquals("getTimeRange", EPOCH
, request
.getTimeRange());
228 assertEquals("getNbRequested", ALL_EVENTS
, request
.getNbRequested());
229 assertEquals("getStartIndex", 0, request
.getStartIndex());
231 assertEquals("getNbEventsRead", 0, request
.getNbEventsRead());
232 assertEquals("getState", PENDING
, request
.getState());
233 assertFalse("isRunning", request
.isRunning());
234 assertFalse("isCompleted", request
.isCompleted());
236 assertNull("getStatus", request
.getStatus());
237 assertFalse("isOK", request
.isOK());
238 assertFalse("isFailed", request
.isFailed());
239 assertFalse("isCancelled", request
.isCancelled());
243 public void testTmfRequestBlock() {
246 ITmfRequest request
= new TmfRequestStub(0, ALL_EVENTS
);
249 assertEquals("getRequestId", fLastRequestId
, request
.getRequestId());
250 assertEquals("getRequestPriority", NORMAL
, request
.getRequestPriority());
251 assertEquals("getTimeRange", ETERNITY
, request
.getTimeRange());
252 assertEquals("getNbRequested", ALL_EVENTS
, request
.getNbRequested());
253 assertEquals("getStartIndex", 0, request
.getStartIndex());
255 assertEquals("getNbEventsRead", 0, request
.getNbEventsRead());
256 assertEquals("getState", PENDING
, request
.getState());
257 assertFalse("isRunning", request
.isRunning());
258 assertFalse("isCompleted", request
.isCompleted());
260 assertNull("getStatus", request
.getStatus());
261 assertFalse("isOK", request
.isOK());
262 assertFalse("isFailed", request
.isFailed());
263 assertFalse("isCancelled", request
.isCancelled());
265 // 2. For an event count
266 long nbRequested
= 10000;
267 request
= new TmfRequestStub(0, nbRequested
);
270 assertEquals("getRequestId", fLastRequestId
, request
.getRequestId());
271 assertEquals("getRequestPriority", NORMAL
, request
.getRequestPriority());
272 assertEquals("getTimeRange", ETERNITY
, request
.getTimeRange());
273 assertEquals("getNbRequested", nbRequested
, request
.getNbRequested());
274 assertEquals("getStartIndex", 0, request
.getStartIndex());
276 assertEquals("getNbEventsRead", 0, request
.getNbEventsRead());
277 assertEquals("getState", PENDING
, request
.getState());
278 assertFalse("isRunning", request
.isRunning());
279 assertFalse("isCompleted", request
.isCompleted());
281 assertNull("getStatus", request
.getStatus());
282 assertFalse("isOK", request
.isOK());
283 assertFalse("isFailed", request
.isFailed());
284 assertFalse("isCancelled", request
.isCancelled());
286 // 3. From a given index
288 request
= new TmfRequestStub(index
, ALL_EVENTS
);
291 assertEquals("getRequestId", fLastRequestId
, request
.getRequestId());
292 assertEquals("getRequestPriority", NORMAL
, request
.getRequestPriority());
293 assertEquals("getTimeRange", ETERNITY
, request
.getTimeRange());
294 assertEquals("getNbRequested", ALL_EVENTS
, request
.getNbRequested());
295 assertEquals("getStartIndex", index
, request
.getStartIndex());
297 assertEquals("getNbEventsRead", 0, request
.getNbEventsRead());
298 assertEquals("getState", PENDING
, request
.getState());
299 assertFalse("isRunning", request
.isRunning());
300 assertFalse("isCompleted", request
.isCompleted());
302 assertNull("getStatus", request
.getStatus());
303 assertFalse("isOK", request
.isOK());
304 assertFalse("isFailed", request
.isFailed());
305 assertFalse("isCancelled", request
.isCancelled());
307 // 4. From a given index, for an event count
308 request
= new TmfRequestStub(index
, nbRequested
);
311 assertEquals("getRequestId", fLastRequestId
, request
.getRequestId());
312 assertEquals("getRequestPriority", NORMAL
, request
.getRequestPriority());
313 assertEquals("getTimeRange", ETERNITY
, request
.getTimeRange());
314 assertEquals("getNbRequested", nbRequested
, request
.getNbRequested());
315 assertEquals("getStartIndex", index
, request
.getStartIndex());
317 assertEquals("getNbEventsRead", 0, request
.getNbEventsRead());
318 assertEquals("getState", PENDING
, request
.getState());
319 assertFalse("isRunning", request
.isRunning());
320 assertFalse("isCompleted", request
.isCompleted());
322 assertNull("getStatus", request
.getStatus());
323 assertFalse("isOK", request
.isOK());
324 assertFalse("isFailed", request
.isFailed());
325 assertFalse("isCancelled", request
.isCancelled());
329 public void testTmfRequestRangeAndBlock() {
331 // 1. All events since beginning of time
332 ITmfRequest request
= new TmfRequestStub(ETERNITY
, 0, ALL_EVENTS
);
335 assertEquals("getRequestId", fLastRequestId
, request
.getRequestId());
336 assertEquals("getRequestPriority", NORMAL
, request
.getRequestPriority());
337 assertEquals("getTimeRange", ETERNITY
, request
.getTimeRange());
338 assertEquals("getNbRequested", ALL_EVENTS
, request
.getNbRequested());
339 assertEquals("getStartIndex", 0, request
.getStartIndex());
341 assertEquals("getNbEventsRead", 0, request
.getNbEventsRead());
342 assertEquals("getState", PENDING
, request
.getState());
343 assertFalse("isRunning", request
.isRunning());
344 assertFalse("isCompleted", request
.isCompleted());
346 assertNull("getStatus", request
.getStatus());
347 assertFalse("isOK", request
.isOK());
348 assertFalse("isFailed", request
.isFailed());
349 assertFalse("isCancelled", request
.isCancelled());
351 // 2. All events since the epoch
352 request
= new TmfRequestStub(EPOCH
, 0, ALL_EVENTS
);
355 assertEquals("getRequestId", fLastRequestId
, request
.getRequestId());
356 assertEquals("getRequestPriority", NORMAL
, request
.getRequestPriority());
357 assertEquals("getTimeRange", EPOCH
, request
.getTimeRange());
358 assertEquals("getNbRequested", ALL_EVENTS
, request
.getNbRequested());
359 assertEquals("getStartIndex", 0, request
.getStartIndex());
361 assertEquals("getNbEventsRead", 0, request
.getNbEventsRead());
362 assertEquals("getState", PENDING
, request
.getState());
363 assertFalse("isRunning", request
.isRunning());
364 assertFalse("isCompleted", request
.isCompleted());
366 assertNull("getStatus", request
.getStatus());
367 assertFalse("isOK", request
.isOK());
368 assertFalse("isFailed", request
.isFailed());
369 assertFalse("isCancelled", request
.isCancelled());
371 // 3. A block of events since the beginning of time
372 long nbRequested
= 10000;
373 request
= new TmfRequestStub(ETERNITY
, 0, nbRequested
);
376 assertEquals("getRequestId", fLastRequestId
, request
.getRequestId());
377 assertEquals("getRequestPriority", NORMAL
, request
.getRequestPriority());
378 assertEquals("getTimeRange", ETERNITY
, request
.getTimeRange());
379 assertEquals("getNbRequested", nbRequested
, request
.getNbRequested());
380 assertEquals("getStartIndex", 0, request
.getStartIndex());
382 assertEquals("getNbEventsRead", 0, request
.getNbEventsRead());
383 assertEquals("getState", PENDING
, request
.getState());
384 assertFalse("isRunning", request
.isRunning());
385 assertFalse("isCompleted", request
.isCompleted());
387 assertNull("getStatus", request
.getStatus());
388 assertFalse("isOK", request
.isOK());
389 assertFalse("isFailed", request
.isFailed());
390 assertFalse("isCancelled", request
.isCancelled());
392 // 4. All events from a given index since the beginning of time
394 request
= new TmfRequestStub(ETERNITY
, index
, ALL_EVENTS
);
397 assertEquals("getRequestId", fLastRequestId
, request
.getRequestId());
398 assertEquals("getRequestPriority", NORMAL
, request
.getRequestPriority());
399 assertEquals("getTimeRange", ETERNITY
, request
.getTimeRange());
400 assertEquals("getNbRequested", ALL_EVENTS
, request
.getNbRequested());
401 assertEquals("getStartIndex", index
, request
.getStartIndex());
403 assertEquals("getNbEventsRead", 0, request
.getNbEventsRead());
404 assertEquals("getState", PENDING
, request
.getState());
405 assertFalse("isRunning", request
.isRunning());
406 assertFalse("isCompleted", request
.isCompleted());
408 assertNull("getStatus", request
.getStatus());
409 assertFalse("isOK", request
.isOK());
410 assertFalse("isFailed", request
.isFailed());
411 assertFalse("isCancelled", request
.isCancelled());
413 // 4. Some events from a given index since the epoch
414 request
= new TmfRequestStub(EPOCH
, index
, nbRequested
);
417 assertEquals("getRequestId", fLastRequestId
, request
.getRequestId());
418 assertEquals("getRequestPriority", NORMAL
, request
.getRequestPriority());
419 assertEquals("getTimeRange", EPOCH
, request
.getTimeRange());
420 assertEquals("getNbRequested", nbRequested
, request
.getNbRequested());
421 assertEquals("getStartIndex", index
, request
.getStartIndex());
423 assertEquals("getNbEventsRead", 0, request
.getNbEventsRead());
424 assertEquals("getState", PENDING
, request
.getState());
425 assertFalse("isRunning", request
.isRunning());
426 assertFalse("isCompleted", request
.isCompleted());
428 assertNull("getStatus", request
.getStatus());
429 assertFalse("isOK", request
.isOK());
430 assertFalse("isFailed", request
.isFailed());
431 assertFalse("isCancelled", request
.isCancelled());
435 public void testTmfRequestRangeAndBlockWithPriority() {
437 // 1. All events since beginning of time
438 ITmfRequest request
= new TmfRequestStub(ETERNITY
, 0, ALL_EVENTS
, NORMAL
);
441 assertEquals("getRequestId", fLastRequestId
, request
.getRequestId());
442 assertEquals("getRequestPriority", NORMAL
, request
.getRequestPriority());
443 assertEquals("getTimeRange", ETERNITY
, request
.getTimeRange());
444 assertEquals("getNbRequested", ALL_EVENTS
, request
.getNbRequested());
445 assertEquals("getStartIndex", 0, request
.getStartIndex());
447 assertEquals("getNbEventsRead", 0, request
.getNbEventsRead());
448 assertEquals("getState", PENDING
, request
.getState());
449 assertFalse("isRunning", request
.isRunning());
450 assertFalse("isCompleted", request
.isCompleted());
452 assertNull("getStatus", request
.getStatus());
453 assertFalse("isOK", request
.isOK());
454 assertFalse("isFailed", request
.isFailed());
455 assertFalse("isCancelled", request
.isCancelled());
457 // 2. All events since beginning of time, high priority
458 request
= new TmfRequestStub(ETERNITY
, 0, ALL_EVENTS
, HIGH
);
461 assertEquals("getRequestId", fLastRequestId
, request
.getRequestId());
462 assertEquals("getRequestPriority", HIGH
, request
.getRequestPriority());
463 assertEquals("getTimeRange", ETERNITY
, request
.getTimeRange());
464 assertEquals("getNbRequested", ALL_EVENTS
, request
.getNbRequested());
465 assertEquals("getStartIndex", 0, request
.getStartIndex());
467 assertEquals("getNbEventsRead", 0, request
.getNbEventsRead());
468 assertEquals("getState", PENDING
, request
.getState());
469 assertFalse("isRunning", request
.isRunning());
470 assertFalse("isCompleted", request
.isCompleted());
472 assertNull("getStatus", request
.getStatus());
473 assertFalse("isOK", request
.isOK());
474 assertFalse("isFailed", request
.isFailed());
475 assertFalse("isCancelled", request
.isCancelled());
477 // 3. A block of events since the beginning of time
478 long nbRequested
= 10000;
480 request
= new TmfRequestStub(EPOCH
, index
, nbRequested
, NORMAL
);
483 assertEquals("getRequestId", fLastRequestId
, request
.getRequestId());
484 assertEquals("getRequestPriority", NORMAL
, request
.getRequestPriority());
485 assertEquals("getTimeRange", EPOCH
, request
.getTimeRange());
486 assertEquals("getNbRequested", nbRequested
, request
.getNbRequested());
487 assertEquals("getStartIndex", index
, request
.getStartIndex());
489 assertEquals("getNbEventsRead", 0, request
.getNbEventsRead());
490 assertEquals("getState", PENDING
, request
.getState());
491 assertFalse("isRunning", request
.isRunning());
492 assertFalse("isCompleted", request
.isCompleted());
494 assertNull("getStatus", request
.getStatus());
495 assertFalse("isOK", request
.isOK());
496 assertFalse("isFailed", request
.isFailed());
497 assertFalse("isCancelled", request
.isCancelled());
499 // 4. A block of events since the beginning of time, high priority
500 request
= new TmfRequestStub(EPOCH
, index
, nbRequested
, HIGH
);
503 assertEquals("getRequestId", fLastRequestId
, request
.getRequestId());
504 assertEquals("getRequestPriority", HIGH
, request
.getRequestPriority());
505 assertEquals("getTimeRange", EPOCH
, request
.getTimeRange());
506 assertEquals("getNbRequested", nbRequested
, request
.getNbRequested());
507 assertEquals("getStartIndex", index
, request
.getStartIndex());
509 assertEquals("getNbEventsRead", 0, request
.getNbEventsRead());
510 assertEquals("getState", PENDING
, request
.getState());
511 assertFalse("isRunning", request
.isRunning());
512 assertFalse("isCompleted", request
.isCompleted());
514 assertNull("getStatus", request
.getStatus());
515 assertFalse("isOK", request
.isOK());
516 assertFalse("isFailed", request
.isFailed());
517 assertFalse("isCancelled", request
.isCancelled());
521 public void testTmfRequestCopy() {
522 TmfRequestStub other
= new TmfRequestStub();
523 ITmfRequest request
= new TmfRequestStub(other
);
526 assertEquals("getRequestId", fLastRequestId
, request
.getRequestId());
527 assertEquals("getRequestPriority", NORMAL
, request
.getRequestPriority());
528 assertEquals("getTimeRange", ETERNITY
, request
.getTimeRange());
529 assertEquals("getNbRequested", ALL_EVENTS
, request
.getNbRequested());
530 assertEquals("getStartIndex", 0, request
.getStartIndex());
532 assertEquals("getNbEventsRead", 0, request
.getNbEventsRead());
533 assertEquals("getState", PENDING
, request
.getState());
534 assertFalse("isRunning", request
.isRunning());
535 assertFalse("isCompleted", request
.isCompleted());
537 assertNull("getStatus", request
.getStatus());
538 assertFalse("isOK", request
.isOK());
539 assertFalse("isFailed", request
.isFailed());
540 assertFalse("isCancelled", request
.isCancelled());
543 // ------------------------------------------------------------------------
545 // ------------------------------------------------------------------------
548 public void testEqualsReflexivity() {
549 assertEquals("equals", fRequest1
, fRequest1
);
550 assertEquals("equals", fRequest2
, fRequest2
);
552 assertFalse("equals", fRequest1
.equals(fRequest2
));
553 assertFalse("equals", fRequest2
.equals(fRequest1
));
557 public void testEqualsSymmetry() {
558 assertEquals("equals", fRequest1
, fRequest1b
);
559 assertEquals("equals", fRequest1b
, fRequest1
);
561 assertFalse("equals", fRequest1
.equals(fRequest2
));
562 assertFalse("equals", fRequest2
.equals(fRequest1
));
566 public void testEqualsTransivity() {
567 assertEquals("equals", fRequest1
, fRequest1b
);
568 assertEquals("equals", fRequest1b
, fRequest1c
);
569 assertEquals("equals", fRequest1c
, fRequest1
);
573 public void testEqualsNull() {
574 assertFalse("equals", fRequest1
.equals(null));
575 assertFalse("equals", fRequest2
.equals(null));
578 // ------------------------------------------------------------------------
580 // ------------------------------------------------------------------------
583 public void testHashCode() {
584 assertTrue("hashCode", fRequest1
.hashCode() == fRequest1
.hashCode());
585 assertTrue("hashCode", fRequest2
.hashCode() == fRequest2
.hashCode());
586 assertTrue("hashCode", fRequest1
.hashCode() != fRequest2
.hashCode());
589 // ------------------------------------------------------------------------
591 // ------------------------------------------------------------------------
594 public void testToString() {
595 String expected1
= "TmfRequest [fRequestId=" + fRequest1
.getRequestId() + "]";
596 String expected2
= "TmfRequest [fRequestId=" + fRequest2
.getRequestId() + "]";
598 assertEquals("toString", expected1
, fRequest1
.toString());
599 assertEquals("toString", expected2
, fRequest2
.toString());
602 // ------------------------------------------------------------------------
604 // ------------------------------------------------------------------------
607 public void testSetTimeRange() {
609 TmfRequestStub request
= new TmfRequestStub(ETERNITY
);
610 request
.setTimeRange(EPOCH
);
613 assertEquals("getRequestId", fLastRequestId
, request
.getRequestId());
614 assertEquals("getRequestPriority", NORMAL
, request
.getRequestPriority());
615 assertEquals("getTimeRange", EPOCH
, request
.getTimeRange());
616 assertEquals("getNbRequested", ALL_EVENTS
, request
.getNbRequested());
617 assertEquals("getStartIndex", 0, request
.getStartIndex());
619 assertEquals("getNbEventsRead", 0, request
.getNbEventsRead());
620 assertEquals("getState", PENDING
, request
.getState());
621 assertFalse("isRunning", request
.isRunning());
622 assertFalse("isCompleted", request
.isCompleted());
624 assertNull("getStatus", request
.getStatus());
625 assertFalse("isOK", request
.isOK());
626 assertFalse("isFailed", request
.isFailed());
627 assertFalse("isCancelled", request
.isCancelled());
631 public void testSetNbRequested() {
632 long nbRequested
= 10000;
634 TmfRequestStub request
= new TmfRequestStub(ETERNITY
, 0, ALL_EVENTS
);
635 request
.setNbRequested(nbRequested
);
638 assertEquals("getRequestId", fLastRequestId
, request
.getRequestId());
639 assertEquals("getRequestPriority", NORMAL
, request
.getRequestPriority());
640 assertEquals("getTimeRange", ETERNITY
, request
.getTimeRange());
641 assertEquals("getNbRequested", nbRequested
, request
.getNbRequested());
642 assertEquals("getStartIndex", 0, request
.getStartIndex());
644 assertEquals("getNbEventsRead", 0, request
.getNbEventsRead());
645 assertEquals("getState", PENDING
, request
.getState());
646 assertFalse("isRunning", request
.isRunning());
647 assertFalse("isCompleted", request
.isCompleted());
649 assertNull("getStatus", request
.getStatus());
650 assertFalse("isOK", request
.isOK());
651 assertFalse("isFailed", request
.isFailed());
652 assertFalse("isCancelled", request
.isCancelled());
656 public void testSetStartIndex() {
659 TmfRequestStub request
= new TmfRequestStub(ETERNITY
, 0, ALL_EVENTS
);
660 request
.setStartIndex(index
);
663 assertEquals("getRequestId", fLastRequestId
, request
.getRequestId());
664 assertEquals("getRequestPriority", NORMAL
, request
.getRequestPriority());
665 assertEquals("getTimeRange", ETERNITY
, request
.getTimeRange());
666 assertEquals("getNbRequested", ALL_EVENTS
, request
.getNbRequested());
667 assertEquals("getStartIndex", index
, request
.getStartIndex());
669 assertEquals("getNbEventsRead", 0, request
.getNbEventsRead());
670 assertEquals("getState", PENDING
, request
.getState());
671 assertFalse("isRunning", request
.isRunning());
672 assertFalse("isCompleted", request
.isCompleted());
674 assertNull("getStatus", request
.getStatus());
675 assertFalse("isOK", request
.isOK());
676 assertFalse("isFailed", request
.isFailed());
677 assertFalse("isCancelled", request
.isCancelled());
680 // ------------------------------------------------------------------------
681 // setEventFilters, addEventFilter
682 // ------------------------------------------------------------------------
685 public void testSetEventFilters() {
686 TmfRequestStub request
= new TmfRequestStub();
687 Collection
<ITmfFilter
> filters
= new ArrayList
<ITmfFilter
>();
688 request
.setEventFilters(filters
);
689 assertEquals("setEventFilters", TmfBlockFilter
.ALL_EVENTS
, request
.getEventFilter(TmfBlockFilter
.class));
690 assertEquals("setEventFilters", TmfRangeFilter
.ALL_EVENTS
, request
.getEventFilter(TmfRangeFilter
.class));
692 TmfBlockFilter blockFilter
= new TmfBlockFilter(10, 1000);
693 filters
.add(blockFilter
);
694 request
.setEventFilters(filters
);
695 assertEquals("setEventFilters", blockFilter
, request
.getEventFilter(TmfBlockFilter
.class));
696 assertEquals("setEventFilters", TmfRangeFilter
.ALL_EVENTS
, request
.getEventFilter(TmfRangeFilter
.class));
698 TmfRangeFilter rangeFilter
= new TmfRangeFilter(EPOCH
);
699 filters
.add(rangeFilter
);
700 request
.setEventFilters(filters
);
701 assertEquals("setEventFilters", blockFilter
, request
.getEventFilter(TmfBlockFilter
.class));
702 assertEquals("setEventFilters", rangeFilter
, request
.getEventFilter(TmfRangeFilter
.class));
706 public void testAddEventFilters() {
707 TmfRequestStub request
= new TmfRequestStub();
708 Collection
<ITmfFilter
> filters
= new ArrayList
<ITmfFilter
>();
709 request
.setEventFilters(filters
);
710 assertEquals("setEventFilters", TmfBlockFilter
.ALL_EVENTS
, request
.getEventFilter(TmfBlockFilter
.class));
711 assertEquals("setEventFilters", TmfRangeFilter
.ALL_EVENTS
, request
.getEventFilter(TmfRangeFilter
.class));
713 TmfBlockFilter blockFilter
= new TmfBlockFilter(10, 1000);
714 request
.addEventFilter(blockFilter
);
715 assertEquals("setEventFilters", blockFilter
, request
.getEventFilter(TmfBlockFilter
.class));
716 assertEquals("setEventFilters", TmfRangeFilter
.ALL_EVENTS
, request
.getEventFilter(TmfRangeFilter
.class));
718 TmfRangeFilter rangeFilter
= new TmfRangeFilter(EPOCH
);
719 request
.addEventFilter(rangeFilter
);
720 assertEquals("setEventFilters", blockFilter
, request
.getEventFilter(TmfBlockFilter
.class));
721 assertEquals("setEventFilters", rangeFilter
, request
.getEventFilter(TmfRangeFilter
.class));
724 // ------------------------------------------------------------------------
725 // setParent, notifyParent
726 // ------------------------------------------------------------------------
729 public void testSetParent() {
730 TmfRequestStub request1
= new TmfRequestStub();
731 TmfRequestStub request2
= new TmfRequestStub();
733 assertNull("getParent", request2
.getParent());
734 request2
.setParent(request1
);
735 assertEquals("getParent", request1
, request2
.getParent());
736 request2
.setParent(null);
737 assertNull("getParent", request2
.getParent());
741 public void testNotifyParent() {
742 final Boolean
[] notifications
= new Boolean
[2];
743 notifications
[0] = notifications
[1] = false;
745 TmfRequestStub request1
= new TmfRequestStub() {
747 public void notifyParent(ITmfRequest child
) {
748 notifications
[0] = true;
749 super.notifyParent(this);
752 TmfRequestStub request2
= new TmfRequestStub() {
754 public void notifyParent(ITmfRequest child
) {
755 notifications
[1] = true;
756 super.notifyParent(this);
760 request2
.setParent(request1
);
761 assertFalse("notifyParent", notifications
[0]);
762 assertFalse("notifyParent", notifications
[1]);
764 request2
.notifyParent(null);
765 assertTrue("notifyParent", notifications
[0]);
766 assertTrue("notifyParent", notifications
[1]);
769 // ------------------------------------------------------------------------
771 // ------------------------------------------------------------------------
774 public void testStart() {
776 final boolean[] flags
= new boolean[4];
777 ITmfRequest request
= setupDummyRequest(flags
);
780 assertTrue("isRunning", request
.isRunning());
781 assertFalse("isCompleted", request
.isCompleted());
782 assertEquals("getState", RUNNING
, request
.getState());
784 assertNull("getStatus", request
.getStatus());
786 assertFalse("handleCompleted", flags
[0]);
787 assertFalse("handleSuccess", flags
[1]);
788 assertFalse("handleFailure", flags
[2]);
789 assertFalse("handleCancel", flags
[3]);
792 // ------------------------------------------------------------------------
794 // ------------------------------------------------------------------------
797 public void testDone() {
799 final boolean[] flags
= new boolean[4];
800 ITmfRequest request
= setupDummyRequest(flags
);
803 assertFalse("isRunning", request
.isRunning());
804 assertTrue("isCompleted", request
.isCompleted());
805 assertEquals("getState", COMPLETED
, request
.getState());
807 assertEquals("getStatus", IStatus
.OK
, request
.getStatus().getSeverity());
808 assertTrue("isOK", request
.isOK());
809 assertFalse("isFailed", request
.isFailed());
810 assertFalse("isCancelled", request
.isCancelled());
812 assertTrue("handleCompleted", flags
[0]);
813 assertTrue("handleSuccess", flags
[1]);
814 assertFalse("handleFailure", flags
[2]);
815 assertFalse("handleCancel", flags
[3]);
818 // ------------------------------------------------------------------------
820 // ------------------------------------------------------------------------
823 public void testFail() {
825 final boolean[] flags
= new boolean[4];
826 ITmfRequest request
= setupDummyRequest(flags
);
829 assertFalse("isRunning", request
.isRunning());
830 assertTrue("isCompleted", request
.isCompleted());
831 assertEquals("getState", COMPLETED
, request
.getState());
833 assertEquals("getStatus", IStatus
.ERROR
, request
.getStatus().getSeverity());
834 assertFalse("isOK", request
.isOK());
835 assertTrue("isFailed", request
.isFailed());
836 assertFalse("isCancelled", request
.isCancelled());
838 assertTrue("handleCompleted", flags
[0]);
839 assertFalse("handleSuccess", flags
[1]);
840 assertTrue("handleFailure", flags
[2]);
841 assertFalse("handleCancel", flags
[3]);
844 // ------------------------------------------------------------------------
846 // ------------------------------------------------------------------------
849 public void testCancel() {
851 final boolean[] flags
= new boolean[4];
852 ITmfRequest request
= setupDummyRequest(flags
);
855 assertFalse("isRunning", request
.isRunning());
856 assertTrue("isCompleted", request
.isCompleted());
857 assertEquals("getState", COMPLETED
, request
.getState());
859 assertEquals("getStatus", IStatus
.CANCEL
, request
.getStatus().getSeverity());
860 assertFalse("isOK", request
.isOK());
861 assertFalse("isFailed", request
.isFailed());
862 assertTrue("isCancelled", request
.isCancelled());
864 assertTrue("handleCompleted", flags
[0]);
865 assertFalse("handleSuccess", flags
[1]);
866 assertFalse("handleFailure", flags
[2]);
867 assertTrue("handleCancel", flags
[3]);