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