1 /*******************************************************************************
2 * Copyright (c) 2009, 2013 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 * Francois Chouinard - Initial API and implementation
11 * Francois Chouinard - Adjusted for new Event Model
12 * Alexandre Montplaisir - Port to JUnit4
13 *******************************************************************************/
15 package org
.eclipse
.tracecompass
.tmf
.core
.tests
.event
;
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
;
26 import java
.util
.Collection
;
28 import org
.eclipse
.tracecompass
.tmf
.core
.event
.ITmfEventField
;
29 import org
.eclipse
.tracecompass
.tmf
.core
.event
.TmfEvent
;
30 import org
.eclipse
.tracecompass
.tmf
.core
.event
.TmfEventField
;
31 import org
.junit
.Test
;
34 * Test suite for the TmfEventField class.
36 @SuppressWarnings("javadoc")
37 public class TmfEventFieldTest
{
39 // ------------------------------------------------------------------------
41 // ------------------------------------------------------------------------
43 private final String fFieldName1
= "Field-1";
44 private final String fFieldName2
= "Field-2";
46 private final Object fValue1
= "Value";
47 private final Object fValue2
= Integer
.valueOf(10);
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);
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
});
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
});
66 // ------------------------------------------------------------------------
68 // ------------------------------------------------------------------------
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());
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
));
87 final Collection
<String
> names
= fStructRootField
.getFieldNames();
88 assertEquals("getFieldNames length", 2, names
.size());
89 assertArrayEquals(fStructFieldNames
, names
.toArray(new String
[names
.size()]));
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());
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
));
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
));
114 final Collection
<String
> names
= fRootField
.getFieldNames();
115 assertEquals("getFieldNames length", 2, names
.size());
116 assertArrayEquals(fFieldNames
, names
.toArray(new String
[names
.size()]));
120 public void testConstructorBadArg() {
122 new TmfEventField(null, fValue1
, null);
123 fail("Invalid (null) field name");
124 } catch (final IllegalArgumentException e
) {
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());
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
));
146 final Collection
<String
> names
= fRootField
.getFieldNames();
147 assertEquals("getFieldNames length", 2, names
.size());
148 assertArrayEquals(fFieldNames
, names
.toArray(new String
[names
.size()]));
152 public void testCopyConstructorBadArg() {
154 new TmfEventField(null);
155 fail("TmfEventField: null arguemnt");
156 } catch (final IllegalArgumentException e
) {
161 * Test that we correctly fail to create a field with subfields having the
165 public void testDuplicateFieldNames() {
166 ITmfEventField
[] fields
= {
167 new TmfEventField("samename", null, null),
168 new TmfEventField("samename", null, null)
172 new TmfEventField("field", null, fields
);
173 fail("TmfEventField: Duplicate field names");
174 } catch (IllegalArgumentException e
) {
175 /* Expected exception */
179 // ------------------------------------------------------------------------
181 // ------------------------------------------------------------------------
184 public void testHashCode() {
185 TmfEventField copy
= new TmfEventField(fField1
);
186 assertTrue("hashCode", fField1
.hashCode() == copy
.hashCode());
187 assertTrue("hashCode", fField1
.hashCode() != fField2
.hashCode());
189 copy
= new TmfEventField(fStructTerminalField1
);
190 assertTrue("hashCode", fStructTerminalField1
.hashCode() == copy
.hashCode());
191 assertTrue("hashCode", fStructTerminalField1
.hashCode() != fStructTerminalField2
.hashCode());
194 // ------------------------------------------------------------------------
196 // ------------------------------------------------------------------------
199 public void testEqualsReflexivity() {
200 assertTrue("equals", fField1
.equals(fField1
));
201 assertTrue("equals", fField2
.equals(fField2
));
203 assertFalse("equals", fField1
.equals(fField2
));
204 assertFalse("equals", fField2
.equals(fField1
));
206 assertTrue("equals", fStructTerminalField1
.equals(fStructTerminalField1
));
207 assertTrue("equals", fStructTerminalField2
.equals(fStructTerminalField2
));
209 assertFalse("equals", fStructTerminalField1
.equals(fStructTerminalField2
));
210 assertFalse("equals", fStructTerminalField2
.equals(fStructTerminalField1
));
214 public void testEqualsSymmetry() {
215 final TmfEventField copy0
= new TmfEventField(fField1
);
216 assertTrue("equals", fField1
.equals(copy0
));
217 assertTrue("equals", copy0
.equals(fField1
));
219 final TmfEventField copy3
= new TmfEventField(fField2
);
220 assertTrue("equals", fField2
.equals(copy3
));
221 assertTrue("equals", copy3
.equals(fField2
));
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
));
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
));
240 public void testEquals() {
241 assertTrue("equals", fStructTerminalField1
.equals(fStructTerminalField3
));
242 assertTrue("equals", fStructTerminalField3
.equals(fStructTerminalField1
));
244 assertFalse("equals", fStructTerminalField1
.equals(fField3
));
245 assertFalse("equals", fField3
.equals(fStructTerminalField1
));
249 public void testEqualsNull() {
250 assertFalse("equals", fField1
.equals(null));
251 assertFalse("equals", fField2
.equals(null));
255 public void testNonEqualClasses() {
256 assertFalse("equals", fField1
.equals(fStructTerminalField1
));
257 assertFalse("equals", fField1
.equals(fValue1
));
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
));
267 copy2
= new TmfEventField(fFieldName1
, fValue2
, null);
268 assertFalse("equals", copy1
.equals(copy2
));
269 assertFalse("equals", copy2
.equals(copy1
));
271 copy2
= new TmfEventField(fFieldName1
, null, null);
272 assertFalse("equals", copy1
.equals(copy2
));
273 assertFalse("equals", copy2
.equals(copy1
));
277 public void testNonEquals() {
278 assertFalse("equals", fField1
.equals(fField2
));
279 assertFalse("equals", fField2
.equals(fField1
));
281 assertFalse("equals", fField1
.equals(fStructTerminalField1
));
285 * Test with same fields, but different values (should not be equal)
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
};
294 final TmfEventField field1
= new TmfEventField(fieldName
, value1
, fields
);
295 final TmfEventField field2
= new TmfEventField(fieldName
, value2
, fields
);
297 assertNotEquals(field1
, field2
);
298 assertNotEquals(field2
, field1
);
302 * Test with same value, but different fields (should not be equal)
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
};
311 final TmfEventField field1
= new TmfEventField(fieldName
, value
, fields1
);
312 final TmfEventField field2
= new TmfEventField(fieldName
, value
, fields2
);
314 assertNotEquals(field1
, field2
);
315 assertNotEquals(field2
, field1
);
319 * Test with same field and values (should be equals)
322 public void testEqualsEverything() {
323 final String fieldName
= "myfield";
324 final Object value
= new String("test-string");
325 final TmfEventField
[] fields
= { fField1
, fField2
};
327 final TmfEventField field1
= new TmfEventField(fieldName
, value
, fields
);
328 final TmfEventField field2
= new TmfEventField(fieldName
, value
, fields
);
330 assertEquals(field1
, field2
);
331 assertEquals(field2
, field1
);
334 // ------------------------------------------------------------------------
336 // ------------------------------------------------------------------------
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());
344 final String expected2
= fFieldName1
+ "=" + fValue2
.toString();
345 field
= new TmfEventField(fFieldName1
, fValue2
, null);
346 assertEquals("toString", expected2
, field
.toString());
349 // ------------------------------------------------------------------------
351 // ------------------------------------------------------------------------
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()]));
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()]));