[deliverable/tracecompass.git] / org.eclipse.linuxtools.lttng.core.tests / src / org / eclipse / linuxtools / lttng / core / tests / trace / LTTngTextTraceTest.java

package org.eclipse.linuxtools.lttng.core.tests.trace;

import java.io.File;
import java.net.URL;

import junit.framework.TestCase;

import org.eclipse.core.runtime.FileLocator;
import org.eclipse.core.runtime.Path;
import org.eclipse.linuxtools.internal.lttng.core.trace.LTTngTextTrace;
import org.eclipse.linuxtools.tmf.core.event.ITmfEvent;
import org.eclipse.linuxtools.tmf.core.event.TmfTimestamp;
import org.eclipse.linuxtools.tmf.core.trace.ITmfContext;
import org.eclipse.linuxtools.tmf.core.trace.TmfContext;
import org.eclipse.linuxtools.tmf.core.trace.TmfLocation;
import org.osgi.framework.FrameworkUtil;

/*
 Functions tested here :
 public LTTngTextTrace(String path) throws Exception
 public LTTngTextTrace(String path, boolean skipIndexing) throws Exception

 public TmfTraceContext seekLocation(Object location) {
 public TmfTraceContext seekEvent(TmfTimestamp timestamp) {
 public TmfTraceContext seekEvent(long position) {

 public TmfEvent getNextEvent(TmfTraceContext context) {
 public Object getCurrentLocation() {

 public LttngEvent parseEvent(TmfTraceContext context) {

 public int getCpuNumber() {
 */

@SuppressWarnings("nls")
public class LTTngTextTraceTest extends TestCase {

    private final static String tracepath1 = "traceset/trace-15316events_nolost_newformat.txt";
    private final static String wrongTracePath = "/somewhere/that/does/not/exist";

    private final static int traceCpuNumber = 1;

    private final static boolean skipIndexing = true;

    private final static long firstEventTimestamp = 13589759412128L;
    private final static long secondEventTimestamp = 13589759419903L;
    private final static Long locationAfterFirstEvent = 311L;

    private final static String tracename = "traceset/trace-15316events_nolost_newformat";

    private final static long indexToSeekFirst = 0;
    private final static Long locationToSeekFirst = 0L;
    private final static long contextValueAfterFirstEvent = 13589759412128L;
    private final static String firstEventReference = tracename + "/metadata_0";

    private final static long timestampToSeekTest1 = 13589826657302L;
    private final static Long indexToSeekTest1 = 7497L;
    private final static long locationToSeekTest1 = 2177044;
    private final static long contextValueAfterSeekTest1 = 13589826657302L;
    private final static String seek1EventReference = tracename + "/vm_state_0";

    private final static long timestampToSeekLast = 13589906758692L;
    private final static Long indexToSeekLast = 15315L;
    private final static long locationToSeekLast = 4420634;
    private final static long contextValueAfterSeekLast = 13589906758692L;
    private final static String seekLastEventReference = tracename + "/kernel_0";

    private static LTTngTextTrace testStream = null;

    private synchronized LTTngTextTrace prepareStreamToTest() {
        if (testStream == null)
            try {
                final URL location = FileLocator.find(FrameworkUtil.getBundle(this.getClass()), new Path(tracepath1), null);
                final File testfile = new File(FileLocator.toFileURL(location).toURI());
                final LTTngTextTrace tmpStream = new LTTngTextTrace(null, testfile.getPath());
                testStream = tmpStream;
            } catch (final Exception e) {
                System.out.println("ERROR : Could not open " + tracepath1);
                testStream = null;
            }
        else
            testStream.seekEvent(0);

        return testStream;
    }

    public void testTraceConstructorFailure() {
        // Default constructor
        // Test constructor with argument on a wrong tracepath, skipping
        // indexing
        try {
            final LTTngTextTrace testStream = new LTTngTextTrace(null, wrongTracePath, skipIndexing);
            fail("Construction with wrong tracepath should fail!");
            testStream.dispose();
        } catch (final Exception e) {
        }
    }
    /*
    public void testTraceConstructor() {
        // Test constructor with argument on a correct tracepath, skipping
        // indexing
        try {
            URL location = FileLocator.find(LTTngCoreTestPlugin.getPlugin().getBundle(), new Path(tracepath1), null);
            File testfile = new File(FileLocator.toFileURL(location).toURI());
            LTTngTextTrace testStream = new LTTngTextTrace(testfile.getPath(), skipIndexing);
            testStream.dispose();
        } catch (Exception e) {
            fail("Construction with correct tracepath failed!");
        }
    }
     */
    public void testGetNextEvent() {
        ITmfEvent tmpEvent = null;
        final LTTngTextTrace testStream1 = prepareStreamToTest();

        final TmfContext tmpContext = new TmfContext(null, 0);
        // We should be at the beginning of the trace, so we will just read the
        // first event now
        tmpEvent = testStream1.getNextEvent(tmpContext);
        assertNotSame("tmpEvent is null after first getNextEvent()", null, tmpEvent);
        assertEquals("tmpEvent has wrong timestamp after first getNextEvent()", firstEventTimestamp, tmpEvent.getTimestamp().getValue());

        // Read the next event as well
        tmpEvent = testStream1.getNextEvent(tmpContext);
        assertNotSame("tmpEvent is null after second getNextEvent()", null, tmpEvent);
        assertEquals("tmpEvent has wrong timestamp after second getNextEvent()", secondEventTimestamp, tmpEvent.getTimestamp().getValue());
    }

    public void testParseEvent() {
        ITmfEvent tmpEvent = null;
        final LTTngTextTrace testStream1 = prepareStreamToTest();

        final TmfContext tmpContext = new TmfContext(null, 0);
        // We should be at the beginning of the trace, so we will just parse the
        // first event now
        tmpEvent = testStream1.parseEvent(tmpContext);
        assertNotSame("tmpEvent is null after first parseEvent()", null, tmpEvent);
        assertEquals("tmpEvent has wrong timestamp after first parseEvent()", firstEventTimestamp, tmpEvent.getTimestamp().getValue());

        // Use parseEvent again. Should be the same event
        tmpEvent = testStream1.parseEvent(tmpContext);
        assertNotSame("tmpEvent is null after first parseEvent()", null, tmpEvent);
        assertEquals("tmpEvent has wrong timestamp after first parseEvent()", firstEventTimestamp, tmpEvent.getTimestamp().getValue());
    }

    public void testSeekEventTimestamp() {
        ITmfEvent tmpEvent = null;
        ITmfContext tmpContext = new TmfContext(null, 0);
        final LTTngTextTrace testStream1 = prepareStreamToTest();

        // We should be at the beginning of the trace, we will seek at a certain
        // timestamp
        tmpContext = testStream1.seekEvent(new TmfTimestamp(timestampToSeekTest1, (byte) -9, 0));
        tmpEvent = testStream1.getNextEvent(tmpContext);
        assertNotSame("tmpContext is null after first seekEvent()", null, tmpContext);
        assertEquals("tmpContext has wrong timestamp after first seekEvent()", contextValueAfterSeekTest1, tmpEvent.getTimestamp().getValue());
        assertNotSame("tmpEvent is null after first seekEvent()", null, tmpEvent);
        assertTrue("tmpEvent has wrong reference after first seekEvent()", seek1EventReference.contains(tmpEvent.getReference()));

        // Seek to the last timestamp
        tmpContext = testStream1.seekEvent(new TmfTimestamp(timestampToSeekLast, (byte) -9, 0));
        tmpEvent = testStream1.getNextEvent(tmpContext);
        assertNotSame("tmpContext is null after seekEvent() to last", null, tmpContext);
        assertEquals("tmpContext has wrong timestamp after seekEvent() to last", contextValueAfterSeekLast, tmpEvent.getTimestamp().getValue());
        assertNotSame("tmpEvent is null after seekEvent() to last ", null, tmpEvent);
        assertTrue("tmpEvent has wrong reference after seekEvent() to last", seekLastEventReference.contains(tmpEvent.getReference()));

        // Seek to the first timestamp (startTime)
        tmpContext = testStream1.seekEvent(new TmfTimestamp(firstEventTimestamp, (byte) -9, 0));
        tmpEvent = testStream1.getNextEvent(tmpContext);
        assertNotSame("tmpEvent is null after seekEvent() to start ", null, tmpEvent);
        assertTrue("tmpEvent has wrong reference after seekEvent() to start", firstEventReference.contains(tmpEvent.getReference()));
        assertNotSame("tmpContext is null after seekEvent() to first", null, tmpContext);
        assertEquals("tmpContext has wrong timestamp after seekEvent() to first", contextValueAfterFirstEvent, tmpEvent.getTimestamp().getValue());
    }

    public void testSeekEventIndex() {
        ITmfEvent tmpEvent = null;
        ITmfContext tmpContext = new TmfContext(null, 0);
        final LTTngTextTrace testStream1 = prepareStreamToTest();

        // We should be at the beginning of the trace, we will seek at a certain
        // timestamp
        tmpContext = testStream1.seekEvent(indexToSeekTest1);
        tmpEvent = testStream1.getNextEvent(tmpContext);
        assertNotSame("tmpContext is null after first seekEvent()", null, tmpContext);
        assertEquals("tmpContext has wrong timestamp after first seekEvent()", contextValueAfterSeekTest1, tmpEvent.getTimestamp().getValue());
        assertNotSame("tmpEvent is null after first seekEvent()", null, tmpEvent);
        assertTrue("tmpEvent has wrong reference after first seekEvent()", seek1EventReference.contains(tmpEvent.getReference()));

        // Seek to the last timestamp
        tmpContext = testStream1.seekEvent(indexToSeekLast);
        tmpEvent = testStream1.getNextEvent(tmpContext);
        assertNotSame("tmpContext is null after first seekEvent()", null, tmpContext);
        assertEquals("tmpContext has wrong timestamp after first seekEvent()", contextValueAfterSeekLast, tmpEvent.getTimestamp().getValue());
        assertNotSame("tmpEvent is null after seekEvent() to last ", null, tmpEvent);
        assertTrue("tmpEvent has wrong reference after seekEvent() to last", seekLastEventReference.contains(tmpEvent.getReference()));

        // Seek to the first timestamp (startTime)
        tmpContext = testStream1.seekEvent(indexToSeekFirst);
        tmpEvent = testStream1.getNextEvent(tmpContext);
        assertNotSame("tmpContext is null after first seekEvent()", null, tmpContext);
        assertEquals("tmpContext has wrong timestamp after first seekEvent()", contextValueAfterFirstEvent, tmpEvent.getTimestamp().getValue());
        assertNotSame("tmpEvent is null after seekEvent() to start ", null, tmpEvent);
        assertTrue("tmpEvent has wrong reference after seekEvent() to start", firstEventReference.contains(tmpEvent.getReference()));
    }

    public void testSeekLocation() {
        ITmfEvent tmpEvent = null;
        TmfContext tmpContext = new TmfContext(null, 0);
        final LTTngTextTrace testStream1 = prepareStreamToTest();

        // We should be at the beginning of the trace, we will seek at a certain
        // timestamp
        tmpContext = testStream1.seekLocation(new TmfLocation<Long>(locationToSeekTest1));
        tmpEvent = testStream1.getNextEvent(tmpContext);
        assertNotSame("tmpContext is null after first seekLocation()", null, tmpContext);
        assertEquals("tmpContext has wrong timestamp after first seekLocation()", contextValueAfterSeekTest1, tmpEvent.getTimestamp().getValue());
        assertNotSame("tmpEvent is null after first seekLocation()", null, tmpEvent);
        assertTrue("tmpEvent has wrong reference after first seekLocation()", seek1EventReference.contains(tmpEvent.getReference()));

        // Seek to the last timestamp
        tmpContext = testStream1.seekLocation(new TmfLocation<Long>(locationToSeekLast));
        tmpEvent = testStream1.getNextEvent(tmpContext);
        assertNotSame("tmpContext is null after first seekLocation()", null, tmpContext);
        assertEquals("tmpContext has wrong timestamp after first seekLocation()", contextValueAfterSeekLast, tmpEvent.getTimestamp().getValue());
        assertNotSame("tmpEvent is null after seekLocation() to last ", null, tmpEvent);
        assertTrue("tmpEvent has wrong reference after seekLocation() to last", seekLastEventReference.contains(tmpEvent.getReference()));

        // Seek to the first timestamp (startTime)
        tmpContext = testStream1.seekLocation(new TmfLocation<Long>(locationToSeekFirst));
        tmpEvent = testStream1.getNextEvent(tmpContext);
        assertNotSame("tmpContext is null after first seekLocation()", null, tmpContext);
        assertEquals("tmpContext has wrong timestamp after first seekLocation()", contextValueAfterFirstEvent, tmpEvent.getTimestamp().getValue());
        assertNotSame("tmpEvent is null after seekLocation() to start ", null, tmpEvent);
        assertTrue("tmpEvent has wrong reference after seekLocation() to start", firstEventReference.contains(tmpEvent.getReference()));
    }

    @SuppressWarnings("unchecked")
    public void testGetter() {
        ITmfEvent tmpEvent = null;
        final LTTngTextTrace testStream1 = prepareStreamToTest();
        final TmfContext tmpContext = new TmfContext(null, 0);

        // Move to the first event to have something to play with
        tmpEvent = testStream1.parseEvent(tmpContext);

        // Test current event
        assertNotSame("tmpEvent is null after first event", null, tmpEvent);
        assertTrue("tmpEvent has wrong reference after first event", firstEventReference.contains(tmpEvent.getReference()));
        assertNotSame("tmpContext is null after first seekEvent()", null, testStream1.getCurrentLocation());
        assertEquals("tmpContext has wrong timestamp after first seekEvent()", locationAfterFirstEvent, ((TmfLocation<Long>) testStream1.getCurrentLocation()).getLocation());
        // Test CPU number of the trace
        assertSame("getCpuNumber() return wrong number of cpu", traceCpuNumber, testStream1.getCpuNumber());
    }

    public void testToString() {
        final LTTngTextTrace testStream1 = prepareStreamToTest();

        // Move to the first event to have something to play with
        testStream1.parseEvent(new TmfContext(null, 0));

        // Just make sure toString() does not return null or the java reference
        assertNotSame("toString returned null", null, testStream1.toString());
        assertNotSame("toString is not overridded!", testStream1.getClass().getName() + '@' + Integer.toHexString(testStream1.hashCode()), testStream1.toString());
    }

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