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