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 }