projects / deliverable / tracecompass.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
[CTF] fix support for traces with per-event contexts
[deliverable/tracecompass.git] / org.eclipse.linuxtools.tmf.core.tests / src / org / eclipse / linuxtools / tmf / core / tests / request / TmfRequestTest.java
CommitLineData
8584dc20
FC		 1/*******************************************************************************
2 * Copyright (c) 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 *******************************************************************************/
12
13package org.eclipse.linuxtools.tmf.core.tests.request;
14
15import java.util.ArrayList;
16import java.util.Collection;
17
18import junit.framework.TestCase;
19
20import org.eclipse.core.runtime.IStatus;
21import org.eclipse.linuxtools.tmf.core.event.TmfTimeRange;
22import org.eclipse.linuxtools.tmf.core.event.TmfTimestamp;
23import org.eclipse.linuxtools.tmf.core.filter.ITmfFilter;
24import org.eclipse.linuxtools.tmf.core.request.ITmfRequest;
25import org.eclipse.linuxtools.tmf.core.request.ITmfRequest.TmfRequestPriority;
26import org.eclipse.linuxtools.tmf.core.request.ITmfRequest.TmfRequestState;
27import org.eclipse.linuxtools.tmf.core.request.TmfBlockFilter;
28import org.eclipse.linuxtools.tmf.core.request.TmfRangeFilter;
29import org.eclipse.linuxtools.tmf.tests.stubs.request.TmfRequestStub;
30import org.junit.Test;
31
32/**
33 * <b><u>TmfRequestTest</u></b>
34 * <p>
35 * Test suite for the TmfRequest class.
36 */
37@SuppressWarnings({"nls","javadoc"})
38public class TmfRequestTest extends TestCase {
39
40 // ------------------------------------------------------------------------
41 // Constants
42 // ------------------------------------------------------------------------
43
44 private static final TmfRequestPriority NORMAL = TmfRequestPriority.NORMAL;
45 private static final TmfRequestPriority HIGH = TmfRequestPriority.HIGH;
46
47 private static final long ALL_EVENTS = ITmfRequest.ALL_EVENTS;
48
49 private static final TmfTimeRange ETERNITY = TmfTimeRange.ETERNITY;
50 private static final TmfTimeRange EPOCH = new TmfTimeRange(TmfTimestamp.ZERO, TmfTimestamp.BIG_BANG);
51
52 private static final TmfRequestState PENDING = TmfRequestState.PENDING;
53 private static final TmfRequestState RUNNING = TmfRequestState.RUNNING;
54 private static final TmfRequestState COMPLETED = TmfRequestState.COMPLETED;
55
56 // ------------------------------------------------------------------------
57 // Variables
58 // ------------------------------------------------------------------------
59
140b65fa
FC		 60 private ITmfRequest fRequest1;
61 private ITmfRequest fRequest1b;
62 private ITmfRequest fRequest1c;
8584dc20 63
140b65fa 64 private ITmfRequest fRequest2;
8584dc20
FC		 65
66 private static int fLastRequestId;
67
68 // ------------------------------------------------------------------------
69 // Housekeeping
70 // ------------------------------------------------------------------------
71
72 /**
73 * @param name the test name
74 */
75 public TmfRequestTest(String name) {
76 super(name);
77 }
78
79 @Override
80 protected void setUp() throws Exception {
81 super.setUp();
82 fRequest1 = new TmfRequestStub();
83 fRequest1b = new TmfRequestStub();
84 fRequest1c = new TmfRequestStub();
85 fRequest2 = new TmfRequestStub(HIGH);
86 fLastRequestId = fRequest2.getRequestId();
87 }
88
89 @Override
90 protected void tearDown() throws Exception {
91 super.tearDown();
92 }
93
94 private static ITmfRequest setupDummyRequest(final boolean[] flags) {
95
96 ITmfRequest request = new TmfRequestStub(10, 100) {
97 @Override
98 public synchronized void handleCompleted() {
99 super.handleCompleted();
100 flags[0] = true;
101 }
102
103 @Override
104 public void handleSuccess() {
105 super.handleSuccess();
106 flags[1] = true;
107 }
108
109 @Override
110 public void handleFailure() {
111 super.handleFailure();
112 flags[2] = true;
113 }
114
115 @Override
116 public void handleCancel() {
117 super.handleCancel();
118 flags[3] = true;
119 }
120 };
121 fLastRequestId = request.getRequestId();
122 return request;
123 }
124
125 // ------------------------------------------------------------------------
126 // Constructors
127 // ------------------------------------------------------------------------
128
129 @Test
130 public void testTmfRequest() {
131 ITmfRequest request = new TmfRequestStub();
132 fLastRequestId++;
133
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());
142
143 assertEquals("getNbEventsRead", 0, request.getNbEventsRead());
144 assertEquals("getState", PENDING, request.getState());
145 assertFalse("isRunning", request.isRunning());
146 assertFalse("isCompleted", request.isCompleted());
147
148 assertNull("getStatus", request.getStatus());
149 assertFalse("isOK", request.isOK());
150 assertFalse("isFailed", request.isFailed());
151 assertFalse("isCancelled", request.isCancelled());
152 }
153
154 @Test
155 public void testTmfRequestPriority() {
156
157 // 1. Normal priority
158 ITmfRequest request = new TmfRequestStub(TmfRequestPriority.NORMAL);
159 fLastRequestId++;
160
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());
166
167 assertEquals("getNbEventsRead", 0, request.getNbEventsRead());
168 assertEquals("getState", PENDING, request.getState());
169 assertFalse("isRunning", request.isRunning());
170 assertFalse("isCompleted", request.isCompleted());
171
172 assertNull("getStatus", request.getStatus());
173 assertFalse("isOK", request.isOK());
174 assertFalse("isFailed", request.isFailed());
175 assertFalse("isCancelled", request.isCancelled());
176
177 // 2. High priority
178 request = new TmfRequestStub(TmfRequestPriority.HIGH);
179 fLastRequestId++;
180
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());
186
187 assertEquals("getNbEventsRead", 0, request.getNbEventsRead());
188 assertEquals("getState", PENDING, request.getState());
189 assertFalse("isRunning", request.isRunning());
190 assertFalse("isCompleted", request.isCompleted());
191
192 assertNull("getStatus", request.getStatus());
193 assertFalse("isOK", request.isOK());
194 assertFalse("isFailed", request.isFailed());
195 assertFalse("isCancelled", request.isCancelled());
196 }
197
198 @Test
199 public void testTmfRequestTimeRange() {
200
201 // 1. Eternity
202 ITmfRequest request = new TmfRequestStub(ETERNITY);
203 fLastRequestId++;
204
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());
210
211 assertEquals("getNbEventsRead", 0, request.getNbEventsRead());
212 assertEquals("getState", PENDING, request.getState());
213 assertFalse("isRunning", request.isRunning());
214 assertFalse("isCompleted", request.isCompleted());
215
216 assertNull("getStatus", request.getStatus());
217 assertFalse("isOK", request.isOK());
218 assertFalse("isFailed", request.isFailed());
219 assertFalse("isCancelled", request.isCancelled());
220
221 // 2. Since the epoch
222 request = new TmfRequestStub(EPOCH);
223 fLastRequestId++;
224
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());
230
231 assertEquals("getNbEventsRead", 0, request.getNbEventsRead());
232 assertEquals("getState", PENDING, request.getState());
233 assertFalse("isRunning", request.isRunning());
234 assertFalse("isCompleted", request.isCompleted());
235
236 assertNull("getStatus", request.getStatus());
237 assertFalse("isOK", request.isOK());
238 assertFalse("isFailed", request.isFailed());
239 assertFalse("isCancelled", request.isCancelled());
240 }
241
242 @Test
243 public void testTmfRequestBlock() {
244
245 // 1. All events
246 ITmfRequest request = new TmfRequestStub(0, ALL_EVENTS);
247 fLastRequestId++;
248
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());
254
255 assertEquals("getNbEventsRead", 0, request.getNbEventsRead());
256 assertEquals("getState", PENDING, request.getState());
257 assertFalse("isRunning", request.isRunning());
258 assertFalse("isCompleted", request.isCompleted());
259
260 assertNull("getStatus", request.getStatus());
261 assertFalse("isOK", request.isOK());
262 assertFalse("isFailed", request.isFailed());
263 assertFalse("isCancelled", request.isCancelled());
264
265 // 2. For an event count
266 long nbRequested = 10000;
267 request = new TmfRequestStub(0, nbRequested);
268 fLastRequestId++;
269
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());
275
276 assertEquals("getNbEventsRead", 0, request.getNbEventsRead());
277 assertEquals("getState", PENDING, request.getState());
278 assertFalse("isRunning", request.isRunning());
279 assertFalse("isCompleted", request.isCompleted());
280
281 assertNull("getStatus", request.getStatus());
282 assertFalse("isOK", request.isOK());
283 assertFalse("isFailed", request.isFailed());
284 assertFalse("isCancelled", request.isCancelled());
285
286 // 3. From a given index
287 long index = 100;
288 request = new TmfRequestStub(index, ALL_EVENTS);
289 fLastRequestId++;
290
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());
296
297 assertEquals("getNbEventsRead", 0, request.getNbEventsRead());
298 assertEquals("getState", PENDING, request.getState());
299 assertFalse("isRunning", request.isRunning());
300 assertFalse("isCompleted", request.isCompleted());
301
302 assertNull("getStatus", request.getStatus());
303 assertFalse("isOK", request.isOK());
304 assertFalse("isFailed", request.isFailed());
305 assertFalse("isCancelled", request.isCancelled());
306
307 // 4. From a given index, for an event count
308 request = new TmfRequestStub(index, nbRequested);
309 fLastRequestId++;
310
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());
316
317 assertEquals("getNbEventsRead", 0, request.getNbEventsRead());
318 assertEquals("getState", PENDING, request.getState());
319 assertFalse("isRunning", request.isRunning());
320 assertFalse("isCompleted", request.isCompleted());
321
322 assertNull("getStatus", request.getStatus());
323 assertFalse("isOK", request.isOK());
324 assertFalse("isFailed", request.isFailed());
325 assertFalse("isCancelled", request.isCancelled());
326 }
327
328 @Test
329 public void testTmfRequestRangeAndBlock() {
330
331 // 1. All events since beginning of time
332 ITmfRequest request = new TmfRequestStub(ETERNITY, 0, ALL_EVENTS);
333 fLastRequestId++;
334
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());
340
341 assertEquals("getNbEventsRead", 0, request.getNbEventsRead());
342 assertEquals("getState", PENDING, request.getState());
343 assertFalse("isRunning", request.isRunning());
344 assertFalse("isCompleted", request.isCompleted());
345
346 assertNull("getStatus", request.getStatus());
347 assertFalse("isOK", request.isOK());
348 assertFalse("isFailed", request.isFailed());
349 assertFalse("isCancelled", request.isCancelled());
350
351 // 2. All events since the epoch
352 request = new TmfRequestStub(EPOCH, 0, ALL_EVENTS);
353 fLastRequestId++;
354
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());
360
361 assertEquals("getNbEventsRead", 0, request.getNbEventsRead());
362 assertEquals("getState", PENDING, request.getState());
363 assertFalse("isRunning", request.isRunning());
364 assertFalse("isCompleted", request.isCompleted());
365
366 assertNull("getStatus", request.getStatus());
367 assertFalse("isOK", request.isOK());
368 assertFalse("isFailed", request.isFailed());
369 assertFalse("isCancelled", request.isCancelled());
370
371 // 3. A block of events since the beginning of time
372 long nbRequested = 10000;
373 request = new TmfRequestStub(ETERNITY, 0, nbRequested);
374 fLastRequestId++;
375
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());
381
382 assertEquals("getNbEventsRead", 0, request.getNbEventsRead());
383 assertEquals("getState", PENDING, request.getState());
384 assertFalse("isRunning", request.isRunning());
385 assertFalse("isCompleted", request.isCompleted());
386
387 assertNull("getStatus", request.getStatus());
388 assertFalse("isOK", request.isOK());
389 assertFalse("isFailed", request.isFailed());
390 assertFalse("isCancelled", request.isCancelled());
391
392 // 4. All events from a given index since the beginning of time
393 long index = 100;
394 request = new TmfRequestStub(ETERNITY, index, ALL_EVENTS);
395 fLastRequestId++;
396
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());
402
403 assertEquals("getNbEventsRead", 0, request.getNbEventsRead());
404 assertEquals("getState", PENDING, request.getState());
405 assertFalse("isRunning", request.isRunning());
406 assertFalse("isCompleted", request.isCompleted());
407
408 assertNull("getStatus", request.getStatus());
409 assertFalse("isOK", request.isOK());
410 assertFalse("isFailed", request.isFailed());
411 assertFalse("isCancelled", request.isCancelled());
412
413 // 4. Some events from a given index since the epoch
414 request = new TmfRequestStub(EPOCH, index, nbRequested);
415 fLastRequestId++;
416
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());
422
423 assertEquals("getNbEventsRead", 0, request.getNbEventsRead());
424 assertEquals("getState", PENDING, request.getState());
425 assertFalse("isRunning", request.isRunning());
426 assertFalse("isCompleted", request.isCompleted());
427
428 assertNull("getStatus", request.getStatus());
429 assertFalse("isOK", request.isOK());
430 assertFalse("isFailed", request.isFailed());
431 assertFalse("isCancelled", request.isCancelled());
432 }
433
434 @Test
435 public void testTmfRequestRangeAndBlockWithPriority() {
436
437 // 1. All events since beginning of time
438 ITmfRequest request = new TmfRequestStub(ETERNITY, 0, ALL_EVENTS, NORMAL);
439 fLastRequestId++;
440
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());
446
447 assertEquals("getNbEventsRead", 0, request.getNbEventsRead());
448 assertEquals("getState", PENDING, request.getState());
449 assertFalse("isRunning", request.isRunning());
450 assertFalse("isCompleted", request.isCompleted());
451
452 assertNull("getStatus", request.getStatus());
453 assertFalse("isOK", request.isOK());
454 assertFalse("isFailed", request.isFailed());
455 assertFalse("isCancelled", request.isCancelled());
456
457 // 2. All events since beginning of time, high priority
458 request = new TmfRequestStub(ETERNITY, 0, ALL_EVENTS, HIGH);
459 fLastRequestId++;
460
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());
466
467 assertEquals("getNbEventsRead", 0, request.getNbEventsRead());
468 assertEquals("getState", PENDING, request.getState());
469 assertFalse("isRunning", request.isRunning());
470 assertFalse("isCompleted", request.isCompleted());
471
472 assertNull("getStatus", request.getStatus());
473 assertFalse("isOK", request.isOK());
474 assertFalse("isFailed", request.isFailed());
475 assertFalse("isCancelled", request.isCancelled());
476
477 // 3. A block of events since the beginning of time
478 long nbRequested = 10000;
479 long index = 100;
480 request = new TmfRequestStub(EPOCH, index, nbRequested, NORMAL);
481 fLastRequestId++;
482
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());
488
489 assertEquals("getNbEventsRead", 0, request.getNbEventsRead());
490 assertEquals("getState", PENDING, request.getState());
491 assertFalse("isRunning", request.isRunning());
492 assertFalse("isCompleted", request.isCompleted());
493
494 assertNull("getStatus", request.getStatus());
495 assertFalse("isOK", request.isOK());
496 assertFalse("isFailed", request.isFailed());
497 assertFalse("isCancelled", request.isCancelled());
498
499 // 4. A block of events since the beginning of time, high priority
500 request = new TmfRequestStub(EPOCH, index, nbRequested, HIGH);
501 fLastRequestId++;
502
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());
508
509 assertEquals("getNbEventsRead", 0, request.getNbEventsRead());
510 assertEquals("getState", PENDING, request.getState());
511 assertFalse("isRunning", request.isRunning());
512 assertFalse("isCompleted", request.isCompleted());
513
514 assertNull("getStatus", request.getStatus());
515 assertFalse("isOK", request.isOK());
516 assertFalse("isFailed", request.isFailed());
517 assertFalse("isCancelled", request.isCancelled());
518 }
519
520 @Test
521 public void testTmfRequestCopy() {
522 TmfRequestStub other = new TmfRequestStub();
523 ITmfRequest request = new TmfRequestStub(other);
524 fLastRequestId += 2;
525
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());
531
532 assertEquals("getNbEventsRead", 0, request.getNbEventsRead());
533 assertEquals("getState", PENDING, request.getState());
534 assertFalse("isRunning", request.isRunning());
535 assertFalse("isCompleted", request.isCompleted());
536
537 assertNull("getStatus", request.getStatus());
538 assertFalse("isOK", request.isOK());
539 assertFalse("isFailed", request.isFailed());
540 assertFalse("isCancelled", request.isCancelled());
541 }
542
543 // ------------------------------------------------------------------------
544 // equals
545 // ------------------------------------------------------------------------
546
547 @Test
548 public void testEqualsReflexivity() {
549 assertEquals("equals", fRequest1, fRequest1);
550 assertEquals("equals", fRequest2, fRequest2);
551
552 assertFalse("equals", fRequest1.equals(fRequest2));
553 assertFalse("equals", fRequest2.equals(fRequest1));
554 }
555
556 @Test
557 public void testEqualsSymmetry() {
558 assertEquals("equals", fRequest1, fRequest1b);
559 assertEquals("equals", fRequest1b, fRequest1);
560
561 assertFalse("equals", fRequest1.equals(fRequest2));
562 assertFalse("equals", fRequest2.equals(fRequest1));
563 }
564
565 @Test
566 public void testEqualsTransivity() {
567 assertEquals("equals", fRequest1, fRequest1b);
568 assertEquals("equals", fRequest1b, fRequest1c);
569 assertEquals("equals", fRequest1c, fRequest1);
570 }
571
572 @Test
573 public void testEqualsNull() {
574 assertFalse("equals", fRequest1.equals(null));
575 assertFalse("equals", fRequest2.equals(null));
576 }
577
578 // ------------------------------------------------------------------------
579 // hashCode
580 // ------------------------------------------------------------------------
581
582 @Test
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());
587 }
588
589 // ------------------------------------------------------------------------
590 // toString
591 // ------------------------------------------------------------------------
592
593 @Test
594 public void testToString() {
595 String expected1 = "TmfRequest [fRequestId=" + fRequest1.getRequestId() + "]";
596 String expected2 = "TmfRequest [fRequestId=" + fRequest2.getRequestId() + "]";
597
598 assertEquals("toString", expected1, fRequest1.toString());
599 assertEquals("toString", expected2, fRequest2.toString());
600 }
601
602 // ------------------------------------------------------------------------
603 // Setters
604 // ------------------------------------------------------------------------
605
606 @Test
607 public void testSetTimeRange() {
608
609 TmfRequestStub request = new TmfRequestStub(ETERNITY);
610 request.setTimeRange(EPOCH);
611 fLastRequestId++;
612
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());
618
619 assertEquals("getNbEventsRead", 0, request.getNbEventsRead());
620 assertEquals("getState", PENDING, request.getState());
621 assertFalse("isRunning", request.isRunning());
622 assertFalse("isCompleted", request.isCompleted());
623
624 assertNull("getStatus", request.getStatus());
625 assertFalse("isOK", request.isOK());
626 assertFalse("isFailed", request.isFailed());
627 assertFalse("isCancelled", request.isCancelled());
628 }
629
630 @Test
631 public void testSetNbRequested() {
632 long nbRequested = 10000;
633
634 TmfRequestStub request = new TmfRequestStub(ETERNITY, 0, ALL_EVENTS);
635 request.setNbRequested(nbRequested);
636 fLastRequestId++;
637
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());
643
644 assertEquals("getNbEventsRead", 0, request.getNbEventsRead());
645 assertEquals("getState", PENDING, request.getState());
646 assertFalse("isRunning", request.isRunning());
647 assertFalse("isCompleted", request.isCompleted());
648
649 assertNull("getStatus", request.getStatus());
650 assertFalse("isOK", request.isOK());
651 assertFalse("isFailed", request.isFailed());
652 assertFalse("isCancelled", request.isCancelled());
653 }
654
655 @Test
656 public void testSetStartIndex() {
657 long index = 100;
658
659 TmfRequestStub request = new TmfRequestStub(ETERNITY, 0, ALL_EVENTS);
660 request.setStartIndex(index);
661 fLastRequestId++;
662
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());
668
669 assertEquals("getNbEventsRead", 0, request.getNbEventsRead());
670 assertEquals("getState", PENDING, request.getState());
671 assertFalse("isRunning", request.isRunning());
672 assertFalse("isCompleted", request.isCompleted());
673
674 assertNull("getStatus", request.getStatus());
675 assertFalse("isOK", request.isOK());
676 assertFalse("isFailed", request.isFailed());
677 assertFalse("isCancelled", request.isCancelled());
678 }
679
680 // ------------------------------------------------------------------------
681 // setEventFilters, addEventFilter
682 // ------------------------------------------------------------------------
683
684 @Test
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));
691
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));
697
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));
703 }
704
705 @Test
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));
712
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));
717
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));
722 }
723
724 // ------------------------------------------------------------------------
725 // setParent, notifyParent
726 // ------------------------------------------------------------------------
727
728 @Test
729 public void testSetParent() {
730 TmfRequestStub request1 = new TmfRequestStub();
731 TmfRequestStub request2 = new TmfRequestStub();
732
733 assertNull("getParent", request2.getParent());
734 request2.setParent(request1);
735 assertEquals("getParent", request1, request2.getParent());
736 request2.setParent(null);
737 assertNull("getParent", request2.getParent());
738 }
739
740 @Test
741 public void testNotifyParent() {
742 final Boolean[] notifications = new Boolean[2];
743 notifications[0] = notifications[1] = false;
744
745 TmfRequestStub request1 = new TmfRequestStub() {
746 @Override
747 public void notifyParent(ITmfRequest child) {
748 notifications[0] = true;
749 super.notifyParent(this);
750 }
751 };
752 TmfRequestStub request2 = new TmfRequestStub() {
753 @Override
754 public void notifyParent(ITmfRequest child) {
755 notifications[1] = true;
756 super.notifyParent(this);
757 }
758 };
759
760 request2.setParent(request1);
761 assertFalse("notifyParent", notifications[0]);
762 assertFalse("notifyParent", notifications[1]);
763
764 request2.notifyParent(null);
765 assertTrue("notifyParent", notifications[0]);
766 assertTrue("notifyParent", notifications[1]);
767 }
768
769 // ------------------------------------------------------------------------
770 // start
771 // ------------------------------------------------------------------------
772
773 @Test
774 public void testStart() {
775
776 final boolean[] flags = new boolean[4];
777 ITmfRequest request = setupDummyRequest(flags);
778 request.start();
779
780 assertTrue("isRunning", request.isRunning());
781 assertFalse("isCompleted", request.isCompleted());
782 assertEquals("getState", RUNNING, request.getState());
783
784 assertNull("getStatus", request.getStatus());
785
786 assertFalse("handleCompleted", flags[0]);
787 assertFalse("handleSuccess", flags[1]);
788 assertFalse("handleFailure", flags[2]);
789 assertFalse("handleCancel", flags[3]);
790 }
791
792 // ------------------------------------------------------------------------
793 // done
794 // ------------------------------------------------------------------------
795
796 @Test
797 public void testDone() {
798
799 final boolean[] flags = new boolean[4];
800 ITmfRequest request = setupDummyRequest(flags);
801 request.done();
802
803 assertFalse("isRunning", request.isRunning());
804 assertTrue("isCompleted", request.isCompleted());
805 assertEquals("getState", COMPLETED, request.getState());
806
807 assertEquals("getStatus", IStatus.OK, request.getStatus().getSeverity());
808 assertTrue("isOK", request.isOK());
809 assertFalse("isFailed", request.isFailed());
810 assertFalse("isCancelled", request.isCancelled());
811
812 assertTrue("handleCompleted", flags[0]);
813 assertTrue("handleSuccess", flags[1]);
814 assertFalse("handleFailure", flags[2]);
815 assertFalse("handleCancel", flags[3]);
816 }
817
818 // ------------------------------------------------------------------------
819 // fail
820 // ------------------------------------------------------------------------
821
822 @Test
823 public void testFail() {
824
825 final boolean[] flags = new boolean[4];
826 ITmfRequest request = setupDummyRequest(flags);
827 request.fail();
828
829 assertFalse("isRunning", request.isRunning());
830 assertTrue("isCompleted", request.isCompleted());
831 assertEquals("getState", COMPLETED, request.getState());
832
833 assertEquals("getStatus", IStatus.ERROR, request.getStatus().getSeverity());
834 assertFalse("isOK", request.isOK());
835 assertTrue("isFailed", request.isFailed());
836 assertFalse("isCancelled", request.isCancelled());
837
838 assertTrue("handleCompleted", flags[0]);
839 assertFalse("handleSuccess", flags[1]);
840 assertTrue("handleFailure", flags[2]);
841 assertFalse("handleCancel", flags[3]);
842 }
843
844 // ------------------------------------------------------------------------
845 // cancel
846 // ------------------------------------------------------------------------
847
848 @Test
849 public void testCancel() {
850
851 final boolean[] flags = new boolean[4];
852 ITmfRequest request = setupDummyRequest(flags);
853 request.cancel();
854
855 assertFalse("isRunning", request.isRunning());
856 assertTrue("isCompleted", request.isCompleted());
857 assertEquals("getState", COMPLETED, request.getState());
858
859 assertEquals("getStatus", IStatus.CANCEL, request.getStatus().getSeverity());
860 assertFalse("isOK", request.isOK());
861 assertFalse("isFailed", request.isFailed());
862 assertTrue("isCancelled", request.isCancelled());
863
864 assertTrue("handleCompleted", flags[0]);
865 assertFalse("handleSuccess", flags[1]);
866 assertFalse("handleFailure", flags[2]);
867 assertTrue("handleCancel", flags[3]);
868 }
869
870}
Tracecompass - Deliverables
This page took 0.059615 seconds and 5 git commands to generate.