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