org.eclipse.linuxtools.lttng.tests/src/org/eclipse/linuxtools/lttng/tests/trace/LTTngTraceTest.java

   1 package org.eclipse.linuxtools.lttng.tests.trace;
   2
   3 import java.io.File;
   4 import java.net.URL;
   5
   6 import junit.framework.TestCase;
   7
   8 import org.eclipse.core.runtime.FileLocator;
   9 import org.eclipse.core.runtime.Path;
  10 import org.eclipse.linuxtools.lttng.event.LttngLocation;
  11 import org.eclipse.linuxtools.lttng.tests.LTTngCoreTestPlugin;
  12 import org.eclipse.linuxtools.lttng.trace.LTTngTrace;
  13 import org.eclipse.linuxtools.tmf.event.TmfEvent;
  14 import org.eclipse.linuxtools.tmf.event.TmfTimestamp;
  15 import org.eclipse.linuxtools.tmf.trace.TmfContext;
  16
  17 /*
  18  Functions tested here :
  19         public LTTngTrace(String path) throws Exception
  20     public LTTngTrace(String path, boolean skipIndexing) throws Exception
  21
  22     public TmfTraceContext seekLocation(Object location) {
  23     public TmfTraceContext seekEvent(TmfTimestamp timestamp) {
  24     public TmfTraceContext seekEvent(long position) {
  25
  26     public TmfEvent getNextEvent(TmfTraceContext context) {
  27     public Object getCurrentLocation() {
  28
  29     public LttngEvent parseEvent(TmfTraceContext context) {
  30
  31     public int getCpuNumber() {
  32  */
  33
  34 @SuppressWarnings("nls")
  35 public class LTTngTraceTest extends TestCase {
  36
  37     private final static String tracepath1="traceset/trace-15316events_nolost_newformat";
  38     private final static String wrongTracePath="/somewhere/that/does/not/exist";
  39
  40     private final static int    traceCpuNumber=1;
  41
  42     private final static boolean skipIndexing=true;
  43
  44     private final static long   firstEventTimestamp = 13589759412128L;
  45     private final static long   secondEventTimestamp = 13589759419903L;
  46     private final static Long   locationAfterFirstEvent = 13589759412128L;
  47
  48     private final static String tracename = "traceset/trace-15316events_nolost_newformat";
  49
  50     private final static long   indexToSeekFirst = 0;
  51     private final static Long   locationToSeekFirst = 13589759412128L;
  52     private final static long   contextValueAfterFirstEvent = 13589759412128L;
  53     private final static String firstEventReference = tracename + "/metadata_0";
  54
  55
  56     private final static long   timestampToSeekTest1 = 13589826657302L;
  57     private final static Long   indexToSeekTest1 = 7497L;
  58     private final static long   locationToSeekTest1 = 13589826657302L;
  59     private final static long   contextValueAfterSeekTest1 = 13589826657302L;
  60     private final static String seek1EventReference = tracename + "/vm_state_0";
  61
  62     private final static long   timestampToSeekLast = 13589906758692L;
  63     private final static Long   indexToSeekLast = 15315L;
  64     private final static long   locationToSeekLast = 13589906758692L;
  65     private final static long   contextValueAfterSeekLast = 13589906758692L;
  66     private final static String seekLastEventReference = tracename + "/kernel_0";
  67
  68     private static LTTngTrace testStream = null;
  69     private LTTngTrace prepareStreamToTest() {
  70                 if (testStream == null) {
  71                         try {
  72                                 URL location = FileLocator.find(LTTngCoreTestPlugin.getPlugin().getBundle(), new Path(tracepath1), null);
  73                                 File testfile = new File(FileLocator.toFileURL(location).toURI());
  74                                 LTTngTrace tmpStream = new LTTngTrace(testfile.getPath(), false);
  75                                 testStream = tmpStream;
  76                         }
  77                         catch (Exception e) {
  78                                 System.out.println("ERROR : Could not open " + tracepath1);
  79                                 testStream = null;
  80                         }
  81                 }
  82                 else {
  83                         testStream.seekEvent(0L);
  84                 }
  85
  86
  87                 return testStream;
  88         }
  89
  90     public void testTraceConstructors() {
  91                 @SuppressWarnings("unused")
  92                 LTTngTrace testStream1 = null;
  93
  94                 // Default constructor
  95                 // Test constructor with argument on a wrong tracepath, skipping indexing
  96         try {
  97                         testStream1 = new LTTngTrace(wrongTracePath, skipIndexing);
  98                 fail("Construction with wrong tracepath should fail!");
  99         }
 100         catch( Exception e) {
 101         }
 102
 103         // Test constructor with argument on a correct tracepath, skipping indexing
 104         try {
 105             URL location = FileLocator.find(LTTngCoreTestPlugin.getPlugin().getBundle(), new Path(tracepath1), null);
 106             File testfile = new File(FileLocator.toFileURL(location).toURI());
 107             testStream1 = new LTTngTrace(testfile.getPath(), skipIndexing);
 108         }
 109         catch( Exception e) {
 110                 fail("Construction with correct tracepath failed!");
 111         }
 112         System.out.println("Test completed");
 113         }
 114
 115         public void testGetNextEvent() {
 116                 TmfEvent tmpEvent = null;
 117                 LTTngTrace testStream1 = prepareStreamToTest();
 118
 119                 TmfContext tmpContext = new TmfContext(null, 0);
 120                 // We should be at the beginning of the trace, so we will just read the first event now
 121                 tmpEvent = testStream1.getNextEvent(tmpContext );
 122                 assertNotSame("tmpEvent is null after first getNextEvent()",null,tmpEvent );
 123                 assertEquals("tmpEvent has wrong timestamp after first getNextEvent()",firstEventTimestamp,(long)tmpEvent.getTimestamp().getValue() );
 124
 125                 // Read the next event as well
 126                 tmpEvent = testStream1.getNextEvent( tmpContext);
 127                 assertNotSame("tmpEvent is null after second getNextEvent()",null,tmpEvent );
 128                 assertEquals("tmpEvent has wrong timestamp after second getNextEvent()",secondEventTimestamp,(long)tmpEvent.getTimestamp().getValue() );
 129         }
 130
 131         public void testParseEvent() {
 132                 TmfEvent tmpEvent = null;
 133                 LTTngTrace testStream1 = prepareStreamToTest();
 134
 135                 TmfContext tmpContext = new TmfContext(null, 0);
 136                 // We should be at the beginning of the trace, so we will just parse the first event now
 137                 tmpEvent = testStream1.parseEvent(tmpContext );
 138                 assertNotSame("tmpEvent is null after first parseEvent()",null,tmpEvent );
 139                 assertEquals("tmpEvent has wrong timestamp after first parseEvent()",firstEventTimestamp,(long)tmpEvent.getTimestamp().getValue() );
 140
 141                 // Use parseEvent again. Should be the same event
 142                 tmpEvent = testStream1.parseEvent(tmpContext );
 143                 assertNotSame("tmpEvent is null after first parseEvent()",null,tmpEvent );
 144                 assertEquals("tmpEvent has wrong timestamp after first parseEvent()",firstEventTimestamp,(long)tmpEvent.getTimestamp().getValue() );
 145         }
 146
 147         public void testSeekEventTimestamp() {
 148                 TmfEvent tmpEvent = null;
 149                 TmfContext tmpContext = new TmfContext(null, 0);
 150                 LTTngTrace testStream1 = prepareStreamToTest();
 151
 152                 // We should be at the beginning of the trace, we will seek at a certain timestamp
 153                 tmpContext = testStream1.seekEvent(new TmfTimestamp(timestampToSeekTest1, (byte) -9, 0));
 154                 tmpEvent = testStream1.getNextEvent(tmpContext);
 155                 assertNotSame("tmpContext is null after first seekEvent()",null,tmpContext );
 156                 assertEquals("tmpContext has wrong timestamp after first seekEvent()",contextValueAfterSeekTest1,(long)((TmfTimestamp)tmpEvent.getTimestamp()).getValue() );
 157                 assertNotSame("tmpEvent is null after first seekEvent()",null,tmpEvent );
 158                 assertTrue("tmpEvent has wrong reference after first seekEvent()", ((String)tmpEvent.getReference().getReference()).contains(seek1EventReference) );
 159
 160                 // Seek to the last timestamp
 161                 tmpContext = testStream1.seekEvent(new TmfTimestamp(timestampToSeekLast, (byte) -9, 0));
 162                 tmpEvent = testStream1.getNextEvent(tmpContext);
 163                 assertNotSame("tmpContext is null after seekEvent() to last",null,tmpContext );
 164                 assertEquals("tmpContext has wrong timestamp after seekEvent() to last",contextValueAfterSeekLast,(long)((TmfTimestamp)tmpEvent.getTimestamp()).getValue() );
 165                 assertNotSame("tmpEvent is null after seekEvent() to last ",null,tmpEvent );
 166                 assertTrue("tmpEvent has wrong reference after seekEvent() to last",((String)tmpEvent.getReference().getReference()).contains(seekLastEventReference) );
 167
 168                 // Seek to the first timestamp (startTime)
 169                 tmpContext = testStream1.seekEvent(new TmfTimestamp(firstEventTimestamp, (byte) -9, 0));
 170                 tmpEvent = testStream1.getNextEvent(tmpContext);
 171                 assertNotSame("tmpEvent is null after seekEvent() to start ",null,tmpEvent );
 172                 assertTrue("tmpEvent has wrong reference after seekEvent() to start",((String)tmpEvent.getReference().getReference()).contains(firstEventReference) );
 173                 assertNotSame("tmpContext is null after seekEvent() to first",null,tmpContext );
 174                 assertEquals("tmpContext has wrong timestamp after seekEvent() to first",contextValueAfterFirstEvent,(long)((TmfTimestamp)tmpEvent.getTimestamp()).getValue() );
 175         }
 176
 177         public void testSeekEventIndex() {
 178                 TmfEvent tmpEvent = null;
 179                 TmfContext tmpContext = new TmfContext(null, 0);
 180                 LTTngTrace testStream1 = prepareStreamToTest();
 181
 182                 // We should be at the beginning of the trace, we will seek at a certain timestamp
 183                 tmpContext = testStream1.seekEvent(indexToSeekTest1);
 184                 tmpEvent = testStream1.getNextEvent(tmpContext);
 185                 assertNotSame("tmpContext is null after first seekEvent()",null,tmpContext );
 186                 assertEquals("tmpContext has wrong timestamp after first seekEvent()",contextValueAfterSeekTest1,(long)((TmfTimestamp)tmpEvent.getTimestamp()).getValue() );
 187                 assertNotSame("tmpEvent is null after first seekEvent()",null,tmpEvent );
 188                 assertTrue("tmpEvent has wrong reference after first seekEvent()", ((String)tmpEvent.getReference().getReference()).contains(seek1EventReference) );
 189
 190                 // Seek to the last timestamp
 191                 tmpContext = testStream1.seekEvent(indexToSeekLast);
 192                 tmpEvent = testStream1.getNextEvent(tmpContext);
 193                 assertNotSame("tmpContext is null after first seekEvent()",null,tmpContext );
 194                 assertEquals("tmpContext has wrong timestamp after first seekEvent()",contextValueAfterSeekLast,(long)((TmfTimestamp)tmpEvent.getTimestamp()).getValue() );
 195                 assertNotSame("tmpEvent is null after seekEvent() to last ",null,tmpEvent );
 196                 assertTrue("tmpEvent has wrong reference after seekEvent() to last",((String)tmpEvent.getReference().getReference()).contains(seekLastEventReference) );
 197
 198                 // Seek to the first timestamp (startTime)
 199                 tmpContext = testStream1.seekEvent(indexToSeekFirst);
 200                 tmpEvent = testStream1.getNextEvent(tmpContext);
 201                 assertNotSame("tmpContext is null after first seekEvent()",null,tmpContext );
 202                 assertEquals("tmpContext has wrong timestamp after first seekEvent()",contextValueAfterFirstEvent,(long)((TmfTimestamp)tmpEvent.getTimestamp()).getValue() );
 203                 assertNotSame("tmpEvent is null after seekEvent() to start ",null,tmpEvent );
 204                 assertTrue("tmpEvent has wrong reference after seekEvent() to start",((String)tmpEvent.getReference().getReference()).contains(firstEventReference) );
 205         }
 206
 207         public void testSeekLocation() {
 208                 TmfEvent tmpEvent = null;
 209                 TmfContext tmpContext = new TmfContext(null, 0);
 210                 LTTngTrace testStream1 = prepareStreamToTest();
 211
 212                 // We should be at the beginning of the trace, we will seek at a certain timestamp
 213                 tmpContext = testStream1.seekLocation(new LttngLocation(locationToSeekTest1));
 214                 tmpEvent = testStream1.getNextEvent(tmpContext);
 215                 assertNotSame("tmpContext is null after first seekLocation()",null,tmpContext );
 216                 assertEquals("tmpContext has wrong timestamp after first seekLocation()",contextValueAfterSeekTest1,(long)((TmfTimestamp)tmpEvent.getTimestamp()).getValue() );
 217                 assertNotSame("tmpEvent is null after first seekLocation()",null,tmpEvent );
 218                 assertTrue("tmpEvent has wrong reference after first seekLocation()", ((String)tmpEvent.getReference().getReference()).contains(seek1EventReference) );
 219
 220                 // Seek to the last timestamp
 221                 tmpContext = testStream1.seekLocation(new LttngLocation(locationToSeekLast));
 222                 tmpEvent = testStream1.getNextEvent(tmpContext);
 223                 assertNotSame("tmpContext is null after first seekLocation()",null,tmpContext );
 224                 assertEquals("tmpContext has wrong timestamp after first seekLocation()",contextValueAfterSeekLast,(long)((TmfTimestamp)tmpEvent.getTimestamp()).getValue() );
 225                 assertNotSame("tmpEvent is null after seekLocation() to last ",null,tmpEvent );
 226                 assertTrue("tmpEvent has wrong reference after seekLocation() to last",((String)tmpEvent.getReference().getReference()).contains(seekLastEventReference) );
 227
 228                 // Seek to the first timestamp (startTime)
 229                 tmpContext = testStream1.seekLocation(new LttngLocation(locationToSeekFirst));
 230                 tmpEvent = testStream1.getNextEvent(tmpContext);
 231                 assertNotSame("tmpContext is null after first seekLocation()",null,tmpContext );
 232                 assertEquals("tmpContext has wrong timestamp after first seekLocation()",contextValueAfterFirstEvent,(long)((TmfTimestamp)tmpEvent.getTimestamp()).getValue() );
 233                 assertNotSame("tmpEvent is null after seekLocation() to start ",null,tmpEvent );
 234                 assertTrue("tmpEvent has wrong reference after seekLocation() to start",((String)tmpEvent.getReference().getReference()).contains(firstEventReference) );
 235         }
 236
 237         public void testGetter() {
 238         TmfEvent tmpEvent = null;
 239         LTTngTrace testStream1 = prepareStreamToTest();
 240
 241                 // Move to the first event to have something to play with
 242                 tmpEvent = testStream1.parseEvent( new TmfContext(null, 0));
 243
 244                 // Test current event
 245                 assertNotSame("tmpEvent is null after first event",null,tmpEvent );
 246                 assertTrue("tmpEvent has wrong reference after first event",((String)tmpEvent.getReference().getReference()).contains(firstEventReference) );
 247                 assertNotSame("tmpContext is null after first seekEvent()",null,testStream1.getCurrentLocation() );
 248                 assertTrue("tmpContext has wrong timestamp after first seekEvent()",locationAfterFirstEvent.equals( ((LttngLocation)testStream1.getCurrentLocation()).getOperationTimeValue()) );
 249
 250                 // Test CPU number of the trace
 251                 assertSame("getCpuNumber() return wrong number of cpu",traceCpuNumber ,testStream1.getCpuNumber() );
 252     }
 253
 254         public void testToString() {
 255                 LTTngTrace testStream1 = prepareStreamToTest();
 256
 257                 // Move to the first event to have something to play with
 258                 testStream1.parseEvent( new TmfContext(null, 0) );
 259
 260                 // Just make sure toString() does not return null or the java reference
 261                 assertNotSame("toString returned null",null, testStream1.toString() );
 262                 assertNotSame("toString is not overridded!", testStream1.getClass().getName() + '@' + Integer.toHexString(testStream1.hashCode()), testStream1.toString() );
 263     }
 264
 265 }