← Back to branch summary

~ubuntu-branches/ubuntu/trusty/eclipse-linuxtools/trusty

« back to all changes in this revision

Viewing changes to lttng/org.eclipse.linuxtools.tmf.core.tests/src/org/eclipse/linuxtools/tmf/core/tests/request/TmfEventRequestTest.java

  • Committer: Package Import Robot
  • Author(s): Jakub Adam
  • Date: 2012-06-29 12:07:30 UTC
  • Revision ID: package-import@ubuntu.com-20120629120730-bfri1xys1i71dpn6
Tags: upstream-1.0.0
Import upstream version 1.0.0

Show diffs side-by-side

added added

removed removed

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