1 /*******************************************************************************
2 * Copyright (c) 2009, 2010 Ericsson
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
10 * Francois Chouinard - Initial API and implementation
11 *******************************************************************************/
13 package org
.eclipse
.linuxtools
.tmf
.tests
.trace
;
16 import java
.io
.IOException
;
17 import java
.net
.URISyntaxException
;
19 import java
.util
.Vector
;
21 import junit
.framework
.TestCase
;
23 import org
.eclipse
.core
.runtime
.FileLocator
;
24 import org
.eclipse
.core
.runtime
.Path
;
25 import org
.eclipse
.linuxtools
.tmf
.event
.TmfEvent
;
26 import org
.eclipse
.linuxtools
.tmf
.event
.TmfTimeRange
;
27 import org
.eclipse
.linuxtools
.tmf
.event
.TmfTimestamp
;
28 import org
.eclipse
.linuxtools
.tmf
.experiment
.TmfExperiment
;
29 import org
.eclipse
.linuxtools
.tmf
.experiment
.TmfExperimentContext
;
30 import org
.eclipse
.linuxtools
.tmf
.request
.TmfEventRequest
;
31 import org
.eclipse
.linuxtools
.tmf
.tests
.TmfCoreTestPlugin
;
32 import org
.eclipse
.linuxtools
.tmf
.trace
.ITmfTrace
;
33 import org
.eclipse
.linuxtools
.tmf
.trace
.TmfTraceStub
;
36 * <b><u>TmfExperimentTest</u></b>
38 * TODO: Implement me. Please.
40 public class TmfExperimentTest
extends TestCase
{
42 private static final String DIRECTORY
= "testfiles";
43 private static final String TEST_STREAM
= "A-Test-10K";
44 private static final String EXPERIMENT
= "MyExperiment";
45 private static int NB_EVENTS
= 10000;
46 private static int fDefaultBlockSize
= 1000;
48 private static ITmfTrace
[] fTrace
;
49 private static TmfExperiment
<TmfEvent
> fExperiment
;
51 private static byte SCALE
= (byte) -3;
53 // ------------------------------------------------------------------------
55 // ------------------------------------------------------------------------
57 private ITmfTrace
[] setupTrace(String path
) {
59 fTrace
= new ITmfTrace
[1];
61 URL location
= FileLocator
.find(TmfCoreTestPlugin
.getPlugin().getBundle(), new Path(path
), null);
62 File test
= new File(FileLocator
.toFileURL(location
).toURI());
63 TmfTraceStub trace
= new TmfTraceStub(test
.getPath(), true);
65 } catch (URISyntaxException e
) {
67 } catch (IOException e
) {
74 private void setupExperiment() {
75 if (fExperiment
== null) {
76 fExperiment
= new TmfExperiment
<TmfEvent
>(TmfEvent
.class, EXPERIMENT
, fTrace
);
77 fExperiment
.indexExperiment(true);
81 public TmfExperimentTest(String name
) throws Exception
{
86 protected void setUp() throws Exception
{
88 setupTrace(DIRECTORY
+ File
.separator
+ TEST_STREAM
);
93 protected void tearDown() throws Exception
{
97 // ------------------------------------------------------------------------
99 // ------------------------------------------------------------------------
101 public void testBasicTmfExperiment() {
102 assertEquals("GetId", EXPERIMENT
, fExperiment
.getName());
103 assertEquals("GetEpoch", TmfTimestamp
.Zero
, fExperiment
.getEpoch());
104 assertEquals("GetNbEvents", NB_EVENTS
, fExperiment
.getNbEvents());
106 TmfTimeRange timeRange
= fExperiment
.getTimeRange();
107 assertEquals("getStartTime", 1, timeRange
.getStartTime().getValue());
108 assertEquals("getEndTime", NB_EVENTS
, timeRange
.getEndTime().getValue());
111 // ------------------------------------------------------------------------
113 // ------------------------------------------------------------------------
115 public void testSeekOnCacheBoundary() throws Exception
{
116 TmfExperimentContext context
= fExperiment
.seekLocation(null);
118 context
= fExperiment
.seekEvent(new TmfTimestamp(1, SCALE
, 0));
119 TmfEvent event
= fExperiment
.getNextEvent(context
);
120 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
121 assertEquals("Event rank", 1, context
.getRank());
123 context
= fExperiment
.seekEvent(new TmfTimestamp(1001, SCALE
, 0));
124 event
= fExperiment
.getNextEvent(context
);
125 assertEquals("Event timestamp", 1001, event
.getTimestamp().getValue());
126 assertEquals("Event rank", 1001, context
.getRank());
128 context
= fExperiment
.seekEvent(new TmfTimestamp(4001, SCALE
, 0));
129 event
= fExperiment
.getNextEvent(context
);
130 assertEquals("Event timestamp", 4001, event
.getTimestamp().getValue());
131 assertEquals("Event rank", 4001, context
.getRank());
134 public void testSeekNotOnCacheBoundary() throws Exception
{
135 TmfExperimentContext context
= fExperiment
.seekLocation(null);
137 context
= fExperiment
.seekEvent(new TmfTimestamp(10, SCALE
, 0));
138 TmfEvent event
= fExperiment
.getNextEvent(context
);
139 assertEquals("Event timestamp", 10, event
.getTimestamp().getValue());
140 assertEquals("Event rank", 10, context
.getRank());
142 context
= fExperiment
.seekEvent(new TmfTimestamp(999, SCALE
, 0));
143 event
= fExperiment
.getNextEvent(context
);
144 assertEquals("Event timestamp", 999, event
.getTimestamp().getValue());
145 assertEquals("Event rank", 999, context
.getRank());
147 context
= fExperiment
.seekEvent(new TmfTimestamp(1001, SCALE
, 0));
148 event
= fExperiment
.getNextEvent(context
);
149 assertEquals("Event timestamp", 1001, event
.getTimestamp().getValue());
150 assertEquals("Event rank", 1001, context
.getRank());
152 context
= fExperiment
.seekEvent(new TmfTimestamp(4499, SCALE
, 0));
153 event
= fExperiment
.getNextEvent(context
);
154 assertEquals("Event timestamp", 4499, event
.getTimestamp().getValue());
155 assertEquals("Event rank", 4499, context
.getRank());
158 public void testSeekForEventOutOfBounds() throws Exception
{
159 TmfExperimentContext context
= fExperiment
.seekLocation(null);
161 // On lower bound, returns the first event (ts = 1)
162 context
= fExperiment
.seekEvent(new TmfTimestamp(-1, SCALE
, 0));
163 TmfEvent event
= fExperiment
.getNextEvent(context
);
164 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
166 // On higher bound, returns null (no event)
167 context
= fExperiment
.seekEvent(new TmfTimestamp(NB_EVENTS
+ 1, SCALE
, 0));
168 event
= fExperiment
.getNextEvent(context
);
169 assertEquals("Event timestamp", null, event
);
172 public void testSeekOnIndex() throws Exception
{
173 TmfExperimentContext context
= fExperiment
.seekLocation(null);
175 // On lower bound, returns the first event (ts = 1)
176 context
= fExperiment
.seekEvent(0);
177 TmfEvent event
= fExperiment
.getNextEvent(context
);
178 assertEquals("Event timestamp", 1, event
.getTimestamp().getValue());
181 context
= fExperiment
.seekEvent(NB_EVENTS
- 1);
182 event
= fExperiment
.getNextEvent(context
);
183 assertEquals("Event timestamp", NB_EVENTS
, event
.getTimestamp().getValue());
186 context
= fExperiment
.seekEvent(NB_EVENTS
);
187 event
= fExperiment
.getNextEvent(context
);
188 assertEquals("Event", null, event
);
191 // ------------------------------------------------------------------------
193 // ------------------------------------------------------------------------
195 public void testProcessRequestForNbEvents() throws Exception
{
196 final int blockSize
= 100;
197 final int nbEvents
= 1000;
198 final Vector
<TmfEvent
> requestedEvents
= new Vector
<TmfEvent
>();
200 TmfTimeRange range
= new TmfTimeRange(TmfTimestamp
.BigBang
, TmfTimestamp
.BigCrunch
);
201 final TmfEventRequest
<TmfEvent
> request
= new TmfEventRequest
<TmfEvent
>(TmfEvent
.class, range
, nbEvents
, blockSize
) {
203 public void handleData() {
204 TmfEvent
[] events
= getData();
205 for (TmfEvent e
: events
) {
206 requestedEvents
.add(e
);
210 fExperiment
.sendRequest(request
);
211 request
.waitForCompletion();
213 assertEquals("nbEvents", nbEvents
, requestedEvents
.size());
214 assertTrue("isCompleted", request
.isCompleted());
215 assertFalse("isCancelled", request
.isCancelled());
217 // Ensure that we have distinct events.
218 // Don't go overboard: we are not validating the stub!
219 for (int i
= 0; i
< nbEvents
; i
++) {
220 assertEquals("Distinct events", i
+1, requestedEvents
.get(i
).getTimestamp().getValue());
224 public void testProcessRequestForNbEvents2() throws Exception
{
225 final int blockSize
= 2 * NB_EVENTS
;
226 final int nbEvents
= 1000;
227 final Vector
<TmfEvent
> requestedEvents
= new Vector
<TmfEvent
>();
229 TmfTimeRange range
= new TmfTimeRange(TmfTimestamp
.BigBang
, TmfTimestamp
.BigCrunch
);
230 final TmfEventRequest
<TmfEvent
> request
= new TmfEventRequest
<TmfEvent
>(TmfEvent
.class, range
, nbEvents
, blockSize
) {
232 public void handleData() {
233 TmfEvent
[] events
= getData();
234 for (TmfEvent e
: events
) {
235 requestedEvents
.add(e
);
239 fExperiment
.sendRequest(request
);
240 request
.waitForCompletion();
242 assertEquals("nbEvents", nbEvents
, requestedEvents
.size());
243 assertTrue("isCompleted", request
.isCompleted());
244 assertFalse("isCancelled", request
.isCancelled());
246 // Ensure that we have distinct events.
247 // Don't go overboard: we are not validating the stub!
248 for (int i
= 0; i
< nbEvents
; i
++) {
249 assertEquals("Distinct events", i
+1, requestedEvents
.get(i
).getTimestamp().getValue());
253 public void testProcessRequestForAllEvents() throws Exception
{
254 final int nbEvents
= TmfEventRequest
.ALL_DATA
;
255 final int blockSize
= 1;
256 final Vector
<TmfEvent
> requestedEvents
= new Vector
<TmfEvent
>();
257 long nbExpectedEvents
= fExperiment
.getNbEvents();
259 TmfTimeRange range
= new TmfTimeRange(TmfTimestamp
.BigBang
, TmfTimestamp
.BigCrunch
);
260 final TmfEventRequest
<TmfEvent
> request
= new TmfEventRequest
<TmfEvent
>(TmfEvent
.class, range
, nbEvents
, blockSize
) {
262 public void handleData() {
263 TmfEvent
[] events
= getData();
264 for (TmfEvent e
: events
) {
265 requestedEvents
.add(e
);
269 fExperiment
.sendRequest(request
);
270 request
.waitForCompletion();
272 assertEquals("nbEvents", nbExpectedEvents
, requestedEvents
.size());
273 assertTrue("isCompleted", request
.isCompleted());
274 assertFalse("isCancelled", request
.isCancelled());
276 // Ensure that we have distinct events.
277 // Don't go overboard: we are not validating the stub!
278 for (int i
= 0; i
< nbExpectedEvents
; i
++) {
279 assertEquals("Distinct events", i
+1, requestedEvents
.get(i
).getTimestamp().getValue());
283 // ------------------------------------------------------------------------
285 // ------------------------------------------------------------------------
287 public void testCancel() throws Exception
{
288 final int nbEvents
= NB_EVENTS
;
289 final int blockSize
= fDefaultBlockSize
;
290 final Vector
<TmfEvent
> requestedEvents
= new Vector
<TmfEvent
>();
292 TmfTimeRange range
= new TmfTimeRange(TmfTimestamp
.BigBang
, TmfTimestamp
.BigCrunch
);
293 final TmfEventRequest
<TmfEvent
> request
= new TmfEventRequest
<TmfEvent
>(TmfEvent
.class, range
, nbEvents
, blockSize
) {
295 public void handleData() {
296 TmfEvent
[] events
= getData();
297 for (TmfEvent e
: events
) {
298 requestedEvents
.add(e
);
300 // Cancel request after the first chunk is received
304 fExperiment
.sendRequest(request
);
305 request
.waitForCompletion();
307 assertEquals("nbEvents", blockSize
, requestedEvents
.size());
308 assertTrue("isCompleted", request
.isCompleted());
309 assertTrue("isCancelled", request
.isCancelled());
312 // ------------------------------------------------------------------------
314 // ------------------------------------------------------------------------
316 public void testGetRank() throws Exception
{
317 assertEquals("getRank", 0, fExperiment
.getRank(new TmfTimestamp()));
318 assertEquals("getRank", 0, fExperiment
.getRank(new TmfTimestamp( 1, (byte) -3)));
319 assertEquals("getRank", 10, fExperiment
.getRank(new TmfTimestamp( 11, (byte) -3)));
320 assertEquals("getRank", 100, fExperiment
.getRank(new TmfTimestamp( 101, (byte) -3)));
321 assertEquals("getRank", 1000, fExperiment
.getRank(new TmfTimestamp(1001, (byte) -3)));
324 // ------------------------------------------------------------------------
326 // ------------------------------------------------------------------------
328 public void testGetTimestamp() throws Exception
{
329 assertTrue("getTimestamp", fExperiment
.getTimestamp( 0).equals(new TmfTimestamp( 1, (byte) -3)));
330 assertTrue("getTimestamp", fExperiment
.getTimestamp( 10).equals(new TmfTimestamp( 11, (byte) -3)));
331 assertTrue("getTimestamp", fExperiment
.getTimestamp( 100).equals(new TmfTimestamp( 101, (byte) -3)));
332 assertTrue("getTimestamp", fExperiment
.getTimestamp(1000).equals(new TmfTimestamp(1001, (byte) -3)));