org.eclipse.linuxtools.tmf.ctf.core.tests/src/org/eclipse/linuxtools/tmf/ctf/core/tests/CtfTmfTraceTest.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  *   Matthew Khouzam - Initial generation with CodePro tools
  11  *   Alexandre Montplaisir - Clean up, consolidate redundant tests
  12  *******************************************************************************/
  13
  14 package org.eclipse.linuxtools.tmf.ctf.core.tests;
  15
  16 import static org.junit.Assert.assertEquals;
  17 import static org.junit.Assert.assertFalse;
  18 import static org.junit.Assert.assertNotNull;
  19 import static org.junit.Assert.assertNull;
  20 import static org.junit.Assert.assertTrue;
  21 import static org.junit.Assume.assumeTrue;
  22
  23 import java.util.Arrays;
  24 import java.util.HashSet;
  25 import java.util.Set;
  26
  27 import org.eclipse.core.resources.IProject;
  28 import org.eclipse.core.resources.IResource;
  29 import org.eclipse.core.runtime.IStatus;
  30 import org.eclipse.linuxtools.tmf.core.event.ITmfEventType;
  31 import org.eclipse.linuxtools.tmf.core.exceptions.TmfTraceException;
  32 import org.eclipse.linuxtools.tmf.core.signal.TmfEndSynchSignal;
  33 import org.eclipse.linuxtools.tmf.core.signal.TmfSignal;
  34 import org.eclipse.linuxtools.tmf.core.timestamp.ITmfTimestamp;
  35 import org.eclipse.linuxtools.tmf.core.timestamp.TmfTimeRange;
  36 import org.eclipse.linuxtools.tmf.core.timestamp.TmfTimestamp;
  37 import org.eclipse.linuxtools.tmf.core.trace.ITmfContext;
  38 import org.eclipse.linuxtools.tmf.core.trace.TmfEventTypeCollectionHelper;
  39 import org.eclipse.linuxtools.tmf.ctf.core.CtfLocation;
  40 import org.eclipse.linuxtools.tmf.ctf.core.CtfLocationInfo;
  41 import org.eclipse.linuxtools.tmf.ctf.core.CtfTmfEvent;
  42 import org.eclipse.linuxtools.tmf.ctf.core.CtfTmfTimestamp;
  43 import org.eclipse.linuxtools.tmf.ctf.core.CtfTmfTrace;
  44 import org.eclipse.linuxtools.tmf.ctf.core.tests.shared.CtfTmfTestTrace;
  45 import org.junit.After;
  46 import org.junit.Before;
  47 import org.junit.Test;
  48
  49 /**
  50  * The class <code>CtfTmfTraceTest</code> contains tests for the class
  51  * <code>{@link CtfTmfTrace}</code>.
  52  *
  53  * @author ematkho
  54  * @version 1.0
  55  */
  56 public class CtfTmfTraceTest {
  57
  58     private static final CtfTmfTestTrace testTrace = CtfTmfTestTrace.KERNEL;
  59
  60     private CtfTmfTrace fixture;
  61
  62     /**
  63      * Perform pre-test initialization.
  64      *
  65      * @throws TmfTraceException
  66      *             If the test trace is not found
  67      */
  68     @Before
  69     public void setUp() throws TmfTraceException {
  70         assumeTrue(testTrace.exists());
  71         fixture = new CtfTmfTrace();
  72         fixture.initTrace((IResource) null, testTrace.getPath(), CtfTmfEvent.class);
  73     }
  74
  75     /**
  76      * Perform post-test clean-up.
  77      */
  78     @After
  79     public void tearDown() {
  80         if (fixture != null) {
  81             fixture.dispose();
  82         }
  83     }
  84
  85     /**
  86      * Run the CtfTmfTrace() constructor test.
  87      */
  88     @Test
  89     public void testCtfTmfTrace() {
  90         try (CtfTmfTrace result = new CtfTmfTrace();) {
  91             assertNotNull(result);
  92             assertEquals(1000, result.getCacheSize());
  93             assertEquals(0L, result.getNbEvents());
  94             assertEquals(0L, result.getStreamingInterval());
  95             assertNull(result.getResource());
  96             assertNull(result.getType());
  97         }
  98     }
  99
 100     /**
 101      * Test the parseEvent() method
 102      */
 103     @Test
 104     public void testParseEvent() {
 105         ITmfContext ctx = fixture.seekEvent(0);
 106         fixture.getNext(ctx);
 107         CtfTmfEvent event = fixture.parseEvent(ctx);
 108         assertNotNull(event);
 109     }
 110
 111     /**
 112      * Run the void broadcast(TmfSignal) method test.
 113      */
 114     @Test
 115     public void testBroadcast() {
 116         TmfSignal signal = new TmfEndSynchSignal(1);
 117         fixture.broadcast(signal);
 118     }
 119
 120     /**
 121      * Run the void dispose() method test.
 122      */
 123     @Test
 124     public void testClose() {
 125         try (CtfTmfTrace emptyFixture = new CtfTmfTrace();) {
 126         }
 127     }
 128
 129     /**
 130      * Run the int getCacheSize() method test.
 131      */
 132     @Test
 133     public void testGetCacheSize() {
 134         try (CtfTmfTrace emptyFixture = new CtfTmfTrace();) {
 135             int result = emptyFixture.getCacheSize();
 136             assertEquals(1000, result);
 137         }
 138     }
 139
 140     /**
 141      * Run the ITmfLocation<Comparable> getCurrentLocation() method test.
 142      */
 143     @Test
 144     public void testGetCurrentLocation() {
 145         CtfLocation result = (CtfLocation) fixture.getCurrentLocation();
 146         assertNull(result);
 147     }
 148
 149     /**
 150      * Test the seekEvent() method with a null location.
 151      */
 152     @Test
 153     public void testSeekEventLoc_null() {
 154         CtfLocation loc = null;
 155         fixture.seekEvent(loc);
 156         assertNotNull(fixture);
 157     }
 158
 159     /**
 160      * Test the seekEvent() method with a location from a timestamp.
 161      */
 162     @Test
 163     public void testSeekEventLoc_timetamp() {
 164         CtfLocation loc = new CtfLocation(new CtfTmfTimestamp(0L));
 165         fixture.seekEvent(loc);
 166         assertNotNull(fixture);
 167     }
 168
 169     /**
 170      * Run the ITmfTimestamp getEndTime() method test.
 171      */
 172     @Test
 173     public void testGetEndTime() {
 174         ITmfTimestamp result = fixture.getEndTime();
 175         assertNotNull(result);
 176     }
 177
 178     /**
 179      * Run the String getEnvironment method test.
 180      */
 181     @Test
 182     public void testGetEnvValue() {
 183         String key = "tracer_name";
 184         String result = fixture.getTraceProperties().get(key);
 185         assertEquals("\"lttng-modules\"", result);
 186     }
 187
 188     /**
 189      * Test the {@link CtfTmfTrace#getEventType()} method.
 190      */
 191     @Test
 192     public void testGetEventType() {
 193         Class<?> result = fixture.getEventType();
 194         assertNotNull(result);
 195         assertEquals(CtfTmfEvent.class, result);
 196     }
 197
 198     /**
 199      * Run the Class<CtfTmfEvent> getContainedEventTypes() method test.
 200      */
 201     @Test
 202     public void testGetContainedEventTypes() {
 203         Set<ITmfEventType> result = fixture.getContainedEventTypes();
 204         assertNotNull(result);
 205         assertFalse(result.isEmpty());
 206     }
 207
 208     /**
 209      * Run the double getLocationRatio(ITmfLocation<?>) method test.
 210      */
 211     @Test
 212     public void testGetLocationRatio() {
 213         final CtfLocationInfo location2 = new CtfLocationInfo(1, 0);
 214         CtfLocation location = new CtfLocation(location2);
 215         double result = fixture.getLocationRatio(location);
 216
 217         assertEquals(Double.NEGATIVE_INFINITY, result, 0.1);
 218     }
 219
 220     /**
 221      * Run the String getName() method test.
 222      */
 223     @Test
 224     public void testGetName() {
 225         String result = fixture.getName();
 226         assertNotNull(result);
 227     }
 228
 229     /**
 230      * Run the getTraceProperties() method test.
 231      */
 232     @Test
 233     public void testGetTraceProperties() {
 234         int result = fixture.getTraceProperties().size();
 235         assertEquals(9, result);
 236     }
 237
 238     /**
 239      * Run the long getNbEvents() method test.
 240      */
 241     @Test
 242     public void testGetNbEvents() {
 243         long result = fixture.getNbEvents();
 244         assertEquals(1L, result);
 245     }
 246
 247     /**
 248      * Run the CtfTmfEvent getNext(ITmfContext) method test.
 249      */
 250     @Test
 251     public void testGetNext() {
 252         ITmfContext context = fixture.seekEvent(0);
 253         CtfTmfEvent result = fixture.getNext(context);
 254         assertNotNull(result);
 255     }
 256
 257     /**
 258      * Run the String getPath() method test.
 259      */
 260     @Test
 261     public void testGetPath() {
 262         String result = fixture.getPath();
 263         assertNotNull(result);
 264     }
 265
 266     /**
 267      * Run the IResource getResource() method test.
 268      */
 269     @Test
 270     public void testGetResource() {
 271         IResource result = fixture.getResource();
 272         assertNull(result);
 273     }
 274
 275     /**
 276      * Run the ITmfTimestamp getStartTime() method test.
 277      */
 278     @Test
 279     public void testGetStartTime() {
 280         ITmfTimestamp result = fixture.getStartTime();
 281         assertNotNull(result);
 282     }
 283
 284     /**
 285      * Run the long getStreamingInterval() method test.
 286      */
 287     @Test
 288     public void testGetStreamingInterval() {
 289         long result = fixture.getStreamingInterval();
 290         assertEquals(0L, result);
 291     }
 292
 293     /**
 294      * Run the TmfTimeRange getTimeRange() method test.
 295      */
 296     @Test
 297     public void testGetTimeRange() {
 298         TmfTimeRange result = fixture.getTimeRange();
 299         assertNotNull(result);
 300     }
 301
 302     /**
 303      * Run the CtfTmfEvent readNextEvent(ITmfContext) method test.
 304      */
 305     @Test
 306     public void testReadNextEvent() {
 307         ITmfContext context = fixture.seekEvent(0);
 308         CtfTmfEvent result = fixture.getNext(context);
 309         assertNotNull(result);
 310     }
 311
 312     /**
 313      * Run the ITmfContext seekEvent(double) method test.
 314      */
 315     @Test
 316     public void testSeekEvent_ratio() {
 317         double ratio = 0.99;
 318         ITmfContext result = fixture.seekEvent(ratio);
 319         assertNotNull(result);
 320     }
 321
 322     /**
 323      * Run the ITmfContext seekEvent(long) method test.
 324      */
 325     @Test
 326     public void testSeekEvent_rank() {
 327         long rank = 1L;
 328         ITmfContext result = fixture.seekEvent(rank);
 329         assertNotNull(result);
 330     }
 331
 332     /**
 333      * Run the ITmfContext seekEvent(ITmfTimestamp) method test.
 334      */
 335     @Test
 336     public void testSeekEvent_timestamp() {
 337         ITmfTimestamp timestamp = new TmfTimestamp();
 338         ITmfContext result = fixture.seekEvent(timestamp);
 339         assertNotNull(result);
 340     }
 341
 342     /**
 343      * Run the ITmfContext seekEvent(ITmfLocation<?>) method test.
 344      */
 345     @Test
 346     public void testSeekEvent_location() {
 347         final CtfLocationInfo location2 = new CtfLocationInfo(1L, 0L);
 348         CtfLocation ctfLocation = new CtfLocation(location2);
 349         ITmfContext result = fixture.seekEvent(ctfLocation);
 350         assertNotNull(result);
 351     }
 352
 353     /**
 354      * Run the boolean validate(IProject,String) method test.
 355      */
 356     @Test
 357     public void testValidate() {
 358         IProject project = null;
 359         IStatus result = fixture.validate(project, testTrace.getPath());
 360         assertTrue(result.isOK());
 361     }
 362
 363     /**
 364      * Run the boolean hasEvent(final String) method test
 365      */
 366     @Test
 367     public void testEventLookup() {
 368         Set<ITmfEventType> eventTypes = fixture.getContainedEventTypes();
 369         Set<String> eventNames = TmfEventTypeCollectionHelper.getEventNames(eventTypes);
 370         assertTrue(eventNames.contains("sched_switch"));
 371         assertFalse(eventNames.contains("Sched_switch"));
 372         String[] events = { "sched_switch", "sched_wakeup", "timer_init" };
 373         assertTrue(eventNames.containsAll(Arrays.asList(events)));
 374         Set<String> copy = new HashSet<>(eventNames);
 375         copy.retainAll(Arrays.asList(events));
 376         assertFalse(copy.isEmpty());
 377         String[] names = { "inexistent", "sched_switch", "SomeThing" };
 378         copy = new HashSet<>(eventNames);
 379         copy.retainAll(Arrays.asList(names));
 380         assertTrue(!copy.isEmpty());
 381         assertFalse(eventNames.containsAll(Arrays.asList(names)));
 382     }
 383
 384     /**
 385      * Run the String getHostId() method test
 386      */
 387     @Test
 388     public void testCtfHostId() {
 389         String a = fixture.getHostId();
 390         assertEquals("\"84db105b-b3f4-4821-b662-efc51455106a\"", a);
 391     }
 392
 393 }