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