org.eclipse.tracecompass.ctf.core.tests/src/org/eclipse/tracecompass/ctf/core/tests/trace/CTFTraceTest.java

   1 /*******************************************************************************
   2  * Copyright (c) 2013, 2014 Ericsson
   3  * All rights reserved. This program and the accompanying materials
   4  * are made available under the terms of the Eclipse Public License v1.0
   5  * which accompanies this distribution, and is available at
   6  * http://www.eclipse.org/legal/epl-v10.html
   7  *
   8  * Contributors:
   9  *     Matthew Khouzam - Initial API and implementation
  10  *     Marc-Andre Laperle - Test in traces directory recursively
  11  *     Simon Delisle - Add test for getCallsite(eventName, ip)
  12  *******************************************************************************/
  13
  14 package org.eclipse.tracecompass.ctf.core.tests.trace;
  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.Assert.fail;
  22 import static org.junit.Assume.assumeTrue;
  23
  24 import java.io.File;
  25 import java.nio.ByteOrder;
  26 import java.util.UUID;
  27
  28 import org.eclipse.tracecompass.ctf.core.CTFException;
  29 import org.eclipse.tracecompass.ctf.core.event.CTFClock;
  30 import org.eclipse.tracecompass.ctf.core.event.types.IDefinition;
  31 import org.eclipse.tracecompass.ctf.core.event.types.StructDeclaration;
  32 import org.eclipse.tracecompass.ctf.core.tests.shared.CtfTestTrace;
  33 import org.eclipse.tracecompass.ctf.core.trace.CTFStream;
  34 import org.eclipse.tracecompass.ctf.core.trace.CTFTrace;
  35 import org.eclipse.tracecompass.internal.ctf.core.event.metadata.exceptions.ParseException;
  36 import org.junit.Before;
  37 import org.junit.Test;
  38
  39 /**
  40  * The class <code>CTFTraceTest</code> contains tests for the class
  41  * <code>{@link CTFTrace}</code>.
  42  *
  43  * @author ematkho
  44  */
  45 public class CTFTraceTest {
  46
  47     private static final CtfTestTrace testTrace = CtfTestTrace.KERNEL;
  48
  49     private CTFTrace fixture;
  50
  51     /**
  52      * Perform pre-test initialization.
  53      */
  54     @Before
  55     public void setUp() {
  56         assumeTrue(testTrace.exists());
  57         try {
  58             fixture = testTrace.getTraceFromFile();
  59         } catch (CTFException e) {
  60             /* If the assumeTrue() call passed, this should not happen. */
  61             fail();
  62         }
  63         fixture.setMinor(1L);
  64         fixture.setUUID(UUID.randomUUID());
  65         fixture.setPacketHeader(new StructDeclaration(1L));
  66         fixture.setMajor(1L);
  67         fixture.setByteOrder(ByteOrder.BIG_ENDIAN);
  68     }
  69
  70     /**
  71      * Run the CTFTrace(File) constructor test with a known existing trace.
  72      */
  73     @Test
  74     public void testOpen_existing() {
  75         try {
  76             CTFTrace result = testTrace.getTraceFromFile();
  77             assertNotNull(result.getUUID());
  78         } catch (CTFException e) {
  79             fail();
  80         }
  81     }
  82
  83     /**
  84      * Run the CTFTrace(File) constructor test with an invalid path.
  85      *
  86      * @throws CTFException
  87      *             is expected
  88      */
  89     @Test(expected = org.eclipse.tracecompass.ctf.core.CTFException.class)
  90     public void testOpen_invalid() throws CTFException {
  91         File path = new File("");
  92         CTFTrace result = new CTFTrace(path);
  93         assertNotNull(result);
  94     }
  95
  96     /**
  97      * Run the boolean UUIDIsSet() method test.
  98      */
  99     @Test
 100     public void testUUIDIsSet() {
 101         boolean result = fixture.uuidIsSet();
 102         assertTrue(result);
 103     }
 104
 105     /**
 106      * Run the void addStream(Stream) method test.
 107      */
 108     @Test
 109     public void testAddStream() {
 110         // test number of streams
 111         int nbStreams = fixture.nbStreams();
 112         assertEquals(1, nbStreams);
 113
 114         // Add a stream
 115         try {
 116             CTFStream stream = new CTFStream(testTrace.getTrace());
 117             stream.setId(1234);
 118             fixture.addStream(stream);
 119         } catch (CTFException e) {
 120             fail();
 121         } catch (ParseException e) {
 122             fail();
 123         }
 124
 125         // test number of streams
 126         nbStreams = fixture.nbStreams();
 127         assertEquals(2, nbStreams);
 128     }
 129
 130     /**
 131      * Run the boolean byteOrderIsSet() method test.
 132      */
 133     @Test
 134     public void testByteOrderIsSet() {
 135         boolean result = fixture.byteOrderIsSet();
 136         assertTrue(result);
 137     }
 138
 139     /**
 140      * Run the ByteOrder getByteOrder() method test.
 141      */
 142     @Test
 143     public void testGetByteOrder_1() {
 144         ByteOrder result = fixture.getByteOrder();
 145         assertNotNull(result);
 146     }
 147
 148     /**
 149      * Run the long getMajor() method test.
 150      */
 151     @Test
 152     public void testGetMajor() {
 153         long result = fixture.getMajor();
 154         assertEquals(1L, result);
 155     }
 156
 157     /**
 158      * Run the long getMinor() method test.
 159      */
 160     @Test
 161     public void testGetMinor() {
 162         long result = fixture.getMinor();
 163         assertEquals(1L, result);
 164     }
 165
 166     /**
 167      * Run the StructDeclaration getPacketHeader() method test.
 168      */
 169     @Test
 170     public void testGetPacketHeader() {
 171         StructDeclaration result = fixture.getPacketHeader();
 172         assertNotNull(result);
 173     }
 174
 175     /**
 176      * Run the String getPath() method test.
 177      */
 178     @Test
 179     public void testGetPath() {
 180         String result = fixture.getPath();
 181         assertNotNull(result);
 182     }
 183
 184     /**
 185      * Run the Stream getStream(Long) method test.
 186      */
 187     @Test
 188     public void testGetStream() {
 189         Long id = new Long(0L);
 190         CTFStream result = fixture.getStream(id);
 191         assertNotNull(result);
 192     }
 193
 194     /**
 195      * Run the File getTraceDirectory() method test.
 196      */
 197     @Test
 198     public void testGetTraceDirectory() {
 199         File result = fixture.getTraceDirectory();
 200         assertNotNull(result);
 201     }
 202
 203     /**
 204      * Run the UUID getUUID() method test.
 205      */
 206     @Test
 207     public void testGetUUID() {
 208         UUID result = fixture.getUUID();
 209         assertNotNull(result);
 210     }
 211
 212     /**
 213      * Run the Definition lookupDefinition(String) method test.
 214      */
 215     @Test
 216     public void testLookupDefinition() {
 217         String lookupPath = "trace.packet.header";
 218         IDefinition result = fixture.lookupDefinition(lookupPath);
 219         assertNotNull(result);
 220     }
 221
 222     /**
 223      * Run the boolean majorIsSet() method test.
 224      */
 225     @Test
 226     public void testMajorIsSet() {
 227         boolean result = fixture.majorIsSet();
 228         assertTrue(result);
 229     }
 230
 231     /**
 232      * Run the boolean minorIsSet() method test.
 233      */
 234     @Test
 235     public void testMinorIsSet() {
 236         boolean result = fixture.minorIsSet();
 237         assertTrue(result);
 238     }
 239
 240     /**
 241      * Run the boolean packetHeaderIsSet() method test with a valid header set.
 242      */
 243     @Test
 244     public void testPacketHeaderIsSet_valid() {
 245         boolean result = fixture.packetHeaderIsSet();
 246         assertTrue(result);
 247     }
 248
 249     /**
 250      * Run the boolean packetHeaderIsSet() method test, without having a valid
 251      * header set.
 252      */
 253     @Test
 254     public void testPacketHeaderIsSet_invalid() {
 255         try {
 256             CTFTrace fixture2 = testTrace.getTraceFromFile();
 257             fixture2.setMinor(1L);
 258             fixture2.setUUID(UUID.randomUUID());
 259             /*
 260              * it's null here!
 261              */
 262             fixture2.setPacketHeader((StructDeclaration) null);
 263             fixture2.setMajor(1L);
 264             fixture2.setByteOrder(ByteOrder.BIG_ENDIAN);
 265
 266             boolean result = fixture2.packetHeaderIsSet();
 267             assertFalse(result);
 268         } catch (CTFException e) {
 269             fail();
 270         }
 271     }
 272
 273     /**
 274      * Run the void setByteOrder(ByteOrder) method test.
 275      */
 276     @Test
 277     public void testSetByteOrder() {
 278         ByteOrder byteOrder = ByteOrder.BIG_ENDIAN;
 279         fixture.setByteOrder(byteOrder);
 280     }
 281
 282     /**
 283      * Run the void setMajor(long) method test.
 284      */
 285     @Test
 286     public void testSetMajor() {
 287         long major = 1L;
 288         fixture.setMajor(major);
 289     }
 290
 291     /**
 292      * Run the void setMinor(long) method test.
 293      */
 294     @Test
 295     public void testSetMinor() {
 296         long minor = 1L;
 297         fixture.setMinor(minor);
 298     }
 299
 300     /**
 301      * Run the void setPacketHeader(StructDeclaration) method test.
 302      */
 303     @Test
 304     public void testSetPacketHeader() {
 305         StructDeclaration packetHeader = new StructDeclaration(1L);
 306         fixture.setPacketHeader(packetHeader);
 307     }
 308
 309     /**
 310      * Run the void setUUID(UUID) method test.
 311      */
 312     @Test
 313     public void testSetUUID() {
 314         UUID uuid = UUID.randomUUID();
 315         fixture.setUUID(uuid);
 316     }
 317
 318     /**
 319      * Run the CTFClock getClock/setClock method test.
 320      */
 321     @Test
 322     public void testGetSetClock_1() {
 323         String name = "clockyClock";
 324         fixture.addClock(name, new CTFClock());
 325         CTFClock result = fixture.getClock(name);
 326
 327         assertNotNull(result);
 328     }
 329
 330     /**
 331      * Run the CTFClock getClock/setClock method test.
 332      */
 333     @Test
 334     public void testGetSetClock_2() {
 335         String name = "";
 336         CTFClock ctfClock = new CTFClock();
 337         ctfClock.addAttribute("name", "Bob");
 338         ctfClock.addAttribute("pi", new Double(java.lang.Math.PI));
 339         fixture.addClock(name, ctfClock);
 340         CTFClock result = fixture.getClock(name);
 341
 342         assertNotNull(result);
 343         assertTrue((Double) ctfClock.getProperty("pi") > 3.0);
 344         assertTrue(ctfClock.getName().equals("Bob"));
 345     }
 346
 347     /**
 348      * Run the String lookupEnvironment(String) method test.
 349      */
 350     @Test
 351     public void testLookupEnvironment_1() {
 352         String key = "";
 353         String result = fixture.getEnvironment().get(key);
 354         assertNull(result);
 355     }
 356
 357     /**
 358      * Run the String lookupEnvironment(String) method test.
 359      */
 360     @Test
 361     public void testLookupEnvironment_2() {
 362         String key = "otherTest";
 363         String result = fixture.getEnvironment().get(key);
 364         assertNull(result);
 365     }
 366
 367     /**
 368      * Run the String lookupEnvironment(String) method test.
 369      */
 370     @Test
 371     public void testLookupEnvironment_3() {
 372         String key = "test";
 373         fixture.addEnvironmentVar(key, key);
 374         String result = fixture.getEnvironment().get(key);
 375         assertTrue(result.equals(key));
 376     }
 377
 378     /**
 379      * Run the String lookupEnvironment(String) method test.
 380      */
 381     @Test
 382     public void testLookupEnvironment_4() {
 383         String key = "test";
 384         fixture.addEnvironmentVar(key, "bozo");
 385         fixture.addEnvironmentVar(key, "the clown");
 386         String result = fixture.getEnvironment().get(key);
 387         assertNotNull(result);
 388     }
 389
 390     /**
 391      * Test for getCallsite(eventName, ip)
 392      *
 393      * @throws CTFException
 394      *             not expected
 395      */
 396     @Test
 397     public void callsitePosition() throws CTFException {
 398         long ip1 = 2;
 399         long ip2 = 5;
 400         long ip3 = 7;
 401         CTFTrace callsiteTest = testTrace.getTraceFromFile();
 402         callsiteTest.addCallsite("testEvent", null, ip1, null, 23);
 403         callsiteTest.addCallsite("testEvent", null, ip2, null, 50);
 404         callsiteTest.addCallsite("testEvent", null, ip3, null, 15);
 405
 406         assertEquals(2, (callsiteTest.getCallsite("testEvent", 1)).getIp());
 407         assertEquals(2, (callsiteTest.getCallsite("testEvent", 2)).getIp());
 408         assertEquals(5, (callsiteTest.getCallsite("testEvent", 3)).getIp());
 409         assertEquals(5, (callsiteTest.getCallsite("testEvent", 5)).getIp());
 410         assertEquals(7, (callsiteTest.getCallsite("testEvent", 6)).getIp());
 411         assertEquals(7, (callsiteTest.getCallsite("testEvent", 7)).getIp());
 412         assertEquals(7, (callsiteTest.getCallsite("testEvent", 8)).getIp());
 413     }
 414 }