projects / deliverable / tracecompass.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Make TmfLocation abstract and implement a couple of Tmf<type>Location
[deliverable/tracecompass.git] / org.eclipse.linuxtools.tmf.core.tests / src / org / eclipse / linuxtools / tmf / core / tests / trace / TmfExperimentTest.java
CommitLineData
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 14package org.eclipse.linuxtools.tmf.core.tests.trace;
d18dd09b
ASL		 15
16import java.io.File;
17import java.io.IOException;
18import java.net.URISyntaxException;
19import java.net.URL;
20import java.util.Vector;
21
22import junit.framework.TestCase;
23
9e0640dc 24import org.eclipse.core.resources.IFile;
d18dd09b
ASL		 25import org.eclipse.core.runtime.FileLocator;
26import org.eclipse.core.runtime.Path;
17324c9a 27import org.eclipse.linuxtools.internal.tmf.core.trace.TmfExperimentContext;
9e0640dc 28import org.eclipse.linuxtools.internal.tmf.core.trace.TmfExperimentLocation;
72f1e62a 29import org.eclipse.linuxtools.tmf.core.event.ITmfEvent;
6c13869b
FC		 30import org.eclipse.linuxtools.tmf.core.event.TmfEvent;
31import org.eclipse.linuxtools.tmf.core.event.TmfTimeRange;
32import org.eclipse.linuxtools.tmf.core.event.TmfTimestamp;
b4f71e4a 33import org.eclipse.linuxtools.tmf.core.exceptions.TmfTraceException;
9b749023 34import org.eclipse.linuxtools.tmf.core.request.TmfDataRequest;
6c13869b
FC		 35import org.eclipse.linuxtools.tmf.core.request.TmfEventRequest;
36import org.eclipse.linuxtools.tmf.core.tests.TmfCoreTestPlugin;
37import org.eclipse.linuxtools.tmf.core.trace.ITmfContext;
0316808c 38import org.eclipse.linuxtools.tmf.core.trace.ITmfLocation;
6c13869b 39import org.eclipse.linuxtools.tmf.core.trace.ITmfTrace;
9e0640dc 40import org.eclipse.linuxtools.tmf.core.trace.TmfExperiment;
cb8c854e 41import org.eclipse.linuxtools.tmf.core.trace.TmfLongLocation;
9e0640dc 42import org.eclipse.linuxtools.tmf.tests.stubs.trace.TmfExperimentStub;
4918b8f2 43import 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		 49public 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() {
cb8c854e 193 ITmfContext context = fExperiment.seekEvent(new TmfLongLocation(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}
Tracecompass - Deliverables
This page took 0.098389 seconds and 5 git commands to generate.