org.eclipse.linuxtools.lttng2.control.core.tests/src/org/eclipse/linuxtools/lttng2/control/core/tests/model/impl/EventInfoTest.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.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 org.eclipse.linuxtools.internal.lttng2.control.core.model.IEventInfo;
  22 import org.eclipse.linuxtools.internal.lttng2.control.core.model.LogLevelType;
  23 import org.eclipse.linuxtools.internal.lttng2.control.core.model.TraceEnablement;
  24 import org.eclipse.linuxtools.internal.lttng2.control.core.model.TraceEventType;
  25 import org.eclipse.linuxtools.internal.lttng2.control.core.model.impl.EventInfo;
  26 import org.junit.Before;
  27 import org.junit.Test;
  28
  29 /**
  30  * The class <code>EventInfoTest</code> contains test for the class
  31  * <code>{@link EventInfo}</code>.
  32  */
  33 public class EventInfoTest {
  34
  35     // ------------------------------------------------------------------------
  36     // Test data
  37     // ------------------------------------------------------------------------
  38
  39     private IEventInfo fEventInfo1 = null;
  40     private IEventInfo fEventInfo2 = null;
  41
  42     // ------------------------------------------------------------------------
  43     // Housekeeping
  44     // ------------------------------------------------------------------------
  45
  46     /**
  47      * Perform pre-test initialization.
  48      */
  49     @Before
  50     public void setUp() {
  51         ModelImplFactory factory = new ModelImplFactory();
  52         fEventInfo1 = factory.getEventInfo1();
  53         fEventInfo2 = factory.getEventInfo2();
  54     }
  55
  56     // ------------------------------------------------------------------------
  57     // Tests
  58     // ------------------------------------------------------------------------
  59
  60     /**
  61      * Run the EventInfo() constructor test.
  62      */
  63     @Test
  64     public void testBaseEventInfo() {
  65         EventInfo fixture = new EventInfo("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         TraceEnablement state = fixture.getState();
  77         assertEquals("disabled", state.getInName());
  78         assertEquals("DISABLED", state.name());
  79         assertEquals("DISABLED", state.toString());
  80         assertEquals(0, state.ordinal());
  81
  82         LogLevelType logType = fixture.getLogLevelType();
  83         assertEquals("", logType.getShortName());
  84         assertEquals("LOGLEVEL_NONE", logType.name());
  85         assertEquals("LOGLEVEL_NONE", logType.toString());
  86         assertEquals(0, state.ordinal());
  87
  88
  89     }
  90
  91     /**
  92      * Test Copy Constructor
  93      */
  94     @Test
  95     public void testEventInfoCopy() {
  96         EventInfo info = new EventInfo((EventInfo)fEventInfo1);
  97
  98         assertEquals(fEventInfo1.getName(), info.getName());
  99         assertEquals(fEventInfo1.getEventType(), info.getEventType());
 100         assertEquals(fEventInfo1.getState(), info.getState());
 101         assertEquals(fEventInfo1.getLogLevelType(), info.getLogLevelType());
 102     }
 103
 104     /**
 105      * Test Copy Constructor
 106      */
 107     @Test
 108     public void testEventCopy2() {
 109         try {
 110             EventInfo info = null;
 111             new EventInfo(info);
 112             fail("null copy");
 113         }
 114         catch (IllegalArgumentException e) {
 115             // Success
 116         }
 117     }
 118
 119     /**
 120      *  Getter/Setter tests
 121      */
 122     @Test
 123     public void testGetAndSetter() {
 124         EventInfo fixture = new EventInfo("event");
 125
 126         fixture.setEventType(TraceEventType.TRACEPOINT);
 127         TraceEventType result = fixture.getEventType();
 128
 129         // setEventType(TraceEventType type)
 130         assertNotNull(result);
 131         assertEquals("tracepoint", result.getInName());
 132         assertEquals("TRACEPOINT", result.name());
 133         assertEquals("TRACEPOINT", result.toString());
 134         assertEquals(0, result.ordinal());
 135
 136         fixture.setEventType(TraceEventType.UNKNOWN);
 137         result = fixture.getEventType();
 138         assertEquals("unknown", result.getInName());
 139         assertEquals("UNKNOWN", result.name());
 140         assertEquals("UNKNOWN", result.toString());
 141         assertEquals(4, result.ordinal());
 142
 143         // setEventType(String typeName)
 144         String typeName = "";
 145         fixture.setEventType(typeName);
 146         result = fixture.getEventType();
 147
 148         assertEquals("unknown", result.getInName());
 149         assertEquals("UNKNOWN", result.name());
 150         assertEquals("UNKNOWN", result.toString());
 151         assertEquals(4, result.ordinal());
 152
 153         typeName = "unknown";
 154
 155         fixture.setEventType(typeName);
 156         result = fixture.getEventType();
 157
 158         assertEquals("unknown", result.getInName());
 159         assertEquals("UNKNOWN", result.name());
 160         assertEquals("UNKNOWN", result.toString());
 161         assertEquals(4, result.ordinal());
 162
 163         // setState(String stateName)
 164         fixture.setState("disabled");
 165         TraceEnablement state = fixture.getState();
 166         assertEquals("disabled", state.getInName());
 167         assertEquals("DISABLED", state.name());
 168         assertEquals("DISABLED", state.toString());
 169         assertEquals(0, state.ordinal());
 170
 171         fixture.setState("false");
 172         state = fixture.getState();
 173         assertEquals("false", state.getInMiName());
 174         assertEquals("DISABLED", state.name());
 175         assertEquals("DISABLED", state.toString());
 176         assertEquals(0, state.ordinal());
 177
 178         fixture.setState("bla");
 179         state = fixture.getState();
 180         assertEquals("disabled", state.getInName());
 181         assertEquals("DISABLED", state.name());
 182         assertEquals("DISABLED", state.toString());
 183         assertEquals(0, state.ordinal());
 184
 185         fixture.setState("enabled");
 186         state = fixture.getState();
 187         assertEquals("enabled", state.getInName());
 188         assertEquals("ENABLED", state.name());
 189         assertEquals("ENABLED", state.toString());
 190         assertEquals(1, state.ordinal());
 191
 192         fixture.setState("true");
 193         state = fixture.getState();
 194         assertEquals("true", state.getInMiName());
 195         assertEquals("ENABLED", state.name());
 196         assertEquals("ENABLED", state.toString());
 197         assertEquals(1, state.ordinal());
 198
 199         // setState(TraceEnablement state)
 200         fixture.setState(TraceEnablement.DISABLED);
 201         state = fixture.getState();
 202         assertEquals("disabled", state.getInName());
 203         assertEquals("DISABLED", state.name());
 204         assertEquals("DISABLED", state.toString());
 205         assertEquals(0, state.ordinal());
 206
 207         fixture.setState(TraceEnablement.ENABLED);
 208         state = fixture.getState();
 209         assertEquals("enabled", state.getInName());
 210         assertEquals("ENABLED", state.name());
 211         assertEquals("ENABLED", state.toString());
 212         assertEquals(1, state.ordinal());
 213
 214         // setLogLevelType(String name)
 215         fixture.setLogLevelType("==");
 216         assertEquals("LOGLEVEL_ONLY", fixture.getLogLevelType().name());
 217         assertEquals("==", fixture.getLogLevelType().getShortName());
 218
 219         fixture.setLogLevelType("<=");
 220         assertEquals("LOGLEVEL", fixture.getLogLevelType().name());
 221         assertEquals("<=", fixture.getLogLevelType().getShortName());
 222
 223         fixture.setLogLevelType("");
 224         assertEquals("LOGLEVEL_ALL", fixture.getLogLevelType().name());
 225         assertEquals("", fixture.getLogLevelType().getShortName());
 226
 227         fixture.setLogLevelType(LogLevelType.LOGLEVEL_ONLY);
 228         assertEquals("LOGLEVEL_ONLY", fixture.getLogLevelType().name());
 229         assertEquals("==", fixture.getLogLevelType().getShortName());
 230
 231         fixture.setLogLevelType(LogLevelType.LOGLEVEL);
 232         assertEquals("LOGLEVEL", fixture.getLogLevelType().name());
 233         assertEquals("<=", fixture.getLogLevelType().getShortName());
 234
 235         fixture.setLogLevelType(LogLevelType.LOGLEVEL_ALL);
 236         assertEquals("LOGLEVEL_ALL", fixture.getLogLevelType().name());
 237         assertEquals("", fixture.getLogLevelType().getShortName());
 238
 239         fixture.setLogLevelType(LogLevelType.LOGLEVEL_NONE);
 240         assertEquals("LOGLEVEL_NONE", fixture.getLogLevelType().name());
 241         assertEquals("", fixture.getLogLevelType().getShortName());
 242
 243         // setLogLevelType(String name)
 244         // machine interface
 245         fixture.setLogLevelType("SINGLE");
 246         assertEquals("LOGLEVEL_ONLY", fixture.getLogLevelType().name());
 247         assertEquals("SINGLE", fixture.getLogLevelType().getMiName());
 248
 249         fixture.setLogLevelType("RANGE");
 250         assertEquals("LOGLEVEL", fixture.getLogLevelType().name());
 251         assertEquals("RANGE", fixture.getLogLevelType().getMiName());
 252
 253         fixture.setLogLevelType("ALL");
 254         assertEquals("LOGLEVEL_ALL", fixture.getLogLevelType().name());
 255         assertEquals("ALL", fixture.getLogLevelType().getMiName());
 256
 257         fixture.setLogLevelType("UNKNOWN");
 258         assertEquals("LOGLEVEL_NONE", fixture.getLogLevelType().name());
 259         assertEquals("UNKNOWN", fixture.getLogLevelType().getMiName());
 260
 261     }
 262
 263     /**
 264      * Run the String toString() method test.
 265      */
 266     @Test
 267     public void testToString_1() {
 268         EventInfo fixture = new EventInfo("event");
 269         fixture.setName("testName");
 270         fixture.setEventType(TraceEventType.TRACEPOINT);
 271
 272         String result = fixture.toString();
 273
 274         // add additional test code here
 275         assertEquals("[EventInfo([BaseEventInfo([TraceInfo(Name=testName)],type=TRACEPOINT,level=TRACE_DEBUG)],State=DISABLED,levelType=LOGLEVEL_NONE)]", result);
 276     }
 277
 278     /**
 279      * Run the String toString() method test.
 280      */
 281     @Test
 282     public void testToString_2() {
 283         EventInfo fixture = new EventInfo("event");
 284         fixture.setName("testName");
 285         fixture.setEventType(TraceEventType.TRACEPOINT);
 286         fixture.setLogLevelType(LogLevelType.LOGLEVEL_ONLY);
 287
 288         String result = fixture.toString();
 289
 290         // add additional test code here
 291         assertEquals("[EventInfo([BaseEventInfo([TraceInfo(Name=testName)],type=TRACEPOINT,level=TRACE_DEBUG)],State=DISABLED,levelType=LOGLEVEL_ONLY)]", result);
 292     }
 293
 294     // ------------------------------------------------------------------------
 295     // equals
 296     // ------------------------------------------------------------------------
 297
 298     /**
 299      * Run the equals() method test.
 300      */
 301     @Test
 302     public void testEqualsReflexivity() {
 303         assertTrue("equals", fEventInfo1.equals(fEventInfo1));
 304         assertTrue("equals", fEventInfo2.equals(fEventInfo2));
 305
 306         assertTrue("equals", !fEventInfo1.equals(fEventInfo2));
 307         assertTrue("equals", !fEventInfo2.equals(fEventInfo1));
 308     }
 309
 310     /**
 311      * Run the equals() method test.
 312      */
 313     @Test
 314     public void testEqualsSymmetry() {
 315         EventInfo info1 = new EventInfo((EventInfo)fEventInfo1);
 316         EventInfo info2 = new EventInfo((EventInfo)fEventInfo2);
 317
 318         assertTrue("equals", info1.equals(fEventInfo1));
 319         assertTrue("equals", fEventInfo1.equals(info1));
 320
 321         assertTrue("equals", info2.equals(fEventInfo2));
 322         assertTrue("equals", fEventInfo2.equals(info2));
 323     }
 324
 325     /**
 326      * Run the equals() method test.
 327      */
 328     @Test
 329     public void testEqualsTransivity() {
 330         EventInfo info1 = new EventInfo((EventInfo)fEventInfo1);
 331         EventInfo info2 = new EventInfo((EventInfo)fEventInfo1);
 332         EventInfo info3 = new EventInfo((EventInfo)fEventInfo1);
 333
 334         assertTrue("equals", info1.equals(info2));
 335         assertTrue("equals", info2.equals(info3));
 336         assertTrue("equals", info1.equals(info3));
 337     }
 338
 339     /**
 340      * Run the equals() method test.
 341      */
 342     @Test
 343     public void testEqualsNull() {
 344         assertTrue("equals", !fEventInfo1.equals(null));
 345         assertTrue("equals", !fEventInfo2.equals(null));
 346     }
 347
 348     // ------------------------------------------------------------------------
 349     // hashCode
 350     // ------------------------------------------------------------------------
 351
 352     /**
 353      * Run the hashCode() method test.
 354      */
 355     @Test
 356     public void testHashCode() {
 357         EventInfo info1 = new EventInfo((EventInfo)fEventInfo1);
 358         EventInfo info2 = new EventInfo((EventInfo)fEventInfo2);
 359
 360         assertTrue("hashCode", fEventInfo1.hashCode() == info1.hashCode());
 361         assertTrue("hashCode", fEventInfo2.hashCode() == info2.hashCode());
 362
 363         assertTrue("hashCode", fEventInfo1.hashCode() != info2.hashCode());
 364         assertTrue("hashCode", fEventInfo2.hashCode() != info1.hashCode());
 365     }
 366 }