1 /**********************************************************************
2 * Copyright (c) 2012 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 * Bernd Hufmann - Initial API and implementation
11 **********************************************************************/
12 package org
.eclipse
.linuxtools
.lttng
.ui
.tests
.control
.model
.impl
;
14 import java
.util
.LinkedList
;
15 import java
.util
.List
;
17 import junit
.framework
.TestCase
;
19 import org
.eclipse
.linuxtools
.internal
.lttng
.ui
.views
.control
.model
.IChannelInfo
;
20 import org
.eclipse
.linuxtools
.internal
.lttng
.ui
.views
.control
.model
.IEventInfo
;
21 import org
.eclipse
.linuxtools
.internal
.lttng
.ui
.views
.control
.model
.TraceEnablement
;
22 import org
.eclipse
.linuxtools
.internal
.lttng
.ui
.views
.control
.model
.impl
.ChannelInfo
;
23 import org
.eclipse
.linuxtools
.internal
.lttng
.ui
.views
.control
.model
.impl
.EventInfo
;
26 * The class <code>ChannelInfoTest</code> contains tests for the class <code>{@link ChannelInfo}</code>.
29 @SuppressWarnings("nls")
30 public class ChannelInfoTest
extends TestCase
{
31 // ------------------------------------------------------------------------
33 // ------------------------------------------------------------------------
34 private IChannelInfo fChannelInfo1
= null;
35 private IChannelInfo fChannelInfo2
= null;
37 // ------------------------------------------------------------------------
39 // ------------------------------------------------------------------------
42 * Perform pre-test initialization.
45 * if the initialization fails for some reason
50 ModelImplFactory factory
= new ModelImplFactory();
51 fChannelInfo1
= factory
.getChannel1();
52 fChannelInfo2
= factory
.getChannel2();
56 * Perform post-test clean-up.
59 * if the clean-up fails for some reason
63 public void tearDown() {
66 // ------------------------------------------------------------------------
68 // ------------------------------------------------------------------------
70 // ------------------------------------------------------------------------
72 // ------------------------------------------------------------------------
75 * Run the ChannelInfo() constructor test.
78 public void testChannelInfo() {
79 ChannelInfo result
= new ChannelInfo("test");
80 assertNotNull(result
);
82 assertEquals("test", result
.getName());
83 assertEquals(0, result
.getNumberOfSubBuffers());
84 assertEquals("", result
.getOutputType());
85 assertEquals(false, result
.isOverwriteMode());
86 assertEquals(0, result
.getReadTimer());
87 assertEquals("disabled", result
.getState().getInName());
88 assertEquals(0, result
.getSubBufferSize());
89 assertEquals(0, result
.getSwitchTimer());
92 public void testChannelInfoCopy() {
93 ChannelInfo channelInfo
= new ChannelInfo((ChannelInfo
)fChannelInfo1
);
95 assertEquals(fChannelInfo1
.getName(), channelInfo
.getName());
96 assertEquals(fChannelInfo1
.getNumberOfSubBuffers(), channelInfo
.getNumberOfSubBuffers());
97 assertEquals(fChannelInfo1
.getOutputType(), channelInfo
.getOutputType());
98 assertEquals(fChannelInfo1
.isOverwriteMode(), channelInfo
.isOverwriteMode());
99 assertEquals(fChannelInfo1
.getReadTimer(), channelInfo
.getReadTimer());
100 assertEquals(fChannelInfo1
.getState(), channelInfo
.getState());
101 assertEquals(fChannelInfo1
.getSwitchTimer(), channelInfo
.getSwitchTimer());
102 assertEquals(fChannelInfo1
.getEvents().length
, channelInfo
.getEvents().length
);
104 IEventInfo
[] orignalEvents
= fChannelInfo1
.getEvents();
105 IEventInfo
[] resultEvents
= channelInfo
.getEvents();
106 for (int i
= 0; i
< orignalEvents
.length
; i
++) {
107 assertEquals(orignalEvents
[i
], resultEvents
[i
]);
111 public void testChannelCopy2() {
113 ChannelInfo channel
= null;
114 new ChannelInfo(channel
);
117 catch (IllegalArgumentException e
) {
123 * Run the IEventInfo[] getEvents() method test.
126 public void testAddAndGetEvents_1() {
127 ChannelInfo fixture
= new ChannelInfo("test");
128 fixture
.setSwitchTimer(1L);
129 fixture
.setOverwriteMode(true);
130 fixture
.setReadTimer(1L);
131 fixture
.setState(TraceEnablement
.DISABLED
);
132 fixture
.setNumberOfSubBuffers(1);
133 fixture
.setOutputType("");
134 fixture
.setSubBufferSize(1L);
137 IEventInfo event
= new EventInfo("event");
138 fixture
.addEvent(event
);
140 // Verify the stored events
141 IEventInfo
[] result
= fixture
.getEvents();
143 assertNotNull(result
);
144 assertEquals(1, result
.length
);
145 assertNotNull(result
[0]);
146 assertTrue(event
.equals(result
[0]));
150 * Run the long getNumberOfSubBuffers() method test.
153 public void testGetAndSetters() {
154 ChannelInfo fixture
= new ChannelInfo("test");
155 fixture
.setSwitchTimer(2L);
156 fixture
.setOverwriteMode(true);
157 fixture
.setReadTimer(3L);
158 fixture
.setState(TraceEnablement
.DISABLED
);
159 fixture
.setNumberOfSubBuffers(4);
160 fixture
.setOutputType("splice()");
161 fixture
.setSubBufferSize(1L);
162 fixture
.addEvent(new EventInfo("event"));
164 long switchTimer
= fixture
.getSwitchTimer();
165 assertEquals(2L, switchTimer
);
167 boolean mode
= fixture
.isOverwriteMode();
170 long readTimer
= fixture
.getReadTimer();
171 assertEquals(3L, readTimer
);
173 TraceEnablement state
= fixture
.getState();
174 assertEquals("disabled", state
.getInName());
176 long numSubBuffers
= fixture
.getNumberOfSubBuffers();
177 assertEquals(4, numSubBuffers
);
179 String outputType
= fixture
.getOutputType();
180 assertEquals("splice()", outputType
);
182 long subBufferSize
= fixture
.getSubBufferSize();
183 assertEquals(1L, subBufferSize
);
185 fixture
.setSwitchTimer(5L);
186 fixture
.setOverwriteMode(false);
187 fixture
.setReadTimer(6L);
188 fixture
.setState(TraceEnablement
.ENABLED
);
189 fixture
.setNumberOfSubBuffers(7);
190 fixture
.setOutputType("mmap()");
191 fixture
.setSubBufferSize(8L);
193 switchTimer
= fixture
.getSwitchTimer();
194 assertEquals(5L, switchTimer
);
196 mode
= fixture
.isOverwriteMode();
199 readTimer
= fixture
.getReadTimer();
200 assertEquals(6L, readTimer
);
202 state
= fixture
.getState();
203 assertEquals("enabled", state
.getInName());
205 numSubBuffers
= fixture
.getNumberOfSubBuffers();
206 assertEquals(7, numSubBuffers
);
208 outputType
= fixture
.getOutputType();
209 assertEquals("mmap()", outputType
);
211 subBufferSize
= fixture
.getSubBufferSize();
212 assertEquals(8L, subBufferSize
);
216 * Run the void setEvents(List<IEventInfo>) method test.
219 public void testSetEvents_1() {
220 ChannelInfo fixture
= new ChannelInfo("test");
221 fixture
.setSwitchTimer(1L);
222 fixture
.setOverwriteMode(true);
223 fixture
.setReadTimer(1L);
224 fixture
.setState(TraceEnablement
.DISABLED
);
225 fixture
.setNumberOfSubBuffers(1);
226 fixture
.setOutputType("");
227 fixture
.setSubBufferSize(1L);
228 List
<IEventInfo
> events
= new LinkedList
<IEventInfo
>();
230 for (int i
= 0; i
< 2; i
++) {
231 IEventInfo info
= new EventInfo("event" + i
);
232 info
.setEventType("tracepoint");
233 info
.setState((i
% 2 == 0 ?
"enabled" : "disabled"));
237 fixture
.setEvents(events
);
239 IEventInfo
[] infos
= fixture
.getEvents();
241 assertEquals(events
.size(), infos
.length
);
243 for (int i
= 0; i
< infos
.length
; i
++) {
244 assertEquals(events
.get(i
), infos
[i
]);
248 public void testToString_1() {
249 ChannelInfo fixture
= new ChannelInfo("channel");
250 fixture
.setSwitchTimer(1L);
251 fixture
.setOverwriteMode(true);
252 fixture
.setReadTimer(1L);
253 fixture
.setState(TraceEnablement
.DISABLED
);
254 fixture
.setNumberOfSubBuffers(1);
255 fixture
.setOutputType("splice()");
256 fixture
.setSubBufferSize(1L);
258 String result
= fixture
.toString();
260 // add additional test code here
261 assertEquals("[ChannelInfo([TraceInfo(Name=channel)],State=DISABLED,OverwriteMode=true,SubBuffersSize=1,NumberOfSubBuffers=1,SwitchTimer=1,ReadTimer=1,output=splice(),Events=None)]", result
);
265 * Run the String toString() method test.
268 public void testToString_2() {
269 String result
= fChannelInfo1
.toString();
271 // add additional test code here
272 assertEquals("[ChannelInfo([TraceInfo(Name=channel1)],State=DISABLED,OverwriteMode=true,SubBuffersSize=13,NumberOfSubBuffers=12,SwitchTimer=10,ReadTimer=11,output=splice(),Events=[EventInfo([BaseEventInfo([TraceInfo(Name=event1)],type=TRACEPOINT,level=TRACE_DEBUG)],State=ENABLED)])]", result
);
275 // ------------------------------------------------------------------------
277 // ------------------------------------------------------------------------
279 public void testEqualsReflexivity() {
280 assertTrue("equals", fChannelInfo1
.equals(fChannelInfo1
));
281 assertTrue("equals", fChannelInfo2
.equals(fChannelInfo2
));
283 assertTrue("equals", !fChannelInfo1
.equals(fChannelInfo2
));
284 assertTrue("equals", !fChannelInfo2
.equals(fChannelInfo1
));
287 public void testEqualsSymmetry() {
288 ChannelInfo event1
= new ChannelInfo((ChannelInfo
)fChannelInfo1
);
289 ChannelInfo event2
= new ChannelInfo((ChannelInfo
)fChannelInfo2
);
291 assertTrue("equals", event1
.equals(fChannelInfo1
));
292 assertTrue("equals", fChannelInfo1
.equals(event1
));
294 assertTrue("equals", event2
.equals(fChannelInfo2
));
295 assertTrue("equals", fChannelInfo2
.equals(event2
));
298 public void testEqualsTransivity() {
299 ChannelInfo channel1
= new ChannelInfo((ChannelInfo
)fChannelInfo1
);
300 ChannelInfo channel2
= new ChannelInfo((ChannelInfo
)fChannelInfo1
);
301 ChannelInfo channel3
= new ChannelInfo((ChannelInfo
)fChannelInfo1
);
303 assertTrue("equals", channel1
.equals(channel2
));
304 assertTrue("equals", channel2
.equals(channel3
));
305 assertTrue("equals", channel1
.equals(channel3
));
308 public void testEqualsNull() throws Exception
{
309 assertTrue("equals", !fChannelInfo1
.equals(null));
310 assertTrue("equals", !fChannelInfo2
.equals(null));
313 // ------------------------------------------------------------------------
315 // ------------------------------------------------------------------------
317 public void testHashCode() {
318 ChannelInfo channel1
= new ChannelInfo((ChannelInfo
)fChannelInfo1
);
319 ChannelInfo channel2
= new ChannelInfo((ChannelInfo
)fChannelInfo2
);
321 assertTrue("hashCode", fChannelInfo1
.hashCode() == channel1
.hashCode());
322 assertTrue("hashCode", fChannelInfo2
.hashCode() == channel2
.hashCode());
324 assertTrue("hashCode", fChannelInfo1
.hashCode() != channel2
.hashCode());
325 assertTrue("hashCode", fChannelInfo2
.hashCode() != channel1
.hashCode());