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

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