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