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