org.eclipse.linuxtools.lttng2.core.tests/src/org/eclipse/linuxtools/lttng2/core/tests/control/model/impl/ChannelInfoTest.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.IChannelInfo;
  22 import org.eclipse.linuxtools.internal.lttng2.core.control.model.IEventInfo;
  23 import org.eclipse.linuxtools.internal.lttng2.core.control.model.TraceEnablement;
  24 import org.eclipse.linuxtools.internal.lttng2.core.control.model.impl.ChannelInfo;
  25 import org.eclipse.linuxtools.internal.lttng2.core.control.model.impl.EventInfo;
  26 import org.junit.Before;
  27 import org.junit.Test;
  28
  29 /**
  30  * The class <code>ChannelInfoTest</code> contains tests for the class
  31  * <code>{@link ChannelInfo}</code>.
  32  */
  33 @SuppressWarnings("nls")
  34 public class ChannelInfoTest {
  35
  36     // ------------------------------------------------------------------------
  37     // Test data
  38     // ------------------------------------------------------------------------
  39
  40     private IChannelInfo fChannelInfo1 = null;
  41     private IChannelInfo fChannelInfo2 = null;
  42
  43     // ------------------------------------------------------------------------
  44     // Housekeeping
  45     // ------------------------------------------------------------------------
  46
  47     /**
  48      * Perform pre-test initialization.
  49      */
  50     @Before
  51     public void setUp() {
  52         ModelImplFactory factory = new ModelImplFactory();
  53         fChannelInfo1 = factory.getChannel1();
  54         fChannelInfo2 = factory.getChannel2();
  55     }
  56
  57     // ------------------------------------------------------------------------
  58     // Tests
  59     // ------------------------------------------------------------------------
  60
  61     // ------------------------------------------------------------------------
  62     // Constructors
  63     // ------------------------------------------------------------------------
  64
  65     /**
  66      * Run the ChannelInfo() constructor test.
  67      */
  68     @Test
  69     public void testChannelInfo() {
  70         ChannelInfo result = new ChannelInfo("test");
  71         assertNotNull(result);
  72
  73         assertEquals("test", result.getName());
  74         assertEquals(0, result.getNumberOfSubBuffers());
  75         assertEquals("", result.getOutputType());
  76         assertEquals(false, result.isOverwriteMode());
  77         assertEquals(0, result.getReadTimer());
  78         assertEquals("disabled", result.getState().getInName());
  79         assertEquals(0, result.getSubBufferSize());
  80         assertEquals(0, result.getSwitchTimer());
  81     }
  82
  83     /**
  84      * Test copy constructor.
  85      */
  86     @Test
  87     public void testChannelInfoCopy() {
  88         ChannelInfo channelInfo = new ChannelInfo((ChannelInfo)fChannelInfo1);
  89
  90         assertEquals(fChannelInfo1.getName(), channelInfo.getName());
  91         assertEquals(fChannelInfo1.getNumberOfSubBuffers(), channelInfo.getNumberOfSubBuffers());
  92         assertEquals(fChannelInfo1.getOutputType(), channelInfo.getOutputType());
  93         assertEquals(fChannelInfo1.isOverwriteMode(), channelInfo.isOverwriteMode());
  94         assertEquals(fChannelInfo1.getReadTimer(), channelInfo.getReadTimer());
  95         assertEquals(fChannelInfo1.getState(), channelInfo.getState());
  96         assertEquals(fChannelInfo1.getSwitchTimer(), channelInfo.getSwitchTimer());
  97         assertEquals(fChannelInfo1.getEvents().length, channelInfo.getEvents().length);
  98
  99         IEventInfo[] orignalEvents = fChannelInfo1.getEvents();
 100         IEventInfo[] resultEvents = channelInfo.getEvents();
 101         for (int i = 0; i < orignalEvents.length; i++) {
 102             assertEquals(orignalEvents[i], resultEvents[i]);
 103         }
 104     }
 105
 106     /**
 107      * Test copy constructor with a null value.
 108      */
 109     @Test
 110     public void testChannelCopy2() {
 111         try {
 112             ChannelInfo channel = null;
 113             new ChannelInfo(channel);
 114             fail("null copy");
 115         }
 116         catch (IllegalArgumentException e) {
 117             // Success
 118         }
 119     }
 120
 121     /**
 122      * Run the IEventInfo[] getEvents() method test.
 123      */
 124     @Test
 125     public void testAddAndGetEvents_1() {
 126         ChannelInfo fixture = new ChannelInfo("test");
 127         fixture.setSwitchTimer(1L);
 128         fixture.setOverwriteMode(true);
 129         fixture.setReadTimer(1L);
 130         fixture.setState(TraceEnablement.DISABLED);
 131         fixture.setNumberOfSubBuffers(1);
 132         fixture.setOutputType("");
 133         fixture.setSubBufferSize(1L);
 134
 135         // add an event
 136         IEventInfo event = new EventInfo("event");
 137         fixture.addEvent(event);
 138
 139         // Verify the stored events
 140         IEventInfo[] result = fixture.getEvents();
 141
 142         assertNotNull(result);
 143         assertEquals(1, result.length);
 144         assertNotNull(result[0]);
 145         assertTrue(event.equals(result[0]));
 146     }
 147
 148     /**
 149      * Run the long getNumberOfSubBuffers() method test.
 150      */
 151     @Test
 152     public void testGetAndSetters() {
 153         ChannelInfo fixture = new ChannelInfo("test");
 154         fixture.setSwitchTimer(2L);
 155         fixture.setOverwriteMode(true);
 156         fixture.setReadTimer(3L);
 157         fixture.setState(TraceEnablement.DISABLED);
 158         fixture.setNumberOfSubBuffers(4);
 159         fixture.setOutputType("splice()");
 160         fixture.setSubBufferSize(1L);
 161         fixture.addEvent(new EventInfo("event"));
 162
 163         long switchTimer = fixture.getSwitchTimer();
 164         assertEquals(2L, switchTimer);
 165
 166         boolean mode = fixture.isOverwriteMode();
 167         assertTrue(mode);
 168
 169         long readTimer = fixture.getReadTimer();
 170         assertEquals(3L, readTimer);
 171
 172         TraceEnablement state = fixture.getState();
 173         assertEquals("disabled", state.getInName());
 174
 175         long numSubBuffers = fixture.getNumberOfSubBuffers();
 176         assertEquals(4, numSubBuffers);
 177
 178         String outputType = fixture.getOutputType();
 179         assertEquals("splice()", outputType);
 180
 181         long subBufferSize = fixture.getSubBufferSize();
 182         assertEquals(1L, subBufferSize);
 183
 184         fixture.setSwitchTimer(5L);
 185         fixture.setOverwriteMode(false);
 186         fixture.setReadTimer(6L);
 187         fixture.setState(TraceEnablement.ENABLED);
 188         fixture.setNumberOfSubBuffers(7);
 189         fixture.setOutputType("mmap()");
 190         fixture.setSubBufferSize(8L);
 191
 192         switchTimer = fixture.getSwitchTimer();
 193         assertEquals(5L, switchTimer);
 194
 195         mode = fixture.isOverwriteMode();
 196         assertFalse(mode);
 197
 198         readTimer = fixture.getReadTimer();
 199         assertEquals(6L, readTimer);
 200
 201         state = fixture.getState();
 202         assertEquals("enabled", state.getInName());
 203
 204         numSubBuffers = fixture.getNumberOfSubBuffers();
 205         assertEquals(7, numSubBuffers);
 206
 207         outputType = fixture.getOutputType();
 208         assertEquals("mmap()", outputType);
 209
 210         subBufferSize = fixture.getSubBufferSize();
 211         assertEquals(8L, subBufferSize);
 212     }
 213
 214     /**
 215      * Run the void setEvents(List<IEventInfo>) method test.
 216      */
 217     @Test
 218     public void testSetEvents_1() {
 219         ChannelInfo fixture = new ChannelInfo("test");
 220         fixture.setSwitchTimer(1L);
 221         fixture.setOverwriteMode(true);
 222         fixture.setReadTimer(1L);
 223         fixture.setState(TraceEnablement.DISABLED);
 224         fixture.setNumberOfSubBuffers(1);
 225         fixture.setOutputType("");
 226         fixture.setSubBufferSize(1L);
 227         List<IEventInfo> events = new LinkedList<IEventInfo>();
 228
 229         for (int i = 0; i < 2; i++) {
 230             IEventInfo info = new EventInfo("event" + i);
 231             info.setEventType("tracepoint");
 232             info.setState((i % 2 == 0 ? "enabled" : "disabled"));
 233             events.add(info);
 234         }
 235
 236         fixture.setEvents(events);
 237
 238         IEventInfo[] infos = fixture.getEvents();
 239
 240         assertEquals(events.size(), infos.length);
 241
 242         for (int i = 0; i < infos.length; i++) {
 243             assertEquals(events.get(i), infos[i]);
 244         }
 245     }
 246
 247     /**
 248      * Run the String toString() method test.
 249      */
 250     @Test
 251     public void testToString_1() {
 252         ChannelInfo fixture = new ChannelInfo("channel");
 253         fixture.setSwitchTimer(1L);
 254         fixture.setOverwriteMode(true);
 255         fixture.setReadTimer(1L);
 256         fixture.setState(TraceEnablement.DISABLED);
 257         fixture.setNumberOfSubBuffers(1);
 258         fixture.setOutputType("splice()");
 259         fixture.setSubBufferSize(1L);
 260
 261         String result = fixture.toString();
 262
 263         // add additional test code here
 264         assertEquals("[ChannelInfo([TraceInfo(Name=channel)],State=DISABLED,OverwriteMode=true,SubBuffersSize=1,NumberOfSubBuffers=1,SwitchTimer=1,ReadTimer=1,output=splice(),Events=None)]", result);
 265     }
 266
 267     /**
 268      * Run another String toString() method test.
 269      */
 270     @Test
 271     public void testToString_2() {
 272         String result = fChannelInfo1.toString();
 273
 274         // add additional test code here
 275         assertEquals("[ChannelInfo([TraceInfo(Name=channel1)],State=DISABLED,OverwriteMode=true,SubBuffersSize=13,NumberOfSubBuffers=12,SwitchTimer=10,ReadTimer=11,output=splice(),Events=[EventInfo([BaseEventInfo([TraceInfo(Name=event1)],type=TRACEPOINT,level=TRACE_DEBUG)],State=ENABLED)])]", result);
 276     }
 277
 278     // ------------------------------------------------------------------------
 279     // equals
 280     // ------------------------------------------------------------------------
 281
 282     /**
 283      * Run the equals() method test.
 284      */
 285     @Test
 286     public void testEqualsReflexivity() {
 287         assertTrue("equals", fChannelInfo1.equals(fChannelInfo1));
 288         assertTrue("equals", fChannelInfo2.equals(fChannelInfo2));
 289
 290         assertTrue("equals", !fChannelInfo1.equals(fChannelInfo2));
 291         assertTrue("equals", !fChannelInfo2.equals(fChannelInfo1));
 292     }
 293
 294     /**
 295      * Run the equals() method test.
 296      */
 297     @Test
 298     public void testEqualsSymmetry() {
 299         ChannelInfo event1 = new ChannelInfo((ChannelInfo)fChannelInfo1);
 300         ChannelInfo event2 = new ChannelInfo((ChannelInfo)fChannelInfo2);
 301
 302         assertTrue("equals", event1.equals(fChannelInfo1));
 303         assertTrue("equals", fChannelInfo1.equals(event1));
 304
 305         assertTrue("equals", event2.equals(fChannelInfo2));
 306         assertTrue("equals", fChannelInfo2.equals(event2));
 307     }
 308
 309     /**
 310      * Run the equals() method test.
 311      */
 312     @Test
 313     public void testEqualsTransivity() {
 314         ChannelInfo channel1 = new ChannelInfo((ChannelInfo)fChannelInfo1);
 315         ChannelInfo channel2 = new ChannelInfo((ChannelInfo)fChannelInfo1);
 316         ChannelInfo channel3 = new ChannelInfo((ChannelInfo)fChannelInfo1);
 317
 318         assertTrue("equals", channel1.equals(channel2));
 319         assertTrue("equals", channel2.equals(channel3));
 320         assertTrue("equals", channel1.equals(channel3));
 321     }
 322
 323     /**
 324      * Run the equals() method test.
 325      */
 326     @Test
 327     public void testEqualsNull() {
 328         assertTrue("equals", !fChannelInfo1.equals(null));
 329         assertTrue("equals", !fChannelInfo2.equals(null));
 330     }
 331
 332     // ------------------------------------------------------------------------
 333     // hashCode
 334     // ------------------------------------------------------------------------
 335
 336     /**
 337      * Run the hashCode() method test.
 338      */
 339     @Test
 340     public void testHashCode() {
 341         ChannelInfo channel1 = new ChannelInfo((ChannelInfo)fChannelInfo1);
 342         ChannelInfo channel2 = new ChannelInfo((ChannelInfo)fChannelInfo2);
 343
 344         assertTrue("hashCode", fChannelInfo1.hashCode() == channel1.hashCode());
 345         assertTrue("hashCode", fChannelInfo2.hashCode() == channel2.hashCode());
 346
 347         assertTrue("hashCode", fChannelInfo1.hashCode() != channel2.hashCode());
 348         assertTrue("hashCode", fChannelInfo2.hashCode() != channel1.hashCode());
 349     }
 350 }