projects / deliverable / tracecompass.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
2010-06-05 fchouinard@gmail.com Contributions for bugs 292965, 292963, 293102,...
[deliverable/tracecompass.git] / org.eclipse.linuxtools.tmf.tests / src / org / eclipse / linuxtools / tmf / tests / experiment / TmfMultiTraceExperimentTest.java
CommitLineData
d18dd09b
ASL		 1/*******************************************************************************
2 * Copyright (c) 2009, 2010 Ericsson
3 *
4 * All rights reserved. This program and the accompanying materials are
5 * made available under the terms of the Eclipse Public License v1.0 which
6 * accompanies this distribution, and is available at
7 * http://www.eclipse.org/legal/epl-v10.html
8 *
9 * Contributors:
10 * Francois Chouinard - Initial API and implementation
11 *******************************************************************************/
12
13package org.eclipse.linuxtools.tmf.tests.experiment;
14
15import java.io.File;
16import java.io.IOException;
17import java.net.URISyntaxException;
18import java.net.URL;
19import java.util.Vector;
20
21import junit.framework.TestCase;
22
23import org.eclipse.core.runtime.FileLocator;
24import org.eclipse.core.runtime.Path;
25import org.eclipse.linuxtools.tmf.event.TmfEvent;
26import org.eclipse.linuxtools.tmf.event.TmfTimeRange;
27import org.eclipse.linuxtools.tmf.event.TmfTimestamp;
28import org.eclipse.linuxtools.tmf.experiment.TmfExperiment;
29import org.eclipse.linuxtools.tmf.request.TmfEventRequest;
30import org.eclipse.linuxtools.tmf.tests.TmfCoreTestPlugin;
31import org.eclipse.linuxtools.tmf.trace.ITmfTrace;
32import org.eclipse.linuxtools.tmf.trace.TmfContext;
33import org.eclipse.linuxtools.tmf.trace.TmfTraceStub;
34
35/**
36 * <b><u>TmfExperimentTest</u></b>
37 * <p>
38 * TODO: Implement me. Please.
39 */
40public class TmfMultiTraceExperimentTest extends TestCase {
41
42 private static final String DIRECTORY = "testfiles";
43 private static final String TEST_STREAM1 = "O-Test-10K";
44 private static final String TEST_STREAM2 = "E-Test-10K";
45 private static final String EXPERIMENT = "MyExperiment";
46 private static int NB_EVENTS = 20000;
47 private static int fDefaultBlockSize = 1000;
48
cb866e08 49 private static ITmfTrace[] fTraces;
d18dd09b
ASL		 50 private static TmfExperiment<TmfEvent> fExperiment;
51
52 private static byte SCALE = (byte) -3;
53
54 // ------------------------------------------------------------------------
55 // Housekeeping
56 // ------------------------------------------------------------------------
57
cb866e08
FC		 58 private synchronized static ITmfTrace[] setupTrace(String path1, String path2) {
59 if (fTraces == null) {
60 fTraces = new ITmfTrace[2];
d18dd09b
ASL		 61 try {
62 URL location = FileLocator.find(TmfCoreTestPlugin.getDefault().getBundle(), new Path(path1), null);
63 File test = new File(FileLocator.toFileURL(location).toURI());
64 TmfTraceStub trace1 = new TmfTraceStub(test.getPath(), true);
cb866e08 65 fTraces[0] = trace1;
d18dd09b
ASL		 66 location = FileLocator.find(TmfCoreTestPlugin.getDefault().getBundle(), new Path(path2), null);
67 test = new File(FileLocator.toFileURL(location).toURI());
68 TmfTraceStub trace2 = new TmfTraceStub(test.getPath(), true);
cb866e08 69 fTraces[1] = trace2;
d18dd09b
ASL		 70 } catch (URISyntaxException e) {
71 e.printStackTrace();
72 } catch (IOException e) {
73 e.printStackTrace();
74 }
75 }
cb866e08 76 return fTraces;
d18dd09b
ASL		 77 }
78
cb866e08
FC		 79 private synchronized static void setupExperiment() {
80 synchronized (TmfMultiTraceExperimentTest.class) {
81 if (fExperiment == null) {
82 fExperiment = new TmfExperiment<TmfEvent>(TmfEvent.class, EXPERIMENT, fTraces, TmfTimestamp.Zero, 1000, true);
83 }
d18dd09b
ASL		 84 }
85 }
86
87 public TmfMultiTraceExperimentTest(String name) throws Exception {
88 super(name);
89 }
90
91 @Override
92 protected void setUp() throws Exception {
93 super.setUp();
94 setupTrace(DIRECTORY + File.separator + TEST_STREAM1, DIRECTORY + File.separator + TEST_STREAM2);
95 setupExperiment();
96 }
97
98 @Override
99 protected void tearDown() throws Exception {
100 super.tearDown();
101 }
102
103 // ------------------------------------------------------------------------
104 // Constructor
105 // ------------------------------------------------------------------------
106
107 public void testBasicTmfExperimentConstructor() {
108 assertEquals("GetId", EXPERIMENT, fExperiment.getName());
109 assertEquals("GetEpoch", TmfTimestamp.Zero, fExperiment.getEpoch());
110 assertEquals("GetNbEvents", NB_EVENTS, fExperiment.getNbEvents());
111
112 TmfTimeRange timeRange = fExperiment.getTimeRange();
113 assertEquals("getStartTime", 1, timeRange.getStartTime().getValue());
114 assertEquals("getEndTime", NB_EVENTS, timeRange.getEndTime().getValue());
115 }
116
117 // ------------------------------------------------------------------------
118 // parseEvent - make sure parseEvent doesn't update the context
119 // ------------------------------------------------------------------------
120
121 public void testParseEvent() throws Exception {
122
123 // On lower bound, returns the first event (ts = 0)
124 TmfContext context = fExperiment.seekEvent(new TmfTimestamp(0, SCALE, 0));
125
126 TmfEvent event = fExperiment.parseEvent(context);
127 assertEquals("Event timestamp", 1, event.getTimestamp().getValue());
128
129 event = fExperiment.parseEvent(context);
130 assertEquals("Event timestamp", 1, event.getTimestamp().getValue());
131
132 event = fExperiment.parseEvent(context);
133 assertEquals("Event timestamp", 1, event.getTimestamp().getValue());
134
135 for (int i = 1; i < 20; i++) {
136 event = fExperiment.getNextEvent(context);
137 assertEquals("Event timestamp", i, event.getTimestamp().getValue());
138 }
139
140 event = fExperiment.parseEvent(context);
141 assertEquals("Event timestamp", 20, event.getTimestamp().getValue());
142
143 event = fExperiment.parseEvent(context);
144 assertEquals("Event timestamp", 20, event.getTimestamp().getValue());
145 }
146
147 // ------------------------------------------------------------------------
148 // getNextEvent - updates the context
149 // ------------------------------------------------------------------------
150
151 public void testGetNextEvent() throws Exception {
152
153 // On lower bound, returns the first event (ts = 0)
154 TmfContext context = fExperiment.seekEvent(new TmfTimestamp(0, SCALE, 0));
155 TmfEvent event = fExperiment.getNextEvent(context);
156 assertEquals("Event timestamp", 1, event.getTimestamp().getValue());
157
158 for (int i = 2; i < 20; i++) {
159 event = fExperiment.getNextEvent(context);
160 assertEquals("Event timestamp", i, event.getTimestamp().getValue());
161 }
162 }
163
164 // ------------------------------------------------------------------------
165 // seekLocation
166 // Note: seekLocation() does not reliably set the rank
167 // ------------------------------------------------------------------------
168
169 public void testSeekLocationOnCacheBoundary() throws Exception {
170
171 // Position trace at event rank 0
172 TmfContext context = fExperiment.seekLocation(null);
173// assertEquals("Event rank", 0, context.getRank());
174 TmfEvent event = fExperiment.parseEvent(context);
175 assertEquals("Event timestamp", 1, event.getTimestamp().getValue());
176// assertEquals("Event rank", 0, context.getRank());
177 event = fExperiment.getNextEvent(context);
178 assertEquals("Event timestamp", 1, event.getTimestamp().getValue());
179// assertEquals("Event rank", 1, context.getRank());
180
181 // Position trace at event rank 1000
182 TmfContext tmpContext = fExperiment.seekEvent(new TmfTimestamp(1001, SCALE, 0));
183 context = fExperiment.seekLocation(tmpContext.getLocation().clone());
184// assertEquals("Event rank", 1000, context.getRank());
185 event = fExperiment.parseEvent(context);
186 assertEquals("Event timestamp", 1001, event.getTimestamp().getValue());
187// assertEquals("Event rank", 1000, context.getRank());
188 event = fExperiment.getNextEvent(context);
189 assertEquals("Event timestamp", 1001, event.getTimestamp().getValue());
190// assertEquals("Event rank", 1001, context.getRank());
191
192 // Position trace at event rank 4000
193 tmpContext = fExperiment.seekEvent(new TmfTimestamp(4001, SCALE, 0));
194 context = fExperiment.seekLocation(tmpContext.getLocation().clone());
195// assertEquals("Event rank", 4000, context.getRank());
196 event = fExperiment.parseEvent(context);
197 assertEquals("Event timestamp", 4001, event.getTimestamp().getValue());
198// assertEquals("Event rank", 4000, context.getRank());
199 event = fExperiment.getNextEvent(context);
200 assertEquals("Event timestamp", 4001, event.getTimestamp().getValue());
201// assertEquals("Event rank", 4001, context.getRank());
202 }
203
204 public void testSeekLocationNotOnCacheBoundary() throws Exception {
205
206 // Position trace at event rank 9
207 TmfContext tmpContext = fExperiment.seekEvent(new TmfTimestamp(10, SCALE, 0));
208 TmfContext context = fExperiment.seekLocation(tmpContext.getLocation().clone());
209// assertEquals("Event rank", 9, context.getRank());
210 TmfEvent event = fExperiment.parseEvent(context);
211 assertEquals("Event timestamp", 10, event.getTimestamp().getValue());
212// assertEquals("Event rank", 9, context.getRank());
213 event = fExperiment.getNextEvent(context);
214 assertEquals("Event timestamp", 10, event.getTimestamp().getValue());
215// assertEquals("Event rank", 10, context.getRank());
216
217 // Position trace at event rank 999
218 tmpContext = fExperiment.seekEvent(new TmfTimestamp(1000, SCALE, 0));
219 context = fExperiment.seekLocation(tmpContext.getLocation().clone());
220// assertEquals("Event rank", 999, context.getRank());
221 event = fExperiment.parseEvent(context);
222 assertEquals("Event timestamp", 1000, event.getTimestamp().getValue());
223// assertEquals("Event rank", 999, context.getRank());
224 event = fExperiment.getNextEvent(context);
225 assertEquals("Event timestamp", 1000, event.getTimestamp().getValue());
226// assertEquals("Event rank", 1000, context.getRank());
227
228 // Position trace at event rank 1001
229 tmpContext = fExperiment.seekEvent(new TmfTimestamp(1002, SCALE, 0));
230 context = fExperiment.seekLocation(tmpContext.getLocation().clone());
231// assertEquals("Event rank", 1001, context.getRank());
232 event = fExperiment.parseEvent(context);
233 assertEquals("Event timestamp", 1002, event.getTimestamp().getValue());
234// assertEquals("Event rank", 1001, context.getRank());
235 event = fExperiment.getNextEvent(context);
236 assertEquals("Event timestamp", 1002, event.getTimestamp().getValue());
237// assertEquals("Event rank", 1002, context.getRank());
238
239 // Position trace at event rank 4500
240 tmpContext = fExperiment.seekEvent(new TmfTimestamp(4501, SCALE, 0));
241 context = fExperiment.seekLocation(tmpContext.getLocation().clone());
242// assertEquals("Event rank", 4500, context.getRank());
243 event = fExperiment.parseEvent(context);
244 assertEquals("Event timestamp", 4501, event.getTimestamp().getValue());
245// assertEquals("Event rank", 4500, context.getRank());
246 event = fExperiment.getNextEvent(context);
247 assertEquals("Event timestamp", 4501, event.getTimestamp().getValue());
248// assertEquals("Event rank", 4501, context.getRank());
249 }
250
251 public void testSeekLocationOutOfScope() throws Exception {
252
253 // Position trace at beginning
254 TmfContext tmpContext = fExperiment.seekLocation(null);
255 TmfContext context = fExperiment.seekLocation(tmpContext.getLocation().clone());
256// assertEquals("Event rank", 0, context.getRank());
257 TmfEvent event = fExperiment.parseEvent(context);
258 assertEquals("Event timestamp", 1, event.getTimestamp().getValue());
259// assertEquals("Event rank", 0, context.getRank());
260 event = fExperiment.getNextEvent(context);
261 assertEquals("Event timestamp", 1, event.getTimestamp().getValue());
262// assertEquals("Event rank", 1, context.getRank());
263
264 // Position trace at event passed the end
265 tmpContext = fExperiment.seekEvent(new TmfTimestamp(NB_EVENTS + 1, SCALE, 0));
266 context = fExperiment.seekLocation(tmpContext.getLocation().clone());
267// assertEquals("Event rank", NB_EVENTS, context.getRank());
268 event = fExperiment.parseEvent(context);
269 assertEquals("Event timestamp", null, event);
270// assertEquals("Event rank", NB_EVENTS, context.getRank());
271 event = fExperiment.getNextEvent(context);
272 assertEquals("Event timestamp", null, event);
273// assertEquals("Event rank", NB_EVENTS, context.getRank());
274 }
275
276 // ------------------------------------------------------------------------
277 // seekEvent on timestamp
278 // ------------------------------------------------------------------------
279
280 public void testSeekEventOnTimestampOnCacheBoundary() throws Exception {
281
282 // Position trace at event rank 0
283 TmfContext context = fExperiment.seekEvent(new TmfTimestamp(1, SCALE, 0));
284 assertEquals("Event rank", 0, context.getRank());
285 TmfEvent event = fExperiment.parseEvent(context);
286 assertEquals("Event timestamp", 1, event.getTimestamp().getValue());
287 assertEquals("Event rank", 0, context.getRank());
288 event = fExperiment.getNextEvent(context);
289 assertEquals("Event timestamp", 1, event.getTimestamp().getValue());
290 assertEquals("Event rank", 1, context.getRank());
291
292 // Position trace at event rank 1000
293 context = fExperiment.seekEvent(new TmfTimestamp(1001, SCALE, 0));
294 assertEquals("Event rank", 1000, context.getRank());
295 event = fExperiment.parseEvent(context);
296 assertEquals("Event timestamp", 1001, event.getTimestamp().getValue());
297 assertEquals("Event rank", 1000, context.getRank());
298 event = fExperiment.getNextEvent(context);
299 assertEquals("Event timestamp", 1001, event.getTimestamp().getValue());
300 assertEquals("Event rank", 1001, context.getRank());
301
302 // Position trace at event rank 4000
303 context = fExperiment.seekEvent(new TmfTimestamp(4001, SCALE, 0));
304 assertEquals("Event rank", 4000, context.getRank());
305 event = fExperiment.parseEvent(context);
306 assertEquals("Event timestamp", 4001, event.getTimestamp().getValue());
307 assertEquals("Event rank", 4000, context.getRank());
308 event = fExperiment.getNextEvent(context);
309 assertEquals("Event timestamp", 4001, event.getTimestamp().getValue());
310 assertEquals("Event rank", 4001, context.getRank());
311 }
312
313 public void testSeekEventOnTimestampNotOnCacheBoundary() throws Exception {
314
315 // Position trace at event rank 1
316 TmfContext context = fExperiment.seekEvent(new TmfTimestamp(2, SCALE, 0));
317 assertEquals("Event rank", 1, context.getRank());
318 TmfEvent event = fExperiment.parseEvent(context);
319 assertEquals("Event timestamp", 2, event.getTimestamp().getValue());
320 assertEquals("Event rank", 1, context.getRank());
321 event = fExperiment.getNextEvent(context);
322 assertEquals("Event timestamp", 2, event.getTimestamp().getValue());
323 assertEquals("Event rank", 2, context.getRank());
324
325 // Position trace at event rank 9
326 context = fExperiment.seekEvent(new TmfTimestamp(10, SCALE, 0));
327 assertEquals("Event rank", 9, context.getRank());
328 event = fExperiment.parseEvent(context);
329 assertEquals("Event timestamp", 10, event.getTimestamp().getValue());
330 assertEquals("Event rank", 9, context.getRank());
331 event = fExperiment.getNextEvent(context);
332 assertEquals("Event timestamp", 10, event.getTimestamp().getValue());
333 assertEquals("Event rank", 10, context.getRank());
334
335 // Position trace at event rank 999
336 context = fExperiment.seekEvent(new TmfTimestamp(1000, SCALE, 0));
337 assertEquals("Event rank", 999, context.getRank());
338 event = fExperiment.parseEvent(context);
339 assertEquals("Event timestamp", 1000, event.getTimestamp().getValue());
340 assertEquals("Event rank", 999, context.getRank());
341 event = fExperiment.getNextEvent(context);
342 assertEquals("Event timestamp", 1000, event.getTimestamp().getValue());
343 assertEquals("Event rank", 1000, context.getRank());
344
345 // Position trace at event rank 1001
346 context = fExperiment.seekEvent(new TmfTimestamp(1002, SCALE, 0));
347 assertEquals("Event rank", 1001, context.getRank());
348 event = fExperiment.parseEvent(context);
349 assertEquals("Event timestamp", 1002, event.getTimestamp().getValue());
350 assertEquals("Event rank", 1001, context.getRank());
351 event = fExperiment.getNextEvent(context);
352 assertEquals("Event timestamp", 1002, event.getTimestamp().getValue());
353 assertEquals("Event rank", 1002, context.getRank());
354
355 // Position trace at event rank 4500
356 context = fExperiment.seekEvent(new TmfTimestamp(4501, SCALE, 0));
357 assertEquals("Event rank", 4500, context.getRank());
358 event = fExperiment.parseEvent(context);
359 assertEquals("Event timestamp", 4501, event.getTimestamp().getValue());
360 assertEquals("Event rank", 4500, context.getRank());
361 event = fExperiment.getNextEvent(context);
362 assertEquals("Event timestamp", 4501, event.getTimestamp().getValue());
363 assertEquals("Event rank", 4501, context.getRank());
364 }
365
366 public void testSeekEventOnTimestampoutOfScope() throws Exception {
367
368 // Position trace at beginning
369 TmfContext context = fExperiment.seekEvent(new TmfTimestamp(-1, SCALE, 0));
370 assertEquals("Event rank", 0, context.getRank());
371 TmfEvent event = fExperiment.parseEvent(context);
372 assertEquals("Event timestamp", 1, event.getTimestamp().getValue());
373 assertEquals("Event rank", 0, context.getRank());
374 event = fExperiment.getNextEvent(context);
375 assertEquals("Event timestamp", 1, event.getTimestamp().getValue());
376 assertEquals("Event rank", 1, context.getRank());
377
378 // Position trace at event passed the end
379 context = fExperiment.seekEvent(new TmfTimestamp(NB_EVENTS + 1, SCALE, 0));
380 assertEquals("Event rank", NB_EVENTS, context.getRank());
381 event = fExperiment.parseEvent(context);
382 assertEquals("Event timestamp", null, event);
383 assertEquals("Event rank", NB_EVENTS, context.getRank());
384 event = fExperiment.getNextEvent(context);
385 assertEquals("Event timestamp", null, event);
386 assertEquals("Event rank", NB_EVENTS, context.getRank());
387 }
388
389 // ------------------------------------------------------------------------
390 // seekEvent on rank
391 // ------------------------------------------------------------------------
392
393 public void testSeekOnRankOnCacheBoundary() throws Exception {
394
395 // On lower bound, returns the first event (ts = 1)
396 TmfContext context = fExperiment.seekEvent(0);
397 assertEquals("Event rank", 0, context.getRank());
398 TmfEvent event = fExperiment.parseEvent(context);
399 assertEquals("Event timestamp", 1, event.getTimestamp().getValue());
400 assertEquals("Event rank", 0, context.getRank());
401 event = fExperiment.getNextEvent(context);
402 assertEquals("Event timestamp", 1, event.getTimestamp().getValue());
403 assertEquals("Event rank", 1, context.getRank());
404
405 // Position trace at event rank 1000
406 context = fExperiment.seekEvent(1000);
407 assertEquals("Event rank", 1000, context.getRank());
408 event = fExperiment.parseEvent(context);
409 assertEquals("Event timestamp", 1001, event.getTimestamp().getValue());
410 assertEquals("Event rank", 1000, context.getRank());
411 event = fExperiment.getNextEvent(context);
412 assertEquals("Event timestamp", 1001, event.getTimestamp().getValue());
413 assertEquals("Event rank", 1001, context.getRank());
414
415 // Position trace at event rank 4000
416 context = fExperiment.seekEvent(4000);
417 assertEquals("Event rank", 4000, context.getRank());
418 event = fExperiment.parseEvent(context);
419 assertEquals("Event timestamp", 4001, event.getTimestamp().getValue());
420 assertEquals("Event rank", 4000, context.getRank());
421 event = fExperiment.getNextEvent(context);
422 assertEquals("Event timestamp", 4001, event.getTimestamp().getValue());
423 assertEquals("Event rank", 4001, context.getRank());
424 }
425
426 public void testSeekOnRankNotOnCacheBoundary() throws Exception {
427
428 // Position trace at event rank 9
429 TmfContext context = fExperiment.seekEvent(9);
430 assertEquals("Event rank", 9, context.getRank());
431 TmfEvent event = fExperiment.parseEvent(context);
432 assertEquals("Event timestamp", 10, event.getTimestamp().getValue());
433 assertEquals("Event rank", 9, context.getRank());
434 event = fExperiment.getNextEvent(context);
435 assertEquals("Event timestamp", 10, event.getTimestamp().getValue());
436 assertEquals("Event rank", 10, context.getRank());
437
438 // Position trace at event rank 999
439 context = fExperiment.seekEvent(999);
440 assertEquals("Event rank", 999, context.getRank());
441 event = fExperiment.parseEvent(context);
442 assertEquals("Event timestamp", 1000, event.getTimestamp().getValue());
443 assertEquals("Event rank", 999, context.getRank());
444 event = fExperiment.getNextEvent(context);
445 assertEquals("Event timestamp", 1000, event.getTimestamp().getValue());
446 assertEquals("Event rank", 1000, context.getRank());
447
448 // Position trace at event rank 1001
449 context = fExperiment.seekEvent(1001);
450 assertEquals("Event rank", 1001, context.getRank());
451 event = fExperiment.parseEvent(context);
452 assertEquals("Event timestamp", 1002, event.getTimestamp().getValue());
453 assertEquals("Event rank", 1001, context.getRank());
454 event = fExperiment.getNextEvent(context);
455 assertEquals("Event timestamp", 1002, event.getTimestamp().getValue());
456 assertEquals("Event rank", 1002, context.getRank());
457
458 // Position trace at event rank 4500
459 context = fExperiment.seekEvent(4500);
460 assertEquals("Event rank", 4500, context.getRank());
461 event = fExperiment.parseEvent(context);
462 assertEquals("Event timestamp", 4501, event.getTimestamp().getValue());
463 assertEquals("Event rank", 4500, context.getRank());
464 event = fExperiment.getNextEvent(context);
465 assertEquals("Event timestamp", 4501, event.getTimestamp().getValue());
466 assertEquals("Event rank", 4501, context.getRank());
467 }
468
469 public void testSeekEventOnRankOfScope() throws Exception {
470
471 // Position trace at beginning
472 TmfContext context = fExperiment.seekEvent(-1);
473 assertEquals("Event rank", 0, context.getRank());
474 TmfEvent event = fExperiment.parseEvent(context);
475 assertEquals("Event timestamp", 1, event.getTimestamp().getValue());
476 assertEquals("Event rank", 0, context.getRank());
477 event = fExperiment.getNextEvent(context);
478 assertEquals("Event timestamp", 1, event.getTimestamp().getValue());
479 assertEquals("Event rank", 1, context.getRank());
480
481 // Position trace at event passed the end
482 context = fExperiment.seekEvent(NB_EVENTS);
483 assertEquals("Event rank", NB_EVENTS, context.getRank());
484 event = fExperiment.parseEvent(context);
485 assertEquals("Event timestamp", null, event);
486 assertEquals("Event rank", NB_EVENTS, context.getRank());
487 event = fExperiment.getNextEvent(context);
488 assertEquals("Event timestamp", null, event);
489 assertEquals("Event rank", NB_EVENTS, context.getRank());
490 }
491
492 // ------------------------------------------------------------------------
493 // processRequest
494 // ------------------------------------------------------------------------
495
496 public void testProcessRequestForNbEvents() throws Exception {
497 final int blockSize = 100;
498 final int nbEvents = 1000;
499 final Vector<TmfEvent> requestedEvents = new Vector<TmfEvent>();
500
501 TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BigBang, TmfTimestamp.BigCrunch);
502 final TmfEventRequest<TmfEvent> request = new TmfEventRequest<TmfEvent>(TmfEvent.class, range, nbEvents, blockSize) {
503 @Override
504 public void handleData() {
505 TmfEvent[] events = getData();
506 for (TmfEvent e : events) {
507 requestedEvents.add(e);
508 }
509 }
510 };
511 fExperiment.sendRequest(request);
512 request.waitForCompletion();
513
514 assertEquals("nbEvents", nbEvents, requestedEvents.size());
515 assertTrue("isCompleted", request.isCompleted());
516 assertFalse("isCancelled", request.isCancelled());
517
518 // Ensure that we have distinct events.
519 // Don't go overboard: we are not validating the stub!
520 for (int i = 0; i < nbEvents; i++) {
521 assertEquals("Distinct events", i+1, requestedEvents.get(i).getTimestamp().getValue());
522 }
523 }
524
525 public void testProcessRequestForNbEvents2() throws Exception {
526 final int blockSize = 2 * NB_EVENTS;
527 final int nbEvents = 1000;
528 final Vector<TmfEvent> requestedEvents = new Vector<TmfEvent>();
529
530 TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BigBang, TmfTimestamp.BigCrunch);
531 final TmfEventRequest<TmfEvent> request = new TmfEventRequest<TmfEvent>(TmfEvent.class, range, nbEvents, blockSize) {
532 @Override
533 public void handleData() {
534 TmfEvent[] events = getData();
535 for (TmfEvent e : events) {
536 requestedEvents.add(e);
537 }
538 }
539 };
540 fExperiment.sendRequest(request);
541 request.waitForCompletion();
542
543 assertEquals("nbEvents", nbEvents, requestedEvents.size());
544 assertTrue("isCompleted", request.isCompleted());
545 assertFalse("isCancelled", request.isCancelled());
546
547 // Ensure that we have distinct events.
548 // Don't go overboard: we are not validating the stub!
549 for (int i = 0; i < nbEvents; i++) {
550 assertEquals("Distinct events", i+1, requestedEvents.get(i).getTimestamp().getValue());
551 }
552 }
553
554 public void testProcessRequestForAllEvents() throws Exception {
555 final int nbEvents = TmfEventRequest.ALL_DATA;
556 final int blockSize = 1;
557 final Vector<TmfEvent> requestedEvents = new Vector<TmfEvent>();
558 long nbExpectedEvents = fExperiment.getNbEvents();
559
560 TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BigBang, TmfTimestamp.BigCrunch);
561 final TmfEventRequest<TmfEvent> request = new TmfEventRequest<TmfEvent>(TmfEvent.class, range, nbEvents, blockSize) {
562 @Override
563 public void handleData() {
564 TmfEvent[] events = getData();
565 for (TmfEvent e : events) {
566 requestedEvents.add(e);
567 }
568 }
569 };
570 fExperiment.sendRequest(request);
571 request.waitForCompletion();
572
cb866e08 573 assertEquals("nbEvents", NB_EVENTS, requestedEvents.size());
d18dd09b
ASL		 574 assertTrue("isCompleted", request.isCompleted());
575 assertFalse("isCancelled", request.isCancelled());
576
577 // Ensure that we have distinct events.
578 // Don't go overboard: we are not validating the stub!
579 for (int i = 0; i < nbExpectedEvents; i++) {
580 assertEquals("Distinct events", i+1, requestedEvents.get(i).getTimestamp().getValue());
581 }
582 }
583
584 // ------------------------------------------------------------------------
585 // cancel
586 // ------------------------------------------------------------------------
587
588 public void testCancel() throws Exception {
589 final int nbEvents = NB_EVENTS;
590 final int blockSize = fDefaultBlockSize;
591 final Vector<TmfEvent> requestedEvents = new Vector<TmfEvent>();
592
593 TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BigBang, TmfTimestamp.BigCrunch);
594 final TmfEventRequest<TmfEvent> request = new TmfEventRequest<TmfEvent>(TmfEvent.class, range, nbEvents, blockSize) {
595 @Override
596 public void handleData() {
597 TmfEvent[] events = getData();
598 for (TmfEvent e : events) {
599 requestedEvents.add(e);
600 }
601 // Cancel request after the first chunk is received
602 cancel();
603 }
604 };
605 fExperiment.sendRequest(request);
606 request.waitForCompletion();
607
608 assertEquals("nbEvents", blockSize, requestedEvents.size());
609 assertTrue("isCompleted", request.isCompleted());
610 assertTrue("isCancelled", request.isCancelled());
611 }
612
613 // ------------------------------------------------------------------------
614 // getRank
615 // ------------------------------------------------------------------------
616
617 public void testGetRank() throws Exception {
618 assertEquals("getRank", 0, fExperiment.getRank(new TmfTimestamp()));
619 assertEquals("getRank", 0, fExperiment.getRank(new TmfTimestamp( 1, (byte) -3)));
620 assertEquals("getRank", 10, fExperiment.getRank(new TmfTimestamp( 11, (byte) -3)));
621 assertEquals("getRank", 100, fExperiment.getRank(new TmfTimestamp( 101, (byte) -3)));
622 assertEquals("getRank", 1000, fExperiment.getRank(new TmfTimestamp(1001, (byte) -3)));
623 assertEquals("getRank", 2000, fExperiment.getRank(new TmfTimestamp(2001, (byte) -3)));
624 assertEquals("getRank", 2500, fExperiment.getRank(new TmfTimestamp(2501, (byte) -3)));
625 }
626
627 // ------------------------------------------------------------------------
628 // getTimestamp
629 // ------------------------------------------------------------------------
630
631 public void testGetTimestamp() throws Exception {
632 assertTrue("getTimestamp", fExperiment.getTimestamp( 0).equals(new TmfTimestamp( 1, (byte) -3)));
633 assertTrue("getTimestamp", fExperiment.getTimestamp( 10).equals(new TmfTimestamp( 11, (byte) -3)));
634 assertTrue("getTimestamp", fExperiment.getTimestamp( 100).equals(new TmfTimestamp( 101, (byte) -3)));
635 assertTrue("getTimestamp", fExperiment.getTimestamp(1000).equals(new TmfTimestamp(1001, (byte) -3)));
636 assertTrue("getTimestamp", fExperiment.getTimestamp(2000).equals(new TmfTimestamp(2001, (byte) -3)));
637 assertTrue("getTimestamp", fExperiment.getTimestamp(2500).equals(new TmfTimestamp(2501, (byte) -3)));
638 }
639
640}
Tracecompass - Deliverables
This page took 0.049665 seconds and 5 git commands to generate.