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