Commit | Line | Data |
---|---|---|
d18dd09b | 1 | /******************************************************************************* |
0316808c | 2 | * Copyright (c) 2009, 2010, 2012 Ericsson |
9b749023 | 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 | |
9b749023 | 8 | * |
d18dd09b ASL |
9 | * Contributors: |
10 | * Francois Chouinard - Initial API and implementation | |
0316808c | 11 | * Francois Chouinard - Adjusted for new Trace Model |
d18dd09b ASL |
12 | *******************************************************************************/ |
13 | ||
9e0640dc | 14 | package org.eclipse.linuxtools.tmf.core.tests.trace; |
d18dd09b ASL |
15 | |
16 | import java.io.File; | |
17 | import java.io.IOException; | |
18 | import java.net.URISyntaxException; | |
19 | import java.net.URL; | |
20 | import java.util.Vector; | |
21 | ||
22 | import junit.framework.TestCase; | |
23 | ||
9e0640dc | 24 | import org.eclipse.core.resources.IFile; |
d18dd09b ASL |
25 | import org.eclipse.core.runtime.FileLocator; |
26 | import org.eclipse.core.runtime.Path; | |
17324c9a | 27 | import org.eclipse.linuxtools.internal.tmf.core.trace.TmfExperimentContext; |
9e0640dc | 28 | import org.eclipse.linuxtools.internal.tmf.core.trace.TmfExperimentLocation; |
72f1e62a | 29 | import org.eclipse.linuxtools.tmf.core.event.ITmfEvent; |
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; |
9b749023 | 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.ITmfLocation; |
6c13869b | 39 | import org.eclipse.linuxtools.tmf.core.trace.ITmfTrace; |
9e0640dc FC |
40 | import org.eclipse.linuxtools.tmf.core.trace.TmfExperiment; |
41 | import org.eclipse.linuxtools.tmf.core.trace.TmfLocation; | |
42 | import org.eclipse.linuxtools.tmf.tests.stubs.trace.TmfExperimentStub; | |
4918b8f2 | 43 | import org.eclipse.linuxtools.tmf.tests.stubs.trace.TmfTraceStub; |
d18dd09b ASL |
44 | |
45 | /** | |
0316808c | 46 | * Test suite for the TmfExperiment class (single trace). |
d18dd09b | 47 | */ |
54a7a54c | 48 | @SuppressWarnings({"nls","javadoc"}) |
d18dd09b ASL |
49 | public class TmfExperimentTest extends TestCase { |
50 | ||
0316808c FC |
51 | // ------------------------------------------------------------------------ |
52 | // Attributes | |
53 | // ------------------------------------------------------------------------ | |
54 | ||
d18dd09b ASL |
55 | private static final String DIRECTORY = "testfiles"; |
56 | private static final String TEST_STREAM = "A-Test-10K"; | |
57 | private static final String EXPERIMENT = "MyExperiment"; | |
58 | private static int NB_EVENTS = 10000; | |
0316808c | 59 | private static int BLOCK_SIZE = 1000; |
d18dd09b | 60 | |
6256d8ad AM |
61 | private ITmfTrace[] fTestTraces; |
62 | private TmfExperimentStub fExperiment; | |
d18dd09b ASL |
63 | |
64 | private static byte SCALE = (byte) -3; | |
65 | ||
66 | // ------------------------------------------------------------------------ | |
67 | // Housekeeping | |
68 | // ------------------------------------------------------------------------ | |
69 | ||
6256d8ad | 70 | private synchronized ITmfTrace[] setupTrace(final String path) { |
9e0640dc FC |
71 | if (fTestTraces == null) { |
72 | fTestTraces = new ITmfTrace[1]; | |
25e48683 FC |
73 | try { |
74 | final URL location = FileLocator.find(TmfCoreTestPlugin.getDefault().getBundle(), new Path(path), null); | |
75 | final File test = new File(FileLocator.toFileURL(location).toURI()); | |
20658947 | 76 | final TmfTraceStub trace = new TmfTraceStub(test.getPath(), 0, true); |
9e0640dc | 77 | fTestTraces[0] = trace; |
b4f71e4a FC |
78 | } catch (final TmfTraceException e) { |
79 | e.printStackTrace(); | |
25e48683 FC |
80 | } catch (final URISyntaxException e) { |
81 | e.printStackTrace(); | |
82 | } catch (final IOException e) { | |
83 | e.printStackTrace(); | |
84 | } | |
85 | } | |
9e0640dc | 86 | return fTestTraces; |
d18dd09b ASL |
87 | } |
88 | ||
9e0640dc | 89 | private synchronized void setupExperiment() { |
20658947 | 90 | if (fExperiment == null) { |
6256d8ad | 91 | fExperiment = new TmfExperimentStub(EXPERIMENT, fTestTraces, BLOCK_SIZE); |
9e0640dc | 92 | fExperiment.getIndexer().buildIndex(0, TmfTimeRange.ETERNITY, true); |
20658947 | 93 | } |
d18dd09b ASL |
94 | } |
95 | ||
54a7a54c FC |
96 | /** |
97 | * @param name the test name | |
98 | */ | |
99 | public TmfExperimentTest(final String name) { | |
25e48683 FC |
100 | super(name); |
101 | } | |
d18dd09b | 102 | |
25e48683 FC |
103 | @Override |
104 | protected void setUp() throws Exception { | |
105 | super.setUp(); | |
106 | setupTrace(DIRECTORY + File.separator + TEST_STREAM); | |
107 | setupExperiment(); | |
108 | } | |
d18dd09b | 109 | |
25e48683 FC |
110 | @Override |
111 | protected void tearDown() throws Exception { | |
112 | super.tearDown(); | |
113 | } | |
d18dd09b ASL |
114 | |
115 | // ------------------------------------------------------------------------ | |
116 | // Constructor | |
117 | // ------------------------------------------------------------------------ | |
118 | ||
9e0640dc FC |
119 | public void testSimpleTmfExperimentConstructor() { |
120 | ||
6256d8ad | 121 | TmfExperiment experiment = new TmfExperiment(TmfEvent.class, EXPERIMENT, fTestTraces); |
9e0640dc FC |
122 | assertEquals("GetId", EXPERIMENT, experiment.getName()); |
123 | assertEquals("GetCacheSize", TmfExperiment.DEFAULT_INDEX_PAGE_SIZE, experiment.getCacheSize()); | |
124 | experiment.dispose(); | |
125 | ||
6256d8ad | 126 | experiment = new TmfExperiment(TmfEvent.class, EXPERIMENT, null); |
9e0640dc FC |
127 | experiment.dispose(); |
128 | } | |
129 | ||
130 | public void testNormalTmfExperimentConstructor() { | |
cb866e08 | 131 | |
25e48683 | 132 | assertEquals("GetId", EXPERIMENT, fExperiment.getName()); |
d18dd09b ASL |
133 | assertEquals("GetNbEvents", NB_EVENTS, fExperiment.getNbEvents()); |
134 | ||
07671572 FC |
135 | final long nbExperimentEvents = fExperiment.getNbEvents(); |
136 | assertEquals("GetNbEvents", NB_EVENTS, nbExperimentEvents); | |
137 | ||
25e48683 | 138 | final long nbTraceEvents = fExperiment.getTraces()[0].getNbEvents(); |
82e04272 FC |
139 | assertEquals("GetNbEvents", NB_EVENTS, nbTraceEvents); |
140 | ||
25e48683 | 141 | final TmfTimeRange timeRange = fExperiment.getTimeRange(); |
d18dd09b ASL |
142 | assertEquals("getStartTime", 1, timeRange.getStartTime().getValue()); |
143 | assertEquals("getEndTime", NB_EVENTS, timeRange.getEndTime().getValue()); | |
25e48683 | 144 | } |
d18dd09b | 145 | |
9e0640dc FC |
146 | @SuppressWarnings("static-access") |
147 | public void testSetCurrentExperiment() { | |
148 | ||
6256d8ad | 149 | TmfExperiment experiment = new TmfExperiment(TmfEvent.class, EXPERIMENT, fTestTraces); |
9e0640dc FC |
150 | experiment.setCurrentExperiment(experiment); |
151 | assertEquals("getCurrentExperiment", experiment, experiment.getCurrentExperiment()); | |
152 | ||
6256d8ad | 153 | TmfExperiment experiment2 = new TmfExperiment(TmfEvent.class, EXPERIMENT, null); |
9e0640dc FC |
154 | experiment.setCurrentExperiment(experiment2); |
155 | assertEquals("getCurrentExperiment", experiment2, experiment.getCurrentExperiment()); | |
156 | ||
157 | experiment.dispose(); | |
158 | experiment2.dispose(); | |
159 | } | |
160 | ||
161 | // ------------------------------------------------------------------------ | |
162 | // getTimestamp | |
163 | // ------------------------------------------------------------------------ | |
164 | ||
54a7a54c | 165 | public void testGetTimestamp() { |
17324c9a FC |
166 | assertEquals("getTimestamp", new TmfTimestamp( 1, (byte) -3), fExperiment.getTimestamp( 0)); |
167 | assertEquals("getTimestamp", new TmfTimestamp( 2, (byte) -3), fExperiment.getTimestamp( 1)); | |
168 | assertEquals("getTimestamp", new TmfTimestamp( 11, (byte) -3), fExperiment.getTimestamp( 10)); | |
169 | assertEquals("getTimestamp", new TmfTimestamp( 101, (byte) -3), fExperiment.getTimestamp( 100)); | |
170 | assertEquals("getTimestamp", new TmfTimestamp( 1001, (byte) -3), fExperiment.getTimestamp(1000)); | |
171 | assertEquals("getTimestamp", new TmfTimestamp( 2001, (byte) -3), fExperiment.getTimestamp(2000)); | |
172 | assertEquals("getTimestamp", new TmfTimestamp( 2501, (byte) -3), fExperiment.getTimestamp(2500)); | |
173 | assertEquals("getTimestamp", new TmfTimestamp(10000, (byte) -3), fExperiment.getTimestamp(9999)); | |
9e0640dc FC |
174 | assertNull("getTimestamp", fExperiment.getTimestamp(10000)); |
175 | } | |
176 | ||
177 | // ------------------------------------------------------------------------ | |
178 | // Bookmarks file handling | |
179 | // ------------------------------------------------------------------------ | |
180 | ||
54a7a54c | 181 | public void testBookmarks() { |
9e0640dc | 182 | assertNull("GetBookmarksFile", fExperiment.getBookmarksFile()); |
9e0640dc FC |
183 | IFile bookmarks = (IFile) fTestTraces[0].getResource(); |
184 | fExperiment.setBookmarksFile(bookmarks); | |
185 | assertEquals("GetBookmarksFile", bookmarks, fExperiment.getBookmarksFile()); | |
186 | } | |
187 | ||
188 | // ------------------------------------------------------------------------ | |
189 | // seekEvent by location | |
190 | // ------------------------------------------------------------------------ | |
191 | ||
54a7a54c | 192 | public void testSeekBadLocation() { |
9b749023 | 193 | ITmfContext context = fExperiment.seekEvent(new TmfLocation<Long>(0L)); |
9e0640dc FC |
194 | assertNull("seekEvent", context); |
195 | } | |
196 | ||
54a7a54c | 197 | public void testSeekNoTrace() { |
6256d8ad | 198 | TmfExperiment experiment = new TmfExperiment(TmfEvent.class, EXPERIMENT, null); |
9e0640dc FC |
199 | ITmfContext context = experiment.seekEvent((TmfExperimentLocation) null); |
200 | assertNull("seekEvent", context); | |
201 | experiment.dispose(); | |
202 | } | |
203 | ||
204 | // ------------------------------------------------------------------------ | |
205 | // seekEvent on ratio | |
206 | // ------------------------------------------------------------------------ | |
207 | ||
54a7a54c | 208 | public void testSeekEventOnRatio() { |
9e0640dc FC |
209 | |
210 | // First event | |
211 | ITmfContext context = fExperiment.seekEvent(0.0); | |
212 | assertEquals("Context rank", 0, context.getRank()); | |
213 | ITmfEvent event = fExperiment.parseEvent(context); | |
214 | assertEquals("Event timestamp", 1, event.getTimestamp().getValue()); | |
215 | assertEquals("Context rank", 0, context.getRank()); | |
216 | ||
217 | // Middle event | |
218 | int midTrace = NB_EVENTS / 2; | |
219 | context = fExperiment.seekEvent(0.5); | |
220 | assertEquals("Context rank", midTrace, context.getRank()); | |
221 | event = fExperiment.parseEvent(context); | |
222 | assertEquals("Event timestamp", midTrace + 1, event.getTimestamp().getValue()); | |
223 | assertEquals("Context rank", midTrace, context.getRank()); | |
9b749023 | 224 | |
9e0640dc FC |
225 | // Last event |
226 | context = fExperiment.seekEvent(1.0); | |
227 | assertEquals("Context rank", NB_EVENTS, context.getRank()); | |
228 | event = fExperiment.parseEvent(context); | |
229 | assertNull("Event timestamp", event); | |
230 | assertEquals("Context rank", NB_EVENTS, context.getRank()); | |
9b749023 | 231 | |
9e0640dc FC |
232 | // Beyond last event |
233 | context = fExperiment.seekEvent(1.1); | |
234 | assertEquals("Context rank", NB_EVENTS, context.getRank()); | |
235 | event = fExperiment.parseEvent(context); | |
236 | assertNull("Event timestamp", event); | |
237 | assertEquals("Context rank", NB_EVENTS, context.getRank()); | |
9b749023 | 238 | |
9e0640dc FC |
239 | // Negative ratio |
240 | context = fExperiment.seekEvent(-0.5); | |
241 | assertEquals("Context rank", 0, context.getRank()); | |
242 | event = fExperiment.parseEvent(context); | |
243 | assertEquals("Event timestamp", 1, event.getTimestamp().getValue()); | |
244 | assertEquals("Context rank", 0, context.getRank()); | |
245 | } | |
246 | ||
0879b6b9 | 247 | @SuppressWarnings("rawtypes") |
54a7a54c | 248 | public void testGetLocationRatio() { |
9e0640dc FC |
249 | |
250 | // First event | |
251 | ITmfContext context = fExperiment.seekEvent((ITmfLocation) null); | |
252 | double ratio = fExperiment.getLocationRatio(context.getLocation()); | |
5cc97265 FC |
253 | context = fExperiment.seekEvent(ratio); |
254 | double ratio2 = fExperiment.getLocationRatio(context.getLocation()); | |
255 | assertEquals("getLocationRatio", ratio, ratio2); | |
9e0640dc FC |
256 | |
257 | // Middle event | |
258 | context = fExperiment.seekEvent(NB_EVENTS / 2); | |
259 | ratio = fExperiment.getLocationRatio(context.getLocation()); | |
5cc97265 FC |
260 | context = fExperiment.seekEvent(ratio); |
261 | ratio2 = fExperiment.getLocationRatio(context.getLocation()); | |
262 | assertEquals("getLocationRatio", ratio, ratio2); | |
9e0640dc FC |
263 | |
264 | // Last event | |
265 | context = fExperiment.seekEvent(NB_EVENTS - 1); | |
266 | ratio = fExperiment.getLocationRatio(context.getLocation()); | |
5cc97265 FC |
267 | context = fExperiment.seekEvent(ratio); |
268 | ratio2 = fExperiment.getLocationRatio(context.getLocation()); | |
269 | assertEquals("getLocationRatio", ratio, ratio2); | |
9e0640dc FC |
270 | } |
271 | ||
17324c9a | 272 | // @SuppressWarnings("rawtypes") |
54a7a54c | 273 | // public void testGetCurrentLocation() { |
9e0640dc FC |
274 | // ITmfContext context = fExperiment.seekEvent((ITmfLocation) null); |
275 | // ITmfLocation location = fExperiment.getCurrentLocation(); | |
276 | // assertEquals("getCurrentLocation", location, context.getLocation()); | |
277 | // } | |
278 | ||
d18dd09b | 279 | // ------------------------------------------------------------------------ |
0316808c | 280 | // seekEvent on rank |
d18dd09b ASL |
281 | // ------------------------------------------------------------------------ |
282 | ||
54a7a54c | 283 | public void testSeekRankOnCacheBoundary() { |
d18dd09b | 284 | |
0316808c | 285 | long cacheSize = fExperiment.getCacheSize(); |
9b635e61 | 286 | |
0316808c FC |
287 | // On lower bound, returns the first event (TS = 1) |
288 | ITmfContext context = fExperiment.seekEvent(0); | |
289 | assertEquals("Context rank", 0, context.getRank()); | |
25e48683 | 290 | |
c32744d6 | 291 | ITmfEvent event = fExperiment.getNext(context); |
d18dd09b | 292 | assertEquals("Event timestamp", 1, event.getTimestamp().getValue()); |
0316808c | 293 | assertEquals("Context rank", 1, context.getRank()); |
25e48683 | 294 | |
0316808c FC |
295 | // Position trace at event rank [cacheSize] |
296 | context = fExperiment.seekEvent(cacheSize); | |
297 | assertEquals("Context rank", cacheSize, context.getRank()); | |
25e48683 | 298 | |
c32744d6 | 299 | event = fExperiment.getNext(context); |
0316808c FC |
300 | assertEquals("Event timestamp", cacheSize + 1, event.getTimestamp().getValue()); |
301 | assertEquals("Context rank", cacheSize + 1, context.getRank()); | |
d18dd09b | 302 | |
0316808c FC |
303 | // Position trace at event rank [4 * cacheSize] |
304 | context = fExperiment.seekEvent(4 * cacheSize); | |
305 | assertEquals("Context rank", 4 * cacheSize, context.getRank()); | |
25e48683 | 306 | |
c32744d6 | 307 | event = fExperiment.getNext(context); |
0316808c FC |
308 | assertEquals("Event timestamp", 4 * cacheSize + 1, event.getTimestamp().getValue()); |
309 | assertEquals("Context rank", 4 * cacheSize + 1, context.getRank()); | |
d18dd09b ASL |
310 | } |
311 | ||
54a7a54c | 312 | public void testSeekRankNotOnCacheBoundary() { |
d18dd09b | 313 | |
0316808c | 314 | long cacheSize = fExperiment.getCacheSize(); |
25e48683 | 315 | |
0316808c FC |
316 | // Position trace at event rank 9 |
317 | ITmfContext context = fExperiment.seekEvent(9); | |
318 | assertEquals("Context rank", 9, context.getRank()); | |
25e48683 | 319 | |
c32744d6 | 320 | ITmfEvent event = fExperiment.getNext(context); |
d18dd09b | 321 | assertEquals("Event timestamp", 10, event.getTimestamp().getValue()); |
0316808c | 322 | assertEquals("Context rank", 10, context.getRank()); |
d18dd09b | 323 | |
0316808c FC |
324 | // Position trace at event rank [cacheSize - 1] |
325 | context = fExperiment.seekEvent(cacheSize - 1); | |
326 | assertEquals("Context rank", cacheSize - 1, context.getRank()); | |
25e48683 | 327 | |
c32744d6 | 328 | event = fExperiment.getNext(context); |
0316808c FC |
329 | assertEquals("Event timestamp", cacheSize, event.getTimestamp().getValue()); |
330 | assertEquals("Context rank", cacheSize, context.getRank()); | |
d18dd09b | 331 | |
0316808c FC |
332 | // Position trace at event rank [cacheSize + 1] |
333 | context = fExperiment.seekEvent(cacheSize + 1); | |
334 | assertEquals("Context rank", cacheSize + 1, context.getRank()); | |
25e48683 | 335 | |
c32744d6 | 336 | event = fExperiment.getNext(context); |
0316808c FC |
337 | assertEquals("Event timestamp", cacheSize + 2, event.getTimestamp().getValue()); |
338 | assertEquals("Context rank", cacheSize + 2, context.getRank()); | |
d18dd09b | 339 | |
25e48683 | 340 | // Position trace at event rank 4500 |
0316808c FC |
341 | context = fExperiment.seekEvent(4500); |
342 | assertEquals("Context rank", 4500, context.getRank()); | |
25e48683 | 343 | |
c32744d6 | 344 | event = fExperiment.getNext(context); |
d18dd09b | 345 | assertEquals("Event timestamp", 4501, event.getTimestamp().getValue()); |
0316808c | 346 | assertEquals("Context rank", 4501, context.getRank()); |
d18dd09b ASL |
347 | } |
348 | ||
54a7a54c | 349 | public void testSeekRankOutOfScope() { |
d18dd09b | 350 | |
25e48683 | 351 | // Position trace at beginning |
0316808c | 352 | ITmfContext context = fExperiment.seekEvent(-1); |
9b635e61 | 353 | assertEquals("Event rank", 0, context.getRank()); |
25e48683 | 354 | |
c32744d6 | 355 | ITmfEvent event = fExperiment.getNext(context); |
d18dd09b | 356 | assertEquals("Event timestamp", 1, event.getTimestamp().getValue()); |
0316808c | 357 | assertEquals("Context rank", 1, context.getRank()); |
d18dd09b | 358 | |
25e48683 | 359 | // Position trace at event passed the end |
0316808c FC |
360 | context = fExperiment.seekEvent(NB_EVENTS); |
361 | assertEquals("Context rank", NB_EVENTS, context.getRank()); | |
362 | ||
c32744d6 | 363 | event = fExperiment.getNext(context); |
0316808c FC |
364 | assertNull("Event", event); |
365 | assertEquals("Context rank", NB_EVENTS, context.getRank()); | |
d18dd09b ASL |
366 | } |
367 | ||
368 | // ------------------------------------------------------------------------ | |
369 | // seekEvent on timestamp | |
370 | // ------------------------------------------------------------------------ | |
371 | ||
54a7a54c | 372 | public void testSeekTimestampOnCacheBoundary() { |
d18dd09b | 373 | |
0316808c | 374 | long cacheSize = fExperiment.getCacheSize(); |
25e48683 | 375 | |
0316808c FC |
376 | // Position trace at event rank 0 |
377 | ITmfContext context = fExperiment.seekEvent(new TmfTimestamp(1, SCALE, 0)); | |
378 | assertEquals("Context rank", 0, context.getRank()); | |
25e48683 | 379 | |
c32744d6 | 380 | ITmfEvent event = fExperiment.getNext(context); |
d18dd09b | 381 | assertEquals("Event timestamp", 1, event.getTimestamp().getValue()); |
0316808c | 382 | assertEquals("Context rank", 1, context.getRank()); |
25e48683 | 383 | |
0316808c FC |
384 | // Position trace at event rank [cacheSize] |
385 | context = fExperiment.seekEvent(new TmfTimestamp(cacheSize + 1, SCALE, 0)); | |
386 | assertEquals("Event rank", cacheSize, context.getRank()); | |
25e48683 | 387 | |
c32744d6 | 388 | event = fExperiment.getNext(context); |
0316808c FC |
389 | assertEquals("Event timestamp", cacheSize + 1, event.getTimestamp().getValue()); |
390 | assertEquals("Context rank", cacheSize + 1, context.getRank()); | |
d18dd09b | 391 | |
0316808c FC |
392 | // Position trace at event rank [4 * cacheSize] |
393 | context = fExperiment.seekEvent(new TmfTimestamp(4 * cacheSize + 1, SCALE, 0)); | |
394 | assertEquals("Context rank", 4 * cacheSize, context.getRank()); | |
25e48683 | 395 | |
c32744d6 | 396 | event = fExperiment.getNext(context); |
0316808c FC |
397 | assertEquals("Event timestamp", 4 * cacheSize + 1, event.getTimestamp().getValue()); |
398 | assertEquals("Context rank", 4 * cacheSize + 1, context.getRank()); | |
d18dd09b ASL |
399 | } |
400 | ||
54a7a54c | 401 | public void testSeekTimestampNotOnCacheBoundary() { |
d18dd09b | 402 | |
0316808c FC |
403 | // Position trace at event rank 1 (TS = 2) |
404 | ITmfContext context = fExperiment.seekEvent(new TmfTimestamp(2, SCALE, 0)); | |
405 | assertEquals("Context rank", 1, context.getRank()); | |
25e48683 | 406 | |
c32744d6 | 407 | ITmfEvent event = fExperiment.getNext(context); |
d18dd09b | 408 | assertEquals("Event timestamp", 2, event.getTimestamp().getValue()); |
0316808c | 409 | assertEquals("Context rank", 2, context.getRank()); |
d18dd09b | 410 | |
0316808c | 411 | // Position trace at event rank 9 (TS = 10) |
25e48683 | 412 | context = fExperiment.seekEvent(new TmfTimestamp(10, SCALE, 0)); |
0316808c | 413 | assertEquals("Context rank", 9, context.getRank()); |
25e48683 | 414 | |
c32744d6 | 415 | event = fExperiment.getNext(context); |
d18dd09b | 416 | assertEquals("Event timestamp", 10, event.getTimestamp().getValue()); |
0316808c | 417 | assertEquals("Context rank", 10, context.getRank()); |
d18dd09b | 418 | |
0316808c | 419 | // Position trace at event rank 999 (TS = 1000) |
d18dd09b | 420 | context = fExperiment.seekEvent(new TmfTimestamp(1000, SCALE, 0)); |
0316808c | 421 | assertEquals("Context rank", 999, context.getRank()); |
25e48683 | 422 | |
c32744d6 | 423 | event = fExperiment.getNext(context); |
d18dd09b | 424 | assertEquals("Event timestamp", 1000, event.getTimestamp().getValue()); |
0316808c | 425 | assertEquals("Context rank", 1000, context.getRank()); |
d18dd09b | 426 | |
0316808c | 427 | // Position trace at event rank 1001 (TS = 1002) |
d18dd09b | 428 | context = fExperiment.seekEvent(new TmfTimestamp(1002, SCALE, 0)); |
0316808c | 429 | assertEquals("Context rank", 1001, context.getRank()); |
25e48683 | 430 | |
c32744d6 | 431 | event = fExperiment.getNext(context); |
d18dd09b | 432 | assertEquals("Event timestamp", 1002, event.getTimestamp().getValue()); |
0316808c | 433 | assertEquals("Context rank", 1002, context.getRank()); |
d18dd09b | 434 | |
0316808c | 435 | // Position trace at event rank 4500 (TS = 4501) |
d18dd09b | 436 | context = fExperiment.seekEvent(new TmfTimestamp(4501, SCALE, 0)); |
0316808c | 437 | assertEquals("Context rank", 4500, context.getRank()); |
25e48683 | 438 | |
c32744d6 | 439 | event = fExperiment.getNext(context); |
d18dd09b | 440 | assertEquals("Event timestamp", 4501, event.getTimestamp().getValue()); |
0316808c | 441 | assertEquals("Context rank", 4501, context.getRank()); |
d18dd09b ASL |
442 | } |
443 | ||
54a7a54c | 444 | public void testSeekTimestampOutOfScope() { |
d18dd09b | 445 | |
25e48683 | 446 | // Position trace at beginning |
0316808c | 447 | ITmfContext context = fExperiment.seekEvent(new TmfTimestamp(-1, SCALE, 0)); |
d18dd09b | 448 | assertEquals("Event rank", 0, context.getRank()); |
25e48683 | 449 | |
c32744d6 | 450 | ITmfEvent event = fExperiment.getNext(context); |
d18dd09b ASL |
451 | assertEquals("Event timestamp", 1, event.getTimestamp().getValue()); |
452 | assertEquals("Event rank", 1, context.getRank()); | |
453 | ||
25e48683 | 454 | // Position trace at event passed the end |
d18dd09b | 455 | context = fExperiment.seekEvent(new TmfTimestamp(NB_EVENTS + 1, SCALE, 0)); |
c32744d6 | 456 | event = fExperiment.getNext(context); |
0316808c | 457 | assertNull("Event location", event); |
9b635e61 | 458 | assertEquals("Event rank", ITmfContext.UNKNOWN_RANK, context.getRank()); |
d18dd09b ASL |
459 | } |
460 | ||
461 | // ------------------------------------------------------------------------ | |
0316808c | 462 | // seekEvent by location (context rank is undefined) |
d18dd09b ASL |
463 | // ------------------------------------------------------------------------ |
464 | ||
54a7a54c | 465 | public void testSeekLocationOnCacheBoundary() { |
9b749023 | 466 | |
0316808c | 467 | long cacheSize = fExperiment.getCacheSize(); |
d18dd09b | 468 | |
0316808c FC |
469 | // Position trace at event rank 0 |
470 | ITmfContext tmpContext = fExperiment.seekEvent(0); | |
471 | ITmfContext context = fExperiment.seekEvent(tmpContext.getLocation()); | |
25e48683 | 472 | |
c32744d6 | 473 | ITmfEvent event = fExperiment.getNext(context); |
d18dd09b | 474 | assertEquals("Event timestamp", 1, event.getTimestamp().getValue()); |
25e48683 | 475 | |
c32744d6 | 476 | event = fExperiment.getNext(context); |
0316808c | 477 | assertEquals("Event timestamp", 2, event.getTimestamp().getValue()); |
d18dd09b | 478 | |
0316808c FC |
479 | // Position trace at event rank 'cacheSize' |
480 | tmpContext = fExperiment.seekEvent(cacheSize); | |
481 | context = fExperiment.seekEvent(tmpContext.getLocation()); | |
25e48683 | 482 | |
c32744d6 | 483 | event = fExperiment.getNext(context); |
0316808c | 484 | assertEquals("Event timestamp", cacheSize + 1, event.getTimestamp().getValue()); |
25e48683 | 485 | |
c32744d6 | 486 | event = fExperiment.getNext(context); |
0316808c | 487 | assertEquals("Event timestamp", cacheSize + 2, event.getTimestamp().getValue()); |
d18dd09b | 488 | |
0316808c FC |
489 | // Position trace at event rank 4 * 'cacheSize' |
490 | tmpContext = fExperiment.seekEvent(4 * cacheSize); | |
491 | context = fExperiment.seekEvent(tmpContext.getLocation()); | |
25e48683 | 492 | |
c32744d6 | 493 | event = fExperiment.getNext(context); |
0316808c | 494 | assertEquals("Event timestamp", 4 * cacheSize + 1, event.getTimestamp().getValue()); |
25e48683 | 495 | |
c32744d6 | 496 | event = fExperiment.getNext(context); |
0316808c | 497 | assertEquals("Event timestamp", 4 * cacheSize + 2, event.getTimestamp().getValue()); |
d18dd09b ASL |
498 | } |
499 | ||
54a7a54c | 500 | public void testSeekLocationNotOnCacheBoundary() { |
25e48683 | 501 | |
0316808c | 502 | long cacheSize = fExperiment.getCacheSize(); |
25e48683 | 503 | |
0316808c FC |
504 | // Position trace at event 'cacheSize' - 1 |
505 | ITmfContext tmpContext = fExperiment.seekEvent(cacheSize - 1); | |
506 | ITmfContext context = fExperiment.seekEvent(tmpContext.getLocation()); | |
d18dd09b | 507 | |
c32744d6 | 508 | ITmfEvent event = fExperiment.getNext(context); |
0316808c | 509 | assertEquals("Event timestamp", cacheSize, event.getTimestamp().getValue()); |
25e48683 | 510 | |
c32744d6 | 511 | event = fExperiment.getNext(context); |
0316808c | 512 | assertEquals("Event timestamp", cacheSize + 1, event.getTimestamp().getValue()); |
d18dd09b | 513 | |
0316808c FC |
514 | // Position trace at event rank 2 * 'cacheSize' - 1 |
515 | tmpContext = fExperiment.seekEvent(2 * cacheSize - 1); | |
516 | context = fExperiment.seekEvent(tmpContext.getLocation()); | |
517 | context = fExperiment.seekEvent(2 * cacheSize - 1); | |
25e48683 | 518 | |
c32744d6 | 519 | event = fExperiment.getNext(context); |
0316808c | 520 | assertEquals("Event timestamp", 2 * cacheSize, event.getTimestamp().getValue()); |
25e48683 | 521 | |
c32744d6 | 522 | event = fExperiment.getNext(context); |
0316808c | 523 | assertEquals("Event timestamp", 2 * cacheSize + 1, event.getTimestamp().getValue()); |
d18dd09b | 524 | |
25e48683 | 525 | // Position trace at event rank 4500 |
0316808c FC |
526 | tmpContext = fExperiment.seekEvent(4500); |
527 | context = fExperiment.seekEvent(tmpContext.getLocation()); | |
25e48683 | 528 | |
c32744d6 | 529 | event = fExperiment.getNext(context); |
d18dd09b | 530 | assertEquals("Event timestamp", 4501, event.getTimestamp().getValue()); |
25e48683 | 531 | |
c32744d6 | 532 | event = fExperiment.getNext(context); |
0316808c | 533 | assertEquals("Event timestamp", 4502, event.getTimestamp().getValue()); |
d18dd09b ASL |
534 | } |
535 | ||
54a7a54c | 536 | public void testSeekLocationOutOfScope() { |
d18dd09b | 537 | |
25e48683 | 538 | // Position trace at beginning |
0316808c | 539 | ITmfContext context = fExperiment.seekEvent((ITmfLocation<?>) null); |
25e48683 | 540 | |
c32744d6 | 541 | ITmfEvent event = fExperiment.getNext(context); |
d18dd09b | 542 | assertEquals("Event timestamp", 1, event.getTimestamp().getValue()); |
d18dd09b | 543 | } |
25e48683 | 544 | |
9b635e61 | 545 | // ------------------------------------------------------------------------ |
17324c9a | 546 | // getNext - updates the context |
9b635e61 FC |
547 | // ------------------------------------------------------------------------ |
548 | ||
54a7a54c | 549 | private static void validateContextRanks(ITmfContext context) { |
17324c9a FC |
550 | assertTrue("Experiment context type", context instanceof TmfExperimentContext); |
551 | TmfExperimentContext ctx = (TmfExperimentContext) context; | |
9b635e61 | 552 | |
17324c9a FC |
553 | int nbTraces = ctx.getContexts().length; |
554 | ||
555 | // expRank = sum(trace ranks) - nbTraces + 1 (if lastTraceRead != NO_TRACE) | |
556 | long expRank = -nbTraces + ((ctx.getLastTrace() != TmfExperimentContext.NO_TRACE) ? 1 : 0); | |
557 | for (int i = 0; i < nbTraces; i++) { | |
558 | long rank = ctx.getContexts()[i].getRank(); | |
559 | if (rank == -1) { | |
560 | expRank = -1; | |
561 | break; | |
562 | } | |
563 | expRank += rank; | |
564 | } | |
565 | assertEquals("Experiment context rank", expRank, ctx.getRank()); | |
566 | } | |
567 | ||
54a7a54c | 568 | public void testGetNextAfteSeekingOnTS_1() { |
9b635e61 | 569 | |
17324c9a FC |
570 | final long INITIAL_TS = 1; |
571 | final int NB_READS = 20; | |
572 | ||
573 | // On lower bound, returns the first event (ts = 1) | |
574 | final ITmfContext context = fExperiment.seekEvent(new TmfTimestamp(INITIAL_TS, SCALE, 0)); | |
575 | ||
576 | validateContextRanks(context); | |
577 | ||
578 | // Read NB_EVENTS | |
579 | ITmfEvent event; | |
580 | for (int i = 0; i < NB_READS; i++) { | |
c32744d6 | 581 | event = fExperiment.getNext(context); |
17324c9a FC |
582 | assertEquals("Event timestamp", INITIAL_TS + i, event.getTimestamp().getValue()); |
583 | assertEquals("Event rank", INITIAL_TS + i, context.getRank()); | |
9b635e61 | 584 | } |
17324c9a FC |
585 | |
586 | // Make sure we stay positioned | |
587 | event = fExperiment.parseEvent(context); | |
588 | assertEquals("Event timestamp", INITIAL_TS + NB_READS, event.getTimestamp().getValue()); | |
589 | assertEquals("Event rank", INITIAL_TS + NB_READS - 1, context.getRank()); | |
590 | ||
591 | validateContextRanks(context); | |
9b635e61 FC |
592 | } |
593 | ||
54a7a54c | 594 | public void testGetNextAfteSeekingOnTS_2() { |
17324c9a FC |
595 | |
596 | final long INITIAL_TS = 2; | |
597 | final int NB_READS = 20; | |
598 | ||
599 | // On lower bound, returns the first event (ts = 2) | |
600 | final ITmfContext context = fExperiment.seekEvent(new TmfTimestamp(INITIAL_TS, SCALE, 0)); | |
601 | ||
602 | validateContextRanks(context); | |
603 | ||
604 | // Read NB_EVENTS | |
605 | ITmfEvent event; | |
606 | for (int i = 0; i < NB_READS; i++) { | |
607 | event = fExperiment.getNext(context); | |
608 | assertEquals("Event timestamp", INITIAL_TS + i, event.getTimestamp().getValue()); | |
609 | assertEquals("Event rank", INITIAL_TS + i, context.getRank()); | |
610 | } | |
611 | ||
612 | // Make sure we stay positioned | |
613 | event = fExperiment.parseEvent(context); | |
614 | assertEquals("Event timestamp", INITIAL_TS + NB_READS, event.getTimestamp().getValue()); | |
615 | assertEquals("Event rank", INITIAL_TS + NB_READS - 1, context.getRank()); | |
616 | ||
617 | validateContextRanks(context); | |
618 | } | |
619 | ||
54a7a54c | 620 | public void testGetNextAfteSeekingOnTS_3() { |
17324c9a FC |
621 | |
622 | final long INITIAL_TS = 500; | |
623 | final int NB_READS = 20; | |
624 | ||
625 | // On lower bound, returns the first event (ts = 500) | |
626 | final ITmfContext context = fExperiment.seekEvent(new TmfTimestamp(INITIAL_TS, SCALE, 0)); | |
627 | ||
628 | validateContextRanks(context); | |
629 | ||
630 | // Read NB_EVENTS | |
631 | ITmfEvent event; | |
632 | for (int i = 0; i < NB_READS; i++) { | |
633 | event = fExperiment.getNext(context); | |
634 | assertEquals("Event timestamp", INITIAL_TS + i, event.getTimestamp().getValue()); | |
635 | assertEquals("Event rank", INITIAL_TS + i, context.getRank()); | |
636 | } | |
637 | ||
638 | // Make sure we stay positioned | |
639 | event = fExperiment.parseEvent(context); | |
640 | assertEquals("Event timestamp", INITIAL_TS + NB_READS, event.getTimestamp().getValue()); | |
641 | assertEquals("Event rank", INITIAL_TS + NB_READS - 1, context.getRank()); | |
642 | ||
643 | validateContextRanks(context); | |
644 | } | |
645 | ||
54a7a54c | 646 | public void testGetNextAfterSeekingOnRank_1() { |
17324c9a FC |
647 | |
648 | final long INITIAL_RANK = 0L; | |
649 | final int NB_READS = 20; | |
650 | ||
651 | // On lower bound, returns the first event (rank = 0) | |
652 | final ITmfContext context = fExperiment.seekEvent(INITIAL_RANK); | |
653 | ||
654 | validateContextRanks(context); | |
655 | ||
656 | // Read NB_EVENTS | |
657 | ITmfEvent event; | |
658 | for (int i = 0; i < NB_READS; i++) { | |
659 | event = fExperiment.getNext(context); | |
660 | assertEquals("Event timestamp", INITIAL_RANK + i + 1, event.getTimestamp().getValue()); | |
661 | assertEquals("Event rank", INITIAL_RANK + i + 1, context.getRank()); | |
662 | } | |
663 | ||
664 | // Make sure we stay positioned | |
665 | event = fExperiment.parseEvent(context); | |
666 | assertEquals("Event timestamp", INITIAL_RANK + NB_READS + 1, event.getTimestamp().getValue()); | |
667 | assertEquals("Event rank", INITIAL_RANK + NB_READS, context.getRank()); | |
668 | ||
669 | validateContextRanks(context); | |
670 | } | |
671 | ||
54a7a54c | 672 | public void testGetNextAfterSeekingOnRank_2() { |
17324c9a FC |
673 | |
674 | final long INITIAL_RANK = 1L; | |
675 | final int NB_READS = 20; | |
676 | ||
677 | // On lower bound, returns the first event (rank = 0) | |
678 | final ITmfContext context = fExperiment.seekEvent(INITIAL_RANK); | |
679 | ||
680 | validateContextRanks(context); | |
681 | ||
682 | // Read NB_EVENTS | |
683 | ITmfEvent event; | |
684 | for (int i = 0; i < NB_READS; i++) { | |
685 | event = fExperiment.getNext(context); | |
686 | assertEquals("Event timestamp", INITIAL_RANK + i + 1, event.getTimestamp().getValue()); | |
687 | assertEquals("Event rank", INITIAL_RANK + i + 1, context.getRank()); | |
688 | } | |
689 | ||
690 | // Make sure we stay positioned | |
691 | event = fExperiment.parseEvent(context); | |
692 | assertEquals("Event timestamp", INITIAL_RANK + NB_READS + 1, event.getTimestamp().getValue()); | |
693 | assertEquals("Event rank", INITIAL_RANK + NB_READS, context.getRank()); | |
694 | ||
695 | validateContextRanks(context); | |
696 | } | |
697 | ||
54a7a54c | 698 | public void testGetNextAfterSeekingOnRank_3() { |
17324c9a FC |
699 | |
700 | final long INITIAL_RANK = 500L; | |
701 | final int NB_READS = 20; | |
702 | ||
703 | // On lower bound, returns the first event (rank = 0) | |
704 | final ITmfContext context = fExperiment.seekEvent(INITIAL_RANK); | |
705 | ||
706 | validateContextRanks(context); | |
707 | ||
708 | // Read NB_EVENTS | |
709 | ITmfEvent event; | |
710 | for (int i = 0; i < NB_READS; i++) { | |
711 | event = fExperiment.getNext(context); | |
712 | assertEquals("Event timestamp", INITIAL_RANK + i + 1, event.getTimestamp().getValue()); | |
713 | assertEquals("Event rank", INITIAL_RANK + i + 1, context.getRank()); | |
714 | } | |
715 | ||
716 | // Make sure we stay positioned | |
717 | event = fExperiment.parseEvent(context); | |
718 | assertEquals("Event timestamp", INITIAL_RANK + NB_READS + 1, event.getTimestamp().getValue()); | |
719 | assertEquals("Event rank", INITIAL_RANK + NB_READS, context.getRank()); | |
720 | ||
721 | validateContextRanks(context); | |
722 | } | |
723 | ||
54a7a54c | 724 | public void testGetNextAfterSeekingOnLocation_1() { |
17324c9a FC |
725 | |
726 | final ITmfLocation<?> INITIAL_LOC = null; | |
727 | final long INITIAL_TS = 1; | |
728 | final int NB_READS = 20; | |
729 | ||
730 | // On lower bound, returns the first event (ts = 1) | |
731 | final ITmfContext context = fExperiment.seekEvent(INITIAL_LOC); | |
732 | ||
733 | validateContextRanks(context); | |
734 | ||
735 | // Read NB_EVENTS | |
736 | ITmfEvent event; | |
737 | for (int i = 0; i < NB_READS; i++) { | |
738 | event = fExperiment.getNext(context); | |
739 | assertEquals("Event timestamp", INITIAL_TS + i, event.getTimestamp().getValue()); | |
740 | assertEquals("Event rank", INITIAL_TS + i, context.getRank()); | |
741 | } | |
742 | ||
743 | // Make sure we stay positioned | |
744 | event = fExperiment.parseEvent(context); | |
745 | assertEquals("Event timestamp", INITIAL_TS + NB_READS, event.getTimestamp().getValue()); | |
746 | assertEquals("Event rank", INITIAL_TS + NB_READS - 1, context.getRank()); | |
747 | ||
748 | validateContextRanks(context); | |
749 | } | |
750 | ||
54a7a54c | 751 | public void testGetNextAfterSeekingOnLocation_2() { |
17324c9a FC |
752 | |
753 | final ITmfLocation<?> INITIAL_LOC = fExperiment.seekEvent(1L).getLocation(); | |
754 | final long INITIAL_TS = 2; | |
755 | final int NB_READS = 20; | |
756 | ||
757 | // On lower bound, returns the first event (ts = 2) | |
758 | final ITmfContext context = fExperiment.seekEvent(INITIAL_LOC); | |
759 | ||
760 | validateContextRanks(context); | |
761 | ||
762 | // Read NB_EVENTS | |
763 | ITmfEvent event; | |
764 | for (int i = 0; i < NB_READS; i++) { | |
765 | event = fExperiment.getNext(context); | |
766 | assertEquals("Event timestamp", INITIAL_TS + i, event.getTimestamp().getValue()); | |
767 | } | |
768 | ||
769 | // Make sure we stay positioned | |
770 | event = fExperiment.parseEvent(context); | |
771 | assertEquals("Event timestamp", INITIAL_TS + NB_READS, event.getTimestamp().getValue()); | |
772 | ||
773 | validateContextRanks(context); | |
774 | } | |
775 | ||
54a7a54c | 776 | public void testGetNextAfterSeekingOnLocation_3() { |
17324c9a FC |
777 | |
778 | final ITmfLocation<?> INITIAL_LOC = fExperiment.seekEvent(500L).getLocation(); | |
779 | final long INITIAL_TS = 501; | |
780 | final int NB_READS = 20; | |
781 | ||
782 | // On lower bound, returns the first event (ts = 501) | |
783 | final ITmfContext context = fExperiment.seekEvent(INITIAL_LOC); | |
784 | ||
785 | validateContextRanks(context); | |
786 | ||
787 | // Read NB_EVENTS | |
788 | ITmfEvent event; | |
789 | for (int i = 0; i < NB_READS; i++) { | |
790 | event = fExperiment.getNext(context); | |
791 | assertEquals("Event timestamp", INITIAL_TS + i, event.getTimestamp().getValue()); | |
792 | } | |
793 | ||
794 | // Make sure we stay positioned | |
795 | event = fExperiment.parseEvent(context); | |
796 | assertEquals("Event timestamp", INITIAL_TS + NB_READS, event.getTimestamp().getValue()); | |
797 | ||
798 | validateContextRanks(context); | |
799 | } | |
800 | ||
54a7a54c | 801 | public void testGetNextLocation() { |
17324c9a FC |
802 | ITmfContext context1 = fExperiment.seekEvent(0); |
803 | fExperiment.getNext(context1); | |
804 | ITmfLocation<?> location = context1.getLocation().clone(); | |
805 | ITmfEvent event1 = fExperiment.getNext(context1); | |
806 | ITmfContext context2 = fExperiment.seekEvent(location); | |
807 | ITmfEvent event2 = fExperiment.getNext(context2); | |
808 | assertEquals("Event timestamp", event1.getTimestamp().getValue(), event2.getTimestamp().getValue()); | |
809 | } | |
810 | ||
54a7a54c | 811 | public void testGetNextEndLocation() { |
17324c9a FC |
812 | ITmfContext context1 = fExperiment.seekEvent(fExperiment.getNbEvents() - 1); |
813 | fExperiment.getNext(context1); | |
814 | ITmfLocation<?> location = context1.getLocation().clone(); | |
815 | ITmfContext context2 = fExperiment.seekEvent(location); | |
816 | ITmfEvent event = fExperiment.getNext(context2); | |
817 | assertNull("Event", event); | |
818 | } | |
54a7a54c | 819 | |
d18dd09b ASL |
820 | // ------------------------------------------------------------------------ |
821 | // processRequest | |
822 | // ------------------------------------------------------------------------ | |
823 | ||
54a7a54c | 824 | public void testProcessRequestForNbEvents() throws InterruptedException { |
cb866e08 | 825 | |
25e48683 | 826 | final int blockSize = 100; |
d18dd09b | 827 | final int nbEvents = 1000; |
6256d8ad | 828 | final Vector<ITmfEvent> requestedEvents = new Vector<ITmfEvent>(); |
d18dd09b | 829 | |
25e48683 | 830 | final TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BIG_BANG, TmfTimestamp.BIG_CRUNCH); |
6256d8ad | 831 | final TmfEventRequest request = new TmfEventRequest(TmfEvent.class, range, nbEvents, blockSize) { |
d18dd09b | 832 | @Override |
6256d8ad | 833 | public void handleData(final ITmfEvent event) { |
25e48683 | 834 | super.handleData(event); |
f9673903 | 835 | requestedEvents.add(event); |
d18dd09b ASL |
836 | } |
837 | }; | |
838 | fExperiment.sendRequest(request); | |
839 | request.waitForCompletion(); | |
840 | ||
841 | assertEquals("nbEvents", nbEvents, requestedEvents.size()); | |
842 | assertTrue("isCompleted", request.isCompleted()); | |
843 | assertFalse("isCancelled", request.isCancelled()); | |
844 | ||
845 | // Ensure that we have distinct events. | |
25e48683 | 846 | // Don't go overboard: we are not validating the stub! |
20658947 | 847 | for (int i = 0; i < nbEvents; i++) { |
d18dd09b | 848 | assertEquals("Distinct events", i+1, requestedEvents.get(i).getTimestamp().getValue()); |
20658947 | 849 | } |
d18dd09b | 850 | } |
25e48683 | 851 | |
54a7a54c | 852 | public void testProcessRequestForNbEvents2() throws InterruptedException { |
cb866e08 | 853 | |
25e48683 | 854 | final int blockSize = 2 * NB_EVENTS; |
d18dd09b | 855 | final int nbEvents = 1000; |
6256d8ad | 856 | final Vector<ITmfEvent> requestedEvents = new Vector<ITmfEvent>(); |
d18dd09b | 857 | |
25e48683 | 858 | final TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BIG_BANG, TmfTimestamp.BIG_CRUNCH); |
6256d8ad | 859 | final TmfEventRequest request = new TmfEventRequest(TmfEvent.class, range, nbEvents, blockSize) { |
25e48683 | 860 | @Override |
6256d8ad | 861 | public void handleData(final ITmfEvent event) { |
25e48683 FC |
862 | super.handleData(event); |
863 | requestedEvents.add(event); | |
864 | } | |
d18dd09b ASL |
865 | }; |
866 | fExperiment.sendRequest(request); | |
867 | request.waitForCompletion(); | |
868 | ||
869 | assertEquals("nbEvents", nbEvents, requestedEvents.size()); | |
870 | assertTrue("isCompleted", request.isCompleted()); | |
871 | assertFalse("isCancelled", request.isCancelled()); | |
872 | ||
873 | // Ensure that we have distinct events. | |
25e48683 | 874 | // Don't go overboard: we are not validating the stub! |
20658947 | 875 | for (int i = 0; i < nbEvents; i++) { |
d18dd09b | 876 | assertEquals("Distinct events", i+1, requestedEvents.get(i).getTimestamp().getValue()); |
20658947 | 877 | } |
d18dd09b | 878 | } |
25e48683 | 879 | |
54a7a54c | 880 | public void testProcessRequestForAllEvents() throws InterruptedException { |
cb866e08 | 881 | |
9b749023 | 882 | final int nbEvents = TmfDataRequest.ALL_DATA; |
d18dd09b | 883 | final int blockSize = 1; |
6256d8ad | 884 | final Vector<ITmfEvent> requestedEvents = new Vector<ITmfEvent>(); |
25e48683 | 885 | final long nbExpectedEvents = NB_EVENTS; |
d18dd09b | 886 | |
25e48683 | 887 | final TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BIG_BANG, TmfTimestamp.BIG_CRUNCH); |
6256d8ad | 888 | final TmfEventRequest request = new TmfEventRequest(TmfEvent.class, range, nbEvents, blockSize) { |
25e48683 | 889 | @Override |
6256d8ad | 890 | public void handleData(final ITmfEvent event) { |
25e48683 FC |
891 | super.handleData(event); |
892 | requestedEvents.add(event); | |
893 | } | |
d18dd09b ASL |
894 | }; |
895 | fExperiment.sendRequest(request); | |
896 | request.waitForCompletion(); | |
897 | ||
898 | assertEquals("nbEvents", nbExpectedEvents, requestedEvents.size()); | |
899 | assertTrue("isCompleted", request.isCompleted()); | |
900 | assertFalse("isCancelled", request.isCancelled()); | |
901 | ||
902 | // Ensure that we have distinct events. | |
25e48683 | 903 | // Don't go overboard: we are not validating the stub! |
20658947 | 904 | for (int i = 0; i < nbExpectedEvents; i++) { |
d18dd09b | 905 | assertEquals("Distinct events", i+1, requestedEvents.get(i).getTimestamp().getValue()); |
20658947 | 906 | } |
d18dd09b | 907 | } |
25e48683 | 908 | |
d18dd09b ASL |
909 | // ------------------------------------------------------------------------ |
910 | // cancel | |
911 | // ------------------------------------------------------------------------ | |
912 | ||
54a7a54c | 913 | public void testCancel() throws InterruptedException { |
cb866e08 | 914 | |
25e48683 | 915 | final int nbEvents = NB_EVENTS; |
0316808c | 916 | final int blockSize = BLOCK_SIZE; |
6256d8ad | 917 | final Vector<ITmfEvent> requestedEvents = new Vector<ITmfEvent>(); |
d18dd09b | 918 | |
25e48683 | 919 | final TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BIG_BANG, TmfTimestamp.BIG_CRUNCH); |
6256d8ad | 920 | final TmfEventRequest request = new TmfEventRequest(TmfEvent.class, range, nbEvents, blockSize) { |
25e48683 FC |
921 | int nbRead = 0; |
922 | @Override | |
6256d8ad | 923 | public void handleData(final ITmfEvent event) { |
25e48683 FC |
924 | super.handleData(event); |
925 | requestedEvents.add(event); | |
20658947 | 926 | if (++nbRead == blockSize) { |
25e48683 | 927 | cancel(); |
20658947 | 928 | } |
25e48683 | 929 | } |
cb866e08 FC |
930 | @Override |
931 | public void handleCancel() { | |
20658947 | 932 | if (requestedEvents.size() < blockSize) { |
25e48683 | 933 | System.out.println("aie"); |
20658947 | 934 | } |
cb866e08 | 935 | } |
d18dd09b ASL |
936 | }; |
937 | fExperiment.sendRequest(request); | |
938 | request.waitForCompletion(); | |
939 | ||
940 | assertEquals("nbEvents", blockSize, requestedEvents.size()); | |
941 | assertTrue("isCompleted", request.isCompleted()); | |
942 | assertTrue("isCancelled", request.isCancelled()); | |
943 | } | |
25e48683 | 944 | |
17324c9a | 945 | } |