Commit | Line | Data |
---|---|---|
d18dd09b | 1 | /******************************************************************************* |
e31e01e8 | 2 | * Copyright (c) 2009, 2010 Ericsson |
d18dd09b ASL |
3 | * |
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 | |
8 | * | |
9 | * Contributors: | |
10 | * Francois Chouinard - Initial API and implementation | |
11 | *******************************************************************************/ | |
12 | ||
13 | package org.eclipse.linuxtools.tmf.tests.trace; | |
14 | ||
15 | import java.io.File; | |
e31e01e8 FC |
16 | import java.io.IOException; |
17 | import java.net.URISyntaxException; | |
18 | import java.net.URL; | |
d18dd09b ASL |
19 | import java.util.Vector; |
20 | ||
e31e01e8 FC |
21 | import junit.framework.TestCase; |
22 | ||
23 | import org.eclipse.core.runtime.FileLocator; | |
24 | import org.eclipse.core.runtime.Path; | |
d18dd09b ASL |
25 | import org.eclipse.linuxtools.tmf.event.TmfEvent; |
26 | import org.eclipse.linuxtools.tmf.event.TmfTimeRange; | |
27 | import org.eclipse.linuxtools.tmf.event.TmfTimestamp; | |
e31e01e8 | 28 | import org.eclipse.linuxtools.tmf.experiment.TmfExperiment; |
9f584e4c | 29 | import org.eclipse.linuxtools.tmf.experiment.TmfExperimentContext; |
e31e01e8 FC |
30 | import org.eclipse.linuxtools.tmf.request.TmfEventRequest; |
31 | import org.eclipse.linuxtools.tmf.tests.TmfCoreTestPlugin; | |
d18dd09b | 32 | import org.eclipse.linuxtools.tmf.trace.ITmfTrace; |
d18dd09b ASL |
33 | import org.eclipse.linuxtools.tmf.trace.TmfTraceStub; |
34 | ||
35 | /** | |
36 | * <b><u>TmfExperimentTest</u></b> | |
37 | * <p> | |
38 | * TODO: Implement me. Please. | |
39 | */ | |
40 | public class TmfExperimentTest extends TestCase { | |
41 | ||
42 | private static final String DIRECTORY = "testfiles"; | |
75828b1a | 43 | private static final String TEST_STREAM = "M-Test-10K"; |
d18dd09b | 44 | private static final String EXPERIMENT = "MyExperiment"; |
e31e01e8 FC |
45 | private static int NB_EVENTS = 10000; |
46 | private static int fDefaultBlockSize = 1000; | |
d18dd09b | 47 | |
e31e01e8 FC |
48 | private static ITmfTrace fTrace; |
49 | private static TmfExperiment<TmfEvent> fExperiment; | |
d18dd09b | 50 | |
9f584e4c FC |
51 | private static byte SCALE = (byte) -3; |
52 | ||
e31e01e8 | 53 | // ------------------------------------------------------------------------ |
d18dd09b | 54 | // Housekeeping |
e31e01e8 FC |
55 | // ------------------------------------------------------------------------ |
56 | ||
57 | private ITmfTrace setupTrace(String path) { | |
58 | if (fTrace == null) { | |
59 | try { | |
60 | URL location = FileLocator.find(TmfCoreTestPlugin.getPlugin().getBundle(), new Path(path), null); | |
61 | File test = new File(FileLocator.toFileURL(location).toURI()); | |
62 | TmfTraceStub trace = new TmfTraceStub(test.getPath(), true); | |
63 | fTrace = trace; | |
64 | } catch (URISyntaxException e) { | |
65 | e.printStackTrace(); | |
66 | } catch (IOException e) { | |
67 | e.printStackTrace(); | |
68 | } | |
69 | } | |
70 | return fTrace; | |
71 | } | |
72 | ||
73 | private void setupExperiment() { | |
74 | if (fExperiment == null) { | |
75 | fExperiment = new TmfExperiment<TmfEvent>(TmfEvent.class, EXPERIMENT, new ITmfTrace[] { fTrace }); | |
76 | fExperiment.indexExperiment(true); | |
77 | } | |
78 | } | |
d18dd09b ASL |
79 | |
80 | public TmfExperimentTest(String name) throws Exception { | |
81 | super(name); | |
82 | } | |
83 | ||
84 | @Override | |
85 | protected void setUp() throws Exception { | |
86 | super.setUp(); | |
e31e01e8 FC |
87 | setupTrace(DIRECTORY + File.separator + TEST_STREAM); |
88 | setupExperiment(); | |
d18dd09b ASL |
89 | } |
90 | ||
91 | @Override | |
92 | protected void tearDown() throws Exception { | |
93 | super.tearDown(); | |
94 | } | |
95 | ||
e31e01e8 | 96 | // ------------------------------------------------------------------------ |
d18dd09b | 97 | // Constructor |
e31e01e8 | 98 | // ------------------------------------------------------------------------ |
d18dd09b | 99 | |
9f584e4c FC |
100 | public void testBasicTmfExperiment() { |
101 | assertEquals("GetId", EXPERIMENT, fExperiment.getName()); | |
e31e01e8 | 102 | assertEquals("GetEpoch", TmfTimestamp.Zero, fExperiment.getEpoch()); |
d18dd09b ASL |
103 | assertEquals("GetNbEvents", NB_EVENTS, fExperiment.getNbEvents()); |
104 | ||
105 | TmfTimeRange timeRange = fExperiment.getTimeRange(); | |
e31e01e8 FC |
106 | assertEquals("getStartTime", 1, timeRange.getStartTime().getValue()); |
107 | assertEquals("getEndTime", NB_EVENTS, timeRange.getEndTime().getValue()); | |
d18dd09b ASL |
108 | } |
109 | ||
9f584e4c FC |
110 | // ------------------------------------------------------------------------ |
111 | // seek | |
112 | // ------------------------------------------------------------------------ | |
113 | ||
114 | public void testSeekEOnCacheBoundary() throws Exception { | |
115 | TmfExperimentContext context = fExperiment.seekLocation(null); | |
116 | ||
117 | context = fExperiment.seekEvent(new TmfTimestamp(1, SCALE, 0)); | |
118 | TmfEvent event = fExperiment.getNextEvent(context); | |
119 | assertEquals("Event timestamp", 1, event.getTimestamp().getValue()); | |
120 | assertEquals("Event rank", 1, context.getRank()); | |
121 | ||
122 | context = fExperiment.seekEvent(new TmfTimestamp(1001, SCALE, 0)); | |
123 | event = fExperiment.getNextEvent(context); | |
124 | assertEquals("Event timestamp", 1001, event.getTimestamp().getValue()); | |
125 | assertEquals("Event rank", 1001, context.getRank()); | |
126 | ||
127 | context = fExperiment.seekEvent(new TmfTimestamp(4001, SCALE, 0)); | |
128 | event = fExperiment.getNextEvent(context); | |
129 | assertEquals("Event timestamp", 4001, event.getTimestamp().getValue()); | |
130 | assertEquals("Event rank", 4001, context.getRank()); | |
131 | } | |
132 | ||
133 | public void testSeekNotOnCacheBoundary() throws Exception { | |
134 | TmfExperimentContext context = fExperiment.seekLocation(null); | |
135 | ||
136 | context = fExperiment.seekEvent(new TmfTimestamp(10, SCALE, 0)); | |
137 | TmfEvent event = fExperiment.getNextEvent(context); | |
138 | assertEquals("Event timestamp", 10, event.getTimestamp().getValue()); | |
139 | assertEquals("Event rank", 10, context.getRank()); | |
140 | ||
141 | context = fExperiment.seekEvent(new TmfTimestamp(999, SCALE, 0)); | |
142 | event = fExperiment.getNextEvent(context); | |
143 | assertEquals("Event timestamp", 999, event.getTimestamp().getValue()); | |
144 | assertEquals("Event rank", 999, context.getRank()); | |
145 | ||
146 | context = fExperiment.seekEvent(new TmfTimestamp(1001, SCALE, 0)); | |
147 | event = fExperiment.getNextEvent(context); | |
148 | assertEquals("Event timestamp", 1001, event.getTimestamp().getValue()); | |
149 | assertEquals("Event rank", 1001, context.getRank()); | |
150 | ||
151 | context = fExperiment.seekEvent(new TmfTimestamp(4499, SCALE, 0)); | |
152 | event = fExperiment.getNextEvent(context); | |
153 | assertEquals("Event timestamp", 4499, event.getTimestamp().getValue()); | |
154 | assertEquals("Event rank", 4499, context.getRank()); | |
155 | } | |
156 | ||
157 | public void testSeekForEventOutOfBounds() throws Exception { | |
158 | TmfExperimentContext context = fExperiment.seekLocation(null); | |
159 | ||
160 | // On lower bound, returns the first event (ts = 1) | |
161 | context = fExperiment.seekEvent(new TmfTimestamp(-1, SCALE, 0)); | |
162 | TmfEvent event = fExperiment.getNextEvent(context); | |
163 | assertEquals("Event timestamp", 1, event.getTimestamp().getValue()); | |
164 | ||
165 | // On higher bound, returns null (no event) | |
166 | context = fExperiment.seekEvent(new TmfTimestamp(NB_EVENTS + 1, SCALE, 0)); | |
167 | event = fExperiment.getNextEvent(context); | |
168 | assertEquals("Event timestamp", null, event); | |
169 | } | |
170 | ||
171 | public void testSeekOnIndex() throws Exception { | |
172 | TmfExperimentContext context = fExperiment.seekLocation(null); | |
173 | ||
174 | // On lower bound, returns the first event (ts = 1) | |
175 | context = fExperiment.seekEvent(0); | |
176 | TmfEvent event = fExperiment.getNextEvent(context); | |
177 | assertEquals("Event timestamp", 1, event.getTimestamp().getValue()); | |
178 | ||
179 | // On higher bound | |
180 | context = fExperiment.seekEvent(NB_EVENTS - 1); | |
181 | event = fExperiment.getNextEvent(context); | |
182 | assertEquals("Event timestamp", NB_EVENTS, event.getTimestamp().getValue()); | |
183 | ||
184 | // Above high bound | |
185 | context = fExperiment.seekEvent(NB_EVENTS); | |
186 | event = fExperiment.getNextEvent(context); | |
187 | assertEquals("Event", null, event); | |
188 | } | |
189 | ||
e31e01e8 | 190 | // ------------------------------------------------------------------------ |
d18dd09b | 191 | // processRequest |
e31e01e8 | 192 | // ------------------------------------------------------------------------ |
d18dd09b ASL |
193 | |
194 | public void testProcessRequestForNbEvents() throws Exception { | |
195 | final int blockSize = 100; | |
e31e01e8 | 196 | final int nbEvents = 1000; |
d18dd09b ASL |
197 | final Vector<TmfEvent> requestedEvents = new Vector<TmfEvent>(); |
198 | ||
199 | TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BigBang, TmfTimestamp.BigCrunch); | |
e31e01e8 | 200 | final TmfEventRequest<TmfEvent> request = new TmfEventRequest<TmfEvent>(TmfEvent.class, range, nbEvents, blockSize) { |
d18dd09b ASL |
201 | @Override |
202 | public void handleData() { | |
203 | TmfEvent[] events = getData(); | |
204 | for (TmfEvent e : events) { | |
205 | requestedEvents.add(e); | |
206 | } | |
207 | } | |
208 | }; | |
75828b1a | 209 | fExperiment.processRequest(request, true); |
d18dd09b ASL |
210 | |
211 | assertEquals("nbEvents", nbEvents, requestedEvents.size()); | |
212 | assertTrue("isCompleted", request.isCompleted()); | |
213 | assertFalse("isCancelled", request.isCancelled()); | |
214 | ||
215 | // Ensure that we have distinct events. | |
216 | // Don't go overboard: we are not validating the stub! | |
217 | for (int i = 0; i < nbEvents; i++) { | |
218 | assertEquals("Distinct events", i+1, requestedEvents.get(i).getTimestamp().getValue()); | |
219 | } | |
220 | } | |
221 | ||
222 | public void testProcessRequestForNbEvents2() throws Exception { | |
223 | final int blockSize = 2 * NB_EVENTS; | |
224 | final int nbEvents = 1000; | |
225 | final Vector<TmfEvent> requestedEvents = new Vector<TmfEvent>(); | |
226 | ||
227 | TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BigBang, TmfTimestamp.BigCrunch); | |
e31e01e8 | 228 | final TmfEventRequest<TmfEvent> request = new TmfEventRequest<TmfEvent>(TmfEvent.class, range, nbEvents, blockSize) { |
d18dd09b ASL |
229 | @Override |
230 | public void handleData() { | |
231 | TmfEvent[] events = getData(); | |
232 | for (TmfEvent e : events) { | |
233 | requestedEvents.add(e); | |
234 | } | |
235 | } | |
236 | }; | |
75828b1a | 237 | fExperiment.processRequest(request, true); |
d18dd09b ASL |
238 | |
239 | assertEquals("nbEvents", nbEvents, requestedEvents.size()); | |
240 | assertTrue("isCompleted", request.isCompleted()); | |
241 | assertFalse("isCancelled", request.isCancelled()); | |
242 | ||
243 | // Ensure that we have distinct events. | |
244 | // Don't go overboard: we are not validating the stub! | |
245 | for (int i = 0; i < nbEvents; i++) { | |
246 | assertEquals("Distinct events", i+1, requestedEvents.get(i).getTimestamp().getValue()); | |
247 | } | |
248 | } | |
249 | ||
250 | public void testProcessRequestForAllEvents() throws Exception { | |
e31e01e8 | 251 | final int nbEvents = TmfEventRequest.ALL_DATA; |
d18dd09b ASL |
252 | final int blockSize = 1; |
253 | final Vector<TmfEvent> requestedEvents = new Vector<TmfEvent>(); | |
9f584e4c | 254 | long nbExpectedEvents = fExperiment.getNbEvents(); |
d18dd09b ASL |
255 | |
256 | TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BigBang, TmfTimestamp.BigCrunch); | |
e31e01e8 | 257 | final TmfEventRequest<TmfEvent> request = new TmfEventRequest<TmfEvent>(TmfEvent.class, range, nbEvents, blockSize) { |
d18dd09b ASL |
258 | @Override |
259 | public void handleData() { | |
260 | TmfEvent[] events = getData(); | |
261 | for (TmfEvent e : events) { | |
262 | requestedEvents.add(e); | |
263 | } | |
264 | } | |
265 | }; | |
75828b1a | 266 | fExperiment.processRequest(request, true); |
d18dd09b ASL |
267 | |
268 | assertEquals("nbEvents", nbExpectedEvents, requestedEvents.size()); | |
269 | assertTrue("isCompleted", request.isCompleted()); | |
270 | assertFalse("isCancelled", request.isCancelled()); | |
271 | ||
272 | // Ensure that we have distinct events. | |
273 | // Don't go overboard: we are not validating the stub! | |
274 | for (int i = 0; i < nbExpectedEvents; i++) { | |
275 | assertEquals("Distinct events", i+1, requestedEvents.get(i).getTimestamp().getValue()); | |
276 | } | |
277 | } | |
278 | ||
e31e01e8 | 279 | // ------------------------------------------------------------------------ |
d18dd09b | 280 | // cancel |
e31e01e8 | 281 | // ------------------------------------------------------------------------ |
d18dd09b ASL |
282 | |
283 | public void testCancel() throws Exception { | |
284 | final int nbEvents = NB_EVENTS; | |
285 | final int blockSize = fDefaultBlockSize; | |
286 | final Vector<TmfEvent> requestedEvents = new Vector<TmfEvent>(); | |
287 | ||
288 | TmfTimeRange range = new TmfTimeRange(TmfTimestamp.BigBang, TmfTimestamp.BigCrunch); | |
e31e01e8 | 289 | final TmfEventRequest<TmfEvent> request = new TmfEventRequest<TmfEvent>(TmfEvent.class, range, nbEvents, blockSize) { |
d18dd09b ASL |
290 | @Override |
291 | public void handleData() { | |
292 | TmfEvent[] events = getData(); | |
293 | for (TmfEvent e : events) { | |
294 | requestedEvents.add(e); | |
295 | } | |
296 | // Cancel request after the first chunk is received | |
297 | cancel(); | |
298 | } | |
299 | }; | |
75828b1a | 300 | fExperiment.processRequest(request, true); |
d18dd09b ASL |
301 | |
302 | assertEquals("nbEvents", blockSize, requestedEvents.size()); | |
303 | assertTrue("isCompleted", request.isCompleted()); | |
304 | assertTrue("isCancelled", request.isCancelled()); | |
305 | } | |
e31e01e8 FC |
306 | |
307 | // ------------------------------------------------------------------------ | |
308 | // getRank | |
309 | // ------------------------------------------------------------------------ | |
310 | ||
311 | public void testGetRank() throws Exception { | |
312 | assertEquals("getRank", 0, fExperiment.getRank(new TmfTimestamp())); | |
313 | assertEquals("getRank", 0, fExperiment.getRank(new TmfTimestamp( 1, (byte) -3))); | |
314 | assertEquals("getRank", 10, fExperiment.getRank(new TmfTimestamp( 11, (byte) -3))); | |
315 | assertEquals("getRank", 100, fExperiment.getRank(new TmfTimestamp( 101, (byte) -3))); | |
316 | assertEquals("getRank", 1000, fExperiment.getRank(new TmfTimestamp(1001, (byte) -3))); | |
317 | } | |
318 | ||
319 | } |