org.eclipse.linuxtools.lttng2.control.core.tests/src/org/eclipse/linuxtools/lttng2/control/core/tests/model/impl/ChannelInfoTest.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.IChannelInfo;
  22 import org.eclipse.linuxtools.internal.lttng2.control.core.model.IEventInfo;
  23 import org.eclipse.linuxtools.internal.lttng2.control.core.model.TraceEnablement;
  24 import org.eclipse.linuxtools.internal.lttng2.control.core.model.impl.BufferType;
  25 import org.eclipse.linuxtools.internal.lttng2.control.core.model.impl.ChannelInfo;
  26 import org.eclipse.linuxtools.internal.lttng2.control.core.model.impl.EventInfo;
  27 import org.junit.Before;
  28 import org.junit.Test;
  29
  30 /**
  31  * The class <code>ChannelInfoTest</code> contains tests for the class
  32  * <code>{@link ChannelInfo}</code>.
  33  */
  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         assertEquals(0, result.getMaxSizeTraceFiles());
  82         assertEquals(0, result.getMaxNumberTraceFiles());
  83         assertEquals(BufferType.BUFFER_TYPE_UNKNOWN, result.getBufferType());
  84     }
  85
  86     /**
  87      * Test copy constructor.
  88      */
  89     @Test
  90     public void testChannelInfoCopy() {
  91         ChannelInfo channelInfo = new ChannelInfo((ChannelInfo)fChannelInfo1);
  92
  93         assertEquals(fChannelInfo1.getName(), channelInfo.getName());
  94         assertEquals(fChannelInfo1.getNumberOfSubBuffers(), channelInfo.getNumberOfSubBuffers());
  95         assertEquals(fChannelInfo1.getOutputType(), channelInfo.getOutputType());
  96         assertEquals(fChannelInfo1.isOverwriteMode(), channelInfo.isOverwriteMode());
  97         assertEquals(fChannelInfo1.getReadTimer(), channelInfo.getReadTimer());
  98         assertEquals(fChannelInfo1.getState(), channelInfo.getState());
  99         assertEquals(fChannelInfo1.getSwitchTimer(), channelInfo.getSwitchTimer());
 100         assertEquals(fChannelInfo1.getEvents().length, channelInfo.getEvents().length);
 101         assertEquals(fChannelInfo1.getMaxSizeTraceFiles(), channelInfo.getMaxSizeTraceFiles());
 102         assertEquals(fChannelInfo1.getMaxNumberTraceFiles(), channelInfo.getMaxNumberTraceFiles());
 103         assertEquals(fChannelInfo1.getBufferType(), channelInfo.getBufferType());
 104
 105         IEventInfo[] orignalEvents = fChannelInfo1.getEvents();
 106         IEventInfo[] resultEvents = channelInfo.getEvents();
 107         for (int i = 0; i < orignalEvents.length; i++) {
 108             assertEquals(orignalEvents[i], resultEvents[i]);
 109         }
 110     }
 111
 112     /**
 113      * Test copy constructor with a null value.
 114      */
 115     @Test
 116     public void testChannelCopy2() {
 117         try {
 118             ChannelInfo channel = null;
 119             new ChannelInfo(channel);
 120             fail("null copy");
 121         }
 122         catch (IllegalArgumentException e) {
 123             // Success
 124         }
 125     }
 126
 127     /**
 128      * Run the IEventInfo[] getEvents() method test.
 129      */
 130     @Test
 131     public void testAddAndGetEvents_1() {
 132         ChannelInfo fixture = new ChannelInfo("test");
 133         fixture.setSwitchTimer(1L);
 134         fixture.setOverwriteMode(true);
 135         fixture.setReadTimer(1L);
 136         fixture.setState(TraceEnablement.DISABLED);
 137         fixture.setNumberOfSubBuffers(1);
 138         fixture.setOutputType("");
 139         fixture.setSubBufferSize(1L);
 140
 141         // add an event
 142         IEventInfo event = new EventInfo("event");
 143         fixture.addEvent(event);
 144
 145         // Verify the stored events
 146         IEventInfo[] result = fixture.getEvents();
 147
 148         assertNotNull(result);
 149         assertEquals(1, result.length);
 150         assertNotNull(result[0]);
 151         assertTrue(event.equals(result[0]));
 152     }
 153
 154     /**
 155      * Run the long getNumberOfSubBuffers() method test.
 156      */
 157     @Test
 158     public void testGetAndSetters() {
 159         ChannelInfo fixture = new ChannelInfo("test");
 160         fixture.setSwitchTimer(2L);
 161         fixture.setOverwriteMode(true);
 162         fixture.setReadTimer(3L);
 163         fixture.setState(TraceEnablement.DISABLED);
 164         fixture.setNumberOfSubBuffers(4);
 165         fixture.setOutputType("splice()");
 166         fixture.setSubBufferSize(1L);
 167         fixture.setMaxSizeTraceFiles(1024);
 168         fixture.setMaxNumberTraceFiles(20);
 169         fixture.setBufferType(BufferType.BUFFER_PER_UID);
 170         fixture.addEvent(new EventInfo("event"));
 171
 172         long switchTimer = fixture.getSwitchTimer();
 173         assertEquals(2L, switchTimer);
 174
 175         boolean mode = fixture.isOverwriteMode();
 176         assertTrue(mode);
 177
 178         long readTimer = fixture.getReadTimer();
 179         assertEquals(3L, readTimer);
 180
 181         TraceEnablement state = fixture.getState();
 182         assertEquals("disabled", state.getInName());
 183
 184         long numSubBuffers = fixture.getNumberOfSubBuffers();
 185         assertEquals(4, numSubBuffers);
 186
 187         String outputType = fixture.getOutputType();
 188         assertEquals("splice()", outputType);
 189
 190         long subBufferSize = fixture.getSubBufferSize();
 191         assertEquals(1L, subBufferSize);
 192
 193         int maxSizeTraceFiles = fixture.getMaxSizeTraceFiles();
 194         assertEquals(1024, maxSizeTraceFiles);
 195
 196         int maxNumberTraceFiles = fixture.getMaxNumberTraceFiles();
 197         assertEquals(20, maxNumberTraceFiles);
 198
 199         BufferType bufferType = fixture.getBufferType();
 200         assertTrue(bufferType == BufferType.BUFFER_PER_UID);
 201
 202         fixture.setSwitchTimer(5L);
 203         fixture.setOverwriteMode(false);
 204         fixture.setReadTimer(6L);
 205         fixture.setState(TraceEnablement.ENABLED);
 206         fixture.setNumberOfSubBuffers(7);
 207         fixture.setOutputType("mmap()");
 208         fixture.setSubBufferSize(8L);
 209         fixture.setMaxSizeTraceFiles(4096);
 210         fixture.setMaxNumberTraceFiles(10);
 211         fixture.setBufferType(BufferType.BUFFER_PER_PID);
 212
 213         switchTimer = fixture.getSwitchTimer();
 214         assertEquals(5L, switchTimer);
 215
 216         mode = fixture.isOverwriteMode();
 217         assertFalse(mode);
 218
 219         readTimer = fixture.getReadTimer();
 220         assertEquals(6L, readTimer);
 221
 222         state = fixture.getState();
 223         assertEquals("enabled", state.getInName());
 224
 225         numSubBuffers = fixture.getNumberOfSubBuffers();
 226         assertEquals(7, numSubBuffers);
 227
 228         outputType = fixture.getOutputType();
 229         assertEquals("mmap()", outputType);
 230
 231         subBufferSize = fixture.getSubBufferSize();
 232         assertEquals(8L, subBufferSize);
 233
 234         maxSizeTraceFiles = fixture.getMaxSizeTraceFiles();
 235         assertEquals(4096, maxSizeTraceFiles);
 236
 237         maxNumberTraceFiles = fixture.getMaxNumberTraceFiles();
 238         assertEquals(10, maxNumberTraceFiles);
 239
 240         bufferType = fixture.getBufferType();
 241         assertTrue(bufferType == BufferType.BUFFER_PER_PID);
 242     }
 243
 244     /**
 245      * Run the void setEvents(List<IEventInfo>) method test.
 246      */
 247     @Test
 248     public void testSetEvents_1() {
 249         ChannelInfo fixture = new ChannelInfo("test");
 250         fixture.setSwitchTimer(1L);
 251         fixture.setOverwriteMode(true);
 252         fixture.setReadTimer(1L);
 253         fixture.setState(TraceEnablement.DISABLED);
 254         fixture.setNumberOfSubBuffers(1);
 255         fixture.setOutputType("");
 256         fixture.setSubBufferSize(1L);
 257         List<IEventInfo> events = new LinkedList<>();
 258
 259         for (int i = 0; i < 2; i++) {
 260             IEventInfo info = new EventInfo("event" + i);
 261             info.setEventType("tracepoint");
 262             info.setState((i % 2 == 0 ? "enabled" : "disabled"));
 263             events.add(info);
 264         }
 265
 266         fixture.setEvents(events);
 267
 268         IEventInfo[] infos = fixture.getEvents();
 269
 270         assertEquals(events.size(), infos.length);
 271
 272         for (int i = 0; i < infos.length; i++) {
 273             assertEquals(events.get(i), infos[i]);
 274         }
 275     }
 276
 277     /**
 278      * Run the String toString() method test.
 279      */
 280     @Test
 281     public void testToString_1() {
 282         ChannelInfo fixture = new ChannelInfo("channel");
 283         fixture.setSwitchTimer(1L);
 284         fixture.setOverwriteMode(true);
 285         fixture.setReadTimer(1L);
 286         fixture.setState(TraceEnablement.DISABLED);
 287         fixture.setNumberOfSubBuffers(1);
 288         fixture.setOutputType("splice()");
 289         fixture.setSubBufferSize(1L);
 290
 291         String result = fixture.toString();
 292
 293         // add additional test code here
 294         assertEquals("[ChannelInfo([TraceInfo(Name=channel)],State=DISABLED,OverwriteMode=true,SubBuffersSize=1,NumberOfSubBuffers=1,SwitchTimer=1,ReadTimer=1,output=splice(),Events=None)]", result);
 295     }
 296
 297     /**
 298      * Run another String toString() method test.
 299      */
 300     @Test
 301     public void testToString_2() {
 302         String result = fChannelInfo1.toString();
 303
 304         // add additional test code here
 305         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,levelType=LOGLEVEL_ONLY)])]", result);
 306     }
 307
 308     // ------------------------------------------------------------------------
 309     // equals
 310     // ------------------------------------------------------------------------
 311
 312     /**
 313      * Run the equals() method test.
 314      */
 315     @Test
 316     public void testEqualsReflexivity() {
 317         assertTrue("equals", fChannelInfo1.equals(fChannelInfo1));
 318         assertTrue("equals", fChannelInfo2.equals(fChannelInfo2));
 319
 320         assertTrue("equals", !fChannelInfo1.equals(fChannelInfo2));
 321         assertTrue("equals", !fChannelInfo2.equals(fChannelInfo1));
 322     }
 323
 324     /**
 325      * Run the equals() method test.
 326      */
 327     @Test
 328     public void testEqualsSymmetry() {
 329         ChannelInfo event1 = new ChannelInfo((ChannelInfo)fChannelInfo1);
 330         ChannelInfo event2 = new ChannelInfo((ChannelInfo)fChannelInfo2);
 331
 332         assertTrue("equals", event1.equals(fChannelInfo1));
 333         assertTrue("equals", fChannelInfo1.equals(event1));
 334
 335         assertTrue("equals", event2.equals(fChannelInfo2));
 336         assertTrue("equals", fChannelInfo2.equals(event2));
 337     }
 338
 339     /**
 340      * Run the equals() method test.
 341      */
 342     @Test
 343     public void testEqualsTransivity() {
 344         ChannelInfo channel1 = new ChannelInfo((ChannelInfo)fChannelInfo1);
 345         ChannelInfo channel2 = new ChannelInfo((ChannelInfo)fChannelInfo1);
 346         ChannelInfo channel3 = new ChannelInfo((ChannelInfo)fChannelInfo1);
 347
 348         assertTrue("equals", channel1.equals(channel2));
 349         assertTrue("equals", channel2.equals(channel3));
 350         assertTrue("equals", channel1.equals(channel3));
 351     }
 352
 353     /**
 354      * Run the equals() method test.
 355      */
 356     @Test
 357     public void testEqualsNull() {
 358         assertTrue("equals", !fChannelInfo1.equals(null));
 359         assertTrue("equals", !fChannelInfo2.equals(null));
 360     }
 361
 362     // ------------------------------------------------------------------------
 363     // hashCode
 364     // ------------------------------------------------------------------------
 365
 366     /**
 367      * Run the hashCode() method test.
 368      */
 369     @Test
 370     public void testHashCode() {
 371         ChannelInfo channel1 = new ChannelInfo((ChannelInfo)fChannelInfo1);
 372         ChannelInfo channel2 = new ChannelInfo((ChannelInfo)fChannelInfo2);
 373
 374         assertTrue("hashCode", fChannelInfo1.hashCode() == channel1.hashCode());
 375         assertTrue("hashCode", fChannelInfo2.hashCode() == channel2.hashCode());
 376
 377         assertTrue("hashCode", fChannelInfo1.hashCode() != channel2.hashCode());
 378         assertTrue("hashCode", fChannelInfo2.hashCode() != channel1.hashCode());
 379     }
 380 }