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


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