projects / deliverable / tracecompass.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Fix for Linux tree item height bug.
[deliverable/tracecompass.git] / org.eclipse.linuxtools.tmf.core.tests / src / org / eclipse / linuxtools / tmf / core / tests / trace / TmfTraceTest.java
CommitLineData
d18dd09b 1/*******************************************************************************
20658947
FC		 2 * Copyright (c) 2009, 2010, 20112 Ericsson
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;
d18dd09b
ASL		 20import java.util.Vector;
21
e1ab8984
FC		 22import junit.framework.TestCase;
23
24import org.eclipse.core.runtime.FileLocator;
25import org.eclipse.core.runtime.Path;
6c13869b
FC		 26import org.eclipse.linuxtools.tmf.core.component.ITmfDataProvider;
27import org.eclipse.linuxtools.tmf.core.component.TmfProviderManager;
72f1e62a 28import org.eclipse.linuxtools.tmf.core.event.ITmfEvent;
7e6347b0 29import org.eclipse.linuxtools.tmf.core.event.ITmfTimestamp;
6c13869b
FC		 30import org.eclipse.linuxtools.tmf.core.event.TmfEvent;
31import org.eclipse.linuxtools.tmf.core.event.TmfTimeRange;
32import org.eclipse.linuxtools.tmf.core.event.TmfTimestamp;
b4f71e4a 33import org.eclipse.linuxtools.tmf.core.exceptions.TmfTraceException;
7e6347b0 34import org.eclipse.linuxtools.tmf.core.request.TmfDataRequest;
6c13869b
FC		 35import org.eclipse.linuxtools.tmf.core.request.TmfEventRequest;
36import org.eclipse.linuxtools.tmf.core.tests.TmfCoreTestPlugin;
37import org.eclipse.linuxtools.tmf.core.trace.ITmfContext;
7e6347b0 38import org.eclipse.linuxtools.tmf.core.trace.TmfCheckpointIndexer;
6c13869b
FC		 39import org.eclipse.linuxtools.tmf.core.trace.TmfContext;
40import org.eclipse.linuxtools.tmf.core.trace.TmfTrace;
4918b8f2 41import org.eclipse.linuxtools.tmf.tests.stubs.trace.TmfTraceStub;
d18dd09b
ASL		 42
43/**
44 * <b><u>TmfTraceTest</u></b>
45 * <p>
ff4ed569 46 * Test suite for the TmfTrace class.
d18dd09b 47 */
3b38ea61 48@SuppressWarnings("nls")
d18dd09b
ASL		 49public class TmfTraceTest extends TestCase {
50
f17b2f70
FC		 51 // ------------------------------------------------------------------------
52 // Variables
53 // ------------------------------------------------------------------------
ff4ed569 54
d18dd09b 55 private static final String DIRECTORY = "testfiles";
85fb0e54 56 private static final String TEST_STREAM = "A-Test-10K";
ff4ed569 57 private static final int BLOCK_SIZE = 500;
e31e01e8
FC		 58 private static final int NB_EVENTS = 10000;
59 private static TmfTraceStub fTrace = null;
d18dd09b 60
20658947 61 private static int SCALE = -3;
d18dd09b 62
e31e01e8 63 // ------------------------------------------------------------------------
d18dd09b 64 // Housekeeping
e31e01e8 65 // ------------------------------------------------------------------------
d18dd09b 66
f17b2f70
FC		 67 public TmfTraceTest(final String name) throws Exception {
68 super(name);
69 }
70
71 @Override
72 protected void setUp() throws Exception {
73 super.setUp();
74 fTrace = setupTrace(DIRECTORY + File.separator + TEST_STREAM);
f17b2f70
FC		 75 }
76
77 @Override
78 protected void tearDown() throws Exception {
79 super.tearDown();
80 fTrace.dispose();
81 fTrace = null;
82 }
ff4ed569
FC		 83
84 // ------------------------------------------------------------------------
85 // Helper functions
86 // ------------------------------------------------------------------------
87
f17b2f70 88 private TmfTraceStub setupTrace(final String path) {
20658947 89 if (fTrace == null) {
f17b2f70
FC		 90 try {
91 final URL location = FileLocator.find(TmfCoreTestPlugin.getDefault().getBundle(), new Path(path), null);
92 final File test = new File(FileLocator.toFileURL(location).toURI());
20658947
FC		 93 fTrace = new TmfTraceStub(test.toURI().getPath(), BLOCK_SIZE);
94 fTrace.indexTrace();
b4f71e4a
FC		 95 } catch (final TmfTraceException e) {
96 e.printStackTrace();
f17b2f70
FC		 97 } catch (final URISyntaxException e) {
98 e.printStackTrace();
99 } catch (final IOException e) {
100 e.printStackTrace();
101 }
20658947 102 }
f17b2f70 103 return fTrace;
e1ab8984
FC		 104 }
105
e31e01e8 106 // ------------------------------------------------------------------------
d18dd09b 107 // Constructors
e31e01e8 108 // ------------------------------------------------------------------------
d18dd09b 109
20658947 110 public void testStandardConstructor() throws Exception {
f17b2f70
FC		 111 TmfTraceStub trace = null;
112 File testfile = null;
113 try {
114 final URL location = FileLocator.find(TmfCoreTestPlugin.getDefault().getBundle(), new Path(DIRECTORY + File.separator + TEST_STREAM), null);
115 testfile = new File(FileLocator.toFileURL(location).toURI());
116 trace = new TmfTraceStub(testfile.toURI().getPath());
20658947 117 trace.indexTrace();
f17b2f70
FC		 118 } catch (final URISyntaxException e) {
119 fail("URISyntaxException");
120 } catch (final IOException e) {
121 fail("IOException");
122 }
20658947
FC		 123
124 assertFalse ("Open trace", trace == null);
125 assertEquals("getType", TmfEvent.class, trace.getType());
126 assertNull ("getResource", trace.getResource());
127 assertEquals("getPath", testfile.toURI().getPath(), trace.getPath());
128 assertEquals("getCacheSize", TmfTrace.DEFAULT_TRACE_CACHE_SIZE, trace.getCacheSize());
129 assertEquals("getStreamingInterval", 0, trace.getStreamingInterval());
130 assertEquals("getName", TEST_STREAM, trace.getName());
131
132 assertEquals("getNbEvents", NB_EVENTS, trace.getNbEvents());
133 assertEquals("getRange-start", 1, trace.getTimeRange().getStartTime().getValue());
134 assertEquals("getRange-end", NB_EVENTS, trace.getTimeRange().getEndTime().getValue());
135 assertEquals("getStartTime", 1, trace.getStartTime().getValue());
136 assertEquals("getEndTime", NB_EVENTS, trace.getEndTime().getValue());
ff4ed569
FC		 137 }
138
20658947 139 public void testStandardConstructorCacheSize() throws Exception {
f17b2f70
FC		 140 TmfTraceStub trace = null;
141 File testfile = null;
142 try {
143 final URL location = FileLocator.find(TmfCoreTestPlugin.getDefault().getBundle(), new Path(DIRECTORY + File.separator + TEST_STREAM), null);
144 testfile = new File(FileLocator.toFileURL(location).toURI());
145 trace = new TmfTraceStub(testfile.toURI().getPath(), 0);
20658947
FC		 146 trace.indexTrace();
147 } catch (final URISyntaxException e) {
148 fail("URISyntaxException");
149 } catch (final IOException e) {
150 fail("IOException");
151 }
152
153 assertFalse ("Open trace", trace == null);
154 assertEquals("getType", TmfEvent.class, trace.getType());
155 assertNull ("getResource", trace.getResource());
156 assertEquals("getPath", testfile.toURI().getPath(), trace.getPath());
157 assertEquals("getCacheSize", TmfTrace.DEFAULT_TRACE_CACHE_SIZE, trace.getCacheSize());
158 assertEquals("getStreamingInterval", 0, trace.getStreamingInterval());
159 assertEquals("getName", TEST_STREAM, trace.getName());
160
161 assertEquals("getNbEvents", NB_EVENTS, trace.getNbEvents());
162 assertEquals("getRange-start", 1, trace.getTimeRange().getStartTime().getValue());
163 assertEquals("getRange-end", NB_EVENTS, trace.getTimeRange().getEndTime().getValue());
164 assertEquals("getStartTime", 1, trace.getStartTime().getValue());
165 assertEquals("getEndTime", NB_EVENTS, trace.getEndTime().getValue());
166
167 try {
168 final URL location = FileLocator.find(TmfCoreTestPlugin.getDefault().getBundle(), new Path(DIRECTORY + File.separator + TEST_STREAM), null);
169 testfile = new File(FileLocator.toFileURL(location).toURI());
170 trace = new TmfTraceStub(testfile.toURI().getPath(), BLOCK_SIZE);
171 trace.indexTrace();
172 } catch (final URISyntaxException e) {
173 fail("URISyntaxException");
174 } catch (final IOException e) {
175 fail("IOException");
176 }
177
178 assertFalse ("Open trace", trace == null);
179 assertEquals("getType", TmfEvent.class, trace.getType());
180 assertNull ("getResource", trace.getResource());
181 assertEquals("getPath", testfile.toURI().getPath(), trace.getPath());
182 assertEquals("getCacheSize", BLOCK_SIZE, trace.getCacheSize());
183 assertEquals("getStreamingInterval", 0, trace.getStreamingInterval());
184 assertEquals("getName", TEST_STREAM, trace.getName());
185
186 assertEquals("getNbEvents", NB_EVENTS, trace.getNbEvents());
187 assertEquals("getRange-start", 1, trace.getTimeRange().getStartTime().getValue());
188 assertEquals("getRange-end", NB_EVENTS, trace.getTimeRange().getEndTime().getValue());
189 assertEquals("getStartTime", 1, trace.getStartTime().getValue());
190 assertEquals("getEndTime", NB_EVENTS, trace.getEndTime().getValue());
191 }
192
193 public void testFullConstructor() throws Exception {
194 TmfTraceStub trace = null;
195 File testfile = null;
196 try {
197 final URL location = FileLocator.find(TmfCoreTestPlugin.getDefault().getBundle(), new Path(DIRECTORY + File.separator + TEST_STREAM), null);
198 testfile = new File(FileLocator.toFileURL(location).toURI());
199 trace = new TmfTraceStub(testfile.toURI().getPath(), BLOCK_SIZE, null);
200 trace.indexTrace();
201 } catch (final URISyntaxException e) {
202 fail("URISyntaxException");
203 } catch (final IOException e) {
204 fail("IOException");
205 }
206
207 assertFalse ("Open trace", trace == null);
208 assertEquals("getType", TmfEvent.class, trace.getType());
209 assertNull ("getResource", trace.getResource());
210 assertEquals("getPath", testfile.toURI().getPath(), trace.getPath());
211 assertEquals("getCacheSize", BLOCK_SIZE, trace.getCacheSize());
212 assertEquals("getStreamingInterval", 0, trace.getStreamingInterval());
213 assertEquals("getName", TEST_STREAM, trace.getName());
214
215 assertEquals("getNbEvents", NB_EVENTS, trace.getNbEvents());
216 assertEquals("getRange-start", 1, trace.getTimeRange().getStartTime().getValue());
217 assertEquals("getRange-end", NB_EVENTS, trace.getTimeRange().getEndTime().getValue());
218 assertEquals("getStartTime", 1, trace.getStartTime().getValue());
219 assertEquals("getEndTime", NB_EVENTS, trace.getEndTime().getValue());
220 }
221
1703b536
FC		 222 public void testLiveTraceConstructor() throws Exception {
223 TmfTraceStub trace = null;
224 File testfile = null;
225 final long interval = 100;
226 try {
227 final URL location = FileLocator.find(TmfCoreTestPlugin.getDefault().getBundle(), new Path(DIRECTORY + File.separator + TEST_STREAM), null);
228 testfile = new File(FileLocator.toFileURL(location).toURI());
229 trace = new TmfTraceStub(testfile.toURI().getPath(), BLOCK_SIZE, interval);
230 trace.indexTrace();
231 } catch (final URISyntaxException e) {
232 fail("URISyntaxException");
233 } catch (final IOException e) {
234 fail("IOException");
235 }
236
237 assertFalse ("Open trace", trace == null);
238 assertEquals("getType", TmfEvent.class, trace.getType());
239 assertNull ("getResource", trace.getResource());
240 assertEquals("getPath", testfile.toURI().getPath(), trace.getPath());
241 assertEquals("getCacheSize", BLOCK_SIZE, trace.getCacheSize());
242 assertEquals("getStreamingInterval", interval, trace.getStreamingInterval());
243 assertEquals("getName", TEST_STREAM, trace.getName());
244
245 assertEquals("getNbEvents", NB_EVENTS, trace.getNbEvents());
246 assertEquals("getRange-start", 1, trace.getTimeRange().getStartTime().getValue());
247 assertEquals("getRange-end", NB_EVENTS, trace.getTimeRange().getEndTime().getValue());
248 assertEquals("getStartTime", 1, trace.getStartTime().getValue());
249 assertEquals("getEndTime", NB_EVENTS, trace.getEndTime().getValue());
250 }
251
20658947
FC		 252 @SuppressWarnings({ "rawtypes", "unchecked" })
253 public void testCopyConstructor() throws Exception {
254 TmfTraceStub original = null;
255 TmfTraceStub trace = null;
256 File testfile = null;
257 try {
258 final URL location = FileLocator.find(TmfCoreTestPlugin.getDefault().getBundle(), new Path(DIRECTORY + File.separator + TEST_STREAM), null);
259 testfile = new File(FileLocator.toFileURL(location).toURI());
7e6347b0 260 original = new TmfTraceStub(testfile.toURI().getPath(), BLOCK_SIZE, new TmfCheckpointIndexer(null));
20658947
FC		 261 trace = new TmfTraceStub(original);
262 trace.indexTrace();
f17b2f70
FC		 263 } catch (final URISyntaxException e) {
264 fail("URISyntaxException");
265 } catch (final IOException e) {
266 fail("IOException");
267 }
20658947
FC		 268
269 assertFalse ("Open trace", trace == null);
270 assertEquals("getType", TmfEvent.class, trace.getType());
271 assertNull ("getResource", trace.getResource());
272 assertEquals("getPath", testfile.toURI().getPath(), trace.getPath());
273 assertEquals("getCacheSize", BLOCK_SIZE, trace.getCacheSize());
274 assertEquals("getStreamingInterval", 0, trace.getStreamingInterval());
275 assertEquals("getName", TEST_STREAM, trace.getName());
276
277 assertEquals("getNbEvents", NB_EVENTS, trace.getNbEvents());
278 assertEquals("getRange-start", 1, trace.getTimeRange().getStartTime().getValue());
279 assertEquals("getRange-end", NB_EVENTS, trace.getTimeRange().getEndTime().getValue());
280 assertEquals("getStartTime", 1, trace.getStartTime().getValue());
281 assertEquals("getEndTime", NB_EVENTS, trace.getEndTime().getValue());
282
283 // Test the copy of a null trace
284 try {
285 new TmfTraceStub((TmfTraceStub) null);
286 fail("Missing exception");
287 } catch (final IllegalArgumentException e) {
288 // test passed
289 } catch (final Exception e) {
290 fail("Unexpected exception");
291 }
d18dd09b
ASL		 292 }
293
20658947 294 // ------------------------------------------------------------------------
1703b536 295 // Trace initialization
20658947
FC		 296 // ------------------------------------------------------------------------
297
1703b536 298 public void testInitializeNullPath() throws Exception {
20658947 299
1703b536
FC		 300 // Instantiate an "empty" trace
301 final TmfTraceStub trace = new TmfTraceStub();
20658947 302
1703b536
FC		 303 try {
304 trace.initialize(null, null, TmfEvent.class);
305 fail("TmfTrace.initialize() - no exception thrown");
b4f71e4a 306 } catch (TmfTraceException e) {
1703b536
FC		 307 // Success
308 } catch (Exception e) {
309 fail("TmfTrace.initialize() - wrong exception thrown");
310 }
ff4ed569 311 }
1703b536
FC		 312
313 public void testInitializeSimplePath() throws Exception {
ff4ed569 314
1703b536
FC		 315 // Instantiate an "empty" trace
316 final TmfTraceStub trace = new TmfTraceStub();
317
318 // Path == trace name
319 String path = "TraceName";
320 try {
321 trace.initialize(null, path, TmfEvent.class);
322 } catch (Exception e) {
323 fail("TmfTrace.initialize() - Exception thrown");
324 }
325
326 assertFalse ("Open trace", trace == null);
327 assertEquals("getType", TmfEvent.class, trace.getType());
328 assertNull ("getResource", trace.getResource());
329 assertEquals("getPath", path, trace.getPath());
330 assertEquals("getCacheSize", TmfTrace.DEFAULT_TRACE_CACHE_SIZE, trace.getCacheSize());
331 assertEquals("getStreamingInterval", 0, trace.getStreamingInterval());
332 assertEquals("getName", path, trace.getName());
333
334 assertEquals("getNbEvents", 0, trace.getNbEvents());
335 assertEquals("getRange-start", Long.MAX_VALUE, trace.getTimeRange().getStartTime().getValue());
336 assertEquals("getRange-end", Long.MIN_VALUE, trace.getTimeRange().getEndTime().getValue());
337 assertEquals("getStartTime", Long.MAX_VALUE, trace.getStartTime().getValue());
338 assertEquals("getEndTime", Long.MIN_VALUE, trace.getEndTime().getValue());
339 }
340
341 public void testInitializeNormalPath() throws Exception {
342
343 // Instantiate an "empty" trace
344 final TmfTraceStub trace = new TmfTraceStub();
345
346 // Path == trace name
347 String name = "TraceName";
348 String path = "/my/trace/path/" + name;
349 try {
350 trace.initialize(null, path, TmfEvent.class);
351 } catch (Exception e) {
352 fail("TmfTrace.initialize() - Exception thrown");
353 }
354
355 assertFalse ("Open trace", trace == null);
356 assertEquals("getType", TmfEvent.class, trace.getType());
357 assertNull ("getResource", trace.getResource());
358 assertEquals("getPath", path, trace.getPath());
359 assertEquals("getCacheSize", TmfTrace.DEFAULT_TRACE_CACHE_SIZE, trace.getCacheSize());
360 assertEquals("getStreamingInterval", 0, trace.getStreamingInterval());
361 assertEquals("getName", name, trace.getName());
362
363 assertEquals("getNbEvents", 0, trace.getNbEvents());
364 assertEquals("getRange-start", Long.MAX_VALUE, trace.getTimeRange().getStartTime().getValue());
365 assertEquals("getRange-end", Long.MIN_VALUE, trace.getTimeRange().getEndTime().getValue());
366 assertEquals("getStartTime", Long.MAX_VALUE, trace.getStartTime().getValue());
367 assertEquals("getEndTime", Long.MIN_VALUE, trace.getEndTime().getValue());
368 }
20658947
FC		 369
370 public void testInitTrace() throws Exception {
371
372 // Instantiate an "empty" trace
373 final TmfTraceStub trace = new TmfTraceStub();
374
375 assertFalse ("Open trace", trace == null);
376 assertNull ("getType", trace.getType());
377 assertNull ("getResource", trace.getResource());
378 assertEquals("getCacheSize", TmfTrace.DEFAULT_TRACE_CACHE_SIZE, trace.getCacheSize());
379 assertEquals("getStreamingInterval", 0, trace.getStreamingInterval());
380 assertEquals("getName", "", trace.getName());
381
382 assertEquals("getNbEvents", 0, trace.getNbEvents());
383 assertEquals("getRange-start", Long.MAX_VALUE, trace.getTimeRange().getStartTime().getValue());
384 assertEquals("getRange-end", Long.MIN_VALUE, trace.getTimeRange().getEndTime().getValue());
385 assertEquals("getStartTime", Long.MAX_VALUE, trace.getStartTime().getValue());
386 assertEquals("getEndTime", Long.MIN_VALUE, trace.getEndTime().getValue());
387
388 // Validate
389 final URL location = FileLocator.find(TmfCoreTestPlugin.getDefault().getBundle(), new Path(DIRECTORY + File.separator + TEST_STREAM), null);
390 final File testfile = new File(FileLocator.toFileURL(location).toURI());
391 assertTrue("validate", trace.validate(null, testfile.getPath()));
392
393 // InitTrace and wait for indexing completion...
394 trace.initTrace(null, testfile.getPath(), TmfEvent.class);
395 int nbSecs = 0;
396 while (trace.getNbEvents() < NB_EVENTS && nbSecs < 10) {
397 Thread.sleep(1000);
398 nbSecs++;
399 }
400 if (trace.getNbEvents() < NB_EVENTS) {
401 fail("indexing");
402 }
403
404 assertFalse ("Open trace", trace == null);
405 assertEquals("getType", TmfEvent.class, trace.getType());
406 assertNull ("getResource", trace.getResource());
407 assertEquals("getCacheSize", TmfTrace.DEFAULT_TRACE_CACHE_SIZE, trace.getCacheSize());
408 assertEquals("getStreamingInterval", 0, trace.getStreamingInterval());
409 assertEquals("getName", TEST_STREAM, trace.getName());
410
411 assertEquals("getNbEvents", NB_EVENTS, trace.getNbEvents());
412 assertEquals("getRange-start", 1, trace.getTimeRange().getStartTime().getValue());
413 assertEquals("getRange-end", NB_EVENTS, trace.getTimeRange().getEndTime().getValue());
414 assertEquals("getStartTime", 1, trace.getStartTime().getValue());
415 assertEquals("getEndTime", NB_EVENTS, trace.getEndTime().getValue());
416 }
d18dd09b 417
ff4ed569 418 // ------------------------------------------------------------------------
1703b536
FC		 419 // Set/Get streaming interval
420 // ------------------------------------------------------------------------
421
422 public void testSetStreamingInterval() throws Exception {
423 final TmfTraceStub trace = new TmfTraceStub(fTrace);
424
425 long interval = 0;
426 assertEquals("getStreamingInterval", interval, trace.getStreamingInterval());
427
428 interval = 100;
429 trace.setStreamingInterval(interval);
430 assertEquals("getStreamingInterval", interval, trace.getStreamingInterval());
431
432 interval = -1;
433 trace.setStreamingInterval(interval);
434 assertEquals("getStreamingInterval", 0, trace.getStreamingInterval());
435
436 interval = 0;
437 trace.setStreamingInterval(interval);
438 assertEquals("getStreamingInterval", interval, trace.getStreamingInterval());
439
440 trace.dispose();
441 }
442
443 // ------------------------------------------------------------------------
444 // Set/Get time range
ff4ed569
FC		 445 // ------------------------------------------------------------------------
446
447 public void testSetTimeRange() throws Exception {
f17b2f70 448 final TmfTraceStub trace = new TmfTraceStub(fTrace);
20658947 449 trace.indexTrace();
f17b2f70 450
ff4ed569
FC		 451 assertEquals("getRange-start", 1, trace.getTimeRange().getStartTime().getValue());
452 assertEquals("getRange-end", NB_EVENTS, trace.getTimeRange().getEndTime().getValue());
453 assertEquals("getStartTime", 1, trace.getStartTime().getValue());
454 assertEquals("getEndTime", NB_EVENTS, trace.getEndTime().getValue());
455
456 trace.setTimeRange(new TmfTimeRange(new TmfTimestamp(100), new TmfTimestamp(200)));
457 assertEquals("setTimeRange", 100, trace.getTimeRange().getStartTime().getValue());
458 assertEquals("setTimeRange", 200, trace.getTimeRange().getEndTime().getValue());
459 assertEquals("setTimeRange", 100, trace.getStartTime().getValue());
460 assertEquals("setTimeRange", 200, trace.getEndTime().getValue());
f17b2f70
FC		 461
462 trace.dispose();
ff4ed569 463 }
f17b2f70 464
ff4ed569 465 public void testSetStartTime() throws Exception {
f17b2f70 466 final TmfTraceStub trace = new TmfTraceStub(fTrace);
20658947 467 trace.indexTrace();
f17b2f70 468
ff4ed569
FC		 469 assertEquals("getRange-start", 1, trace.getTimeRange().getStartTime().getValue());
470 assertEquals("getRange-end", NB_EVENTS, trace.getTimeRange().getEndTime().getValue());
471 assertEquals("getStartTime", 1, trace.getStartTime().getValue());
472 assertEquals("getEndTime", NB_EVENTS, trace.getEndTime().getValue());
473
474 trace.setStartTime(new TmfTimestamp(100));
475 assertEquals("setStartTime", 100, trace.getTimeRange().getStartTime().getValue());
476 assertEquals("setStartTime", NB_EVENTS, trace.getTimeRange().getEndTime().getValue());
477 assertEquals("setStartTime", 100, trace.getStartTime().getValue());
478 assertEquals("setStartTime", NB_EVENTS, trace.getEndTime().getValue());
f17b2f70
FC		 479
480 trace.dispose();
ff4ed569 481 }
f17b2f70 482
ff4ed569 483 public void testSetEndTime() throws Exception {
f17b2f70 484 final TmfTraceStub trace = new TmfTraceStub(fTrace);
20658947 485 trace.indexTrace();
f17b2f70 486
ff4ed569
FC		 487 assertEquals("getRange-start", 1, trace.getTimeRange().getStartTime().getValue());
488 assertEquals("getRange-end", NB_EVENTS, trace.getTimeRange().getEndTime().getValue());
489 assertEquals("getStartTime", 1, trace.getStartTime().getValue());
490 assertEquals("getEndTime", NB_EVENTS, trace.getEndTime().getValue());
491
492 trace.setEndTime(new TmfTimestamp(100));
493 assertEquals("setEndTime", 1, trace.getTimeRange().getStartTime().getValue());
494 assertEquals("setEndTime", 100, trace.getTimeRange().getEndTime().getValue());
495 assertEquals("setEndTime", 1, trace.getStartTime().getValue());
496 assertEquals("setEndTime", 100, trace.getEndTime().getValue());
f17b2f70
FC		 497
498 trace.dispose();
ff4ed569 499 }
f17b2f70 500
e31e01e8 501 // ------------------------------------------------------------------------
7e6347b0
FC		 502 // seekEvent on location (note: does not reliably set the rank)
503 // ------------------------------------------------------------------------
504
505 public void testSeekEventOnCacheBoundary() throws Exception {
506
507 // Position trace at event rank 0
508 ITmfContext context = fTrace.seekEvent(0);
509 ITmfEvent event = fTrace.parseEvent(context);
510 assertEquals("Event timestamp", 1, event.getTimestamp().getValue());
511 assertEquals("Event rank", 0, context.getRank());
512
513 context = fTrace.seekEvent(context.getLocation());
514 assertEquals("Event rank", ITmfContext.UNKNOWN_RANK, context.getRank());
515
516 event = fTrace.parseEvent(context);
517 assertEquals("Event timestamp", 1, event.getTimestamp().getValue());
518 assertEquals("Event rank", ITmfContext.UNKNOWN_RANK, context.getRank());
519
b4f71e4a 520 event = fTrace.readNextEvent(context);
7e6347b0
FC		 521 assertEquals("Event timestamp", 1, event.getTimestamp().getValue());
522 assertEquals("Event rank", ITmfContext.UNKNOWN_RANK, context.getRank());
523
524 // Position trace at event rank 1000
525 ITmfContext tmpContext = fTrace.seekEvent(new TmfTimestamp(1001, SCALE, 0));
526 context = fTrace.seekEvent(tmpContext.getLocation());
527 assertEquals("Event rank", ITmfContext.UNKNOWN_RANK, context.getRank());
528
529 event = fTrace.parseEvent(context);
530 assertEquals("Event timestamp", 1001, event.getTimestamp().getValue());
531 assertEquals("Event rank", ITmfContext.UNKNOWN_RANK, context.getRank());
532
b4f71e4a 533 event = fTrace.readNextEvent(context);
7e6347b0
FC		 534 assertEquals("Event timestamp", 1001, event.getTimestamp().getValue());
535 assertEquals("Event rank", ITmfContext.UNKNOWN_RANK, context.getRank());
536
537 // Position trace at event rank 4000
538 tmpContext = fTrace.seekEvent(new TmfTimestamp(4001, SCALE, 0));
539 context = fTrace.seekEvent(tmpContext.getLocation());
540 assertEquals("Event rank", ITmfContext.UNKNOWN_RANK, context.getRank());
541
542 event = fTrace.parseEvent(context);
543 assertEquals("Event timestamp", 4001, event.getTimestamp().getValue());
544 assertEquals("Event rank", ITmfContext.UNKNOWN_RANK, context.getRank());
545
b4f71e4a 546 event = fTrace.readNextEvent(context);
7e6347b0
FC		 547 assertEquals("Event timestamp", 4001, event.getTimestamp().getValue());
548 assertEquals("Event rank", ITmfContext.UNKNOWN_RANK, context.getRank());
549 }
550
551 public void testSeekEventNotOnCacheBoundary() throws Exception {
552
553 // Position trace at event rank 9
554 ITmfContext tmpContext = fTrace.seekEvent(new TmfTimestamp(10, SCALE, 0));
555 TmfContext context = fTrace.seekEvent(tmpContext.getLocation());
556 assertEquals("Event rank", ITmfContext.UNKNOWN_RANK, context.getRank());
557
558 ITmfEvent event = fTrace.parseEvent(context);
559 assertEquals("Event timestamp", 10, event.getTimestamp().getValue());
560 assertEquals("Event rank", ITmfContext.UNKNOWN_RANK, context.getRank());
561
b4f71e4a 562 event = fTrace.readNextEvent(context);
7e6347b0
FC		 563 assertEquals("Event timestamp", 10, event.getTimestamp().getValue());
564 assertEquals("Event rank", ITmfContext.UNKNOWN_RANK, context.getRank());
565
566 // Position trace at event rank 999
567 tmpContext = fTrace.seekEvent(new TmfTimestamp(1000, SCALE, 0));
568 context = fTrace.seekEvent(tmpContext.getLocation());
569 assertEquals("Event rank", ITmfContext.UNKNOWN_RANK, context.getRank());
570
571 event = fTrace.parseEvent(context);
572 assertEquals("Event timestamp", 1000, event.getTimestamp().getValue());
573 assertEquals("Event rank", ITmfContext.UNKNOWN_RANK, context.getRank());
574
b4f71e4a 575 event = fTrace.readNextEvent(context);
7e6347b0
FC		 576 assertEquals("Event timestamp", 1000, event.getTimestamp().getValue());
577 assertEquals("Event rank", ITmfContext.UNKNOWN_RANK, context.getRank());
578
579 // Position trace at event rank 1001
580 tmpContext = fTrace.seekEvent(new TmfTimestamp(1002, SCALE, 0));
581 context = fTrace.seekEvent(tmpContext.getLocation());
582 assertEquals("Event rank", ITmfContext.UNKNOWN_RANK, context.getRank());
583
584 event = fTrace.parseEvent(context);
585 assertEquals("Event timestamp", 1002, event.getTimestamp().getValue());
586 assertEquals("Event rank", ITmfContext.UNKNOWN_RANK, context.getRank());
587
b4f71e4a 588 event = fTrace.readNextEvent(context);
7e6347b0
FC		 589 assertEquals("Event timestamp", 1002, event.getTimestamp().getValue());
590 assertEquals("Event rank", ITmfContext.UNKNOWN_RANK, context.getRank());
591
592 // Position trace at event rank 4500
593 tmpContext = fTrace.seekEvent(new TmfTimestamp(4501, SCALE, 0));
594 context = fTrace.seekEvent(tmpContext.getLocation());
595 assertEquals("Event rank", ITmfContext.UNKNOWN_RANK, context.getRank());
596
597 event = fTrace.parseEvent(context);
598 assertEquals("Event timestamp", 4501, event.getTimestamp().getValue());
599 assertEquals("Event rank", ITmfContext.UNKNOWN_RANK, context.getRank());
600
b4f71e4a 601 event = fTrace.readNextEvent(context);
7e6347b0
FC		 602 assertEquals("Event timestamp", 4501, event.getTimestamp().getValue());
603 assertEquals("Event rank", ITmfContext.UNKNOWN_RANK, context.getRank());
604 }
605
606 public void testSeekEventOutOfScope() throws Exception {
607
608 // Position trace at beginning
609 ITmfContext tmpContext = fTrace.seekEvent(0);
610 ITmfContext context = fTrace.seekEvent(tmpContext.getLocation());
611 assertEquals("Event rank", ITmfContext.UNKNOWN_RANK, context.getRank());
612
613 ITmfEvent event = fTrace.parseEvent(context);
614 assertEquals("Event timestamp", 1, event.getTimestamp().getValue());
615 assertEquals("Event rank", ITmfContext.UNKNOWN_RANK, context.getRank());
616
b4f71e4a 617 event = fTrace.readNextEvent(context);
7e6347b0
FC		 618 assertEquals("Event timestamp", 1, event.getTimestamp().getValue());
619 assertEquals("Event rank", ITmfContext.UNKNOWN_RANK, context.getRank());
620
621 // Position trace at event passed the end
622 tmpContext = fTrace.seekEvent(new TmfTimestamp(NB_EVENTS + 1, SCALE, 0));
623 context = fTrace.seekEvent(tmpContext.getLocation());
624 assertEquals("Event rank", ITmfContext.UNKNOWN_RANK, context.getRank());
625
626 event = fTrace.parseEvent(context);
627 assertEquals("Event timestamp", null, event);
628 assertEquals("Event rank", ITmfContext.UNKNOWN_RANK, context.getRank());
629
b4f71e4a 630 event = fTrace.readNextEvent(context);
7e6347b0
FC		 631 assertEquals("Event timestamp", null, event);
632 assertEquals("Event rank", ITmfContext.UNKNOWN_RANK, context.getRank());
633 }
634
635 // ------------------------------------------------------------------------
636 // seekEvent on timestamp (note: does not reliably set the rank)
54d55ced
FC		 637 // ------------------------------------------------------------------------
638
20658947 639 public void testSeekEventOnNullTimestamp() throws Exception {
54d55ced 640
f17b2f70 641 // Position trace at event rank 0
7e6347b0 642 ITmfContext context = fTrace.seekEvent((ITmfTimestamp) null);
ff4ed569 643 assertEquals("Event rank", 0, context.getRank());
9b635e61 644
72f1e62a 645 ITmfEvent event = fTrace.parseEvent(context);
54d55ced 646 assertEquals("Event timestamp", 1, event.getTimestamp().getValue());
20658947 647 assertEquals("Event rank", 0, context.getRank());
54d55ced
FC		 648 }
649
54d55ced
FC		 650 public void testSeekEventOnTimestampOnCacheBoundary() throws Exception {
651
f17b2f70
FC		 652 // Position trace at event rank 0
653 ITmfContext context = fTrace.seekEvent(new TmfTimestamp(1, SCALE, 0));
54d55ced 654 assertEquals("Event rank", 0, context.getRank());
9b635e61 655
72f1e62a 656 ITmfEvent event = fTrace.parseEvent(context);
54d55ced
FC		 657 assertEquals("Event timestamp", 1, event.getTimestamp().getValue());
658 assertEquals("Event rank", 0, context.getRank());
f17b2f70 659
b4f71e4a 660 event = fTrace.readNextEvent(context);
75828b1a 661 assertEquals("Event timestamp", 1, event.getTimestamp().getValue());
e31e01e8 662 assertEquals("Event rank", 1, context.getRank());
d18dd09b 663
f17b2f70 664 // Position trace at event rank 1000
54d55ced
FC		 665 context = fTrace.seekEvent(new TmfTimestamp(1001, SCALE, 0));
666 assertEquals("Event rank", 1000, context.getRank());
f17b2f70 667
9b635e61 668 event = fTrace.parseEvent(context);
54d55ced
FC		 669 assertEquals("Event timestamp", 1001, event.getTimestamp().getValue());
670 assertEquals("Event rank", 1000, context.getRank());
f17b2f70 671
b4f71e4a 672 event = fTrace.readNextEvent(context);
e31e01e8
FC		 673 assertEquals("Event timestamp", 1001, event.getTimestamp().getValue());
674 assertEquals("Event rank", 1001, context.getRank());
d18dd09b 675
f17b2f70 676 // Position trace at event rank 4000
54d55ced
FC		 677 context = fTrace.seekEvent(new TmfTimestamp(4001, SCALE, 0));
678 assertEquals("Event rank", 4000, context.getRank());
f17b2f70 679
9b635e61 680 event = fTrace.parseEvent(context);
54d55ced
FC		 681 assertEquals("Event timestamp", 4001, event.getTimestamp().getValue());
682 assertEquals("Event rank", 4000, context.getRank());
f17b2f70 683
b4f71e4a 684 event = fTrace.readNextEvent(context);
e31e01e8
FC		 685 assertEquals("Event timestamp", 4001, event.getTimestamp().getValue());
686 assertEquals("Event rank", 4001, context.getRank());
75828b1a 687 }
d18dd09b 688
54d55ced
FC		 689 public void testSeekEventOnTimestampNotOnCacheBoundary() throws Exception {
690
f17b2f70
FC		 691 // Position trace at event rank 1
692 ITmfContext context = fTrace.seekEvent(new TmfTimestamp(2, SCALE, 0));
54d55ced 693 assertEquals("Event rank", 1, context.getRank());
f17b2f70 694
72f1e62a 695 ITmfEvent event = fTrace.parseEvent(context);
54d55ced
FC		 696 assertEquals("Event timestamp", 2, event.getTimestamp().getValue());
697 assertEquals("Event rank", 1, context.getRank());
f17b2f70 698
b4f71e4a 699 event = fTrace.readNextEvent(context);
54d55ced
FC		 700 assertEquals("Event timestamp", 2, event.getTimestamp().getValue());
701 assertEquals("Event rank", 2, context.getRank());
d18dd09b 702
f17b2f70
FC		 703 // Position trace at event rank 9
704 context = fTrace.seekEvent(new TmfTimestamp(10, SCALE, 0));
54d55ced 705 assertEquals("Event rank", 9, context.getRank());
f17b2f70 706
9b635e61 707 event = fTrace.parseEvent(context);
54d55ced
FC		 708 assertEquals("Event timestamp", 10, event.getTimestamp().getValue());
709 assertEquals("Event rank", 9, context.getRank());
f17b2f70 710
b4f71e4a 711 event = fTrace.readNextEvent(context);
e31e01e8
FC		 712 assertEquals("Event timestamp", 10, event.getTimestamp().getValue());
713 assertEquals("Event rank", 10, context.getRank());
d18dd09b 714
f17b2f70 715 // Position trace at event rank 999
54d55ced
FC		 716 context = fTrace.seekEvent(new TmfTimestamp(1000, SCALE, 0));
717 assertEquals("Event rank", 999, context.getRank());
f17b2f70 718
9b635e61 719 event = fTrace.parseEvent(context);
54d55ced 720 assertEquals("Event timestamp", 1000, event.getTimestamp().getValue());
e31e01e8 721 assertEquals("Event rank", 999, context.getRank());
f17b2f70 722
b4f71e4a 723 event = fTrace.readNextEvent(context);
54d55ced
FC		 724 assertEquals("Event timestamp", 1000, event.getTimestamp().getValue());
725 assertEquals("Event rank", 1000, context.getRank());
e31e01e8 726
f17b2f70 727 // Position trace at event rank 1001
54d55ced 728 context = fTrace.seekEvent(new TmfTimestamp(1002, SCALE, 0));
e31e01e8 729 assertEquals("Event rank", 1001, context.getRank());
f17b2f70 730
9b635e61 731 event = fTrace.parseEvent(context);
54d55ced
FC		 732 assertEquals("Event timestamp", 1002, event.getTimestamp().getValue());
733 assertEquals("Event rank", 1001, context.getRank());
f17b2f70 734
b4f71e4a 735 event = fTrace.readNextEvent(context);
54d55ced
FC		 736 assertEquals("Event timestamp", 1002, event.getTimestamp().getValue());
737 assertEquals("Event rank", 1002, context.getRank());
738
f17b2f70 739 // Position trace at event rank 4500
54d55ced
FC		 740 context = fTrace.seekEvent(new TmfTimestamp(4501, SCALE, 0));
741 assertEquals("Event rank", 4500, context.getRank());
f17b2f70 742
9b635e61 743 event = fTrace.parseEvent(context);
54d55ced
FC		 744 assertEquals("Event timestamp", 4501, event.getTimestamp().getValue());
745 assertEquals("Event rank", 4500, context.getRank());
f17b2f70 746
b4f71e4a 747 event = fTrace.readNextEvent(context);
54d55ced
FC		 748 assertEquals("Event timestamp", 4501, event.getTimestamp().getValue());
749 assertEquals("Event rank", 4501, context.getRank());
75828b1a 750 }
d18dd09b 751
54d55ced 752 public void testSeekEventOnTimestampOutOfScope() throws Exception {
d18dd09b 753
f17b2f70
FC		 754 // Position trace at beginning
755 ITmfContext context = fTrace.seekEvent(new TmfTimestamp(-1, SCALE, 0));
54d55ced 756 assertEquals("Event rank", 0, context.getRank());
f17b2f70 757
72f1e62a 758 ITmfEvent event = fTrace.parseEvent(context);
75828b1a 759 assertEquals("Event timestamp", 1, event.getTimestamp().getValue());
54d55ced 760 assertEquals("Event rank", 0, context.getRank());
f17b2f70 761
b4f71e4a 762 event = fTrace.readNextEvent(context);
54d55ced
FC		 763 assertEquals("Event timestamp", 1, event.getTimestamp().getValue());
764 assertEquals("Event rank", 1, context.getRank());
75828b1a 765
f17b2f70 766 // Position trace at event passed the end
54d55ced
FC		 767 context = fTrace.seekEvent(new TmfTimestamp(NB_EVENTS + 1, SCALE, 0));
768 assertEquals("Event rank", NB_EVENTS, context.getRank());
f17b2f70 769
9b635e61 770 event = fTrace.parseEvent(context);
75828b1a 771 assertEquals("Event timestamp", null, event);
54d55ced 772 assertEquals("Event rank", NB_EVENTS, context.getRank());
f17b2f70 773
b4f71e4a 774 event = fTrace.readNextEvent(context);
54d55ced
FC		 775 assertEquals("Event timestamp", null, event);
776 assertEquals("Event rank", NB_EVENTS, context.getRank());
d18dd09b
ASL		 777 }
778
54d55ced
FC		 779 // ------------------------------------------------------------------------
780 // seekEvent on rank
781 // ------------------------------------------------------------------------
782
20658947
FC		 783 public void testSeekEventOnNegativeRank() throws Exception {
784
785 // Position trace at event rank 0
786 ITmfContext context = fTrace.seekEvent(-1);
787 assertEquals("Event rank", 0, context.getRank());
788
789 ITmfEvent event = fTrace.parseEvent(context);
790 assertEquals("Event timestamp", 1, event.getTimestamp().getValue());
791 assertEquals("Event rank", 0, context.getRank());
792 }
793
54d55ced 794 public void testSeekOnRankOnCacheBoundary() throws Exception {
e31e01e8 795
f17b2f70
FC		 796 // On lower bound, returns the first event (ts = 1)
797 ITmfContext context = fTrace.seekEvent(0);
54d55ced 798 assertEquals("Event rank", 0, context.getRank());
f17b2f70 799
72f1e62a 800 ITmfEvent event = fTrace.parseEvent(context);
e31e01e8 801 assertEquals("Event timestamp", 1, event.getTimestamp().getValue());
54d55ced 802 assertEquals("Event rank", 0, context.getRank());
f17b2f70 803
b4f71e4a 804 event = fTrace.readNextEvent(context);
54d55ced
FC		 805 assertEquals("Event timestamp", 1, event.getTimestamp().getValue());
806 assertEquals("Event rank", 1, context.getRank());
e31e01e8 807
f17b2f70 808 // Position trace at event rank 1000
54d55ced
FC		 809 context = fTrace.seekEvent(1000);
810 assertEquals("Event rank", 1000, context.getRank());
f17b2f70 811
9b635e61 812 event = fTrace.parseEvent(context);
54d55ced
FC		 813 assertEquals("Event timestamp", 1001, event.getTimestamp().getValue());
814 assertEquals("Event rank", 1000, context.getRank());
f17b2f70 815
b4f71e4a 816 event = fTrace.readNextEvent(context);
54d55ced
FC		 817 assertEquals("Event timestamp", 1001, event.getTimestamp().getValue());
818 assertEquals("Event rank", 1001, context.getRank());
e31e01e8 819
f17b2f70 820 // Position trace at event rank 4000
54d55ced
FC		 821 context = fTrace.seekEvent(4000);
822 assertEquals("Event rank", 4000, context.getRank());
f17b2f70 823
9b635e61 824 event = fTrace.parseEvent(context);
54d55ced
FC		 825 assertEquals("Event timestamp", 4001, event.getTimestamp().getValue());
826 assertEquals("Event rank", 4000, context.getRank());
f17b2f70 827
b4f71e4a 828 event = fTrace.readNextEvent(context);
54d55ced
FC		 829 assertEquals("Event timestamp", 4001, event.getTimestamp().getValue());
830 assertEquals("Event rank", 4001, context.getRank());
e31e01e8
FC		 831 }
832
54d55ced 833 public void testSeekOnRankNotOnCacheBoundary() throws Exception {
d18dd09b 834
f17b2f70
FC		 835 // Position trace at event rank 9
836 ITmfContext context = fTrace.seekEvent(9);
54d55ced 837 assertEquals("Event rank", 9, context.getRank());
f17b2f70 838
72f1e62a 839 ITmfEvent event = fTrace.parseEvent(context);
54d55ced
FC		 840 assertEquals("Event timestamp", 10, event.getTimestamp().getValue());
841 assertEquals("Event rank", 9, context.getRank());
f17b2f70 842
b4f71e4a 843 event = fTrace.readNextEvent(context);
54d55ced
FC		 844 assertEquals("Event timestamp", 10, event.getTimestamp().getValue());
845 assertEquals("Event rank", 10, context.getRank());
d18dd09b 846
f17b2f70 847 // Position trace at event rank 999
54d55ced
FC		 848 context = fTrace.seekEvent(999);
849 assertEquals("Event rank", 999, context.getRank());
f17b2f70 850
9b635e61 851 event = fTrace.parseEvent(context);
54d55ced
FC		 852 assertEquals("Event timestamp", 1000, event.getTimestamp().getValue());
853 assertEquals("Event rank", 999, context.getRank());
f17b2f70 854
b4f71e4a 855 event = fTrace.readNextEvent(context);
54d55ced
FC		 856 assertEquals("Event timestamp", 1000, event.getTimestamp().getValue());
857 assertEquals("Event rank", 1000, context.getRank());
d18dd09b 858
f17b2f70 859 // Position trace at event rank 1001
54d55ced
FC		 860 context = fTrace.seekEvent(1001);
861 assertEquals("Event rank", 1001, context.getRank());
f17b2f70 862
9b635e61 863 event = fTrace.parseEvent(context);
54d55ced
FC		 864 assertEquals("Event timestamp", 1002, event.getTimestamp().getValue());
865 assertEquals("Event rank", 1001, context.getRank());
f17b2f70 866
b4f71e4a 867 event = fTrace.readNextEvent(context);
54d55ced
FC		 868 assertEquals("Event timestamp", 1002, event.getTimestamp().getValue());
869 assertEquals("Event rank", 1002, context.getRank());
870
f17b2f70 871 // Position trace at event rank 4500
54d55ced
FC		 872 context = fTrace.seekEvent(4500);
873 assertEquals("Event rank", 4500, context.getRank());
f17b2f70 874
9b635e61 875 event = fTrace.parseEvent(context);
54d55ced
FC		 876 assertEquals("Event timestamp", 4501, event.getTimestamp().getValue());
877 assertEquals("Event rank", 4500, context.getRank());
f17b2f70 878
b4f71e4a 879 event = fTrace.readNextEvent(context);
54d55ced
FC		 880 assertEquals("Event timestamp", 4501, event.getTimestamp().getValue());
881 assertEquals("Event rank", 4501, context.getRank());
d18dd09b
ASL		 882 }
883
54d55ced
FC		 884 public void testSeekEventOnRankOfScope() throws Exception {
885
f17b2f70
FC		 886 // Position trace at beginning
887 ITmfContext context = fTrace.seekEvent(-1);
54d55ced 888 assertEquals("Event rank", 0, context.getRank());
f17b2f70 889
72f1e62a 890 ITmfEvent event = fTrace.parseEvent(context);
54d55ced
FC		 891 assertEquals("Event timestamp", 1, event.getTimestamp().getValue());
892 assertEquals("Event rank", 0, context.getRank());
f17b2f70 893
b4f71e4a 894 event = fTrace.readNextEvent(context);
54d55ced
FC		 895 assertEquals("Event timestamp", 1, event.getTimestamp().getValue());
896 assertEquals("Event rank", 1, context.getRank());
897
f17b2f70 898 // Position trace at event passed the end
54d55ced
FC		 899 context = fTrace.seekEvent(NB_EVENTS);
900 assertEquals("Event rank", NB_EVENTS, context.getRank());
f17b2f70 901
9b635e61 902 event = fTrace.parseEvent(context);
54d55ced
FC		 903 assertEquals("Event timestamp", null, event);
904 assertEquals("Event rank", NB_EVENTS, context.getRank());
f17b2f70 905
b4f71e4a 906 event = fTrace.readNextEvent(context);
54d55ced
FC		 907 assertEquals("Event timestamp", null, event);
908 assertEquals("Event rank", NB_EVENTS, context.getRank());
909 }
f17b2f70 910
20658947
FC		 911 // ------------------------------------------------------------------------
912 // parseEvent - make sure parseEvent doesn't update the context
913 // ------------------------------------------------------------------------
914
915 public void testParseEvent() throws Exception {
916
917 final int NB_READS = 20;
918
919 // On lower bound, returns the first event (ts = 0)
920 final TmfContext context = (TmfContext) fTrace.seekEvent(new TmfTimestamp(0, SCALE, 0));
921 TmfContext svContext = new TmfContext(context);
922
923 ITmfEvent event = fTrace.parseEvent(context);
924 assertEquals("Event timestamp", 1, event.getTimestamp().getValue());
925 assertEquals("Event rank", 0, context.getRank());
926 assertTrue("parseEvent", context.equals(svContext));
927
928 event = fTrace.parseEvent(context);
929 assertEquals("Event timestamp", 1, event.getTimestamp().getValue());
930 assertEquals("Event rank", 0, context.getRank());
931 assertTrue("parseEvent", context.equals(svContext));
932
933 event = fTrace.parseEvent(context);
934 assertEquals("Event timestamp", 1, event.getTimestamp().getValue());
935 assertEquals("Event rank", 0, context.getRank());
936 assertTrue("parseEvent", context.equals(svContext));
937
938 // Position the trace at event NB_READS
939 for (int i = 1; i < NB_READS; i++) {
b4f71e4a 940 event = fTrace.readNextEvent(context);
20658947
FC		 941 assertEquals("Event timestamp", i, event.getTimestamp().getValue());
942 }
943
944 svContext = new TmfContext(context);
945 event = fTrace.parseEvent(context);
946 assertEquals("Event timestamp", NB_READS, event.getTimestamp().getValue());
947 assertEquals("Event rank", NB_READS -1 , context.getRank());
948 assertTrue("parseEvent", context.equals(svContext));
949
950 event = fTrace.parseEvent(context);
951 assertEquals("Event timestamp", NB_READS, event.getTimestamp().getValue());
952 assertEquals("Event rank", NB_READS - 1, context.getRank());
953 assertTrue("parseEvent", context.equals(svContext));
954 }
955
956 // ------------------------------------------------------------------------
b4f71e4a 957 // readNextEvent - updates the context
20658947
FC		 958 // ------------------------------------------------------------------------
959
b4f71e4a 960 public void testReadNextEvent() throws Exception {
20658947
FC		 961
962 final int NB_READS = 20;
963
964 // On lower bound, returns the first event (ts = 1)
965 final ITmfContext context = fTrace.seekEvent(new TmfTimestamp(0, SCALE, 0));
966
967 // Read NB_EVENTS
968 ITmfEvent event;
969 for (int i = 0; i < NB_READS; i++) {
b4f71e4a 970 event = fTrace.readNextEvent(context);
20658947
FC		 971 assertEquals("Event timestamp", i + 1, event.getTimestamp().getValue());
972 assertEquals("Event rank", i + 1, context.getRank());
973 }
974
975 // Make sure we stay positioned
976 event = fTrace.parseEvent(context);
977 assertEquals("Event timestamp", NB_READS + 1, event.getTimestamp().getValue());
978 assertEquals("Event rank", NB_READS, context.getRank());
979 }
980
e31e01e8 981 // ------------------------------------------------------------------------
d18dd09b 982 // processRequest
e31e01e8 983 // ------------------------------------------------------------------------
d18dd09b 984
e31e01e8 985 @SuppressWarnings("unchecked")
7e6347b0
FC		 986 public void testProcessEventRequestForAllEvents() throws Exception {
987 final int BLOCK_SIZE = 1;
988 final Vector<TmfEvent> requestedEvents = new Vector<TmfEvent>();
989
990 final TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BIG_BANG, TmfTimestamp.BIG_CRUNCH);
991 final TmfEventRequest<TmfEvent> request = new TmfEventRequest<TmfEvent>(TmfEvent.class, range, NB_EVENTS, BLOCK_SIZE) {
992 @Override
993 public void handleData(final TmfEvent event) {
994 super.handleData(event);
995 requestedEvents.add(event);
996 }
997 };
998 final ITmfDataProvider<TmfEvent>[] providers = (ITmfDataProvider<TmfEvent>[]) TmfProviderManager.getProviders(TmfEvent.class, TmfTraceStub.class);
999 providers[0].sendRequest(request);
1000 request.waitForCompletion();
1001
1002 assertEquals("nbEvents", NB_EVENTS, requestedEvents.size());
1003 assertTrue("isCompleted", request.isCompleted());
1004 assertFalse("isCancelled", request.isCancelled());
1005
1006 // Ensure that we have distinct events.
1007 // Don't go overboard: we are not validating the stub!
1008 for (int i = 0; i < NB_EVENTS; i++) {
1009 assertEquals("Distinct events", i + 1, requestedEvents.get(i).getTimestamp().getValue());
1010 }
1011 }
1012
1013 @SuppressWarnings("unchecked")
1014 public void testProcessEventRequestForNbEvents() throws Exception {
d18dd09b
ASL		 1015 final int BLOCK_SIZE = 100;
1016 final int NB_EVENTS = 1000;
1017 final Vector<TmfEvent> requestedEvents = new Vector<TmfEvent>();
1018
f17b2f70 1019 final TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BIG_BANG, TmfTimestamp.BIG_CRUNCH);
e31e01e8 1020 final TmfEventRequest<TmfEvent> request = new TmfEventRequest<TmfEvent>(TmfEvent.class, range, NB_EVENTS, BLOCK_SIZE) {
f17b2f70
FC		 1021 @Override
1022 public void handleData(final TmfEvent event) {
1023 super.handleData(event);
1024 requestedEvents.add(event);
1025 }
d18dd09b 1026 };
f17b2f70 1027 final ITmfDataProvider<TmfEvent>[] providers = (ITmfDataProvider<TmfEvent>[]) TmfProviderManager.getProviders(TmfEvent.class, TmfTraceStub.class);
951d134a
FC		 1028 providers[0].sendRequest(request);
1029 request.waitForCompletion();
d18dd09b
ASL		 1030
1031 assertEquals("nbEvents", NB_EVENTS, requestedEvents.size());
1032 assertTrue("isCompleted", request.isCompleted());
1033 assertFalse("isCancelled", request.isCancelled());
1034
1035 // Ensure that we have distinct events.
f17b2f70 1036 // Don't go overboard: we are not validating the stub!
20658947 1037 for (int i = 0; i < NB_EVENTS; i++) {
7e6347b0 1038 assertEquals("Distinct events", i + 1, requestedEvents.get(i).getTimestamp().getValue());
20658947 1039 }
d18dd09b 1040 }
f17b2f70 1041
e31e01e8 1042 @SuppressWarnings("unchecked")
7e6347b0 1043 public void testProcessEventRequestForSomeEvents() throws Exception {
d18dd09b 1044 final int BLOCK_SIZE = 1;
7e6347b0
FC		 1045 final long startTime = 100;
1046 final int NB_EVENTS = 1000;
d18dd09b
ASL		 1047 final Vector<TmfEvent> requestedEvents = new Vector<TmfEvent>();
1048
7e6347b0 1049 final TmfTimeRange range = new TmfTimeRange(new TmfTimestamp(startTime, SCALE), TmfTimestamp.BIG_CRUNCH);
e31e01e8 1050 final TmfEventRequest<TmfEvent> request = new TmfEventRequest<TmfEvent>(TmfEvent.class, range, NB_EVENTS, BLOCK_SIZE) {
f17b2f70
FC		 1051 @Override
1052 public void handleData(final TmfEvent event) {
1053 super.handleData(event);
1054 requestedEvents.add(event);
1055 }
d18dd09b 1056 };
f17b2f70 1057 final ITmfDataProvider<TmfEvent>[] providers = (ITmfDataProvider<TmfEvent>[]) TmfProviderManager.getProviders(TmfEvent.class, TmfTraceStub.class);
951d134a
FC		 1058 providers[0].sendRequest(request);
1059 request.waitForCompletion();
d18dd09b
ASL		 1060
1061 assertEquals("nbEvents", NB_EVENTS, requestedEvents.size());
1062 assertTrue("isCompleted", request.isCompleted());
1063 assertFalse("isCancelled", request.isCancelled());
1064
1065 // Ensure that we have distinct events.
f17b2f70 1066 // Don't go overboard: we are not validating the stub!
20658947 1067 for (int i = 0; i < NB_EVENTS; i++) {
7e6347b0
FC		 1068 assertEquals("Distinct events", startTime + i, requestedEvents.get(i).getTimestamp().getValue());
1069 }
1070 }
1071
1072 @SuppressWarnings("unchecked")
1073 public void testProcessEventRequestForOtherEvents() throws Exception {
1074 final int BLOCK_SIZE = 1;
1075 final int startIndex = 99;
1076 final long startTime = 100;
1077 final int NB_EVENTS = 1000;
1078 final Vector<TmfEvent> requestedEvents = new Vector<TmfEvent>();
1079
1080 final TmfTimeRange range = new TmfTimeRange(new TmfTimestamp(startTime, SCALE), TmfTimestamp.BIG_CRUNCH);
1081 final TmfEventRequest<TmfEvent> request = new TmfEventRequest<TmfEvent>(TmfEvent.class, range, startIndex, NB_EVENTS, BLOCK_SIZE) {
1082 @Override
1083 public void handleData(final TmfEvent event) {
1084 super.handleData(event);
1085 requestedEvents.add(event);
1086 }
1087 };
1088 final ITmfDataProvider<TmfEvent>[] providers = (ITmfDataProvider<TmfEvent>[]) TmfProviderManager.getProviders(TmfEvent.class, TmfTraceStub.class);
1089 providers[0].sendRequest(request);
1090 request.waitForCompletion();
1091
1092 assertEquals("nbEvents", NB_EVENTS, requestedEvents.size());
1093 assertTrue("isCompleted", request.isCompleted());
1094 assertFalse("isCancelled", request.isCancelled());
1095
1096 // Ensure that we have distinct events.
1097 // Don't go overboard: we are not validating the stub!
1098 for (int i = 0; i < NB_EVENTS; i++) {
1099 assertEquals("Distinct events", startTime + i, requestedEvents.get(i).getTimestamp().getValue());
1100 }
1101 }
1102
1103 @SuppressWarnings("unchecked")
1104 public void testProcessDataRequestForSomeEvents() throws Exception {
1105 final int startIndex = 100;
1106 final int NB_EVENTS = 1000;
1107 final Vector<TmfEvent> requestedEvents = new Vector<TmfEvent>();
1108
1109 final TmfDataRequest<TmfEvent> request = new TmfDataRequest<TmfEvent>(TmfEvent.class, startIndex, NB_EVENTS) {
1110 @Override
1111 public void handleData(final TmfEvent event) {
1112 super.handleData(event);
1113 requestedEvents.add(event);
1114 }
1115 };
1116 final ITmfDataProvider<TmfEvent>[] providers = (ITmfDataProvider<TmfEvent>[]) TmfProviderManager.getProviders(TmfEvent.class, TmfTraceStub.class);
1117 providers[0].sendRequest(request);
1118 request.waitForCompletion();
1119
1120 assertEquals("nbEvents", NB_EVENTS, requestedEvents.size());
1121 assertTrue("isCompleted", request.isCompleted());
1122 assertFalse("isCancelled", request.isCancelled());
1123
1124 // Ensure that we have distinct events.
1125 // Don't go overboard: we are not validating the stub!
1126 for (int i = 0; i < NB_EVENTS; i++) {
1127 assertEquals("Distinct events", startIndex + 1 + i, requestedEvents.get(i).getTimestamp().getValue());
20658947 1128 }
d18dd09b 1129 }
f17b2f70 1130
e31e01e8 1131 // ------------------------------------------------------------------------
d18dd09b 1132 // cancel
e31e01e8 1133 // ------------------------------------------------------------------------
d18dd09b 1134
e31e01e8 1135 @SuppressWarnings("unchecked")
f17b2f70 1136 public void testCancel() throws Exception {
d18dd09b
ASL		 1137 final Vector<TmfEvent> requestedEvents = new Vector<TmfEvent>();
1138
f17b2f70 1139 final TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BIG_BANG, TmfTimestamp.BIG_CRUNCH);
cb866e08 1140 final TmfEventRequest<TmfEvent> request = new TmfEventRequest<TmfEvent>(TmfEvent.class, range, NB_EVENTS, BLOCK_SIZE) {
f17b2f70
FC		 1141 int nbRead = 0;
1142 @Override
1143 public void handleData(final TmfEvent event) {
1144 super.handleData(event);
1145 requestedEvents.add(event);
20658947 1146 if (++nbRead == BLOCK_SIZE) {
f17b2f70 1147 cancel();
20658947 1148 }
f17b2f70 1149 }
d18dd09b 1150 };
f17b2f70 1151 final ITmfDataProvider<TmfEvent>[] providers = (ITmfDataProvider<TmfEvent>[]) TmfProviderManager.getProviders(TmfEvent.class, TmfTraceStub.class);
951d134a
FC		 1152 providers[0].sendRequest(request);
1153 request.waitForCompletion();
d18dd09b 1154
cb866e08 1155 assertEquals("nbEvents", BLOCK_SIZE, requestedEvents.size());
d18dd09b
ASL		 1156 assertTrue("isCompleted", request.isCompleted());
1157 assertTrue("isCancelled", request.isCancelled());
1158 }
e31e01e8 1159
1703b536
FC		 1160 // ------------------------------------------------------------------------
1161 // toString
1162 // ------------------------------------------------------------------------
1163
1164 public void testDefaultTmfTraceStub() throws Exception {
1165 assertFalse ("Open trace", fTrace == null);
1166 assertEquals("getType", TmfEvent.class, fTrace.getType());
1167 assertNull ("getResource", fTrace.getResource());
1168 assertEquals("getCacheSize", BLOCK_SIZE, fTrace.getCacheSize());
1169 assertEquals("getStreamingInterval", 0, fTrace.getStreamingInterval());
1170 assertEquals("getName", TEST_STREAM, fTrace.getName());
1171
1172 assertEquals("getNbEvents", NB_EVENTS, fTrace.getNbEvents());
1173 assertEquals("getRange-start", 1, fTrace.getTimeRange().getStartTime().getValue());
1174 assertEquals("getRange-end", NB_EVENTS, fTrace.getTimeRange().getEndTime().getValue());
1175 assertEquals("getStartTime", 1, fTrace.getStartTime().getValue());
1176 assertEquals("getEndTime", NB_EVENTS, fTrace.getEndTime().getValue());
1177
1178 String expected = "TmfTrace [fPath=" + fTrace.getPath() + ", fCacheSize=" + fTrace.getCacheSize() +
1179 ", fNbEvents=" + fTrace.getNbEvents() + ", fStartTime=" + fTrace.getStartTime() +
1180 ", fEndTime=" + fTrace.getEndTime() + ", fStreamingInterval=" + fTrace.getStreamingInterval() +
1181 "]";
1182 assertEquals("toString", expected, fTrace.toString());
1183 }
1184
e31e01e8 1185}
Tracecompass - Deliverables
This page took 0.102856 seconds and 5 git commands to generate.