Move alltests plugin to the Trace Compass namespace
[deliverable/tracecompass.git] / org.eclipse.tracecompass.tmf.core.tests / src / org / eclipse / linuxtools / tmf / core / tests / event / TmfEventFieldTest.java
1 /*******************************************************************************
2 * Copyright (c) 2009, 2013 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 * Francois Chouinard - Adjusted for new Event Model
12 * Alexandre Montplaisir - Port to JUnit4
13 *******************************************************************************/
14
15 package org.eclipse.linuxtools.tmf.core.tests.event;
16
17 import static org.junit.Assert.assertArrayEquals;
18 import static org.junit.Assert.assertEquals;
19 import static org.junit.Assert.assertFalse;
20 import static org.junit.Assert.assertNotEquals;
21 import static org.junit.Assert.assertNull;
22 import static org.junit.Assert.assertSame;
23 import static org.junit.Assert.assertTrue;
24 import static org.junit.Assert.fail;
25
26 import java.util.Collection;
27
28 import org.eclipse.linuxtools.tmf.core.event.ITmfEventField;
29 import org.eclipse.linuxtools.tmf.core.event.TmfEvent;
30 import org.eclipse.linuxtools.tmf.core.event.TmfEventField;
31 import org.junit.Test;
32
33 /**
34 * Test suite for the TmfEventField class.
35 */
36 @SuppressWarnings("javadoc")
37 public class TmfEventFieldTest {
38
39 // ------------------------------------------------------------------------
40 // Variables
41 // ------------------------------------------------------------------------
42
43 private final String fFieldName1 = "Field-1";
44 private final String fFieldName2 = "Field-2";
45
46 private final Object fValue1 = "Value";
47 private final Object fValue2 = Integer.valueOf(10);
48
49 private final TmfEventField fField1 = new TmfEventField(fFieldName1, fValue1, null);
50 private final TmfEventField fField2 = new TmfEventField(fFieldName2, fValue2, null);
51 private final TmfEventField fField3 = new TmfEventField(fFieldName1, fValue2, null);
52
53 private final String fStructRootFieldName = "Root-S";
54 private final String[] fStructFieldNames = new String[] { fFieldName1, fFieldName2 };
55 private final TmfEventField fStructTerminalField1 = new TmfEventField(fFieldName1, null, null);
56 private final TmfEventField fStructTerminalField2 = new TmfEventField(fFieldName2, null, null);
57 private final TmfEventField fStructTerminalField3 = new TmfEventField(fFieldName1, null, null);
58 private final TmfEventField fStructRootField = new TmfEventField(fStructRootFieldName, null,
59 new ITmfEventField[] { fStructTerminalField1, fStructTerminalField2 });
60
61 private final String fRootFieldName = "Root";
62 private final String[] fFieldNames = new String[] { fFieldName1, fFieldName2 };
63 private final TmfEventField fRootField = new TmfEventField(fRootFieldName, null,
64 new ITmfEventField[] { fField1, fField2 });
65
66 // ------------------------------------------------------------------------
67 // Constructors
68 // ------------------------------------------------------------------------
69
70 @Test
71 public void testTerminalStructConstructor() {
72 assertSame("getName", fFieldName1, fStructTerminalField1.getName());
73 assertNull("getValue", fStructTerminalField1.getValue());
74 assertEquals("getFields", 0, fStructTerminalField1.getFields().size());
75 assertNull("getField(name)", fStructTerminalField1.getField(fFieldName1));
76 assertEquals("getFieldNames", 0, fStructTerminalField1.getFieldNames().size());
77 }
78
79 @Test
80 public void testNonTerminalStructConstructor() {
81 assertSame("getName", fStructRootFieldName, fStructRootField.getName());
82 assertNull("getValue", fStructRootField.getValue());
83 assertEquals("getFields", 2, fStructRootField.getFields().size());
84 assertSame("getField(name)", fStructTerminalField1, fStructRootField.getField(fFieldName1));
85 assertSame("getField(name)", fStructTerminalField2, fStructRootField.getField(fFieldName2));
86
87 final Collection<String> names = fStructRootField.getFieldNames();
88 assertEquals("getFieldNames length", 2, names.size());
89 assertArrayEquals(fStructFieldNames, names.toArray(new String[names.size()]));
90 }
91
92 @Test
93 public void testTerminalConstructor() {
94 assertSame("getName", fFieldName1, fField1.getName());
95 assertSame("getValue", fValue1, fField1.getValue());
96 assertEquals("getFields", 0, fField1.getFields().size());
97 assertNull("getField(name)", fField1.getField(fFieldName1));
98 assertEquals("getFieldNames", 0, fField1.getFieldNames().size());
99
100 assertSame("getName", fFieldName2, fField2.getName());
101 assertSame("getValue", fValue2, fField2.getValue());
102 assertEquals("getFields", 0, fField2.getFields().size());
103 assertNull("getField(name)", fField2.getField(fFieldName2));
104 }
105
106 @Test
107 public void testNonTerminalConstructor() {
108 assertSame("getName", fRootFieldName, fRootField.getName());
109 assertNull("getValue", fRootField.getValue());
110 assertEquals("getFields", 2, fRootField.getFields().size());
111 assertSame("getField(name)", fField1, fRootField.getField(fFieldName1));
112 assertSame("getField(name)", fField2, fRootField.getField(fFieldName2));
113
114 final Collection<String> names = fRootField.getFieldNames();
115 assertEquals("getFieldNames length", 2, names.size());
116 assertArrayEquals(fFieldNames, names.toArray(new String[names.size()]));
117 }
118
119 @Test
120 public void testConstructorBadArg() {
121 try {
122 new TmfEventField(null, fValue1, null);
123 fail("Invalid (null) field name");
124 } catch (final IllegalArgumentException e) {
125 }
126 }
127
128 @Test
129 public void testTerminalCopyConstructor() {
130 final TmfEventField copy = new TmfEventField(fField1);
131 assertSame("getName", fFieldName1, copy.getName());
132 assertSame("getValue", fValue1, copy.getValue());
133 assertEquals("getFields", 0, copy.getFields().size());
134 assertNull("getField(name)", copy.getField(fFieldName1));
135 assertEquals("getFieldNames", 0, copy.getFieldNames().size());
136 }
137
138 @Test
139 public void testNonTerminalCopyConstructor() {
140 assertSame("getName", fRootFieldName, fRootField.getName());
141 assertNull("getValue", fRootField.getValue());
142 assertEquals("getFields", 2, fRootField.getFields().size());
143 assertSame("getField(name)", fField1, fRootField.getField(fFieldName1));
144 assertSame("getField(name)", fField2, fRootField.getField(fFieldName2));
145
146 final Collection<String> names = fRootField.getFieldNames();
147 assertEquals("getFieldNames length", 2, names.size());
148 assertArrayEquals(fFieldNames, names.toArray(new String[names.size()]));
149 }
150
151 @Test
152 public void testCopyConstructorBadArg() {
153 try {
154 new TmfEventField(null);
155 fail("TmfEventField: null arguemnt");
156 } catch (final IllegalArgumentException e) {
157 }
158 }
159
160 /**
161 * Test that we correctly fail to create a field with subfields having the
162 * same name.
163 */
164 @Test
165 public void testDuplicateFieldNames() {
166 ITmfEventField[] fields = {
167 new TmfEventField("samename", null, null),
168 new TmfEventField("samename", null, null)
169 };
170
171 try {
172 new TmfEventField("field", null, fields);
173 fail("TmfEventField: Duplicate field names");
174 } catch (IllegalArgumentException e) {
175 /* Expected exception */
176 }
177 }
178
179 // ------------------------------------------------------------------------
180 // hashCode
181 // ------------------------------------------------------------------------
182
183 @Test
184 public void testHashCode() {
185 TmfEventField copy = new TmfEventField(fField1);
186 assertTrue("hashCode", fField1.hashCode() == copy.hashCode());
187 assertTrue("hashCode", fField1.hashCode() != fField2.hashCode());
188
189 copy = new TmfEventField(fStructTerminalField1);
190 assertTrue("hashCode", fStructTerminalField1.hashCode() == copy.hashCode());
191 assertTrue("hashCode", fStructTerminalField1.hashCode() != fStructTerminalField2.hashCode());
192 }
193
194 // ------------------------------------------------------------------------
195 // equals
196 // ------------------------------------------------------------------------
197
198 @Test
199 public void testEqualsReflexivity() {
200 assertTrue("equals", fField1.equals(fField1));
201 assertTrue("equals", fField2.equals(fField2));
202
203 assertFalse("equals", fField1.equals(fField2));
204 assertFalse("equals", fField2.equals(fField1));
205
206 assertTrue("equals", fStructTerminalField1.equals(fStructTerminalField1));
207 assertTrue("equals", fStructTerminalField2.equals(fStructTerminalField2));
208
209 assertFalse("equals", fStructTerminalField1.equals(fStructTerminalField2));
210 assertFalse("equals", fStructTerminalField2.equals(fStructTerminalField1));
211 }
212
213 @Test
214 public void testEqualsSymmetry() {
215 final TmfEventField copy0 = new TmfEventField(fField1);
216 assertTrue("equals", fField1.equals(copy0));
217 assertTrue("equals", copy0.equals(fField1));
218
219 final TmfEventField copy3 = new TmfEventField(fField2);
220 assertTrue("equals", fField2.equals(copy3));
221 assertTrue("equals", copy3.equals(fField2));
222 }
223
224 @Test
225 public void testEqualsTransivity() {
226 TmfEventField copy1 = new TmfEventField(fField1);
227 TmfEventField copy2 = new TmfEventField(copy1);
228 assertTrue("equals", fField1.equals(copy1));
229 assertTrue("equals", copy1.equals(copy2));
230 assertTrue("equals", fField1.equals(copy2));
231
232 copy1 = new TmfEventField(fField2);
233 copy2 = new TmfEventField(copy1);
234 assertTrue("equals", fField2.equals(copy1));
235 assertTrue("equals", copy1.equals(copy2));
236 assertTrue("equals", fField2.equals(copy2));
237 }
238
239 @Test
240 public void testEquals() {
241 assertTrue("equals", fStructTerminalField1.equals(fStructTerminalField3));
242 assertTrue("equals", fStructTerminalField3.equals(fStructTerminalField1));
243
244 assertFalse("equals", fStructTerminalField1.equals(fField3));
245 assertFalse("equals", fField3.equals(fStructTerminalField1));
246 }
247
248 @Test
249 public void testEqualsNull() {
250 assertFalse("equals", fField1.equals(null));
251 assertFalse("equals", fField2.equals(null));
252 }
253
254 @Test
255 public void testNonEqualClasses() {
256 assertFalse("equals", fField1.equals(fStructTerminalField1));
257 assertFalse("equals", fField1.equals(fValue1));
258 }
259
260 @Test
261 public void testNonEqualValues() {
262 final TmfEventField copy1 = new TmfEventField(fFieldName1, fValue1, null);
263 TmfEventField copy2 = new TmfEventField(fFieldName1, fValue1, null);
264 assertTrue("equals", copy1.equals(copy2));
265 assertTrue("equals", copy2.equals(copy1));
266
267 copy2 = new TmfEventField(fFieldName1, fValue2, null);
268 assertFalse("equals", copy1.equals(copy2));
269 assertFalse("equals", copy2.equals(copy1));
270
271 copy2 = new TmfEventField(fFieldName1, null, null);
272 assertFalse("equals", copy1.equals(copy2));
273 assertFalse("equals", copy2.equals(copy1));
274 }
275
276 @Test
277 public void testNonEquals() {
278 assertFalse("equals", fField1.equals(fField2));
279 assertFalse("equals", fField2.equals(fField1));
280
281 assertFalse("equals", fField1.equals(fStructTerminalField1));
282 }
283
284 /**
285 * Test with same fields, but different values (should not be equal)
286 */
287 @Test
288 public void testNonEqualsValue() {
289 final String fieldName = "myfield";
290 final Object value1 = new String("test-string");
291 final Object value2 = new TmfEvent();
292 final TmfEventField[] fields = { fField1, fField2 };
293
294 final TmfEventField field1 = new TmfEventField(fieldName, value1, fields);
295 final TmfEventField field2 = new TmfEventField(fieldName, value2, fields);
296
297 assertNotEquals(field1, field2);
298 assertNotEquals(field2, field1);
299 }
300
301 /**
302 * Test with same value, but different fields (should not be equal)
303 */
304 @Test
305 public void testNonEqualsFields() {
306 final String fieldName = "myfield";
307 final Object value = new String("test-string");
308 final TmfEventField[] fields1 = { fField1, fField2 };
309 final TmfEventField[] fields2 = { fField2, fField3 };
310
311 final TmfEventField field1 = new TmfEventField(fieldName, value, fields1);
312 final TmfEventField field2 = new TmfEventField(fieldName, value, fields2);
313
314 assertNotEquals(field1, field2);
315 assertNotEquals(field2, field1);
316 }
317
318 /**
319 * Test with same field and values (should be equals)
320 */
321 @Test
322 public void testEqualsEverything() {
323 final String fieldName = "myfield";
324 final Object value = new String("test-string");
325 final TmfEventField[] fields = { fField1, fField2 };
326
327 final TmfEventField field1 = new TmfEventField(fieldName, value, fields);
328 final TmfEventField field2 = new TmfEventField(fieldName, value, fields);
329
330 assertEquals(field1, field2);
331 assertEquals(field2, field1);
332 }
333
334 // ------------------------------------------------------------------------
335 // toString
336 // ------------------------------------------------------------------------
337
338 @Test
339 public void testToString() {
340 final String expected1 = fFieldName1 + "=" + fValue1.toString();
341 TmfEventField field = new TmfEventField(fFieldName1, fValue1, null);
342 assertEquals("toString", expected1, field.toString());
343
344 final String expected2 = fFieldName1 + "=" + fValue2.toString();
345 field = new TmfEventField(fFieldName1, fValue2, null);
346 assertEquals("toString", expected2, field.toString());
347 }
348
349 // ------------------------------------------------------------------------
350 // makeRoot
351 // ------------------------------------------------------------------------
352
353 @Test
354 public void testMakeRoot() {
355 ITmfEventField root = TmfEventField.makeRoot(fStructFieldNames);
356 Collection<String> names = root.getFieldNames();
357 assertEquals("getFieldNames length", 2, names.size());
358 assertArrayEquals(fStructFieldNames, names.toArray(new String[names.size()]));
359
360 root = TmfEventField.makeRoot(fFieldNames);
361 names = root.getFieldNames();
362 assertEquals("getFieldNames length", 2, names.size());
363 assertArrayEquals(fFieldNames, names.toArray(new String[names.size()]));
364 }
365 }
This page took 0.0393289999999999 seconds and 5 git commands to generate.