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
.eclipse
.tracecompass
.tmf
.core
.trace
.ITmfContext
;
32 import org
.junit
.Test
;
35 * Test suite for the TmfEventField class.
37 @SuppressWarnings("javadoc")
38 public class TmfEventFieldTest
{
40 // ------------------------------------------------------------------------
42 // ------------------------------------------------------------------------
44 private final String fFieldName1
= "Field-1";
45 private final String fFieldName2
= "Field-2";
47 private final Object fValue1
= "Value";
48 private final Object fValue2
= Integer
.valueOf(10);
50 private final TmfEventField fField1
= new TmfEventField(fFieldName1
, fValue1
, null);
51 private final TmfEventField fField2
= new TmfEventField(fFieldName2
, fValue2
, null);
52 private final TmfEventField fField3
= new TmfEventField(fFieldName1
, fValue2
, null);
54 private final String fStructRootFieldName
= "Root-S";
55 private final String
[] fStructFieldNames
= new String
[] { fFieldName1
, fFieldName2
};
56 private final TmfEventField fStructTerminalField1
= new TmfEventField(fFieldName1
, null, null);
57 private final TmfEventField fStructTerminalField2
= new TmfEventField(fFieldName2
, null, null);
58 private final TmfEventField fStructTerminalField3
= new TmfEventField(fFieldName1
, null, null);
59 private final TmfEventField fStructRootField
= new TmfEventField(fStructRootFieldName
, null,
60 new ITmfEventField
[] { fStructTerminalField1
, fStructTerminalField2
});
62 private final String fRootFieldName
= "Root";
63 private final String
[] fFieldNames
= new String
[] { fFieldName1
, fFieldName2
};
64 private final TmfEventField fRootField
= new TmfEventField(fRootFieldName
, null,
65 new ITmfEventField
[] { fField1
, fField2
});
67 // ------------------------------------------------------------------------
69 // ------------------------------------------------------------------------
72 public void testTerminalStructConstructor() {
73 assertSame("getName", fFieldName1
, fStructTerminalField1
.getName());
74 assertNull("getValue", fStructTerminalField1
.getValue());
75 assertEquals("getFields", 0, fStructTerminalField1
.getFields().size());
76 assertNull("getField(name)", fStructTerminalField1
.getField(fFieldName1
));
77 assertEquals("getFieldNames", 0, fStructTerminalField1
.getFieldNames().size());
81 public void testNonTerminalStructConstructor() {
82 assertSame("getName", fStructRootFieldName
, fStructRootField
.getName());
83 assertNull("getValue", fStructRootField
.getValue());
84 assertEquals("getFields", 2, fStructRootField
.getFields().size());
85 assertSame("getField(name)", fStructTerminalField1
, fStructRootField
.getField(fFieldName1
));
86 assertSame("getField(name)", fStructTerminalField2
, fStructRootField
.getField(fFieldName2
));
88 final Collection
<String
> names
= fStructRootField
.getFieldNames();
89 assertEquals("getFieldNames length", 2, names
.size());
90 assertArrayEquals(fStructFieldNames
, names
.toArray(new String
[names
.size()]));
94 public void testTerminalConstructor() {
95 assertSame("getName", fFieldName1
, fField1
.getName());
96 assertSame("getValue", fValue1
, fField1
.getValue());
97 assertEquals("getFields", 0, fField1
.getFields().size());
98 assertNull("getField(name)", fField1
.getField(fFieldName1
));
99 assertEquals("getFieldNames", 0, fField1
.getFieldNames().size());
101 assertSame("getName", fFieldName2
, fField2
.getName());
102 assertSame("getValue", fValue2
, fField2
.getValue());
103 assertEquals("getFields", 0, fField2
.getFields().size());
104 assertNull("getField(name)", fField2
.getField(fFieldName2
));
108 public void testNonTerminalConstructor() {
109 assertSame("getName", fRootFieldName
, fRootField
.getName());
110 assertNull("getValue", fRootField
.getValue());
111 assertEquals("getFields", 2, fRootField
.getFields().size());
112 assertSame("getField(name)", fField1
, fRootField
.getField(fFieldName1
));
113 assertSame("getField(name)", fField2
, fRootField
.getField(fFieldName2
));
115 final Collection
<String
> names
= fRootField
.getFieldNames();
116 assertEquals("getFieldNames length", 2, names
.size());
117 assertArrayEquals(fFieldNames
, names
.toArray(new String
[names
.size()]));
121 public void testConstructorBadArg() {
123 new TmfEventField(null, fValue1
, null);
124 fail("Invalid (null) field name");
125 } catch (final IllegalArgumentException e
) {
130 public void testTerminalCopyConstructor() {
131 final TmfEventField copy
= new TmfEventField(fField1
);
132 assertSame("getName", fFieldName1
, copy
.getName());
133 assertSame("getValue", fValue1
, copy
.getValue());
134 assertEquals("getFields", 0, copy
.getFields().size());
135 assertNull("getField(name)", copy
.getField(fFieldName1
));
136 assertEquals("getFieldNames", 0, copy
.getFieldNames().size());
140 public void testNonTerminalCopyConstructor() {
141 assertSame("getName", fRootFieldName
, fRootField
.getName());
142 assertNull("getValue", fRootField
.getValue());
143 assertEquals("getFields", 2, fRootField
.getFields().size());
144 assertSame("getField(name)", fField1
, fRootField
.getField(fFieldName1
));
145 assertSame("getField(name)", fField2
, fRootField
.getField(fFieldName2
));
147 final Collection
<String
> names
= fRootField
.getFieldNames();
148 assertEquals("getFieldNames length", 2, names
.size());
149 assertArrayEquals(fFieldNames
, names
.toArray(new String
[names
.size()]));
153 public void testCopyConstructorBadArg() {
155 new TmfEventField(null);
156 fail("TmfEventField: null arguemnt");
157 } catch (final IllegalArgumentException e
) {
162 * Test that we correctly fail to create a field with subfields having the
166 public void testDuplicateFieldNames() {
167 ITmfEventField
[] fields
= {
168 new TmfEventField("samename", null, null),
169 new TmfEventField("samename", null, null)
173 new TmfEventField("field", null, fields
);
174 fail("TmfEventField: Duplicate field names");
175 } catch (IllegalArgumentException e
) {
176 /* Expected exception */
180 // ------------------------------------------------------------------------
182 // ------------------------------------------------------------------------
185 public void testHashCode() {
186 TmfEventField copy
= new TmfEventField(fField1
);
187 assertTrue("hashCode", fField1
.hashCode() == copy
.hashCode());
188 assertTrue("hashCode", fField1
.hashCode() != fField2
.hashCode());
190 copy
= new TmfEventField(fStructTerminalField1
);
191 assertTrue("hashCode", fStructTerminalField1
.hashCode() == copy
.hashCode());
192 assertTrue("hashCode", fStructTerminalField1
.hashCode() != fStructTerminalField2
.hashCode());
195 // ------------------------------------------------------------------------
197 // ------------------------------------------------------------------------
200 public void testEqualsReflexivity() {
201 assertTrue("equals", fField1
.equals(fField1
));
202 assertTrue("equals", fField2
.equals(fField2
));
204 assertFalse("equals", fField1
.equals(fField2
));
205 assertFalse("equals", fField2
.equals(fField1
));
207 assertTrue("equals", fStructTerminalField1
.equals(fStructTerminalField1
));
208 assertTrue("equals", fStructTerminalField2
.equals(fStructTerminalField2
));
210 assertFalse("equals", fStructTerminalField1
.equals(fStructTerminalField2
));
211 assertFalse("equals", fStructTerminalField2
.equals(fStructTerminalField1
));
215 public void testEqualsSymmetry() {
216 final TmfEventField copy0
= new TmfEventField(fField1
);
217 assertTrue("equals", fField1
.equals(copy0
));
218 assertTrue("equals", copy0
.equals(fField1
));
220 final TmfEventField copy3
= new TmfEventField(fField2
);
221 assertTrue("equals", fField2
.equals(copy3
));
222 assertTrue("equals", copy3
.equals(fField2
));
226 public void testEqualsTransivity() {
227 TmfEventField copy1
= new TmfEventField(fField1
);
228 TmfEventField copy2
= new TmfEventField(copy1
);
229 assertTrue("equals", fField1
.equals(copy1
));
230 assertTrue("equals", copy1
.equals(copy2
));
231 assertTrue("equals", fField1
.equals(copy2
));
233 copy1
= new TmfEventField(fField2
);
234 copy2
= new TmfEventField(copy1
);
235 assertTrue("equals", fField2
.equals(copy1
));
236 assertTrue("equals", copy1
.equals(copy2
));
237 assertTrue("equals", fField2
.equals(copy2
));
241 public void testEquals() {
242 assertTrue("equals", fStructTerminalField1
.equals(fStructTerminalField3
));
243 assertTrue("equals", fStructTerminalField3
.equals(fStructTerminalField1
));
245 assertFalse("equals", fStructTerminalField1
.equals(fField3
));
246 assertFalse("equals", fField3
.equals(fStructTerminalField1
));
250 public void testEqualsNull() {
251 assertFalse("equals", fField1
.equals(null));
252 assertFalse("equals", fField2
.equals(null));
256 public void testNonEqualClasses() {
257 assertFalse("equals", fField1
.equals(fStructTerminalField1
));
258 assertFalse("equals", fField1
.equals(fValue1
));
262 public void testNonEqualValues() {
263 final TmfEventField copy1
= new TmfEventField(fFieldName1
, fValue1
, null);
264 TmfEventField copy2
= new TmfEventField(fFieldName1
, fValue1
, null);
265 assertTrue("equals", copy1
.equals(copy2
));
266 assertTrue("equals", copy2
.equals(copy1
));
268 copy2
= new TmfEventField(fFieldName1
, fValue2
, null);
269 assertFalse("equals", copy1
.equals(copy2
));
270 assertFalse("equals", copy2
.equals(copy1
));
272 copy2
= new TmfEventField(fFieldName1
, null, null);
273 assertFalse("equals", copy1
.equals(copy2
));
274 assertFalse("equals", copy2
.equals(copy1
));
278 public void testNonEquals() {
279 assertFalse("equals", fField1
.equals(fField2
));
280 assertFalse("equals", fField2
.equals(fField1
));
282 assertFalse("equals", fField1
.equals(fStructTerminalField1
));
286 * Test with same fields, but different values (should not be equal)
289 public void testNonEqualsValue() {
290 final String fieldName
= "myfield";
291 final Object value1
= new String("test-string");
292 final Object value2
= new TmfEvent(null, ITmfContext
.UNKNOWN_RANK
, null, null, null);
293 final TmfEventField
[] fields
= { fField1
, fField2
};
295 final TmfEventField field1
= new TmfEventField(fieldName
, value1
, fields
);
296 final TmfEventField field2
= new TmfEventField(fieldName
, value2
, fields
);
298 assertNotEquals(field1
, field2
);
299 assertNotEquals(field2
, field1
);
303 * Test with same value, but different fields (should not be equal)
306 public void testNonEqualsFields() {
307 final String fieldName
= "myfield";
308 final Object value
= new String("test-string");
309 final TmfEventField
[] fields1
= { fField1
, fField2
};
310 final TmfEventField
[] fields2
= { fField2
, fField3
};
312 final TmfEventField field1
= new TmfEventField(fieldName
, value
, fields1
);
313 final TmfEventField field2
= new TmfEventField(fieldName
, value
, fields2
);
315 assertNotEquals(field1
, field2
);
316 assertNotEquals(field2
, field1
);
320 * Test with same field and values (should be equals)
323 public void testEqualsEverything() {
324 final String fieldName
= "myfield";
325 final Object value
= new String("test-string");
326 final TmfEventField
[] fields
= { fField1
, fField2
};
328 final TmfEventField field1
= new TmfEventField(fieldName
, value
, fields
);
329 final TmfEventField field2
= new TmfEventField(fieldName
, value
, fields
);
331 assertEquals(field1
, field2
);
332 assertEquals(field2
, field1
);
335 // ------------------------------------------------------------------------
337 // ------------------------------------------------------------------------
340 public void testToString() {
341 final String expected1
= fFieldName1
+ "=" + fValue1
.toString();
342 TmfEventField field
= new TmfEventField(fFieldName1
, fValue1
, null);
343 assertEquals("toString", expected1
, field
.toString());
345 final String expected2
= fFieldName1
+ "=" + fValue2
.toString();
346 field
= new TmfEventField(fFieldName1
, fValue2
, null);
347 assertEquals("toString", expected2
, field
.toString());
350 // ------------------------------------------------------------------------
352 // ------------------------------------------------------------------------
355 public void testMakeRoot() {
356 ITmfEventField root
= TmfEventField
.makeRoot(fStructFieldNames
);
357 Collection
<String
> names
= root
.getFieldNames();
358 assertEquals("getFieldNames length", 2, names
.size());
359 assertArrayEquals(fStructFieldNames
, names
.toArray(new String
[names
.size()]));
361 root
= TmfEventField
.makeRoot(fFieldNames
);
362 names
= root
.getFieldNames();
363 assertEquals("getFieldNames length", 2, names
.size());
364 assertArrayEquals(fFieldNames
, names
.toArray(new String
[names
.size()]));