lttng/org.eclipse.tracecompass.lttng2.control.core.tests/src/org/eclipse/tracecompass/lttng2/control/core/tests/model/impl/BaseEventInfoTest.java

   1 /**********************************************************************
   2  * Copyright (c) 2012, 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  *   Bernd Hufmann - Initial API and implementation
  11  *   Alexandre Montplaisir - Port to JUnit4
  12  **********************************************************************/
  13
  14 package org.eclipse.tracecompass.lttng2.control.core.tests.model.impl;
  15
  16 import static org.junit.Assert.assertEquals;
  17 import static org.junit.Assert.assertNotNull;
  18 import static org.junit.Assert.assertTrue;
  19 import static org.junit.Assert.fail;
  20
  21 import java.util.LinkedList;
  22 import java.util.List;
  23
  24 import org.eclipse.tracecompass.internal.lttng2.control.core.model.IBaseEventInfo;
  25 import org.eclipse.tracecompass.internal.lttng2.control.core.model.IFieldInfo;
  26 import org.eclipse.tracecompass.internal.lttng2.control.core.model.TraceEventType;
  27 import org.eclipse.tracecompass.internal.lttng2.control.core.model.TraceLogLevel;
  28 import org.eclipse.tracecompass.internal.lttng2.control.core.model.impl.BaseEventInfo;
  29 import org.eclipse.tracecompass.internal.lttng2.control.core.model.impl.FieldInfo;
  30 import org.junit.Before;
  31 import org.junit.Test;
  32
  33 /**
  34  * The class <code>BaseEventInfoTest</code> contains test for the class
  35  * <code>{@link BaseEventInfo}</code>.
  36  */
  37 public class BaseEventInfoTest {
  38
  39     // ------------------------------------------------------------------------
  40     // Test data
  41     // ------------------------------------------------------------------------
  42
  43     private IBaseEventInfo fEventInfo1 = null;
  44     private IBaseEventInfo fEventInfo2 = null;
  45
  46     // ------------------------------------------------------------------------
  47     // Housekeeping
  48     // ------------------------------------------------------------------------
  49     /**
  50      * Perform pre-test initialization.
  51      */
  52     @Before
  53     public void setUp() {
  54         ModelImplFactory factory = new ModelImplFactory();
  55         fEventInfo1 = factory.getBaseEventInfo1();
  56         fEventInfo2 = factory.getBaseEventInfo2();
  57     }
  58
  59     // ------------------------------------------------------------------------
  60     // Tests
  61     // ------------------------------------------------------------------------
  62
  63     /**
  64      * Run the BaseEventInfo() constructor test.
  65      */
  66     @Test
  67     public void testBaseEventInfo() {
  68         BaseEventInfo fixture = new BaseEventInfo("event");
  69         assertNotNull(fixture);
  70
  71         TraceEventType result = fixture.getEventType();
  72
  73         assertEquals("event", fixture.getName());
  74         assertEquals("unknown", result.getInName());
  75         assertEquals("UNKNOWN", result.name());
  76         assertEquals("UNKNOWN", result.toString());
  77         assertEquals(4, result.ordinal());
  78
  79         TraceLogLevel level = fixture.getLogLevel();
  80         assertEquals("TRACE_DEBUG", level.getInName());
  81         assertEquals("TRACE_DEBUG", level.name());
  82         assertEquals("TRACE_DEBUG", level.toString());
  83         assertEquals(14, level.ordinal());
  84     }
  85
  86     /**
  87      * Test Copy Constructor
  88      */
  89     @Test
  90     public void testEventInfoCopy() {
  91         BaseEventInfo info = new BaseEventInfo((BaseEventInfo)fEventInfo1);
  92
  93         assertEquals(fEventInfo1.getName(), info.getName());
  94         assertEquals(fEventInfo1.getEventType(), info.getEventType());
  95         assertEquals(fEventInfo1.getLogLevel(), info.getLogLevel());
  96         assertEquals(fEventInfo1.getFilterExpression(), info.getFilterExpression());
  97
  98         IFieldInfo[] orignalFields = fEventInfo1.getFields();
  99         IFieldInfo[] copiedFields = info.getFields();
 100         assertEquals(orignalFields.length, copiedFields.length);
 101
 102         for (int i = 0; i < copiedFields.length; i++) {
 103             assertEquals(orignalFields[i], copiedFields[i]);
 104         }
 105     }
 106
 107     /**
 108      * Test Copy Constructor
 109      */
 110     @Test
 111     public void testEventCopy2() {
 112         try {
 113             BaseEventInfo info = null;
 114             new BaseEventInfo(info);
 115             fail("null copy");
 116         }
 117         catch (IllegalArgumentException e) {
 118             // Success
 119         }
 120     }
 121
 122     /**
 123      * Run the TraceEventType getEventType() method test.
 124      */
 125     @Test
 126     public void testGetEventType_1() {
 127         BaseEventInfo fixture = new BaseEventInfo("event");
 128         fixture.setEventType("unknown");
 129
 130         TraceEventType result = fixture.getEventType();
 131
 132         assertNotNull(result);
 133         assertEquals("unknown", result.getInName());
 134         assertEquals("UNKNOWN", result.name());
 135         assertEquals("UNKNOWN", result.toString());
 136         assertEquals(4, result.ordinal());
 137
 138         fixture.setEventType("");
 139         result = fixture.getEventType();
 140         assertEquals("unknown", result.getInName());
 141         assertEquals("UNKNOWN", result.name());
 142         assertEquals("UNKNOWN", result.toString());
 143         assertEquals(4, result.ordinal());
 144
 145         fixture.setEventType("tracepoint");
 146         result = fixture.getEventType();
 147         assertNotNull(result);
 148         assertEquals("tracepoint", result.getInName());
 149         assertEquals("TRACEPOINT", result.name());
 150         assertEquals("TRACEPOINT", result.toString());
 151         assertEquals(0, result.ordinal());
 152
 153         fixture.setEventType("syscall");
 154         result = fixture.getEventType();
 155         assertNotNull(result);
 156         assertEquals("syscall", result.getInName());
 157         assertEquals("SYSCALL", result.name());
 158         assertEquals("SYSCALL", result.toString());
 159         assertEquals(1, result.ordinal());
 160
 161         fixture.setEventType("probe");
 162         result = fixture.getEventType();
 163         assertNotNull(result);
 164         assertEquals("probe", result.getInName());
 165         assertEquals("PROBE", result.name());
 166         assertEquals("PROBE", result.toString());
 167         assertEquals(2, result.ordinal());
 168
 169         fixture.setEventType("function");
 170         result = fixture.getEventType();
 171         assertNotNull(result);
 172         assertEquals("function", result.getInName());
 173         assertEquals("FUNCTION", result.name());
 174         assertEquals("FUNCTION", result.toString());
 175         assertEquals(3, result.ordinal());
 176
 177
 178     }
 179
 180     /**
 181      * Run the void setEventType(TraceEventType) method test.
 182      */
 183     @Test
 184     public void testSetEventType_2() {
 185         BaseEventInfo fixture = new BaseEventInfo("event");
 186         fixture.setEventType(TraceEventType.TRACEPOINT);
 187
 188         TraceEventType result = fixture.getEventType();
 189
 190         assertNotNull(result);
 191         assertEquals("tracepoint", result.getInName());
 192         assertEquals("TRACEPOINT", result.name());
 193         assertEquals("TRACEPOINT", result.toString());
 194         assertEquals(0, result.ordinal());
 195
 196         fixture.setEventType(TraceEventType.UNKNOWN);
 197         result = fixture.getEventType();
 198
 199         assertNotNull(result);
 200         assertEquals("unknown", result.getInName());
 201         assertEquals("UNKNOWN", result.name());
 202         assertEquals("UNKNOWN", result.toString());
 203         assertEquals(4, result.ordinal());
 204
 205         fixture.setEventType(TraceEventType.SYSCALL);
 206         result = fixture.getEventType();
 207         assertNotNull(result);
 208         assertEquals("syscall", result.getInName());
 209         assertEquals("SYSCALL", result.name());
 210         assertEquals("SYSCALL", result.toString());
 211         assertEquals(1, result.ordinal());
 212
 213         fixture.setEventType(TraceEventType.PROBE);
 214         result = fixture.getEventType();
 215         assertNotNull(result);
 216         assertEquals("probe", result.getInName());
 217         assertEquals("PROBE", result.name());
 218         assertEquals("PROBE", result.toString());
 219         assertEquals(2, result.ordinal());
 220
 221         fixture.setEventType(TraceEventType.FUNCTION);
 222         result = fixture.getEventType();
 223         assertNotNull(result);
 224         assertEquals("function", result.getInName());
 225         assertEquals("FUNCTION", result.name());
 226         assertEquals("FUNCTION", result.toString());
 227         assertEquals(3, result.ordinal());
 228
 229
 230     }
 231
 232     /**
 233      * Run the void setLogLevel(TraceLogLevel) method test.
 234      * Run the TraceLogLevel getLogLevel() method test
 235      */
 236     @Test
 237     public void testSetLogLevel1() {
 238         BaseEventInfo fixture = new BaseEventInfo("event");
 239         fixture.setEventType(TraceEventType.TRACEPOINT);
 240         fixture.setLogLevel(TraceLogLevel.TRACE_CRIT);
 241
 242         // 2 set/get-operations are enough to test the method
 243         TraceLogLevel result = fixture.getLogLevel();
 244         assertNotNull(result);
 245         assertEquals("TRACE_CRIT", result.getInName());
 246         assertEquals("TRACE_CRIT", result.name());
 247         assertEquals("TRACE_CRIT", result.toString());
 248         assertEquals(2, result.ordinal());
 249
 250         fixture.setLogLevel(TraceLogLevel.TRACE_DEBUG_FUNCTION);
 251
 252         result = fixture.getLogLevel();
 253         assertNotNull(result);
 254         assertEquals("TRACE_DEBUG_FUNCTION", result.getInName());
 255         assertEquals("TRACE_DEBUG_FUNCTION", result.name());
 256         assertEquals("TRACE_DEBUG_FUNCTION", result.toString());
 257         assertEquals(12, result.ordinal());
 258     }
 259
 260     /**
 261      * Run the void setLogLevel(String) method test.
 262      * Run the TraceLogLevel getLogLevel() method test
 263      */
 264     @Test
 265     public void testSetLogLevel2() {
 266         BaseEventInfo fixture = new BaseEventInfo("event");
 267         fixture.setEventType(TraceEventType.TRACEPOINT);
 268         fixture.setLogLevel("TRACE_EMERG");
 269
 270         TraceLogLevel result = fixture.getLogLevel();
 271         assertNotNull(result);
 272         assertEquals("TRACE_EMERG", result.getInName());
 273         assertEquals("TRACE_EMERG", result.name());
 274         assertEquals(0, result.ordinal());
 275
 276         //------------------------
 277         fixture.setLogLevel("TRACE_ALERT");
 278
 279         result = fixture.getLogLevel();
 280         assertNotNull(result);
 281         assertEquals("TRACE_ALERT", result.getInName());
 282         assertEquals("TRACE_ALERT", result.name());
 283         assertEquals(1, result.ordinal());
 284
 285         //------------------------
 286         fixture.setLogLevel("TRACE_CRIT");
 287
 288         result = fixture.getLogLevel();
 289         assertNotNull(result);
 290         assertEquals("TRACE_CRIT", result.getInName());
 291         assertEquals("TRACE_CRIT", result.name());
 292         assertEquals(2, result.ordinal());
 293
 294         //------------------------
 295         fixture.setLogLevel("TRACE_ERR");
 296
 297         result = fixture.getLogLevel();
 298         assertNotNull(result);
 299         assertEquals("TRACE_ERR", result.getInName());
 300         assertEquals("TRACE_ERR", result.name());
 301         assertEquals(3, result.ordinal());
 302
 303         //------------------------
 304         fixture.setLogLevel("TRACE_WARNING");
 305
 306         result = fixture.getLogLevel();
 307         assertNotNull(result);
 308         assertEquals("TRACE_WARNING", result.getInName());
 309         assertEquals("TRACE_WARNING", result.name());
 310         assertEquals(4, result.ordinal());
 311
 312         //------------------------
 313         fixture.setLogLevel("TRACE_NOTICE");
 314
 315         result = fixture.getLogLevel();
 316         assertNotNull(result);
 317         assertEquals("TRACE_NOTICE", result.getInName());
 318         assertEquals("TRACE_NOTICE", result.name());
 319         assertEquals(5, result.ordinal());
 320
 321         //------------------------
 322         fixture.setLogLevel("TRACE_INFO");
 323
 324         result = fixture.getLogLevel();
 325         assertNotNull(result);
 326         assertEquals("TRACE_INFO", result.getInName());
 327         assertEquals("TRACE_INFO", result.name());
 328         assertEquals(6, result.ordinal());
 329
 330         //------------------------
 331         fixture.setLogLevel("TRACE_DEBUG_SYSTEM");
 332
 333         result = fixture.getLogLevel();
 334         assertNotNull(result);
 335         assertEquals("TRACE_DEBUG_SYSTEM", result.getInName());
 336         assertEquals("TRACE_DEBUG_SYSTEM", result.name());
 337         assertEquals(7, result.ordinal());
 338
 339         //------------------------
 340         fixture.setLogLevel("TRACE_DEBUG_PROGRAM");
 341
 342         result = fixture.getLogLevel();
 343         assertNotNull(result);
 344         assertEquals("TRACE_DEBUG_PROGRAM", result.getInName());
 345         assertEquals("TRACE_DEBUG_PROGRAM", result.name());
 346         assertEquals(8, result.ordinal());
 347
 348         //------------------------
 349         fixture.setLogLevel("TRACE_DEBUG_PROCESS");
 350
 351         result = fixture.getLogLevel();
 352         assertNotNull(result);
 353         assertEquals("TRACE_DEBUG_PROCESS", result.getInName());
 354         assertEquals("TRACE_DEBUG_PROCESS", result.name());
 355         assertEquals(9, result.ordinal());
 356
 357         //------------------------
 358         fixture.setLogLevel("TRACE_DEBUG_MODULE");
 359
 360         result = fixture.getLogLevel();
 361         assertNotNull(result);
 362         assertEquals("TRACE_DEBUG_MODULE", result.getInName());
 363         assertEquals("TRACE_DEBUG_MODULE", result.name());
 364         assertEquals(10, result.ordinal());
 365
 366         //------------------------
 367         fixture.setLogLevel("TRACE_DEBUG_UNIT");
 368
 369         result = fixture.getLogLevel();
 370         assertNotNull(result);
 371         assertEquals("TRACE_DEBUG_UNIT", result.getInName());
 372         assertEquals("TRACE_DEBUG_UNIT", result.name());
 373         assertEquals(11, result.ordinal());
 374
 375         //------------------------
 376         fixture.setLogLevel("TRACE_DEBUG_FUNCTION");
 377
 378         result = fixture.getLogLevel();
 379         assertNotNull(result);
 380         assertEquals("TRACE_DEBUG_FUNCTION", result.getInName());
 381         assertEquals("TRACE_DEBUG_FUNCTION", result.name());
 382         assertEquals(12, result.ordinal());
 383
 384         //------------------------
 385         fixture.setLogLevel("TRACE_DEBUG_LINE");
 386
 387         result = fixture.getLogLevel();
 388         assertNotNull(result);
 389         assertEquals("TRACE_DEBUG_LINE", result.getInName());
 390         assertEquals("TRACE_DEBUG_LINE", result.name());
 391         assertEquals(13, result.ordinal());
 392
 393         //------------------------
 394         fixture.setLogLevel("TRACE_DEBUG");
 395
 396         result = fixture.getLogLevel();
 397         assertNotNull(result);
 398         assertEquals("TRACE_DEBUG", result.getInName());
 399         assertEquals("TRACE_DEBUG", result.name());
 400         assertEquals(14, result.ordinal());
 401
 402         //-------------------------
 403         fixture.setLogLevel("LEVEL_UNKNOWN");
 404
 405         result = fixture.getLogLevel();
 406         assertNotNull(result);
 407         assertEquals("LEVEL_UNKNOWN", result.getInName());
 408         assertEquals("LEVEL_UNKNOWN", result.name());
 409         assertEquals(15, result.ordinal());
 410
 411         fixture.setLogLevel("garbage");
 412
 413         result = fixture.getLogLevel();
 414         assertNotNull(result);
 415         assertEquals("LEVEL_UNKNOWN", result.getInName());
 416         assertEquals("LEVEL_UNKNOWN", result.name());
 417         assertEquals(15, result.ordinal());
 418     }
 419
 420     /**
 421      * test filter expression
 422      */
 423     @Test
 424      public void testSetFields() {
 425          BaseEventInfo info = new BaseEventInfo((BaseEventInfo)fEventInfo2);
 426          info.setFilterExpression("stringfield==test");
 427          assertEquals("stringfield==test", info.getFilterExpression());
 428      }
 429
 430
 431    /**
 432     * test add field
 433     */
 434     @Test
 435     public void testAddField() {
 436         BaseEventInfo info = new BaseEventInfo((BaseEventInfo)fEventInfo2);
 437
 438         IFieldInfo field =  new FieldInfo("intfield");
 439         field.setFieldType("int");
 440
 441         info.addField(field);
 442
 443         // Verify the stored events
 444         IFieldInfo[] result = info.getFields();
 445
 446         assertNotNull(result);
 447         assertEquals(1, result.length);
 448         assertNotNull(result[0]);
 449         assertTrue(field.equals(result[0]));
 450     }
 451
 452     /**
 453      * test set fields
 454      */
 455     @Test
 456     public void testFields() {
 457         BaseEventInfo info = new BaseEventInfo((BaseEventInfo)fEventInfo2);
 458
 459         IFieldInfo field1 =  new FieldInfo("intfield");
 460         field1.setFieldType("int");
 461
 462         IFieldInfo field2 =  new FieldInfo("stringfield");
 463         field2.setFieldType("string");
 464
 465         List<IFieldInfo> fields = new LinkedList<>();
 466         fields.add(field1);
 467         fields.add(field2);
 468         info.setFields(fields);
 469
 470         // Verify the stored events
 471         IFieldInfo[] result = info.getFields();
 472
 473         assertNotNull(result);
 474         assertEquals(2, result.length);
 475
 476         for (int i = 0; i < result.length; i++) {
 477             assertNotNull(result[i]);
 478             assertTrue(fields.get(i).equals(result[i]));
 479         }
 480     }
 481
 482     /**
 483      * Run the String toString() method test.
 484      */
 485     @Test
 486     public void testToString_1() {
 487         BaseEventInfo fixture = new BaseEventInfo("event");
 488         fixture.setName("testName");
 489         fixture.setEventType(TraceEventType.TRACEPOINT);
 490         fixture.setLogLevel(TraceLogLevel.TRACE_ERR);
 491
 492         String result = fixture.toString();
 493
 494         // add additional test code here
 495         assertEquals("[BaseEventInfo([TraceInfo(Name=testName)],type=TRACEPOINT,level=TRACE_ERR)]", result);
 496     }
 497
 498     // ------------------------------------------------------------------------
 499     // equals
 500     // ------------------------------------------------------------------------
 501
 502     /**
 503      * Test the .equals() method.
 504      */
 505     @Test
 506     public void testEqualsReflexivity() {
 507         assertTrue("equals", fEventInfo1.equals(fEventInfo1));
 508         assertTrue("equals", fEventInfo2.equals(fEventInfo2));
 509
 510         assertTrue("equals", !fEventInfo1.equals(fEventInfo2));
 511         assertTrue("equals", !fEventInfo2.equals(fEventInfo1));
 512     }
 513
 514     /**
 515      * Test the .equals() method.
 516      */
 517     @Test
 518     public void testEqualsSymmetry() {
 519         BaseEventInfo info1 = new BaseEventInfo((BaseEventInfo)fEventInfo1);
 520         BaseEventInfo info2 = new BaseEventInfo((BaseEventInfo)fEventInfo2);
 521
 522         assertTrue("equals", info1.equals(fEventInfo1));
 523         assertTrue("equals", fEventInfo1.equals(info1));
 524
 525         assertTrue("equals", info2.equals(fEventInfo2));
 526         assertTrue("equals", fEventInfo2.equals(info2));
 527     }
 528
 529     /**
 530      * Test the .equals() method.
 531      */
 532     @Test
 533     public void testEqualsTransivity() {
 534         BaseEventInfo info1 = new BaseEventInfo((BaseEventInfo)fEventInfo1);
 535         BaseEventInfo info2 = new BaseEventInfo((BaseEventInfo)fEventInfo1);
 536         BaseEventInfo info3 = new BaseEventInfo((BaseEventInfo)fEventInfo1);
 537
 538         assertTrue("equals", info1.equals(info2));
 539         assertTrue("equals", info2.equals(info3));
 540         assertTrue("equals", info1.equals(info3));
 541     }
 542
 543     /**
 544      * Test the .equals() method.
 545      */
 546     @Test
 547     public void testEqualsNull() {
 548         assertTrue("equals", !fEventInfo1.equals(null));
 549         assertTrue("equals", !fEventInfo2.equals(null));
 550     }
 551
 552     // ------------------------------------------------------------------------
 553     // hashCode
 554     // ------------------------------------------------------------------------
 555
 556     /**
 557      * Test the hashCode() method.
 558      */
 559     @Test
 560     public void testHashCode() {
 561         BaseEventInfo info1 = new BaseEventInfo((BaseEventInfo)fEventInfo1);
 562         BaseEventInfo info2 = new BaseEventInfo((BaseEventInfo)fEventInfo2);
 563
 564         assertTrue("hashCode", fEventInfo1.hashCode() == info1.hashCode());
 565         assertTrue("hashCode", fEventInfo2.hashCode() == info2.hashCode());
 566
 567         assertTrue("hashCode", fEventInfo1.hashCode() != info2.hashCode());
 568         assertTrue("hashCode", fEventInfo2.hashCode() != info1.hashCode());
 569     }
 570 }