tmf/org.eclipse.tracecompass.tmf.core.tests/src/org/eclipse/tracecompass/tmf/core/tests/event/TmfEventFieldTest.java

   1 /*******************************************************************************
   2  * Copyright (c) 2009, 2014 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.tracecompass.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.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;
  33
  34 /**
  35  * Test suite for the TmfEventField class.
  36  */
  37 @SuppressWarnings("javadoc")
  38 public class TmfEventFieldTest {
  39
  40     // ------------------------------------------------------------------------
  41     // Variables
  42     // ------------------------------------------------------------------------
  43
  44     private final String fFieldName1 = "Field-1";
  45     private final String fFieldName2 = "Field-2";
  46
  47     private final Object fValue1 = "Value";
  48     private final Object fValue2 = Integer.valueOf(10);
  49
  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);
  53
  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 });
  61
  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 });
  66
  67     // ------------------------------------------------------------------------
  68     // Constructors
  69     // ------------------------------------------------------------------------
  70
  71     @Test
  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());
  78     }
  79
  80     @Test
  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));
  87
  88         final Collection<String> names = fStructRootField.getFieldNames();
  89         assertEquals("getFieldNames length", 2, names.size());
  90         assertArrayEquals(fStructFieldNames, names.toArray(new String[names.size()]));
  91     }
  92
  93     @Test
  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());
 100
 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));
 105     }
 106
 107     @Test
 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));
 114
 115         final Collection<String> names = fRootField.getFieldNames();
 116         assertEquals("getFieldNames length", 2, names.size());
 117         assertArrayEquals(fFieldNames, names.toArray(new String[names.size()]));
 118     }
 119
 120     @Test
 121     public void testConstructorBadArg() {
 122         try {
 123             new TmfEventField(null, fValue1, null);
 124             fail("Invalid (null) field name");
 125         } catch (final IllegalArgumentException e) {
 126         }
 127     }
 128
 129     @Test
 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());
 137     }
 138
 139     @Test
 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));
 146
 147         final Collection<String> names = fRootField.getFieldNames();
 148         assertEquals("getFieldNames length", 2, names.size());
 149         assertArrayEquals(fFieldNames, names.toArray(new String[names.size()]));
 150     }
 151
 152     @Test
 153     public void testCopyConstructorBadArg() {
 154         try {
 155             new TmfEventField(null);
 156             fail("TmfEventField: null arguemnt");
 157         } catch (final IllegalArgumentException e) {
 158         }
 159     }
 160
 161     /**
 162      * Test that we correctly fail to create a field with subfields having the
 163      * same name.
 164      */
 165     @Test
 166     public void testDuplicateFieldNames() {
 167         ITmfEventField[] fields = {
 168                 new TmfEventField("samename", null, null),
 169                 new TmfEventField("samename", null, null)
 170         };
 171
 172         try {
 173             new TmfEventField("field", null, fields);
 174             fail("TmfEventField: Duplicate field names");
 175         } catch (IllegalArgumentException e) {
 176             /* Expected exception */
 177         }
 178     }
 179
 180     // ------------------------------------------------------------------------
 181     // hashCode
 182     // ------------------------------------------------------------------------
 183
 184     @Test
 185     public void testHashCode() {
 186         TmfEventField copy = new TmfEventField(fField1);
 187         assertTrue("hashCode", fField1.hashCode() == copy.hashCode());
 188         assertTrue("hashCode", fField1.hashCode() != fField2.hashCode());
 189
 190         copy = new TmfEventField(fStructTerminalField1);
 191         assertTrue("hashCode", fStructTerminalField1.hashCode() == copy.hashCode());
 192         assertTrue("hashCode", fStructTerminalField1.hashCode() != fStructTerminalField2.hashCode());
 193     }
 194
 195     // ------------------------------------------------------------------------
 196     // equals
 197     // ------------------------------------------------------------------------
 198
 199     @Test
 200     public void testEqualsReflexivity() {
 201         assertTrue("equals", fField1.equals(fField1));
 202         assertTrue("equals", fField2.equals(fField2));
 203
 204         assertFalse("equals", fField1.equals(fField2));
 205         assertFalse("equals", fField2.equals(fField1));
 206
 207         assertTrue("equals", fStructTerminalField1.equals(fStructTerminalField1));
 208         assertTrue("equals", fStructTerminalField2.equals(fStructTerminalField2));
 209
 210         assertFalse("equals", fStructTerminalField1.equals(fStructTerminalField2));
 211         assertFalse("equals", fStructTerminalField2.equals(fStructTerminalField1));
 212     }
 213
 214     @Test
 215     public void testEqualsSymmetry() {
 216         final TmfEventField copy0 = new TmfEventField(fField1);
 217         assertTrue("equals", fField1.equals(copy0));
 218         assertTrue("equals", copy0.equals(fField1));
 219
 220         final TmfEventField copy3 = new TmfEventField(fField2);
 221         assertTrue("equals", fField2.equals(copy3));
 222         assertTrue("equals", copy3.equals(fField2));
 223     }
 224
 225     @Test
 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));
 232
 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));
 238     }
 239
 240     @Test
 241     public void testEquals() {
 242         assertTrue("equals", fStructTerminalField1.equals(fStructTerminalField3));
 243         assertTrue("equals", fStructTerminalField3.equals(fStructTerminalField1));
 244
 245         assertFalse("equals", fStructTerminalField1.equals(fField3));
 246         assertFalse("equals", fField3.equals(fStructTerminalField1));
 247     }
 248
 249     @Test
 250     public void testEqualsNull() {
 251         assertFalse("equals", fField1.equals(null));
 252         assertFalse("equals", fField2.equals(null));
 253     }
 254
 255     @Test
 256     public void testNonEqualClasses() {
 257         assertFalse("equals", fField1.equals(fStructTerminalField1));
 258         assertFalse("equals", fField1.equals(fValue1));
 259     }
 260
 261     @Test
 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));
 267
 268         copy2 = new TmfEventField(fFieldName1, fValue2, null);
 269         assertFalse("equals", copy1.equals(copy2));
 270         assertFalse("equals", copy2.equals(copy1));
 271
 272         copy2 = new TmfEventField(fFieldName1, null, null);
 273         assertFalse("equals", copy1.equals(copy2));
 274         assertFalse("equals", copy2.equals(copy1));
 275     }
 276
 277     @Test
 278     public void testNonEquals() {
 279         assertFalse("equals", fField1.equals(fField2));
 280         assertFalse("equals", fField2.equals(fField1));
 281
 282         assertFalse("equals", fField1.equals(fStructTerminalField1));
 283     }
 284
 285     /**
 286      * Test with same fields, but different values (should not be equal)
 287      */
 288     @Test
 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 };
 294
 295         final TmfEventField field1 = new TmfEventField(fieldName, value1, fields);
 296         final TmfEventField field2 = new TmfEventField(fieldName, value2, fields);
 297
 298         assertNotEquals(field1, field2);
 299         assertNotEquals(field2, field1);
 300     }
 301
 302     /**
 303      * Test with same value, but different fields (should not be equal)
 304      */
 305     @Test
 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 };
 311
 312         final TmfEventField field1 = new TmfEventField(fieldName, value, fields1);
 313         final TmfEventField field2 = new TmfEventField(fieldName, value, fields2);
 314
 315         assertNotEquals(field1, field2);
 316         assertNotEquals(field2, field1);
 317     }
 318
 319     /**
 320      * Test with same field and values (should be equals)
 321      */
 322     @Test
 323     public void testEqualsEverything() {
 324         final String fieldName = "myfield";
 325         final Object value = new String("test-string");
 326         final TmfEventField[] fields = { fField1, fField2 };
 327
 328         final TmfEventField field1 = new TmfEventField(fieldName, value, fields);
 329         final TmfEventField field2 = new TmfEventField(fieldName, value, fields);
 330
 331         assertEquals(field1, field2);
 332         assertEquals(field2, field1);
 333     }
 334
 335     // ------------------------------------------------------------------------
 336     // toString
 337     // ------------------------------------------------------------------------
 338
 339     @Test
 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());
 344
 345         final String expected2 = fFieldName1 + "=" + fValue2.toString();
 346         field = new TmfEventField(fFieldName1, fValue2, null);
 347         assertEquals("toString", expected2, field.toString());
 348     }
 349
 350     // ------------------------------------------------------------------------
 351     // makeRoot
 352     // ------------------------------------------------------------------------
 353
 354     @Test
 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()]));
 360
 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()]));
 365     }
 366 }