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