Commit | Line | Data |
---|---|---|
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 | ||
13 | package org.eclipse.linuxtools.tmf.core.tests.request; | |
14 | ||
15 | import java.util.ArrayList; | |
16 | import java.util.Collection; | |
17 | ||
18 | import junit.framework.TestCase; | |
19 | ||
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; | |
31 | ||
32 | /** | |
33 | * <b><u>TmfRequestTest</u></b> | |
34 | * <p> | |
35 | * Test suite for the TmfRequest class. | |
36 | */ | |
37 | @SuppressWarnings({"nls","javadoc"}) | |
38 | public 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 | } |