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