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