projects / deliverable / tracecompass.git / blob
? search:


30e8577ef6cfa43409e2fcd2542d4a8db62e79a7
[deliverable/tracecompass.git] / org.eclipse.linuxtools.tmf.core.tests / src / org / eclipse / linuxtools / tmf / core / tests / trace / TmfTraceTest.java
1 /*******************************************************************************
2 * Copyright (c) 2009, 2013 Ericsson
3 *
4 * All rights reserved. This program and the accompanying materials are
5 * made available under the terms of the Eclipse Public License v1.0 which
6 * accompanies this distribution, and is available at
7 * http://www.eclipse.org/legal/epl-v10.html
8 *
9 * Contributors:
10 * Francois Chouinard - Initial API and implementation
11 * Francois Chouinard - Adapted for TMF Trace Model 1.0
12 * Alexandre Montplaisir - Port to JUnit4
13 *******************************************************************************/
14
15 package org.eclipse.linuxtools.tmf.core.tests.trace;
16
17 import static org.junit.Assert.assertEquals;
18 import static org.junit.Assert.assertFalse;
19 import static org.junit.Assert.assertNull;
20 import static org.junit.Assert.assertTrue;
21 import static org.junit.Assert.fail;
22
23 import java.io.File;
24 import java.io.IOException;
25 import java.net.URISyntaxException;
26 import java.net.URL;
27 import java.util.Map;
28 import java.util.Map.Entry;
29 import java.util.Vector;
30
31 import org.eclipse.core.runtime.FileLocator;
32 import org.eclipse.core.runtime.Path;
33 import org.eclipse.linuxtools.internal.tmf.core.component.TmfProviderManager;
34 import org.eclipse.linuxtools.tmf.core.analysis.IAnalysisModule;
35 import org.eclipse.linuxtools.tmf.core.component.ITmfEventProvider;
36 import org.eclipse.linuxtools.tmf.core.event.ITmfEvent;
37 import org.eclipse.linuxtools.tmf.core.exceptions.TmfTraceException;
38 import org.eclipse.linuxtools.tmf.core.request.ITmfEventRequest.ExecutionType;
39 import org.eclipse.linuxtools.tmf.core.request.TmfEventRequest;
40 import org.eclipse.linuxtools.tmf.core.signal.TmfSignalManager;
41 import org.eclipse.linuxtools.tmf.core.signal.TmfTraceOpenedSignal;
42 import org.eclipse.linuxtools.tmf.core.statistics.ITmfStatistics;
43 import org.eclipse.linuxtools.tmf.core.tests.TmfCoreTestPlugin;
44 import org.eclipse.linuxtools.tmf.core.tests.shared.TmfTestTrace;
45 import org.eclipse.linuxtools.tmf.core.timestamp.ITmfTimestamp;
46 import org.eclipse.linuxtools.tmf.core.timestamp.TmfTimeRange;
47 import org.eclipse.linuxtools.tmf.core.timestamp.TmfTimestamp;
48 import org.eclipse.linuxtools.tmf.core.trace.ITmfContext;
49 import org.eclipse.linuxtools.tmf.core.trace.ITmfTrace;
50 import org.eclipse.linuxtools.tmf.core.trace.TmfContext;
51 import org.eclipse.linuxtools.tmf.core.trace.location.ITmfLocation;
52 import org.eclipse.linuxtools.tmf.tests.stubs.analysis.TestAnalysis;
53 import org.eclipse.linuxtools.tmf.tests.stubs.trace.TmfTraceStub;
54 import org.junit.After;
55 import org.junit.Before;
56 import org.junit.Rule;
57 import org.junit.Test;
58 import org.junit.rules.TestRule;
59 import org.junit.rules.Timeout;
60
61 /**
62 * Test suite for the TmfTrace class.
63 */
64 @SuppressWarnings("javadoc")
65 public class TmfTraceTest {
66
67 /** Time-out tests after 20 seconds */
68 @Rule
69 public TestRule globalTimeout= new Timeout(20000);
70
71 // ------------------------------------------------------------------------
72 // Variables
73 // ------------------------------------------------------------------------
74
75 private static final TmfTestTrace TEST_TRACE = TmfTestTrace.A_TEST_10K;
76 private static final long DEFAULT_INITIAL_OFFSET_VALUE = (1L * 100 * 1000 * 1000); // .1sec
77 private static final int NB_EVENTS = 10000;
78 private TmfTraceStub fTrace = null;
79
80 private static int SCALE = -3;
81
82 // ------------------------------------------------------------------------
83 // Housekeeping
84 // ------------------------------------------------------------------------
85
86 @Before
87 public void setUp() {
88 try {
89 final URL location = FileLocator.find(TmfCoreTestPlugin.getDefault().getBundle(), new Path(TEST_TRACE.getFullPath()), null);
90 final File test = new File(FileLocator.toFileURL(location).toURI());
91 fTrace = new TmfTraceStub(test.toURI().getPath(), ITmfTrace.DEFAULT_TRACE_CACHE_SIZE, false, null);
92 TmfSignalManager.deregister(fTrace);
93 fTrace.indexTrace(true);
94 } catch (final TmfTraceException e) {
95 e.printStackTrace();
96 } catch (final URISyntaxException e) {
97 e.printStackTrace();
98 } catch (final IOException e) {
99 e.printStackTrace();
100 }
101 }
102
103 @After
104 public void tearDown() {
105 fTrace.dispose();
106 fTrace = null;
107 }
108
109 // ------------------------------------------------------------------------
110 // Constructors
111 // ------------------------------------------------------------------------
112
113 @Test
114 public void testFullConstructor() throws TmfTraceException {
115 try {
116 final URL location = FileLocator.find(TmfCoreTestPlugin.getDefault().getBundle(), new Path(TEST_TRACE.getFullPath()), null);
117 File testfile = new File(FileLocator.toFileURL(location).toURI());
118 TmfTraceStub trace = new TmfTraceStub(testfile.toURI().getPath(), ITmfTrace.DEFAULT_TRACE_CACHE_SIZE, false, null);
119 trace.indexTrace(true);
120
121 assertEquals("getType", ITmfEvent.class, trace.getType());
122 assertNull("getResource", trace.getResource());
123 assertEquals("getPath", testfile.toURI().getPath(), trace.getPath());
124 assertEquals("getCacheSize", ITmfTrace.DEFAULT_TRACE_CACHE_SIZE, trace.getCacheSize());
125 assertEquals("getStreamingInterval", 0, trace.getStreamingInterval());
126 assertEquals("getName", TEST_TRACE.getPath(), trace.getName());
127
128 assertEquals("getNbEvents", NB_EVENTS, trace.getNbEvents());
129 assertEquals("getRange-start", 1, trace.getTimeRange().getStartTime().getValue());
130 assertEquals("getRange-end", NB_EVENTS, trace.getTimeRange().getEndTime().getValue());
131 assertEquals("getStartTime", 1, trace.getStartTime().getValue());
132 assertEquals("getEndTime", NB_EVENTS, trace.getEndTime().getValue());
133
134 } catch (final URISyntaxException e) {
135 fail("URISyntaxException");
136 } catch (final IOException e) {
137 fail("IOException");
138 }
139 }
140
141 @Test
142 public void testLiveTraceConstructor() throws TmfTraceException {
143 final long interval = 100;
144 try {
145 final URL location = FileLocator.find(TmfCoreTestPlugin.getDefault().getBundle(), new Path(TEST_TRACE.getFullPath()), null);
146 File testfile = new File(FileLocator.toFileURL(location).toURI());
147 TmfTraceStub trace = new TmfTraceStub(testfile.toURI().getPath(), ITmfTrace.DEFAULT_TRACE_CACHE_SIZE, interval);
148 trace.indexTrace(true);
149
150 assertEquals("getType", ITmfEvent.class, trace.getType());
151 assertNull("getResource", trace.getResource());
152 assertEquals("getPath", testfile.toURI().getPath(), trace.getPath());
153 assertEquals("getCacheSize", ITmfTrace.DEFAULT_TRACE_CACHE_SIZE, trace.getCacheSize());
154 assertEquals("getStreamingInterval", interval, trace.getStreamingInterval());
155 assertEquals("getName", TEST_TRACE.getPath(), trace.getName());
156
157 assertEquals("getNbEvents", NB_EVENTS, trace.getNbEvents());
158 assertEquals("getRange-start", 1, trace.getTimeRange().getStartTime().getValue());
159 assertEquals("getRange-end", NB_EVENTS, trace.getTimeRange().getEndTime().getValue());
160 assertEquals("getStartTime", 1, trace.getStartTime().getValue());
161 assertEquals("getEndTime", NB_EVENTS, trace.getEndTime().getValue());
162
163 } catch (final URISyntaxException e) {
164 fail("URISyntaxException");
165 } catch (final IOException e) {
166 fail("IOException");
167 }
168 }
169
170 @Test
171 public void testCopyConstructor() throws TmfTraceException {
172 try {
173 final URL location = FileLocator.find(TmfCoreTestPlugin.getDefault().getBundle(), new Path(TEST_TRACE.getFullPath()), null);
174 File testfile = new File(FileLocator.toFileURL(location).toURI());
175 TmfTraceStub original = new TmfTraceStub(testfile.toURI().getPath(), ITmfTrace.DEFAULT_TRACE_CACHE_SIZE, false, null);
176 TmfTraceStub trace = new TmfTraceStub(original);
177 trace.indexTrace(true);
178
179 assertEquals("getType", ITmfEvent.class, trace.getType());
180 assertNull("getResource", trace.getResource());
181 assertEquals("getPath", testfile.toURI().getPath(), trace.getPath());
182 assertEquals("getCacheSize", ITmfTrace.DEFAULT_TRACE_CACHE_SIZE, trace.getCacheSize());
183 assertEquals("getStreamingInterval", 0, trace.getStreamingInterval());
184 assertEquals("getName", TEST_TRACE.getPath(), trace.getName());
185
186 assertEquals("getNbEvents", NB_EVENTS, trace.getNbEvents());
187 assertEquals("getRange-start", 1, trace.getTimeRange().getStartTime().getValue());
188 assertEquals("getRange-end", NB_EVENTS, trace.getTimeRange().getEndTime().getValue());
189 assertEquals("getStartTime", 1, trace.getStartTime().getValue());
190 assertEquals("getEndTime", NB_EVENTS, trace.getEndTime().getValue());
191
192 } catch (final URISyntaxException e) {
193 fail("URISyntaxException");
194 } catch (final IOException e) {
195 fail("IOException");
196 }
197
198 // Test the copy of a null trace
199 try {
200 new TmfTraceStub((TmfTraceStub) null);
201 fail("Missing exception");
202 } catch (final IllegalArgumentException e) {
203 // test passed
204 } catch (final Exception e) {
205 fail("Unexpected exception");
206 }
207 }
208
209 // ------------------------------------------------------------------------
210 // Trace initialization
211 // ------------------------------------------------------------------------
212
213 @Test
214 public void testInitializeNullPath() {
215 // Instantiate an "empty" trace
216 final TmfTraceStub trace = new TmfTraceStub();
217
218 try {
219 trace.initialize(null, null, ITmfEvent.class);
220 fail("TmfTrace.initialize() - no exception thrown");
221 } catch (TmfTraceException e) {
222 // Success
223 } catch (Exception e) {
224 fail("TmfTrace.initialize() - wrong exception thrown");
225 }
226 }
227
228 @Test
229 public void testInitializeSimplePath() {
230 // Instantiate an "empty" trace
231 final TmfTraceStub trace = new TmfTraceStub();
232
233 // Path == trace name
234 String path = "TraceName";
235 try {
236 trace.initialize(null, path, ITmfEvent.class);
237 } catch (Exception e) {
238 fail("TmfTrace.initialize() - Exception thrown");
239 }
240
241 assertEquals("getType", ITmfEvent.class, trace.getType());
242 assertNull ("getResource", trace.getResource());
243 assertEquals("getPath", path, trace.getPath());
244 assertEquals("getCacheSize", ITmfTrace.DEFAULT_TRACE_CACHE_SIZE, trace.getCacheSize());
245 assertEquals("getStreamingInterval", 0, trace.getStreamingInterval());
246 assertEquals("getName", path, trace.getName());
247
248 assertEquals("getNbEvents", 0, trace.getNbEvents());
249 assertEquals("getRange-start", Long.MIN_VALUE, trace.getTimeRange().getStartTime().getValue());
250 assertEquals("getRange-end", Long.MIN_VALUE, trace.getTimeRange().getEndTime().getValue());
251 assertEquals("getStartTime", Long.MIN_VALUE, trace.getStartTime().getValue());
252 assertEquals("getEndTime", Long.MIN_VALUE, trace.getEndTime().getValue());
253 }
254
255 @Test
256 public void testInitializeNormalPath() {
257 // Instantiate an "empty" trace
258 final TmfTraceStub trace = new TmfTraceStub();
259
260 // Path == trace name
261 String name = "TraceName";
262 String path = "/my/trace/path/" + name;
263 try {
264 trace.initialize(null, path, ITmfEvent.class);
265 } catch (Exception e) {
266 fail("TmfTrace.initialize() - Exception thrown");
267 }
268
269 assertEquals("getType", ITmfEvent.class, trace.getType());
270 assertNull ("getResource", trace.getResource());
271 assertEquals("getPath", path, trace.getPath());
272 assertEquals("getCacheSize", ITmfTrace.DEFAULT_TRACE_CACHE_SIZE, trace.getCacheSize());
273 assertEquals("getStreamingInterval", 0, trace.getStreamingInterval());
274 assertEquals("getName", name, trace.getName());
275
276 assertEquals("getNbEvents", 0, trace.getNbEvents());
277 assertEquals("getRange-start", Long.MIN_VALUE, trace.getTimeRange().getStartTime().getValue());
278 assertEquals("getRange-end", Long.MIN_VALUE, trace.getTimeRange().getEndTime().getValue());
279 assertEquals("getStartTime", Long.MIN_VALUE, trace.getStartTime().getValue());
280 assertEquals("getEndTime", Long.MIN_VALUE, trace.getEndTime().getValue());
281 }
282
283 @Test
284 public void testInitTrace() throws URISyntaxException, IOException, TmfTraceException, InterruptedException {
285 // Instantiate an "empty" trace
286 final TmfTraceStub trace = new TmfTraceStub();
287
288 assertNull ("getType", trace.getType());
289 assertNull ("getResource", trace.getResource());
290 assertEquals("getCacheSize", ITmfTrace.DEFAULT_TRACE_CACHE_SIZE, trace.getCacheSize());
291 assertEquals("getStreamingInterval", 0, trace.getStreamingInterval());
292 assertEquals("getName", "", trace.getName());
293
294 assertEquals("getNbEvents", 0, trace.getNbEvents());
295 assertEquals("getRange-start", Long.MIN_VALUE, trace.getTimeRange().getStartTime().getValue());
296 assertEquals("getRange-end", Long.MIN_VALUE, trace.getTimeRange().getEndTime().getValue());
297 assertEquals("getStartTime", Long.MIN_VALUE, trace.getStartTime().getValue());
298 assertEquals("getEndTime", Long.MIN_VALUE, trace.getEndTime().getValue());
299
300 // Validate
301 final URL location = FileLocator.find(TmfCoreTestPlugin.getDefault().getBundle(), new Path(TEST_TRACE.getFullPath()), null);
302 final File testfile = new File(FileLocator.toFileURL(location).toURI());
303 assertTrue("validate", trace.validate(null, testfile.getPath()).isOK());
304
305 // InitTrace and wait for indexing completion...
306 trace.initTrace(null, testfile.toURI().getPath(), ITmfEvent.class);
307 trace.indexTrace(true);
308 int nbSecs = 0;
309 while (trace.getNbEvents() < NB_EVENTS && nbSecs < 10) {
310 Thread.sleep(1000);
311 nbSecs++;
312 }
313 if (trace.getNbEvents() < NB_EVENTS) {
314 fail("indexing");
315 }
316
317 assertEquals("getType", ITmfEvent.class, trace.getType());
318 assertNull ("getResource", trace.getResource());
319 assertEquals("getCacheSize", ITmfTrace.DEFAULT_TRACE_CACHE_SIZE, trace.getCacheSize());
320 assertEquals("getStreamingInterval", 0, trace.getStreamingInterval());
321 assertEquals("getName", TEST_TRACE.getPath(), trace.getName());
322
323 assertEquals("getNbEvents", NB_EVENTS, trace.getNbEvents());
324 assertEquals("getRange-start", 1, trace.getTimeRange().getStartTime().getValue());
325 assertEquals("getRange-end", NB_EVENTS, trace.getTimeRange().getEndTime().getValue());
326 assertEquals("getStartTime", 1, trace.getStartTime().getValue());
327 assertEquals("getEndTime", NB_EVENTS, trace.getEndTime().getValue());
328 }
329
330 // ------------------------------------------------------------------------
331 // Set/Get streaming interval
332 // ------------------------------------------------------------------------
333
334 @Test
335 public void testSetStreamingInterval() throws TmfTraceException {
336 final TmfTraceStub trace = new TmfTraceStub(fTrace);
337
338 long interval = 0;
339 assertEquals("getStreamingInterval", interval, trace.getStreamingInterval());
340
341 interval = 100;
342 trace.setStreamingInterval(interval);
343 assertEquals("getStreamingInterval", interval, trace.getStreamingInterval());
344
345 interval = -1;
346 trace.setStreamingInterval(interval);
347 assertEquals("getStreamingInterval", 0, trace.getStreamingInterval());
348
349 interval = 0;
350 trace.setStreamingInterval(interval);
351 assertEquals("getStreamingInterval", interval, trace.getStreamingInterval());
352
353 trace.dispose();
354 }
355
356 // ------------------------------------------------------------------------
357 // Set/Get time range
358 // ------------------------------------------------------------------------
359
360 @Test
361 public void testSetTimeRange() throws TmfTraceException {
362 final TmfTraceStub trace = new TmfTraceStub(fTrace);
363 trace.indexTrace(true);
364
365 assertEquals("getRange-start", 1, trace.getTimeRange().getStartTime().getValue());
366 assertEquals("getRange-end", NB_EVENTS, trace.getTimeRange().getEndTime().getValue());
367 assertEquals("getStartTime", 1, trace.getStartTime().getValue());
368 assertEquals("getEndTime", NB_EVENTS, trace.getEndTime().getValue());
369
370 trace.setTimeRange(new TmfTimeRange(new TmfTimestamp(100), new TmfTimestamp(200)));
371 assertEquals("setTimeRange", 100, trace.getTimeRange().getStartTime().getValue());
372 assertEquals("setTimeRange", 200, trace.getTimeRange().getEndTime().getValue());
373 assertEquals("setTimeRange", 100, trace.getStartTime().getValue());
374 assertEquals("setTimeRange", 200, trace.getEndTime().getValue());
375
376 trace.dispose();
377 }
378
379 @Test
380 public void testSetStartTime() throws TmfTraceException {
381 final TmfTraceStub trace = new TmfTraceStub(fTrace);
382 trace.indexTrace(true);
383
384 assertEquals("getRange-start", 1, trace.getTimeRange().getStartTime().getValue());
385 assertEquals("getRange-end", NB_EVENTS, trace.getTimeRange().getEndTime().getValue());
386 assertEquals("getStartTime", 1, trace.getStartTime().getValue());
387 assertEquals("getEndTime", NB_EVENTS, trace.getEndTime().getValue());
388
389 trace.setStartTime(new TmfTimestamp(100));
390 assertEquals("setStartTime", 100, trace.getTimeRange().getStartTime().getValue());
391 assertEquals("setStartTime", NB_EVENTS, trace.getTimeRange().getEndTime().getValue());
392 assertEquals("setStartTime", 100, trace.getStartTime().getValue());
393 assertEquals("setStartTime", NB_EVENTS, trace.getEndTime().getValue());
394
395 trace.dispose();
396 }
397
398 @Test
399 public void testSetEndTime() throws TmfTraceException {
400 final TmfTraceStub trace = new TmfTraceStub(fTrace);
401 trace.indexTrace(true);
402
403 assertEquals("getRange-start", 1, trace.getTimeRange().getStartTime().getValue());
404 assertEquals("getRange-end", NB_EVENTS, trace.getTimeRange().getEndTime().getValue());
405 assertEquals("getStartTime", 1, trace.getStartTime().getValue());
406 assertEquals("getEndTime", NB_EVENTS, trace.getEndTime().getValue());
407
408 trace.setEndTime(new TmfTimestamp(100));
409 assertEquals("setEndTime", 1, trace.getTimeRange().getStartTime().getValue());
410 assertEquals("setEndTime", 100, trace.getTimeRange().getEndTime().getValue());
411 assertEquals("setEndTime", 1, trace.getStartTime().getValue());
412 assertEquals("setEndTime", 100, trace.getEndTime().getValue());
413
414 trace.dispose();
415 }
416
417 @Test
418 public void testSetNbEvents() throws TmfTraceException {
419 final TmfTraceStub trace = new TmfTraceStub(fTrace);
420 trace.indexTrace(true);
421
422 assertEquals("getNbEvents", NB_EVENTS, trace.getNbEvents());
423
424 trace.setNbEvents(0);
425 assertEquals("getNbEvents", 0, trace.getNbEvents());
426
427 trace.setNbEvents(-1);
428 assertEquals("getNbEvents", 0, trace.getNbEvents());
429
430 trace.setNbEvents(NB_EVENTS + 1);
431 assertEquals("getNbEvents", NB_EVENTS + 1, trace.getNbEvents());
432
433 trace.setNbEvents(NB_EVENTS);
434 assertEquals("getNbEvents", NB_EVENTS, trace.getNbEvents());
435
436 trace.dispose();
437 }
438
439 // ------------------------------------------------------------------------
440 // State system, statistics and modules methods
441 // ------------------------------------------------------------------------
442
443 @Test
444 public void testGetStatistics() {
445 /* Should be null in unit tests */
446 ITmfStatistics stats = fTrace.getStatistics();
447 assertNull(stats);
448 }
449
450 @Test
451 public void testGetModulesByClass() {
452 /* There should not be any modules at this point */
453 Map<String, IAnalysisModule> modules = fTrace.getAnalysisModules();
454 assertTrue(modules.isEmpty());
455
456 /* Open the trace, the modules should be populated */
457 fTrace.traceOpened(new TmfTraceOpenedSignal(this, fTrace, null));
458
459 modules = fTrace.getAnalysisModules();
460 Map<String, TestAnalysis> testModules = fTrace.getAnalysisModules(TestAnalysis.class);
461 assertFalse(modules.isEmpty());
462 assertFalse(testModules.isEmpty());
463
464 /* Make sure all modules of type TestAnalysis are returned in the second call */
465 for (Entry<String, IAnalysisModule> module : modules.entrySet()) {
466 if (module.getValue() instanceof TestAnalysis) {
467 assertTrue(testModules.containsKey(module.getKey()));
468 }
469 }
470
471 }
472
473 // ------------------------------------------------------------------------
474 // seekEvent on location (note: does not reliably set the rank)
475 // ------------------------------------------------------------------------
476
477 @Test
478 public void testSeekEventOnCacheBoundary() {
479 // Position trace at event rank 0
480 ITmfContext context = fTrace.seekEvent(0);
481 ITmfEvent event = fTrace.parseEvent(context);
482 assertEquals("Event timestamp", 1, event.getTimestamp().getValue());
483 assertEquals("Event rank", 0, context.getRank());
484
485 context = fTrace.seekEvent(context.getLocation());
486 assertEquals("Event rank", ITmfContext.UNKNOWN_RANK, context.getRank());
487
488 event = fTrace.parseEvent(context);
489 assertEquals("Event timestamp", 1, event.getTimestamp().getValue());
490 assertEquals("Event rank", ITmfContext.UNKNOWN_RANK, context.getRank());
491
492 event = fTrace.getNext(context);
493 assertEquals("Event timestamp", 1, event.getTimestamp().getValue());
494 assertEquals("Event rank", ITmfContext.UNKNOWN_RANK, context.getRank());
495
496 // Position trace at event rank 1000
497 ITmfContext tmpContext = fTrace.seekEvent(new TmfTimestamp(1001, SCALE, 0));
498 context = fTrace.seekEvent(tmpContext.getLocation());
499 assertEquals("Event rank", ITmfContext.UNKNOWN_RANK, context.getRank());
500
501 event = fTrace.parseEvent(context);
502 assertEquals("Event timestamp", 1001, event.getTimestamp().getValue());
503 assertEquals("Event rank", ITmfContext.UNKNOWN_RANK, context.getRank());
504
505 event = fTrace.getNext(context);
506 assertEquals("Event timestamp", 1001, event.getTimestamp().getValue());
507 assertEquals("Event rank", ITmfContext.UNKNOWN_RANK, context.getRank());
508
509 // Position trace at event rank 4000
510 tmpContext = fTrace.seekEvent(new TmfTimestamp(4001, SCALE, 0));
511 context = fTrace.seekEvent(tmpContext.getLocation());
512 assertEquals("Event rank", ITmfContext.UNKNOWN_RANK, context.getRank());
513
514 event = fTrace.parseEvent(context);
515 assertEquals("Event timestamp", 4001, event.getTimestamp().getValue());
516 assertEquals("Event rank", ITmfContext.UNKNOWN_RANK, context.getRank());
517
518 event = fTrace.getNext(context);
519 assertEquals("Event timestamp", 4001, event.getTimestamp().getValue());
520 assertEquals("Event rank", ITmfContext.UNKNOWN_RANK, context.getRank());
521 }
522
523 @Test
524 public void testSeekEventNotOnCacheBoundary() {
525 // Position trace at event rank 9
526 ITmfContext tmpContext = fTrace.seekEvent(new TmfTimestamp(10, SCALE, 0));
527 TmfContext context = fTrace.seekEvent(tmpContext.getLocation());
528 assertEquals("Event rank", ITmfContext.UNKNOWN_RANK, context.getRank());
529
530 ITmfEvent event = fTrace.parseEvent(context);
531 assertEquals("Event timestamp", 10, event.getTimestamp().getValue());
532 assertEquals("Event rank", ITmfContext.UNKNOWN_RANK, context.getRank());
533
534 event = fTrace.getNext(context);
535 assertEquals("Event timestamp", 10, event.getTimestamp().getValue());
536 assertEquals("Event rank", ITmfContext.UNKNOWN_RANK, context.getRank());
537
538 // Position trace at event rank 999
539 tmpContext = fTrace.seekEvent(new TmfTimestamp(1000, SCALE, 0));
540 context = fTrace.seekEvent(tmpContext.getLocation());
541 assertEquals("Event rank", ITmfContext.UNKNOWN_RANK, context.getRank());
542
543 event = fTrace.parseEvent(context);
544 assertEquals("Event timestamp", 1000, event.getTimestamp().getValue());
545 assertEquals("Event rank", ITmfContext.UNKNOWN_RANK, context.getRank());
546
547 event = fTrace.getNext(context);
548 assertEquals("Event timestamp", 1000, event.getTimestamp().getValue());
549 assertEquals("Event rank", ITmfContext.UNKNOWN_RANK, context.getRank());
550
551 // Position trace at event rank 1001
552 tmpContext = fTrace.seekEvent(new TmfTimestamp(1002, SCALE, 0));
553 context = fTrace.seekEvent(tmpContext.getLocation());
554 assertEquals("Event rank", ITmfContext.UNKNOWN_RANK, context.getRank());
555
556 event = fTrace.parseEvent(context);
557 assertEquals("Event timestamp", 1002, event.getTimestamp().getValue());
558 assertEquals("Event rank", ITmfContext.UNKNOWN_RANK, context.getRank());
559
560 event = fTrace.getNext(context);
561 assertEquals("Event timestamp", 1002, event.getTimestamp().getValue());
562 assertEquals("Event rank", ITmfContext.UNKNOWN_RANK, context.getRank());
563
564 // Position trace at event rank 4500
565 tmpContext = fTrace.seekEvent(new TmfTimestamp(4501, SCALE, 0));
566 context = fTrace.seekEvent(tmpContext.getLocation());
567 assertEquals("Event rank", ITmfContext.UNKNOWN_RANK, context.getRank());
568
569 event = fTrace.parseEvent(context);
570 assertEquals("Event timestamp", 4501, event.getTimestamp().getValue());
571 assertEquals("Event rank", ITmfContext.UNKNOWN_RANK, context.getRank());
572
573 event = fTrace.getNext(context);
574 assertEquals("Event timestamp", 4501, event.getTimestamp().getValue());
575 assertEquals("Event rank", ITmfContext.UNKNOWN_RANK, context.getRank());
576 }
577
578 @Test
579 public void testSeekEventOutOfScope() {
580 // Position trace at beginning
581 ITmfContext tmpContext = fTrace.seekEvent(0);
582 ITmfContext context = fTrace.seekEvent(tmpContext.getLocation());
583 assertEquals("Event rank", ITmfContext.UNKNOWN_RANK, context.getRank());
584
585 ITmfEvent event = fTrace.parseEvent(context);
586 assertEquals("Event timestamp", 1, event.getTimestamp().getValue());
587 assertEquals("Event rank", ITmfContext.UNKNOWN_RANK, context.getRank());
588
589 event = fTrace.getNext(context);
590 assertEquals("Event timestamp", 1, event.getTimestamp().getValue());
591 assertEquals("Event rank", ITmfContext.UNKNOWN_RANK, context.getRank());
592
593 // Position trace at event passed the end
594 context = fTrace.seekEvent(new TmfTimestamp(NB_EVENTS + 1, SCALE, 0));
595 assertNull("Event timestamp", context.getLocation());
596 assertEquals("Event rank", ITmfContext.UNKNOWN_RANK, context.getRank());
597
598 event = fTrace.getNext(context);
599 assertNull("Event", event);
600 }
601
602 // ------------------------------------------------------------------------
603 // seekEvent on timestamp (note: does not reliably set the rank)
604 // ------------------------------------------------------------------------
605
606 @Test
607 public void testSeekEventOnNullTimestamp() {
608 // Position trace at event rank 0
609 ITmfContext context = fTrace.seekEvent((ITmfTimestamp) null);
610 assertEquals("Event rank", 0, context.getRank());
611
612 ITmfEvent event = fTrace.parseEvent(context);
613 assertEquals("Event timestamp", 1, event.getTimestamp().getValue());
614 assertEquals("Event rank", 0, context.getRank());
615 }
616
617 @Test
618 public void testSeekEventOnTimestampOnCacheBoundary() {
619 // Position trace at event rank 0
620 ITmfContext context = fTrace.seekEvent(new TmfTimestamp(1, SCALE, 0));
621 assertEquals("Event rank", 0, context.getRank());
622
623 ITmfEvent event = fTrace.parseEvent(context);
624 assertEquals("Event timestamp", 1, event.getTimestamp().getValue());
625 assertEquals("Event rank", 0, context.getRank());
626
627 event = fTrace.getNext(context);
628 assertEquals("Event timestamp", 1, event.getTimestamp().getValue());
629 assertEquals("Event rank", 1, context.getRank());
630
631 // Position trace at event rank 1000
632 context = fTrace.seekEvent(new TmfTimestamp(1001, SCALE, 0));
633 assertEquals("Event rank", 1000, context.getRank());
634
635 event = fTrace.parseEvent(context);
636 assertEquals("Event timestamp", 1001, event.getTimestamp().getValue());
637 assertEquals("Event rank", 1000, context.getRank());
638
639 event = fTrace.getNext(context);
640 assertEquals("Event timestamp", 1001, event.getTimestamp().getValue());
641 assertEquals("Event rank", 1001, context.getRank());
642
643 // Position trace at event rank 4000
644 context = fTrace.seekEvent(new TmfTimestamp(4001, SCALE, 0));
645 assertEquals("Event rank", 4000, context.getRank());
646
647 event = fTrace.parseEvent(context);
648 assertEquals("Event timestamp", 4001, event.getTimestamp().getValue());
649 assertEquals("Event rank", 4000, context.getRank());
650
651 event = fTrace.getNext(context);
652 assertEquals("Event timestamp", 4001, event.getTimestamp().getValue());
653 assertEquals("Event rank", 4001, context.getRank());
654 }
655
656 @Test
657 public void testSeekEventOnTimestampNotOnCacheBoundary() {
658 // Position trace at event rank 1
659 ITmfContext context = fTrace.seekEvent(new TmfTimestamp(2, SCALE, 0));
660 assertEquals("Event rank", 1, context.getRank());
661
662 ITmfEvent event = fTrace.parseEvent(context);
663 assertEquals("Event timestamp", 2, event.getTimestamp().getValue());
664 assertEquals("Event rank", 1, context.getRank());
665
666 event = fTrace.getNext(context);
667 assertEquals("Event timestamp", 2, event.getTimestamp().getValue());
668 assertEquals("Event rank", 2, context.getRank());
669
670 // Position trace at event rank 9
671 context = fTrace.seekEvent(new TmfTimestamp(10, SCALE, 0));
672 assertEquals("Event rank", 9, context.getRank());
673
674 event = fTrace.parseEvent(context);
675 assertEquals("Event timestamp", 10, event.getTimestamp().getValue());
676 assertEquals("Event rank", 9, context.getRank());
677
678 event = fTrace.getNext(context);
679 assertEquals("Event timestamp", 10, event.getTimestamp().getValue());
680 assertEquals("Event rank", 10, context.getRank());
681
682 // Position trace at event rank 999
683 context = fTrace.seekEvent(new TmfTimestamp(1000, SCALE, 0));
684 assertEquals("Event rank", 999, context.getRank());
685
686 event = fTrace.parseEvent(context);
687 assertEquals("Event timestamp", 1000, event.getTimestamp().getValue());
688 assertEquals("Event rank", 999, context.getRank());
689
690 event = fTrace.getNext(context);
691 assertEquals("Event timestamp", 1000, event.getTimestamp().getValue());
692 assertEquals("Event rank", 1000, context.getRank());
693
694 // Position trace at event rank 1001
695 context = fTrace.seekEvent(new TmfTimestamp(1002, SCALE, 0));
696 assertEquals("Event rank", 1001, context.getRank());
697
698 event = fTrace.parseEvent(context);
699 assertEquals("Event timestamp", 1002, event.getTimestamp().getValue());
700 assertEquals("Event rank", 1001, context.getRank());
701
702 event = fTrace.getNext(context);
703 assertEquals("Event timestamp", 1002, event.getTimestamp().getValue());
704 assertEquals("Event rank", 1002, context.getRank());
705
706 // Position trace at event rank 4500
707 context = fTrace.seekEvent(new TmfTimestamp(4501, SCALE, 0));
708 assertEquals("Event rank", 4500, context.getRank());
709
710 event = fTrace.parseEvent(context);
711 assertEquals("Event timestamp", 4501, event.getTimestamp().getValue());
712 assertEquals("Event rank", 4500, context.getRank());
713
714 event = fTrace.getNext(context);
715 assertEquals("Event timestamp", 4501, event.getTimestamp().getValue());
716 assertEquals("Event rank", 4501, context.getRank());
717 }
718
719 @Test
720 public void testSeekEventOnTimestampOutOfScope() {
721 // Position trace at beginning
722 ITmfContext context = fTrace.seekEvent(new TmfTimestamp(-1, SCALE, 0));
723 assertEquals("Event rank", 0, context.getRank());
724
725 ITmfEvent event = fTrace.parseEvent(context);
726 assertEquals("Event timestamp", 1, event.getTimestamp().getValue());
727 assertEquals("Event rank", 0, context.getRank());
728
729 event = fTrace.getNext(context);
730 assertEquals("Event timestamp", 1, event.getTimestamp().getValue());
731 assertEquals("Event rank", 1, context.getRank());
732
733 // Position trace at event passed the end
734 context = fTrace.seekEvent(new TmfTimestamp(NB_EVENTS + 1, SCALE, 0));
735 assertEquals("Event rank", ITmfContext.UNKNOWN_RANK, context.getRank());
736
737 event = fTrace.parseEvent(context);
738 assertEquals("Event timestamp", null, event);
739 assertEquals("Event rank", ITmfContext.UNKNOWN_RANK, context.getRank());
740
741 event = fTrace.getNext(context);
742 assertEquals("Event timestamp", null, event);
743 assertEquals("Event rank", ITmfContext.UNKNOWN_RANK, context.getRank());
744 }
745
746 // ------------------------------------------------------------------------
747 // seekEvent on rank
748 // ------------------------------------------------------------------------
749
750 @Test
751 public void testSeekEventOnNegativeRank() {
752 // Position trace at event rank 0
753 ITmfContext context = fTrace.seekEvent(-1);
754 assertEquals("Event rank", 0, context.getRank());
755
756 ITmfEvent event = fTrace.parseEvent(context);
757 assertEquals("Event timestamp", 1, event.getTimestamp().getValue());
758 assertEquals("Event rank", 0, context.getRank());
759 }
760
761 @Test
762 public void testSeekOnRankOnCacheBoundary() {
763 // On lower bound, returns the first event (ts = 1)
764 ITmfContext context = fTrace.seekEvent(0);
765 assertEquals("Event rank", 0, context.getRank());
766
767 ITmfEvent event = fTrace.parseEvent(context);
768 assertEquals("Event timestamp", 1, event.getTimestamp().getValue());
769 assertEquals("Event rank", 0, context.getRank());
770
771 event = fTrace.getNext(context);
772 assertEquals("Event timestamp", 1, event.getTimestamp().getValue());
773 assertEquals("Event rank", 1, context.getRank());
774
775 // Position trace at event rank 1000
776 context = fTrace.seekEvent(1000);
777 assertEquals("Event rank", 1000, context.getRank());
778
779 event = fTrace.parseEvent(context);
780 assertEquals("Event timestamp", 1001, event.getTimestamp().getValue());
781 assertEquals("Event rank", 1000, context.getRank());
782
783 event = fTrace.getNext(context);
784 assertEquals("Event timestamp", 1001, event.getTimestamp().getValue());
785 assertEquals("Event rank", 1001, context.getRank());
786
787 // Position trace at event rank 4000
788 context = fTrace.seekEvent(4000);
789 assertEquals("Event rank", 4000, context.getRank());
790
791 event = fTrace.parseEvent(context);
792 assertEquals("Event timestamp", 4001, event.getTimestamp().getValue());
793 assertEquals("Event rank", 4000, context.getRank());
794
795 event = fTrace.getNext(context);
796 assertEquals("Event timestamp", 4001, event.getTimestamp().getValue());
797 assertEquals("Event rank", 4001, context.getRank());
798 }
799
800 @Test
801 public void testSeekOnRankNotOnCacheBoundary() {
802 // Position trace at event rank 9
803 ITmfContext context = fTrace.seekEvent(9);
804 assertEquals("Event rank", 9, context.getRank());
805
806 ITmfEvent event = fTrace.parseEvent(context);
807 assertEquals("Event timestamp", 10, event.getTimestamp().getValue());
808 assertEquals("Event rank", 9, context.getRank());
809
810 event = fTrace.getNext(context);
811 assertEquals("Event timestamp", 10, event.getTimestamp().getValue());
812 assertEquals("Event rank", 10, context.getRank());
813
814 // Position trace at event rank 999
815 context = fTrace.seekEvent(999);
816 assertEquals("Event rank", 999, context.getRank());
817
818 event = fTrace.parseEvent(context);
819 assertEquals("Event timestamp", 1000, event.getTimestamp().getValue());
820 assertEquals("Event rank", 999, context.getRank());
821
822 event = fTrace.getNext(context);
823 assertEquals("Event timestamp", 1000, event.getTimestamp().getValue());
824 assertEquals("Event rank", 1000, context.getRank());
825
826 // Position trace at event rank 1001
827 context = fTrace.seekEvent(1001);
828 assertEquals("Event rank", 1001, context.getRank());
829
830 event = fTrace.parseEvent(context);
831 assertEquals("Event timestamp", 1002, event.getTimestamp().getValue());
832 assertEquals("Event rank", 1001, context.getRank());
833
834 event = fTrace.getNext(context);
835 assertEquals("Event timestamp", 1002, event.getTimestamp().getValue());
836 assertEquals("Event rank", 1002, context.getRank());
837
838 // Position trace at event rank 4500
839 context = fTrace.seekEvent(4500);
840 assertEquals("Event rank", 4500, context.getRank());
841
842 event = fTrace.parseEvent(context);
843 assertEquals("Event timestamp", 4501, event.getTimestamp().getValue());
844 assertEquals("Event rank", 4500, context.getRank());
845
846 event = fTrace.getNext(context);
847 assertEquals("Event timestamp", 4501, event.getTimestamp().getValue());
848 assertEquals("Event rank", 4501, context.getRank());
849 }
850
851 @Test
852 public void testSeekEventOnRankOutOfScope() {
853 // Position trace at beginning
854 ITmfContext context = fTrace.seekEvent(-1);
855 assertEquals("Event rank", 0, context.getRank());
856
857 ITmfEvent event = fTrace.parseEvent(context);
858 assertEquals("Event timestamp", 1, event.getTimestamp().getValue());
859 assertEquals("Event rank", 0, context.getRank());
860
861 event = fTrace.getNext(context);
862 assertEquals("Event timestamp", 1, event.getTimestamp().getValue());
863 assertEquals("Event rank", 1, context.getRank());
864
865 // Position trace at event passed the end
866 context = fTrace.seekEvent(NB_EVENTS);
867 assertEquals("Event rank", NB_EVENTS, context.getRank());
868
869 event = fTrace.parseEvent(context);
870 assertNull("Event", event);
871 assertEquals("Event rank", NB_EVENTS, context.getRank());
872
873 event = fTrace.getNext(context);
874 assertNull("Event", event);
875 assertEquals("Event rank", NB_EVENTS, context.getRank());
876 }
877
878 // ------------------------------------------------------------------------
879 // parseEvent - make sure parseEvent doesn't update the context
880 // ------------------------------------------------------------------------
881
882 @Test
883 public void testParseEvent() {
884 final int NB_READS = 20;
885
886 // On lower bound, returns the first event (ts = 0)
887 final TmfContext context = (TmfContext) fTrace.seekEvent(new TmfTimestamp(0, SCALE, 0));
888 TmfContext svContext = new TmfContext(context);
889
890 ITmfEvent event = fTrace.parseEvent(context);
891 assertEquals("Event timestamp", 1, event.getTimestamp().getValue());
892 assertEquals("Event rank", 0, context.getRank());
893 assertTrue("parseEvent", context.equals(svContext));
894
895 event = fTrace.parseEvent(context);
896 assertEquals("Event timestamp", 1, event.getTimestamp().getValue());
897 assertEquals("Event rank", 0, context.getRank());
898 assertTrue("parseEvent", context.equals(svContext));
899
900 event = fTrace.parseEvent(context);
901 assertEquals("Event timestamp", 1, event.getTimestamp().getValue());
902 assertEquals("Event rank", 0, context.getRank());
903 assertTrue("parseEvent", context.equals(svContext));
904
905 // Position the trace at event NB_READS
906 for (int i = 1; i < NB_READS; i++) {
907 event = fTrace.getNext(context);
908 assertEquals("Event timestamp", i, event.getTimestamp().getValue());
909 }
910
911 svContext = new TmfContext(context);
912 event = fTrace.parseEvent(context);
913 assertEquals("Event timestamp", NB_READS, event.getTimestamp().getValue());
914 assertEquals("Event rank", NB_READS -1 , context.getRank());
915 assertTrue("parseEvent", context.equals(svContext));
916
917 event = fTrace.parseEvent(context);
918 assertEquals("Event timestamp", NB_READS, event.getTimestamp().getValue());
919 assertEquals("Event rank", NB_READS - 1, context.getRank());
920 assertTrue("parseEvent", context.equals(svContext));
921 }
922
923 // ------------------------------------------------------------------------
924 // getNext - updates the context
925 // ------------------------------------------------------------------------
926
927 @Test
928 public void testGetNextAfteSeekingOnTS_1() {
929 final long INITIAL_TS = 1;
930 final int NB_READS = 20;
931
932 // On lower bound, returns the first event (ts = 1)
933 final ITmfContext context = fTrace.seekEvent(new TmfTimestamp(INITIAL_TS, SCALE, 0));
934
935 // Read NB_EVENTS
936 ITmfEvent event;
937 for (int i = 0; i < NB_READS; i++) {
938 event = fTrace.getNext(context);
939 assertEquals("Event timestamp", INITIAL_TS + i, event.getTimestamp().getValue());
940 assertEquals("Event rank", INITIAL_TS + i, context.getRank());
941 }
942
943 // Make sure we stay positioned
944 event = fTrace.parseEvent(context);
945 assertEquals("Event timestamp", INITIAL_TS + NB_READS, event.getTimestamp().getValue());
946 assertEquals("Event rank", INITIAL_TS + NB_READS - 1, context.getRank());
947 }
948
949 @Test
950 public void testGetNextAfteSeekingOnTS_2() {
951 final long INITIAL_TS = 2;
952 final int NB_READS = 20;
953
954 // On lower bound, returns the first event (ts = 500)
955 final ITmfContext context = fTrace.seekEvent(new TmfTimestamp(INITIAL_TS, SCALE, 0));
956
957 // Read NB_EVENTS
958 ITmfEvent event;
959 for (int i = 0; i < NB_READS; i++) {
960 event = fTrace.getNext(context);
961 assertEquals("Event timestamp", INITIAL_TS + i, event.getTimestamp().getValue());
962 assertEquals("Event rank", INITIAL_TS + i, context.getRank());
963 }
964
965 // Make sure we stay positioned
966 event = fTrace.parseEvent(context);
967 assertEquals("Event timestamp", INITIAL_TS + NB_READS, event.getTimestamp().getValue());
968 assertEquals("Event rank", INITIAL_TS + NB_READS - 1, context.getRank());
969 }
970
971 @Test
972 public void testGetNextAfteSeekingOnTS_3() {
973 final long INITIAL_TS = 500;
974 final int NB_READS = 20;
975
976 // On lower bound, returns the first event (ts = 500)
977 final ITmfContext context = fTrace.seekEvent(new TmfTimestamp(INITIAL_TS, SCALE, 0));
978
979 // Read NB_EVENTS
980 ITmfEvent event;
981 for (int i = 0; i < NB_READS; i++) {
982 event = fTrace.getNext(context);
983 assertEquals("Event timestamp", INITIAL_TS + i, event.getTimestamp().getValue());
984 assertEquals("Event rank", INITIAL_TS + i, context.getRank());
985 }
986
987 // Make sure we stay positioned
988 event = fTrace.parseEvent(context);
989 assertEquals("Event timestamp", INITIAL_TS + NB_READS, event.getTimestamp().getValue());
990 assertEquals("Event rank", INITIAL_TS + NB_READS - 1, context.getRank());
991 }
992
993 @Test
994 public void testGetNextAfterSeekingOnRank_1() {
995 final long INITIAL_RANK = 0L;
996 final int NB_READS = 20;
997
998 // On lower bound, returns the first event (rank = 0)
999 final ITmfContext context = fTrace.seekEvent(INITIAL_RANK);
1000
1001 // Read NB_EVENTS
1002 ITmfEvent event;
1003 for (int i = 0; i < NB_READS; i++) {
1004 event = fTrace.getNext(context);
1005 assertEquals("Event timestamp", INITIAL_RANK + i + 1, event.getTimestamp().getValue());
1006 assertEquals("Event rank", INITIAL_RANK + i + 1, context.getRank());
1007 }
1008
1009 // Make sure we stay positioned
1010 event = fTrace.parseEvent(context);
1011 assertEquals("Event timestamp", INITIAL_RANK + NB_READS + 1, event.getTimestamp().getValue());
1012 assertEquals("Event rank", INITIAL_RANK + NB_READS, context.getRank());
1013 }
1014
1015 @Test
1016 public void testGetNextAfterSeekingOnRank_2() {
1017 final long INITIAL_RANK = 1L;
1018 final int NB_READS = 20;
1019
1020 // On lower bound, returns the first event (rank = 0)
1021 final ITmfContext context = fTrace.seekEvent(INITIAL_RANK);
1022
1023 // Read NB_EVENTS
1024 ITmfEvent event;
1025 for (int i = 0; i < NB_READS; i++) {
1026 event = fTrace.getNext(context);
1027 assertEquals("Event timestamp", INITIAL_RANK + i + 1, event.getTimestamp().getValue());
1028 assertEquals("Event rank", INITIAL_RANK + i + 1, context.getRank());
1029 }
1030
1031 // Make sure we stay positioned
1032 event = fTrace.parseEvent(context);
1033 assertEquals("Event timestamp", INITIAL_RANK + NB_READS + 1, event.getTimestamp().getValue());
1034 assertEquals("Event rank", INITIAL_RANK + NB_READS, context.getRank());
1035 }
1036
1037 @Test
1038 public void testGetNextAfterSeekingOnRank_3() {
1039 final long INITIAL_RANK = 500L;
1040 final int NB_READS = 20;
1041
1042 // On lower bound, returns the first event (rank = 0)
1043 final ITmfContext context = fTrace.seekEvent(INITIAL_RANK);
1044
1045 // Read NB_EVENTS
1046 ITmfEvent event;
1047 for (int i = 0; i < NB_READS; i++) {
1048 event = fTrace.getNext(context);
1049 assertEquals("Event timestamp", INITIAL_RANK + i + 1, event.getTimestamp().getValue());
1050 assertEquals("Event rank", INITIAL_RANK + i + 1, context.getRank());
1051 }
1052
1053 // Make sure we stay positioned
1054 event = fTrace.parseEvent(context);
1055 assertEquals("Event timestamp", INITIAL_RANK + NB_READS + 1, event.getTimestamp().getValue());
1056 assertEquals("Event rank", INITIAL_RANK + NB_READS, context.getRank());
1057 }
1058
1059 @Test
1060 public void testGetNextAfterSeekingOnLocation_1() {
1061 final ITmfLocation INITIAL_LOC = null;
1062 final long INITIAL_TS = 1;
1063 final int NB_READS = 20;
1064
1065 // On lower bound, returns the first event (ts = 1)
1066 final ITmfContext context = fTrace.seekEvent(INITIAL_LOC);
1067
1068 // Read NB_EVENTS
1069 ITmfEvent event;
1070 for (int i = 0; i < NB_READS; i++) {
1071 event = fTrace.getNext(context);
1072 assertEquals("Event timestamp", INITIAL_TS + i, event.getTimestamp().getValue());
1073 assertEquals("Event rank", INITIAL_TS + i, context.getRank());
1074 }
1075
1076 // Make sure we stay positioned
1077 event = fTrace.parseEvent(context);
1078 assertEquals("Event timestamp", INITIAL_TS + NB_READS, event.getTimestamp().getValue());
1079 assertEquals("Event rank", INITIAL_TS + NB_READS - 1, context.getRank());
1080 }
1081
1082 @Test
1083 public void testGetNextAfterSeekingOnLocation_2() {
1084 final ITmfLocation INITIAL_LOC = fTrace.seekEvent(1L).getLocation();
1085 final long INITIAL_TS = 2;
1086 final int NB_READS = 20;
1087
1088 // On lower bound, returns the first event (ts = 501)
1089 final ITmfContext context = fTrace.seekEvent(INITIAL_LOC);
1090
1091 // Read NB_EVENTS
1092 ITmfEvent event;
1093 for (int i = 0; i < NB_READS; i++) {
1094 event = fTrace.getNext(context);
1095 assertEquals("Event timestamp", INITIAL_TS + i, event.getTimestamp().getValue());
1096 }
1097
1098 // Make sure we stay positioned
1099 event = fTrace.parseEvent(context);
1100 assertEquals("Event timestamp", INITIAL_TS + NB_READS, event.getTimestamp().getValue());
1101 }
1102
1103 @Test
1104 public void testGetNextAfterSeekingOnLocation_3() {
1105 final ITmfLocation INITIAL_LOC = fTrace.seekEvent(500L).getLocation();
1106 final long INITIAL_TS = 501;
1107 final int NB_READS = 20;
1108
1109 // On lower bound, returns the first event (ts = 501)
1110 final ITmfContext context = fTrace.seekEvent(INITIAL_LOC);
1111
1112 // Read NB_EVENTS
1113 ITmfEvent event;
1114 for (int i = 0; i < NB_READS; i++) {
1115 event = fTrace.getNext(context);
1116 assertEquals("Event timestamp", INITIAL_TS + i, event.getTimestamp().getValue());
1117 }
1118
1119 // Make sure we stay positioned
1120 event = fTrace.parseEvent(context);
1121 assertEquals("Event timestamp", INITIAL_TS + NB_READS, event.getTimestamp().getValue());
1122 }
1123
1124 @Test
1125 public void testGetNextLocation() {
1126 ITmfContext context1 = fTrace.seekEvent(0);
1127 fTrace.getNext(context1);
1128 ITmfLocation location = context1.getLocation();
1129 ITmfEvent event1 = fTrace.getNext(context1);
1130 ITmfContext context2 = fTrace.seekEvent(location);
1131 ITmfEvent event2 = fTrace.getNext(context2);
1132 assertEquals("Event timestamp", event1.getTimestamp().getValue(), event2.getTimestamp().getValue());
1133 }
1134
1135 @Test
1136 public void testGetNextEndLocation() {
1137 ITmfContext context1 = fTrace.seekEvent(fTrace.getNbEvents() - 1);
1138 fTrace.getNext(context1);
1139 ITmfLocation location = context1.getLocation();
1140 ITmfContext context2 = fTrace.seekEvent(location);
1141 ITmfEvent event = fTrace.getNext(context2);
1142 assertNull("Event", event);
1143 }
1144
1145 // ------------------------------------------------------------------------
1146 // processRequest
1147 // ------------------------------------------------------------------------
1148
1149 @Test
1150 public void testProcessEventRequestForAllEvents() throws InterruptedException {
1151 final Vector<ITmfEvent> requestedEvents = new Vector<ITmfEvent>();
1152
1153 final TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BIG_BANG, TmfTimestamp.BIG_CRUNCH);
1154 final TmfEventRequest request = new TmfEventRequest(ITmfEvent.class,
1155 range, 0, NB_EVENTS, ExecutionType.FOREGROUND) {
1156 @Override
1157 public void handleData(final ITmfEvent event) {
1158 super.handleData(event);
1159 requestedEvents.add(event);
1160 }
1161 };
1162 final ITmfEventProvider[] providers = TmfProviderManager.getProviders(ITmfEvent.class, TmfTraceStub.class);
1163 providers[0].sendRequest(request);
1164 request.waitForCompletion();
1165
1166 assertEquals("nbEvents", NB_EVENTS, requestedEvents.size());
1167 assertTrue("isCompleted", request.isCompleted());
1168 assertFalse("isCancelled", request.isCancelled());
1169
1170 // Ensure that we have distinct events.
1171 // Don't go overboard: we are not validating the stub!
1172 for (int i = 0; i < NB_EVENTS; i++) {
1173 assertEquals("Distinct events", i + 1, requestedEvents.get(i).getTimestamp().getValue());
1174 }
1175 }
1176
1177 @Test
1178 public void testProcessEventRequestForNbEvents() throws InterruptedException {
1179 final int nbEvents = 1000;
1180 final Vector<ITmfEvent> requestedEvents = new Vector<ITmfEvent>();
1181
1182 final TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BIG_BANG, TmfTimestamp.BIG_CRUNCH);
1183 final TmfEventRequest request = new TmfEventRequest(ITmfEvent.class,
1184 range, 0, nbEvents, ExecutionType.FOREGROUND) {
1185 @Override
1186 public void handleData(final ITmfEvent event) {
1187 super.handleData(event);
1188 requestedEvents.add(event);
1189 }
1190 };
1191 final ITmfEventProvider[] providers = TmfProviderManager.getProviders(ITmfEvent.class, TmfTraceStub.class);
1192 providers[0].sendRequest(request);
1193 request.waitForCompletion();
1194
1195 assertEquals("nbEvents", nbEvents, requestedEvents.size());
1196 assertTrue("isCompleted", request.isCompleted());
1197 assertFalse("isCancelled", request.isCancelled());
1198
1199 // Ensure that we have distinct events.
1200 // Don't go overboard: we are not validating the stub!
1201 for (int i = 0; i < nbEvents; i++) {
1202 assertEquals("Distinct events", i + 1, requestedEvents.get(i).getTimestamp().getValue());
1203 }
1204 }
1205
1206 @Test
1207 public void testProcessEventRequestForSomeEvents() throws InterruptedException {
1208 final long startTime = 100;
1209 final int nbEvents = 1000;
1210 final Vector<ITmfEvent> requestedEvents = new Vector<ITmfEvent>();
1211
1212 final TmfTimeRange range = new TmfTimeRange(new TmfTimestamp(startTime, SCALE), TmfTimestamp.BIG_CRUNCH);
1213 final TmfEventRequest request = new TmfEventRequest(ITmfEvent.class,
1214 range, 0, nbEvents, ExecutionType.FOREGROUND) {
1215 @Override
1216 public void handleData(final ITmfEvent event) {
1217 super.handleData(event);
1218 requestedEvents.add(event);
1219 }
1220 };
1221 final ITmfEventProvider[] providers = TmfProviderManager.getProviders(ITmfEvent.class, TmfTraceStub.class);
1222 providers[0].sendRequest(request);
1223 request.waitForCompletion();
1224
1225 assertEquals("nbEvents", nbEvents, requestedEvents.size());
1226 assertTrue("isCompleted", request.isCompleted());
1227 assertFalse("isCancelled", request.isCancelled());
1228
1229 // Ensure that we have distinct events.
1230 // Don't go overboard: we are not validating the stub!
1231 for (int i = 0; i < nbEvents; i++) {
1232 assertEquals("Distinct events", startTime + i, requestedEvents.get(i).getTimestamp().getValue());
1233 }
1234 }
1235
1236 @Test
1237 public void testProcessEventRequestForOtherEvents() throws InterruptedException {
1238 final int startIndex = 99;
1239 final long startTime = 100;
1240 final int nbEvents = 1000;
1241 final Vector<ITmfEvent> requestedEvents = new Vector<ITmfEvent>();
1242
1243 final TmfTimeRange range = new TmfTimeRange(new TmfTimestamp(startTime, SCALE), TmfTimestamp.BIG_CRUNCH);
1244 final TmfEventRequest request = new TmfEventRequest(ITmfEvent.class,
1245 range, startIndex, nbEvents, ExecutionType.FOREGROUND) {
1246 @Override
1247 public void handleData(final ITmfEvent event) {
1248 super.handleData(event);
1249 requestedEvents.add(event);
1250 }
1251 };
1252 final ITmfEventProvider[] providers = TmfProviderManager.getProviders(ITmfEvent.class, TmfTraceStub.class);
1253 providers[0].sendRequest(request);
1254 request.waitForCompletion();
1255
1256 assertEquals("nbEvents", nbEvents, requestedEvents.size());
1257 assertTrue("isCompleted", request.isCompleted());
1258 assertFalse("isCancelled", request.isCancelled());
1259
1260 // Ensure that we have distinct events.
1261 // Don't go overboard: we are not validating the stub!
1262 for (int i = 0; i < nbEvents; i++) {
1263 assertEquals("Distinct events", startTime + i, requestedEvents.get(i).getTimestamp().getValue());
1264 }
1265 }
1266
1267 @Test
1268 public void testProcessDataRequestForSomeEvents() throws InterruptedException {
1269 final int startIndex = 100;
1270 final int nbEvents = 1000;
1271 final Vector<ITmfEvent> requestedEvents = new Vector<ITmfEvent>();
1272
1273 final TmfEventRequest request = new TmfEventRequest(ITmfEvent.class,
1274 TmfTimeRange.ETERNITY,
1275 startIndex,
1276 nbEvents,
1277 TmfEventRequest.ExecutionType.FOREGROUND) {
1278 @Override
1279 public void handleData(final ITmfEvent event) {
1280 super.handleData(event);
1281 requestedEvents.add(event);
1282 }
1283 };
1284 final ITmfEventProvider[] providers = TmfProviderManager.getProviders(ITmfEvent.class, TmfTraceStub.class);
1285 providers[0].sendRequest(request);
1286 request.waitForCompletion();
1287
1288 assertEquals("nbEvents", nbEvents, requestedEvents.size());
1289 assertTrue("isCompleted", request.isCompleted());
1290 assertFalse("isCancelled", request.isCancelled());
1291
1292 // Ensure that we have distinct events.
1293 // Don't go overboard: we are not validating the stub!
1294 for (int i = 0; i < nbEvents; i++) {
1295 assertEquals("Distinct events", startIndex + 1 + i, requestedEvents.get(i).getTimestamp().getValue());
1296 }
1297 }
1298
1299 // ------------------------------------------------------------------------
1300 // cancel
1301 // ------------------------------------------------------------------------
1302
1303 @Test
1304 public void testCancel() throws InterruptedException {
1305 final int limit = 500;
1306 final Vector<ITmfEvent> requestedEvents = new Vector<ITmfEvent>();
1307
1308 final TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BIG_BANG, TmfTimestamp.BIG_CRUNCH);
1309 final TmfEventRequest request = new TmfEventRequest(ITmfEvent.class,
1310 range, 0, NB_EVENTS, ExecutionType.FOREGROUND) {
1311 int nbRead = 0;
1312
1313 @Override
1314 public void handleData(final ITmfEvent event) {
1315 super.handleData(event);
1316 requestedEvents.add(event);
1317 if (++nbRead == limit) {
1318 cancel();
1319 }
1320 }
1321 };
1322 final ITmfEventProvider[] providers = TmfProviderManager.getProviders(ITmfEvent.class, TmfTraceStub.class);
1323 providers[0].sendRequest(request);
1324 request.waitForCompletion();
1325
1326 assertEquals("nbEvents", limit, requestedEvents.size());
1327 assertTrue("isCompleted", request.isCompleted());
1328 assertTrue("isCancelled", request.isCancelled());
1329 }
1330
1331 // ------------------------------------------------------------------------
1332 // toString
1333 // ------------------------------------------------------------------------
1334
1335 @Test
1336 public void testDefaultTmfTraceStub() {
1337 assertFalse ("Open trace", fTrace == null);
1338 assertEquals("getType", ITmfEvent.class, fTrace.getType());
1339 assertNull ("getResource", fTrace.getResource());
1340 assertEquals("getStreamingInterval", 0, fTrace.getStreamingInterval());
1341 assertEquals("getName", TEST_TRACE.getPath(), fTrace.getName());
1342
1343 assertEquals("getNbEvents", NB_EVENTS, fTrace.getNbEvents());
1344 assertEquals("getRange-start", 1, fTrace.getTimeRange().getStartTime().getValue());
1345 assertEquals("getRange-end", NB_EVENTS, fTrace.getTimeRange().getEndTime().getValue());
1346 assertEquals("getStartTime", 1, fTrace.getStartTime().getValue());
1347 assertEquals("getEndTime", NB_EVENTS, fTrace.getEndTime().getValue());
1348
1349 String expected = "TmfTrace [fPath=" + fTrace.getPath() + ", fCacheSize=" + fTrace.getCacheSize() +
1350 ", fNbEvents=" + fTrace.getNbEvents() + ", fStartTime=" + fTrace.getStartTime() +
1351 ", fEndTime=" + fTrace.getEndTime() + ", fStreamingInterval=" + fTrace.getStreamingInterval() +
1352 "]";
1353 assertEquals("toString", expected, fTrace.toString());
1354 }
1355
1356 // ------------------------------------------------------------------------
1357 // getInitialRangeOffset, getCurrentRange, getCurrentTime
1358 // ------------------------------------------------------------------------
1359
1360 @Test
1361 public void testCurrentTimeValues() throws TmfTraceException {
1362
1363 TmfTraceStub trace = null;
1364 File testfile = null;
1365 try {
1366 final URL location = FileLocator.find(TmfCoreTestPlugin.getDefault().getBundle(), new Path(TEST_TRACE.getFullPath()), null);
1367 testfile = new File(FileLocator.toFileURL(location).toURI());
1368 trace = new TmfTraceStub(testfile.toURI().getPath(), ITmfTrace.DEFAULT_TRACE_CACHE_SIZE, false, null);
1369 // verify initial values
1370 TmfTimestamp defaultInitRange = new TmfTimestamp(DEFAULT_INITIAL_OFFSET_VALUE, ITmfTimestamp.NANOSECOND_SCALE);
1371 assertEquals("getInitialRangeOffset", defaultInitRange, trace.getInitialRangeOffset());
1372 trace.setInitialRangeOffset(new TmfTimestamp(5, ITmfTimestamp.MILLISECOND_SCALE));
1373 trace.indexTrace(true);
1374
1375 TmfTimestamp initRange = new TmfTimestamp(5, ITmfTimestamp.MILLISECOND_SCALE);
1376 assertEquals("getInitialRangeOffset", initRange, trace.getInitialRangeOffset());
1377
1378 } catch (final URISyntaxException e) {
1379 fail("URISyntaxException");
1380 } catch (final IOException e) {
1381 fail("IOException");
1382 }
1383 }
1384
1385 /**
1386 * Run the String getHostId() method test
1387 */
1388 @Test
1389 public void testTraceHostId() {
1390 String a = fTrace.getHostId();
1391 assertEquals("A-Test-10K", a);
1392 }
1393 }
Tracecompass - Deliverables
This page took 0.064753 seconds and 4 git commands to generate.