Commit | Line | Data |
---|---|---|
d18dd09b ASL |
1 | /******************************************************************************* |
2 | * Copyright (c) 2009, 2010 Ericsson | |
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.request; | |
14 | ||
15 | import junit.framework.TestCase; | |
16 | ||
17 | import org.eclipse.linuxtools.tmf.event.TmfEvent; | |
18 | import org.eclipse.linuxtools.tmf.event.TmfEventReference; | |
19 | import org.eclipse.linuxtools.tmf.event.TmfEventSource; | |
20 | import org.eclipse.linuxtools.tmf.event.TmfEventType; | |
21 | import org.eclipse.linuxtools.tmf.event.TmfTimeRange; | |
22 | import org.eclipse.linuxtools.tmf.event.TmfTimestamp; | |
23 | import org.eclipse.linuxtools.tmf.request.TmfDataRequest; | |
24 | import org.eclipse.linuxtools.tmf.request.TmfEventRequest; | |
25 | import org.eclipse.linuxtools.tmf.request.TmfEventRequestStub; | |
26 | ||
27 | /** | |
28 | * <b><u>TmfEventRequestTest</u></b> | |
29 | * <p> | |
30 | * Test suite for the TmfEventRequest class. | |
31 | */ | |
32 | public class TmfEventRequestTest extends TestCase { | |
33 | ||
34 | // ------------------------------------------------------------------------ | |
35 | // Variables | |
36 | // ------------------------------------------------------------------------ | |
37 | ||
38 | private static TmfTimeRange range1 = new TmfTimeRange(TmfTimeRange.Eternity); | |
39 | private static TmfTimeRange range2 = new TmfTimeRange(new TmfTimestamp(), TmfTimestamp.BigCrunch); | |
40 | ||
41 | private static TmfEventRequest<TmfEvent> fRequest1; | |
42 | private static TmfEventRequest<TmfEvent> fRequest1b; | |
43 | private static TmfEventRequest<TmfEvent> fRequest1c; | |
44 | private static TmfEventRequest<TmfEvent> fRequest2; | |
45 | private static TmfEventRequest<TmfEvent> fRequest3; | |
46 | private static TmfEventRequest<TmfEvent> fRequest4; | |
47 | ||
48 | private static int fRequestCount; | |
49 | ||
50 | // ------------------------------------------------------------------------ | |
51 | // Housekeeping | |
52 | // ------------------------------------------------------------------------ | |
53 | ||
54 | public TmfEventRequestTest(String name) { | |
55 | super(name); | |
56 | } | |
57 | ||
58 | @Override | |
59 | protected void setUp() throws Exception { | |
60 | super.setUp(); | |
61 | TmfDataRequest.reset(); | |
62 | fRequest1 = new TmfEventRequestStub<TmfEvent>(TmfEvent.class, range1, 100, 200); | |
63 | fRequest2 = new TmfEventRequestStub<TmfEvent>(TmfEvent.class, range2, 100, 200); | |
64 | fRequest3 = new TmfEventRequestStub<TmfEvent>(TmfEvent.class, range2, 200, 200); | |
65 | fRequest4 = new TmfEventRequestStub<TmfEvent>(TmfEvent.class, range2, 200, 300); | |
66 | fRequest1b = new TmfEventRequestStub<TmfEvent>(TmfEvent.class, range1, 100, 200); | |
67 | fRequest1c = new TmfEventRequestStub<TmfEvent>(TmfEvent.class, range1, 100, 200); | |
68 | fRequestCount = fRequest1c.getRequestId() + 1; | |
69 | } | |
70 | ||
71 | @Override | |
72 | protected void tearDown() throws Exception { | |
73 | super.tearDown(); | |
74 | } | |
75 | ||
76 | private TmfEventRequest<TmfEvent> setupTestRequest(final boolean[] flags) { | |
77 | ||
78 | TmfEventRequest<TmfEvent> request = new TmfEventRequestStub<TmfEvent>(TmfEvent.class, new TmfTimeRange(TmfTimeRange.Eternity), 100, 200) { | |
79 | @Override | |
80 | public void handleCompleted() { | |
81 | super.handleCompleted(); | |
82 | flags[0] = true; | |
83 | } | |
84 | @Override | |
85 | public void handleSuccess() { | |
86 | super.handleSuccess(); | |
87 | flags[1] = true; | |
88 | } | |
89 | @Override | |
90 | public void handleFailure() { | |
91 | super.handleFailure(); | |
92 | flags[2] = true; | |
93 | } | |
94 | @Override | |
95 | public void handleCancel() { | |
96 | super.handleCancel(); | |
97 | flags[3] = true; | |
98 | } | |
99 | }; | |
100 | return request; | |
101 | } | |
102 | ||
103 | // ------------------------------------------------------------------------ | |
104 | // Constructors | |
105 | // ------------------------------------------------------------------------ | |
106 | ||
107 | public void testTmfEventRequest() { | |
108 | TmfEventRequest<TmfEvent> request = new TmfEventRequestStub<TmfEvent>(TmfEvent.class); | |
109 | ||
110 | assertEquals("getRequestId", fRequestCount++, request.getRequestId()); | |
111 | assertEquals("getDataType", TmfEvent.class, request.getDataType()); | |
112 | ||
113 | assertEquals("StartTime", TmfTimestamp.BigBang, request.getRange().getStartTime()); | |
114 | assertEquals("EndTime", TmfTimestamp.BigCrunch, request.getRange().getEndTime()); | |
115 | ||
116 | assertEquals("getIndex", 0, request.getIndex()); | |
117 | assertEquals("getNbRequestedEvents", TmfDataRequest.ALL_DATA, request.getNbRequested()); | |
118 | assertEquals("getBlockize", TmfDataRequest.DEFAULT_BLOCK_SIZE, request.getBlockize()); | |
119 | ||
120 | assertFalse("isCompleted", request.isCompleted()); | |
121 | assertFalse("isFailed", request.isFailed()); | |
122 | assertFalse("isCancelled", request.isCancelled()); | |
123 | ||
124 | assertEquals("getNbRead", 0, request.getNbRead()); | |
125 | } | |
126 | ||
127 | public void testTmfEventRequestTimeRange() { | |
128 | TmfTimeRange range = new TmfTimeRange(new TmfTimestamp(), TmfTimestamp.BigCrunch); | |
129 | TmfEventRequest<TmfEvent> request = new TmfEventRequestStub<TmfEvent>(TmfEvent.class, range); | |
130 | ||
131 | assertEquals("getRequestId", fRequestCount++, request.getRequestId()); | |
132 | assertEquals("getDataType", TmfEvent.class, request.getDataType()); | |
133 | ||
134 | assertEquals("StartTime", new TmfTimestamp(), request.getRange().getStartTime()); | |
135 | assertEquals("EndTime", TmfTimestamp.BigCrunch, request.getRange().getEndTime()); | |
136 | ||
137 | assertEquals("getIndex", 0, request.getIndex()); | |
138 | assertEquals("getNbRequestedEvents", TmfDataRequest.ALL_DATA, request.getNbRequested()); | |
139 | assertEquals("getBlockize", TmfDataRequest.DEFAULT_BLOCK_SIZE, request.getBlockize()); | |
140 | ||
141 | assertFalse("isCompleted", request.isCompleted()); | |
142 | assertFalse("isFailed", request.isFailed()); | |
143 | assertFalse("isCancelled", request.isCancelled()); | |
144 | ||
145 | assertEquals("getNbRead", 0, request.getNbRead()); | |
146 | } | |
147 | ||
148 | public void testTmfEventRequestTimeRangeNbRequested() { | |
149 | TmfTimeRange range = new TmfTimeRange(new TmfTimestamp(), TmfTimestamp.BigCrunch); | |
150 | TmfEventRequest<TmfEvent> request = new TmfEventRequestStub<TmfEvent>(TmfEvent.class, range, 100); | |
151 | ||
152 | assertEquals("getRequestId", fRequestCount++, request.getRequestId()); | |
153 | assertEquals("getDataType", TmfEvent.class, request.getDataType()); | |
154 | ||
155 | assertEquals("StartTime", new TmfTimestamp(), request.getRange().getStartTime()); | |
156 | assertEquals("EndTime", TmfTimestamp.BigCrunch, request.getRange().getEndTime()); | |
157 | ||
158 | assertEquals("getIndex", 0, request.getIndex()); | |
159 | assertEquals("getNbRequestedEvents", 100, request.getNbRequested()); | |
160 | assertEquals("getBlockize", TmfDataRequest.DEFAULT_BLOCK_SIZE, request.getBlockize()); | |
161 | ||
162 | assertFalse("isCompleted", request.isCompleted()); | |
163 | assertFalse("isFailed", request.isFailed()); | |
164 | assertFalse("isCancelled", request.isCancelled()); | |
165 | ||
166 | assertEquals("getNbRead", 0, request.getNbRead()); | |
167 | } | |
168 | ||
169 | public void testTmfEventRequestTimeRangeNbRequestedBlocksize() { | |
170 | TmfTimeRange range = new TmfTimeRange(new TmfTimestamp(), TmfTimestamp.BigCrunch); | |
171 | TmfEventRequest<TmfEvent> request = new TmfEventRequestStub<TmfEvent>(TmfEvent.class, range, 100, 200); | |
172 | ||
173 | assertEquals("getRequestId", fRequestCount++, request.getRequestId()); | |
174 | assertEquals("getDataType", TmfEvent.class, request.getDataType()); | |
175 | ||
176 | assertEquals("StartTime", new TmfTimestamp(), request.getRange().getStartTime()); | |
177 | assertEquals("EndTime", TmfTimestamp.BigCrunch, request.getRange().getEndTime()); | |
178 | ||
179 | assertEquals("getIndex", 0, request.getIndex()); | |
180 | assertEquals("getNbRequestedEvents", 100, request.getNbRequested()); | |
181 | assertEquals("getBlockize", 200, request.getBlockize()); | |
182 | ||
183 | assertFalse("isCompleted", request.isCompleted()); | |
184 | assertFalse("isFailed", request.isFailed()); | |
185 | assertFalse("isCancelled", request.isCancelled()); | |
186 | ||
187 | assertEquals("getNbRead", 0, request.getNbRead()); | |
188 | } | |
189 | ||
190 | // ------------------------------------------------------------------------ | |
191 | // equals | |
192 | // ------------------------------------------------------------------------ | |
193 | ||
194 | public void testEqualsReflexivity() throws Exception { | |
195 | assertTrue("equals", fRequest1.equals(fRequest1)); | |
196 | assertTrue("equals", fRequest2.equals(fRequest2)); | |
197 | ||
198 | assertFalse("equals", fRequest1.equals(fRequest2)); | |
199 | assertFalse("equals", fRequest2.equals(fRequest1)); | |
200 | } | |
201 | ||
202 | public void testEqualsSymmetry() throws Exception { | |
203 | assertTrue("equals", fRequest1.equals(fRequest1b)); | |
204 | assertTrue("equals", fRequest1b.equals(fRequest1)); | |
205 | ||
206 | assertFalse("equals", fRequest1.equals(fRequest3)); | |
207 | assertFalse("equals", fRequest2.equals(fRequest3)); | |
208 | assertFalse("equals", fRequest3.equals(fRequest1)); | |
209 | assertFalse("equals", fRequest3.equals(fRequest2)); | |
210 | } | |
211 | ||
212 | public void testEqualsTransivity() throws Exception { | |
213 | assertTrue("equals", fRequest1.equals(fRequest1b)); | |
214 | assertTrue("equals", fRequest1b.equals(fRequest1c)); | |
215 | assertTrue("equals", fRequest1.equals(fRequest1c)); | |
216 | } | |
217 | ||
218 | public void testEqualsNull() throws Exception { | |
219 | assertFalse("equals", fRequest1.equals(null)); | |
220 | assertFalse("equals", fRequest2.equals(null)); | |
221 | } | |
222 | ||
223 | // ------------------------------------------------------------------------ | |
224 | // hashCode | |
225 | // ------------------------------------------------------------------------ | |
226 | ||
227 | public void testHashCode() throws Exception { | |
228 | assertTrue("hashCode", fRequest1.hashCode() == fRequest1.hashCode()); | |
229 | assertTrue("hashCode", fRequest2.hashCode() == fRequest2.hashCode()); | |
230 | assertTrue("hashCode", fRequest1.hashCode() != fRequest2.hashCode()); | |
231 | } | |
232 | ||
233 | // ------------------------------------------------------------------------ | |
234 | // toString | |
235 | // ------------------------------------------------------------------------ | |
236 | ||
237 | public void testToString() { | |
238 | String expected1 = "[TmfEventRequest(0,TmfEvent," + range1 + ",100,200)]"; | |
239 | String expected2 = "[TmfEventRequest(1,TmfEvent," + range2 + ",100,200)]"; | |
240 | String expected3 = "[TmfEventRequest(2,TmfEvent," + range2 + ",200,200)]"; | |
241 | String expected4 = "[TmfEventRequest(3,TmfEvent," + range2 + ",200,300)]"; | |
242 | ||
243 | assertEquals("toString", expected1, fRequest1.toString()); | |
244 | assertEquals("toString", expected2, fRequest2.toString()); | |
245 | assertEquals("toString", expected3, fRequest3.toString()); | |
246 | assertEquals("toString", expected4, fRequest4.toString()); | |
247 | } | |
248 | ||
249 | // ------------------------------------------------------------------------ | |
250 | // setData/getData | |
251 | // ------------------------------------------------------------------------ | |
252 | ||
253 | public void testSetData() { | |
254 | // Initialize the data | |
255 | int nbEvents = 10; | |
256 | TmfEvent[] events = new TmfEvent[nbEvents]; | |
257 | for (int i = 0; i < nbEvents; i++) { | |
258 | events[i] = new TmfEvent(new TmfTimestamp(i), new TmfEventSource(), | |
259 | new TmfEventType(), new TmfEventReference()); | |
260 | } | |
261 | ||
262 | fRequest1.setData(events); | |
263 | assertEquals("setData", nbEvents, fRequest1.getNbRead()); | |
264 | ||
265 | TmfEvent[] eventsRead = fRequest1.getData(); | |
266 | assertEquals("getData", nbEvents, eventsRead.length); | |
267 | ||
268 | for (int i = 0; i < nbEvents; i++) { | |
269 | assertEquals("getData", i, eventsRead[i].getTimestamp().getValue()); | |
270 | } | |
271 | } | |
272 | ||
273 | // ------------------------------------------------------------------------ | |
274 | // done | |
275 | // ------------------------------------------------------------------------ | |
276 | ||
277 | public void testDone() { | |
278 | ||
279 | final boolean[] flags = new boolean[4]; | |
280 | TmfEventRequest<TmfEvent> request = setupTestRequest(flags); | |
281 | request.done(); | |
282 | ||
283 | assertTrue ("isCompleted", request.isCompleted()); | |
284 | assertFalse("isFailed", request.isFailed()); | |
285 | assertFalse("isCancelled", request.isCancelled()); | |
286 | ||
287 | assertTrue ("handleCompleted", flags[0]); | |
288 | assertTrue ("handleSuccess", flags[1]); | |
289 | assertFalse("handleFailure", flags[2]); | |
290 | assertFalse("handleCancel", flags[3]); | |
291 | } | |
292 | ||
293 | // ------------------------------------------------------------------------ | |
294 | // fail | |
295 | // ------------------------------------------------------------------------ | |
296 | ||
297 | public void testFail() { | |
298 | ||
299 | final boolean[] flags = new boolean[4]; | |
300 | TmfEventRequest<TmfEvent> request = setupTestRequest(flags); | |
301 | request.fail(); | |
302 | ||
303 | assertTrue ("isCompleted", request.isCompleted()); | |
304 | assertTrue ("isFailed", request.isFailed()); | |
305 | assertFalse("isCancelled", request.isCancelled()); | |
306 | ||
307 | assertTrue ("handleCompleted", flags[0]); | |
308 | assertFalse("handleSuccess", flags[1]); | |
309 | assertTrue ("handleFailure", flags[2]); | |
310 | assertFalse("handleCancel", flags[3]); | |
311 | } | |
312 | ||
313 | // ------------------------------------------------------------------------ | |
314 | // cancel | |
315 | // ------------------------------------------------------------------------ | |
316 | ||
317 | public void testCancel() { | |
318 | ||
319 | final boolean[] flags = new boolean[4]; | |
320 | TmfEventRequest<TmfEvent> request = setupTestRequest(flags); | |
321 | request.cancel(); | |
322 | ||
323 | assertTrue ("isCompleted", request.isCompleted()); | |
324 | assertFalse("isFailed", request.isFailed()); | |
325 | assertTrue ("isCancelled", request.isCancelled()); | |
326 | ||
327 | assertTrue ("handleCompleted", flags[0]); | |
328 | assertFalse("handleSuccess", flags[1]); | |
329 | assertFalse("handleFailure", flags[2]); | |
330 | assertTrue ("handleCancel", flags[3]); | |
331 | } | |
332 | ||
333 | // ------------------------------------------------------------------------ | |
334 | // waitForCompletion | |
335 | // ------------------------------------------------------------------------ | |
336 | ||
337 | } |