[deliverable/tracecompass.git] / org.eclipse.linuxtools.lttng.tests / src / org / eclipse / linuxtools / lttng / tests / jni / JniEventTest.java


/*
 Functions tested here :
        public JniEvent(JniEvent oldEvent)
        public JniEvent(long newEventPtr, long newTracefilePtr, HashMap<Integer, JniMarker> newMarkersMap, JniTracefile newParentTracefile) throws JafException
        
        public int readNextEvent()
        public int seekToTime(JniTime seekTime)
        public int seekOrFallBack(JniTime seekTime)
        
        public JniMarker requestEventMarker()
        public String requestEventSource()
        public JniTime requestNextEventTime()
        
        public ArrayList<ParsedContent> parse()
        
        public int getEventMarkerId()
        public JniTime getEventTime()
        public long getEventDataSize()
        public HashMap<Integer, JniMarker> getMarkersMap()
        public long getTracefilePtr()
        public long getEventPtr()
        public int getEventState()
        public JniTracefile getParentTracefile()
        
        public String toString()
        public void printEventInformation()
*/


package org.eclipse.linuxtools.lttng.tests.jni;


import junit.framework.TestCase;

import org.eclipse.linuxtools.lttng.jni.JniEvent;
import org.eclipse.linuxtools.lttng.jni.JniTracefile;
import org.eclipse.linuxtools.lttng.jni.common.JniTime;
import org.eclipse.linuxtools.lttng.jni.exception.JniException;
import org.eclipse.linuxtools.lttng.jni.factory.JniTraceFactory;

@SuppressWarnings("nls")
public class JniEventTest extends TestCase
{
		private final static boolean printLttDebug = false;
	
        private final static String tracepath="traceset/trace-15316events_nolost_newformat";
        private final static String eventName="kernel0";
        
        private final static int    numberOfMarkersInTracefile = 45;
        
        private final static int    numberOfparsedFieldsFirstEvent = 1;
        private final static int    numberOfparsedFieldsSecondEvent = 3;
        
        private final static int    chosenPositionOfFieldsFirstEvent = 1;
        private final static int    chosenPositionOfFieldsSecondEvent = 0;
        private final static int    chosenPositionOfFieldsAfterSeekEvent = 1;
        
        private final static String chosenNameOfFieldsFirstEvent = "string";
        private final static String chosenNameOfFieldsSecondEvent = "ip";
        private final static String chosenNameOfFieldsThirdEvent = "syscall_id";
        
        private final static String contentOfFieldsFirstEvent = "LTT state dump begin";
        private final static String   contentOfFieldsSecondEvent = "0xc142176d";
        private final static long   contentOfFieldsThirdEvent = 3L;
        
        private final static int    numberOfByteInContent = 4;
        
        private final static long   firstEventTimestamp = 13589760262237L;
        private final static long   secondEventTimestamp = 13589762149621L;
        private final static long   thirdEventTimestamp = 13589762917527L;
        
        private final static long   timestampToSeekTest1 = 13589807108560L;
        private final static long   timestampAfterSeekTest1 = 13589807116344L;
        
        private final static long   timestampToSeekLast = 13589906758692L;
        
        private final static long   timestampToSeekTooFarAway = Long.MAX_VALUE;

        private JniEvent prepareEventToTest() {
                
                JniEvent tmpEvent = null;
                
                // This trace should be valid
                try {
                        tmpEvent = JniTraceFactory.getJniTrace(tracepath, null, printLttDebug).requestEventByName(eventName);
                }
                catch( JniException e) { }
                
                return tmpEvent;
        }
        
        
        public void testEventConstructors() {
                JniTracefile testTracefile = null;
                
                @SuppressWarnings("unused")
				JniEvent testEvent1 = null;
                @SuppressWarnings("unused")
				JniEvent testEvent2 = null;
                
                // This trace should be valid and will be used in test
                try {
                        testTracefile = JniTraceFactory.getJniTrace(tracepath, null, printLttDebug).requestTracefileByName(eventName);
                }
                catch( JniException e) { }
                
                
                // Test constructor on a wrong marker HashMap
                try {
                        testEvent1 = testTracefile.allocateNewJniEvent( testTracefile.getCurrentEvent().getEventPtr(), null, testTracefile );
                        fail("Construction with wrong marker hashmap should fail!");
                }
                catch( JniException e) { 
                }
                
                // Test constructor on a wrong tracefile reference
                try {
                        testEvent1 = testTracefile.allocateNewJniEvent( testTracefile.getCurrentEvent().getEventPtr(), testTracefile.getTracefileMarkersMap(), null );
                        fail("Construction with wrong tracefile reference should fail!");
                }
                catch( JniException e) { 
                }
                
                
                // Finally, test constructor with correct information
                try {
                        testEvent1 = testTracefile.allocateNewJniEvent( testTracefile.getCurrentEvent().getEventPtr(), testTracefile.getTracefileMarkersMap(), testTracefile );
                }
                catch( JniException e) { 
                        fail("Construction with correct information failed!");
                }
                
                /*
                // Test copy constructor
                try {
                        testEvent1 = new JniEvent( testTracefile.getCurrentEvent() );
                        testEvent2 = new JniEvent( testEvent1);
                }
                catch( Exception e) {
                        fail("Copy constructor failed!");
                }
                assertEquals("JniEvent timestamp not same after using copy constructor", testEvent1.getEventTime().getTime() , testEvent2.getEventTime().getTime() );
                */
                
        }
        
        public void testPrintAndToString() {
                
                JniEvent testEvent = prepareEventToTest();
                
                // Test printEventInformation
                try {
                        testEvent.printEventInformation();
                }
                catch( Exception e) { 
                        fail("printEventInformation failed!");
                }
                
                // Test ToString()
                assertNotSame("toString returned empty data","",testEvent.toString() );
                
        }
        
        public void testEventDisplacement() {
                
                int readValue = -1;
                int seekValue = -1; 
                JniEvent testEvent = prepareEventToTest();
                
                // Test #1 readNextEvent()
                readValue = testEvent.readNextEvent();
                assertSame("readNextEvent() returned error (test #1)",0,readValue);
                assertEquals("readNextEvent() event timestamp is incoherent (test #1)",secondEventTimestamp,testEvent.getEventTime().getTime() );
                
                // Test #2 readNextEvent()
                readValue = testEvent.readNextEvent();
                assertSame("readNextEvent() returned error (test #1)",0,readValue);
                assertEquals("readNextEvent() event timestamp is incoherent (test #1)",thirdEventTimestamp,testEvent.getEventTime().getTime() );
                
                
                // Test  #1 of seekToTime()
                seekValue = testEvent.seekToTime(new JniTime(timestampToSeekTest1) );
                assertSame("seekToTime() returned error (test #1)",0,seekValue);
                // Read SHOULD NOT be performed after a seek!
                assertEquals("readNextEvent() event timestamp is incoherent (test #1)",timestampToSeekTest1,testEvent.getEventTime().getTime() );
                
                readValue = testEvent.readNextEvent();
                assertEquals("readNextEvent() event timestamp is incoherent (test #1)",timestampAfterSeekTest1,testEvent.getEventTime().getTime() );
                
                
                // Test  #2 of seekToTime()
                seekValue = testEvent.seekToTime(new JniTime(timestampToSeekLast) );
                assertSame("seekToTime() returned error (test #2)",0,seekValue);
                // Read SHOULD NOT be performed after a seek!
                assertEquals("readNextEvent() event timestamp is incoherent (test #2)",timestampToSeekLast,testEvent.getEventTime().getTime() );
                
                // Read AFTER the last event should bring an error
                readValue = testEvent.readNextEvent();
                assertNotSame("readNextEvent() AFTER last event should return error (test #2)",0,readValue);
                
                
                // Test to see if we can seek back
                seekValue = testEvent.seekToTime(new JniTime(firstEventTimestamp) );
                assertSame("seekToTime() returned error (test seek back)",0,seekValue);
                // Read SHOULD NOT be performed after a seek!
                assertEquals("readNextEvent() event timestamp is incoherent (test seek back)",firstEventTimestamp,testEvent.getEventTime().getTime() );
                
                
                // Test  #1 of seekOrFallBack() (seek within range)
                seekValue = testEvent.seekOrFallBack(new JniTime(timestampToSeekTest1) );
                assertSame("seekToTime() returned error (test #1)",0,seekValue);
                // Read SHOULD NOT be performed after a seek!
                assertEquals("readNextEvent() event timestamp is incoherent (test #1)",timestampToSeekTest1,testEvent.getEventTime().getTime() );
                
                // Test  #2 of seekOrFallBack() (seek out of range, should fall back)
                seekValue = testEvent.seekOrFallBack(new JniTime(timestampToSeekTooFarAway) );
                assertNotSame("seekOrFallBack() should return an error (test #2)",0,seekValue);
                // The read should return the "last" value as we seek back
                assertEquals("readNextEvent() event timestamp is incoherent (test #2)",timestampToSeekTest1,testEvent.getEventTime().getTime() );
        }
        
        public void testGetSet() {
                
                JniEvent testEvent = prepareEventToTest();
                
                // Test that all Get/Set return data
                assertNotSame("getEventMarkerId is 0",0,testEvent.getEventMarkerId() );
                
                // JniTime should never be null
                assertNotNull("getEventTime returned null", testEvent.getEventTime() );
                
                assertNotSame("getEventDataSize is 0",0,testEvent.getEventDataSize() );
                
                // Test that the marker map is not null
                assertNotSame("getMarkersMap is null",null,testEvent.getMarkersMap() );
                // Also check that the map contain some data
                assertSame("getMarkersMap returned an unexpected number of markers",numberOfMarkersInTracefile,testEvent.getMarkersMap().size() );
                
                assertNotSame("getTracefilePtr is 0",0,testEvent.getTracefilePtr() );
                assertNotSame("getEventPtr is 0",0,testEvent.getEventPtr() );
                // State 0 (EOK) means the event is in a sane state
                assertSame("getEventState is not EOK",0,testEvent.getEventState() );
                
                // ParentTracefile should never be null
                assertNotNull("getParentTracefile returned null", testEvent.getParentTracefile() );
        }
        
        public void testRequestFunctions() {
                
                JniEvent testEvent = prepareEventToTest();
                
                // Test requestEventMarker(). Should return an unique marker
                assertNotNull("requestEventMarker returned null",testEvent.requestEventMarker() );
                
                // Test requestEventSource()
                assertNotSame("requestEventSource is empty","",testEvent.requestEventSource() );
                
                // Test requestEventContent()
                assertNotNull("requestEventContent returned null",testEvent.requestEventContent() );
                
                // Also check that the byte array contain some data
                assertSame("requestEventContent returned an unexpected number of markers",numberOfByteInContent,testEvent.requestEventContent().length );
                
        }
        
        public void testParseAllFieldsFunctions() {
                
                JniEvent testEvent = prepareEventToTest();
                
                // Test parse()
                assertNotNull("parseAllFields returned null",testEvent.parseAllFields() );
                // Parse shouldn't be empty
                assertSame("parseAllFields returned an unexpected number of parsed fields",numberOfparsedFieldsFirstEvent,testEvent.parseAllFields().size() );
                
                // MORE PARSING TESTS 
                // We will perform several more unit tests about parsing as it is very important
                // All those below use the same call as in the displacement test
                // Test #1 readNextEvent()
                testEvent.readNextEvent();
                assertNotNull("parseAllFields returned null",testEvent.parseAllFields() );
                assertSame("parseAllFields returned an unexpected number of parsed fields",numberOfparsedFieldsSecondEvent,testEvent.parseAllFields().size() );
                // Test #2 readNextEvent()
                testEvent.readNextEvent();
                assertNotNull("parseAllFields returned null",testEvent.parseAllFields() );
                
                // Test  #1 of seekToTime()
                testEvent.seekToTime(new JniTime(timestampToSeekTest1) );
                // Read need to be perform after a seek!
                testEvent.readNextEvent();
                assertNotNull("parseAllFields returned null",testEvent.parseAllFields() );
                testEvent.readNextEvent();
                assertNotNull("parseAllFields returned null",testEvent.parseAllFields() );
                
                // Test  #2 of seekToTime()
                testEvent.seekToTime(new JniTime(timestampToSeekLast) );
                // Read need to be perform after a seek!
                testEvent.readNextEvent();
                assertNotNull("parseAllFields returned null",testEvent.parseAllFields() );
                
                // Test to see if we can seek back
                testEvent.seekToTime(new JniTime(firstEventTimestamp) );
                // Read need to be perform after a seek!
                testEvent.readNextEvent();
                assertNotNull("parseAllFields returned null",testEvent.parseAllFields() );
        }
        
        public void testParseFieldByIdFunctions() {
                JniEvent testEvent = prepareEventToTest();
                
                // Test parse()
                assertNotNull("parseFieldById returned null",testEvent.parseFieldById(0) );
                
                testEvent.readNextEvent();
                assertNotNull("parseFieldById returned null",testEvent.parseFieldById(chosenPositionOfFieldsFirstEvent) );
                assertEquals("Content return by parseFieldById is invalid",contentOfFieldsFirstEvent, testEvent.parseFieldById(chosenPositionOfFieldsFirstEvent) );
                assertEquals("Content return by parseFieldByName is invalid",contentOfFieldsFirstEvent, testEvent.parseFieldByName(chosenNameOfFieldsFirstEvent) );
                
                // MORE PARSING TESTS 
                // We will perform several more unit tests about parsing as it is very important
                // All those below use the same call as in the displacement test
                // Test #1 readNextEvent()
                testEvent.readNextEvent();
                assertNotNull("parseFieldById returned null",testEvent.parseFieldById(chosenPositionOfFieldsSecondEvent) );
                assertEquals("Content return by parseFieldById is invalid", contentOfFieldsSecondEvent, testEvent.parseFieldById(chosenPositionOfFieldsSecondEvent).toString() );
                assertEquals("Content return by parseFieldByName is invalid",contentOfFieldsSecondEvent, testEvent.parseFieldByName(chosenNameOfFieldsSecondEvent).toString() );
                
                // Test  #1 of seekToTime()
                testEvent.seekToTime(new JniTime(timestampToSeekTest1) );
                // Read need to be perform after a seek!
                testEvent.readNextEvent();
                assertNotNull("parseFieldById returned null",testEvent.parseFieldById(chosenPositionOfFieldsAfterSeekEvent) );
                assertEquals("Content return by parseFieldById is invalid",contentOfFieldsThirdEvent, testEvent.parseFieldById(chosenPositionOfFieldsAfterSeekEvent) );
                assertEquals("Content return by parseFieldByName is invalid",contentOfFieldsThirdEvent, testEvent.parseFieldByName(chosenNameOfFieldsThirdEvent) );
                
                // Test to see if we can seek back
                testEvent.seekToTime(new JniTime(firstEventTimestamp) );
                // Read need to be perform after a seek!
                testEvent.readNextEvent();
                assertNotNull("parseFieldById returned null",testEvent.parseFieldById(chosenPositionOfFieldsFirstEvent) );
                assertEquals("Content return by parseFieldById is invalid",contentOfFieldsFirstEvent, testEvent.parseFieldById(chosenPositionOfFieldsFirstEvent) );
                assertEquals("Content return by parseFieldByName is invalid",contentOfFieldsFirstEvent, testEvent.parseFieldByName(chosenNameOfFieldsFirstEvent) );
        }
}
Commit	Line	Data
03c71d1e ASL	1
	2	/*
	3	Functions tested here :
	4	public JniEvent(JniEvent oldEvent)
	5	public JniEvent(long newEventPtr, long newTracefilePtr, HashMap<Integer, JniMarker> newMarkersMap, JniTracefile newParentTracefile) throws JafException
	6
	7	public int readNextEvent()
	8	public int seekToTime(JniTime seekTime)
	9	public int seekOrFallBack(JniTime seekTime)
	10
	11	public JniMarker requestEventMarker()
	12	public String requestEventSource()
	13	public JniTime requestNextEventTime()
	14
	15	public ArrayList<ParsedContent> parse()
	16
	17	public int getEventMarkerId()
	18	public JniTime getEventTime()
	19	public long getEventDataSize()
	20	public HashMap<Integer, JniMarker> getMarkersMap()
	21	public long getTracefilePtr()
	22	public long getEventPtr()
	23	public int getEventState()
	24	public JniTracefile getParentTracefile()
	25
	26	public String toString()
	27	public void printEventInformation()
	28	*/
	29
	30
	31	package org.eclipse.linuxtools.lttng.tests.jni;
	32
9c841e9c	33
8b63111e WB	34	import junit.framework.TestCase;
8b63111e WB	35
03c71d1e ASL	36	import org.eclipse.linuxtools.lttng.jni.JniEvent;
03c71d1e ASL	37	import org.eclipse.linuxtools.lttng.jni.JniTracefile;
9c841e9c	38	import org.eclipse.linuxtools.lttng.jni.common.JniTime;
9c841e9c WB	39	import org.eclipse.linuxtools.lttng.jni.exception.JniException;
9c841e9c WB	40	import org.eclipse.linuxtools.lttng.jni.factory.JniTraceFactory;
86de1b08	41
3b38ea61	42	@SuppressWarnings("nls")
03c71d1e ASL	43	public class JniEventTest extends TestCase
	44	{
	45	private final static boolean printLttDebug = false;
	46
1c859a36	47	private final static String tracepath="traceset/trace-15316events_nolost_newformat";
03c71d1e ASL	48	private final static String eventName="kernel0";
03c71d1e ASL	49
1c859a36	50	private final static int numberOfMarkersInTracefile = 45;
03c71d1e ASL	51
	52	private final static int numberOfparsedFieldsFirstEvent = 1;
	53	private final static int numberOfparsedFieldsSecondEvent = 3;
	54
	55	private final static int chosenPositionOfFieldsFirstEvent = 1;
	56	private final static int chosenPositionOfFieldsSecondEvent = 0;
1c859a36	57	private final static int chosenPositionOfFieldsAfterSeekEvent = 1;
03c71d1e ASL	58
	59	private final static String chosenNameOfFieldsFirstEvent = "string";
	60	private final static String chosenNameOfFieldsSecondEvent = "ip";
1c859a36	61	private final static String chosenNameOfFieldsThirdEvent = "syscall_id";
03c71d1e ASL	62
03c71d1e ASL	63	private final static String contentOfFieldsFirstEvent = "LTT state dump begin";
1c859a36	64	private final static String contentOfFieldsSecondEvent = "0xc142176d";
03c71d1e ASL	65	private final static long contentOfFieldsThirdEvent = 3L;
	66
	67	private final static int numberOfByteInContent = 4;
	68
1c859a36 WB	69	private final static long firstEventTimestamp = 13589760262237L;
	70	private final static long secondEventTimestamp = 13589762149621L;
	71	private final static long thirdEventTimestamp = 13589762917527L;
03c71d1e	72
1c859a36 WB	73	private final static long timestampToSeekTest1 = 13589807108560L;
1c859a36 WB	74	private final static long timestampAfterSeekTest1 = 13589807116344L;
03c71d1e	75
1c859a36	76	private final static long timestampToSeekLast = 13589906758692L;
03c71d1e ASL	77
03c71d1e ASL	78	private final static long timestampToSeekTooFarAway = Long.MAX_VALUE;
1c859a36	79
03c71d1e ASL	80	private JniEvent prepareEventToTest() {
	81
	82	JniEvent tmpEvent = null;
	83
	84	// This trace should be valid
	85	try {
a3767fd9	86	tmpEvent = JniTraceFactory.getJniTrace(tracepath, null, printLttDebug).requestEventByName(eventName);
03c71d1e ASL	87	}
	88	catch( JniException e) { }
	89
	90	return tmpEvent;
	91	}
	92
	93
	94	public void testEventConstructors() {
	95	JniTracefile testTracefile = null;
	96
9c841e9c WB	97	@SuppressWarnings("unused")
	98	JniEvent testEvent1 = null;
	99	@SuppressWarnings("unused")
	100	JniEvent testEvent2 = null;
03c71d1e ASL	101
	102	// This trace should be valid and will be used in test
	103	try {
a3767fd9	104	testTracefile = JniTraceFactory.getJniTrace(tracepath, null, printLttDebug).requestTracefileByName(eventName);
03c71d1e ASL	105	}
	106	catch( JniException e) { }
	107
	108
	109	// Test constructor on a wrong marker HashMap
	110	try {
9c841e9c	111	testEvent1 = testTracefile.allocateNewJniEvent( testTracefile.getCurrentEvent().getEventPtr(), null, testTracefile );
03c71d1e ASL	112	fail("Construction with wrong marker hashmap should fail!");
	113	}
	114	catch( JniException e) {
	115	}
	116
	117	// Test constructor on a wrong tracefile reference
	118	try {
9c841e9c	119	testEvent1 = testTracefile.allocateNewJniEvent( testTracefile.getCurrentEvent().getEventPtr(), testTracefile.getTracefileMarkersMap(), null );
03c71d1e ASL	120	fail("Construction with wrong tracefile reference should fail!");
	121	}
	122	catch( JniException e) {
	123	}
	124
	125
	126	// Finally, test constructor with correct information
	127	try {
9c841e9c	128	testEvent1 = testTracefile.allocateNewJniEvent( testTracefile.getCurrentEvent().getEventPtr(), testTracefile.getTracefileMarkersMap(), testTracefile );
03c71d1e ASL	129	}
	130	catch( JniException e) {
	131	fail("Construction with correct information failed!");
	132	}
	133
9c841e9c	134	/*
03c71d1e ASL	135	// Test copy constructor
	136	try {
	137	testEvent1 = new JniEvent( testTracefile.getCurrentEvent() );
	138	testEvent2 = new JniEvent( testEvent1);
	139	}
	140	catch( Exception e) {
	141	fail("Copy constructor failed!");
	142	}
	143	assertEquals("JniEvent timestamp not same after using copy constructor", testEvent1.getEventTime().getTime() , testEvent2.getEventTime().getTime() );
9c841e9c	144	*/
03c71d1e ASL	145
	146	}
	147
	148	public void testPrintAndToString() {
	149
	150	JniEvent testEvent = prepareEventToTest();
	151
	152	// Test printEventInformation
	153	try {
	154	testEvent.printEventInformation();
	155	}
	156	catch( Exception e) {
	157	fail("printEventInformation failed!");
	158	}
	159
	160	// Test ToString()
	161	assertNotSame("toString returned empty data","",testEvent.toString() );
	162
	163	}
	164
	165	public void testEventDisplacement() {
	166
	167	int readValue = -1;
	168	int seekValue = -1;
	169	JniEvent testEvent = prepareEventToTest();
	170
	171	// Test #1 readNextEvent()
	172	readValue = testEvent.readNextEvent();
	173	assertSame("readNextEvent() returned error (test #1)",0,readValue);
	174	assertEquals("readNextEvent() event timestamp is incoherent (test #1)",secondEventTimestamp,testEvent.getEventTime().getTime() );
	175
	176	// Test #2 readNextEvent()
	177	readValue = testEvent.readNextEvent();
	178	assertSame("readNextEvent() returned error (test #1)",0,readValue);
	179	assertEquals("readNextEvent() event timestamp is incoherent (test #1)",thirdEventTimestamp,testEvent.getEventTime().getTime() );
	180
	181
	182	// Test #1 of seekToTime()
	183	seekValue = testEvent.seekToTime(new JniTime(timestampToSeekTest1) );
	184	assertSame("seekToTime() returned error (test #1)",0,seekValue);
	185	// Read SHOULD NOT be performed after a seek!
	186	assertEquals("readNextEvent() event timestamp is incoherent (test #1)",timestampToSeekTest1,testEvent.getEventTime().getTime() );
	187
	188	readValue = testEvent.readNextEvent();
	189	assertEquals("readNextEvent() event timestamp is incoherent (test #1)",timestampAfterSeekTest1,testEvent.getEventTime().getTime() );
	190
	191
	192	// Test #2 of seekToTime()
	193	seekValue = testEvent.seekToTime(new JniTime(timestampToSeekLast) );
	194	assertSame("seekToTime() returned error (test #2)",0,seekValue);
	195	// Read SHOULD NOT be performed after a seek!
	196	assertEquals("readNextEvent() event timestamp is incoherent (test #2)",timestampToSeekLast,testEvent.getEventTime().getTime() );
	197
	198	// Read AFTER the last event should bring an error
	199	readValue = testEvent.readNextEvent();
	200	assertNotSame("readNextEvent() AFTER last event should return error (test #2)",0,readValue);
	201
	202
	203	// Test to see if we can seek back
	204	seekValue = testEvent.seekToTime(new JniTime(firstEventTimestamp) );
	205	assertSame("seekToTime() returned error (test seek back)",0,seekValue);
	206	// Read SHOULD NOT be performed after a seek!
	207	assertEquals("readNextEvent() event timestamp is incoherent (test seek back)",firstEventTimestamp,testEvent.getEventTime().getTime() );
	208
209
210	// Test #1 of seekOrFallBack() (seek within range)
211	seekValue = testEvent.seekOrFallBack(new JniTime(timestampToSeekTest1) );
212	assertSame("seekToTime() returned error (test #1)",0,seekValue);
213	// Read SHOULD NOT be performed after a seek!
214	assertEquals("readNextEvent() event timestamp is incoherent (test #1)",timestampToSeekTest1,testEvent.getEventTime().getTime() );
215
216	// Test #2 of seekOrFallBack() (seek out of range, should fall back)
217	seekValue = testEvent.seekOrFallBack(new JniTime(timestampToSeekTooFarAway) );
218	assertNotSame("seekOrFallBack() should return an error (test #2)",0,seekValue);
219	// The read should return the "last" value as we seek back
220	assertEquals("readNextEvent() event timestamp is incoherent (test #2)",timestampToSeekTest1,testEvent.getEventTime().getTime() );
221	}
222
223	public void testGetSet() {
224
225	JniEvent testEvent = prepareEventToTest();
226
227	// Test that all Get/Set return data
228	assertNotSame("getEventMarkerId is 0",0,testEvent.getEventMarkerId() );
229
230	// JniTime should never be null
231	assertNotNull("getEventTime returned null", testEvent.getEventTime() );
232
233	assertNotSame("getEventDataSize is 0",0,testEvent.getEventDataSize() );
234
235	// Test that the marker map is not null
236	assertNotSame("getMarkersMap is null",null,testEvent.getMarkersMap() );
237	// Also check that the map contain some data
238	assertSame("getMarkersMap returned an unexpected number of markers",numberOfMarkersInTracefile,testEvent.getMarkersMap().size() );
239
240	assertNotSame("getTracefilePtr is 0",0,testEvent.getTracefilePtr() );
241	assertNotSame("getEventPtr is 0",0,testEvent.getEventPtr() );
242	// State 0 (EOK) means the event is in a sane state
243	assertSame("getEventState is not EOK",0,testEvent.getEventState() );
244
245	// ParentTracefile should never be null
246	assertNotNull("getParentTracefile returned null", testEvent.getParentTracefile() );
247	}
248
249	public void testRequestFunctions() {
250
251	JniEvent testEvent = prepareEventToTest();
252
253	// Test requestEventMarker(). Should return an unique marker
254	assertNotNull("requestEventMarker returned null",testEvent.requestEventMarker() );
255
256	// Test requestEventSource()
257	assertNotSame("requestEventSource is empty","",testEvent.requestEventSource() );
258
259	// Test requestEventContent()
260	assertNotNull("requestEventContent returned null",testEvent.requestEventContent() );
261
262	// Also check that the byte array contain some data
263	assertSame("requestEventContent returned an unexpected number of markers",numberOfByteInContent,testEvent.requestEventContent().length );
264
265	}
266
267	public void testParseAllFieldsFunctions() {
268
269	JniEvent testEvent = prepareEventToTest();
270
271	// Test parse()
272	assertNotNull("parseAllFields returned null",testEvent.parseAllFields() );
273	// Parse shouldn't be empty
274	assertSame("parseAllFields returned an unexpected number of parsed fields",numberOfparsedFieldsFirstEvent,testEvent.parseAllFields().size() );
275
276	// MORE PARSING TESTS
277	// We will perform several more unit tests about parsing as it is very important
278	// All those below use the same call as in the displacement test
279	// Test #1 readNextEvent()
280	testEvent.readNextEvent();
281	assertNotNull("parseAllFields returned null",testEvent.parseAllFields() );
282	assertSame("parseAllFields returned an unexpected number of parsed fields",numberOfparsedFieldsSecondEvent,testEvent.parseAllFields().size() );
283	// Test #2 readNextEvent()
284	testEvent.readNextEvent();
285	assertNotNull("parseAllFields returned null",testEvent.parseAllFields() );
286
287	// Test #1 of seekToTime()
288	testEvent.seekToTime(new JniTime(timestampToSeekTest1) );
289	// Read need to be perform after a seek!
290	testEvent.readNextEvent();
291	assertNotNull("parseAllFields returned null",testEvent.parseAllFields() );
292	testEvent.readNextEvent();
293	assertNotNull("parseAllFields returned null",testEvent.parseAllFields() );
294
295	// Test #2 of seekToTime()
296	testEvent.seekToTime(new JniTime(timestampToSeekLast) );
297	// Read need to be perform after a seek!
298	testEvent.readNextEvent();
299	assertNotNull("parseAllFields returned null",testEvent.parseAllFields() );
300
301	// Test to see if we can seek back
302	testEvent.seekToTime(new JniTime(firstEventTimestamp) );
303	// Read need to be perform after a seek!
304	testEvent.readNextEvent();
305	assertNotNull("parseAllFields returned null",testEvent.parseAllFields() );
306	}
307
308	public void testParseFieldByIdFunctions() {
309	JniEvent testEvent = prepareEventToTest();
310
311	// Test parse()
312	assertNotNull("parseFieldById returned null",testEvent.parseFieldById(0) );
313
314	testEvent.readNextEvent();
315	assertNotNull("parseFieldById returned null",testEvent.parseFieldById(chosenPositionOfFieldsFirstEvent) );
316	assertEquals("Content return by parseFieldById is invalid",contentOfFieldsFirstEvent, testEvent.parseFieldById(chosenPositionOfFieldsFirstEvent) );
317	assertEquals("Content return by parseFieldByName is invalid",contentOfFieldsFirstEvent, testEvent.parseFieldByName(chosenNameOfFieldsFirstEvent) );
318
319	// MORE PARSING TESTS
320	// We will perform several more unit tests about parsing as it is very important
321	// All those below use the same call as in the displacement test
322	// Test #1 readNextEvent()
323	testEvent.readNextEvent();
324	assertNotNull("parseFieldById returned null",testEvent.parseFieldById(chosenPositionOfFieldsSecondEvent) );
1c859a36 WB	325	assertEquals("Content return by parseFieldById is invalid", contentOfFieldsSecondEvent, testEvent.parseFieldById(chosenPositionOfFieldsSecondEvent).toString() );
1c859a36 WB	326	assertEquals("Content return by parseFieldByName is invalid",contentOfFieldsSecondEvent, testEvent.parseFieldByName(chosenNameOfFieldsSecondEvent).toString() );
03c71d1e ASL	327
	328	// Test #1 of seekToTime()
	329	testEvent.seekToTime(new JniTime(timestampToSeekTest1) );
	330	// Read need to be perform after a seek!
	331	testEvent.readNextEvent();
	332	assertNotNull("parseFieldById returned null",testEvent.parseFieldById(chosenPositionOfFieldsAfterSeekEvent) );
	333	assertEquals("Content return by parseFieldById is invalid",contentOfFieldsThirdEvent, testEvent.parseFieldById(chosenPositionOfFieldsAfterSeekEvent) );
	334	assertEquals("Content return by parseFieldByName is invalid",contentOfFieldsThirdEvent, testEvent.parseFieldByName(chosenNameOfFieldsThirdEvent) );
	335
	336	// Test to see if we can seek back
	337	testEvent.seekToTime(new JniTime(firstEventTimestamp) );
	338	// Read need to be perform after a seek!
	339	testEvent.readNextEvent();
	340	assertNotNull("parseFieldById returned null",testEvent.parseFieldById(chosenPositionOfFieldsFirstEvent) );
	341	assertEquals("Content return by parseFieldById is invalid",contentOfFieldsFirstEvent, testEvent.parseFieldById(chosenPositionOfFieldsFirstEvent) );
	342	assertEquals("Content return by parseFieldByName is invalid",contentOfFieldsFirstEvent, testEvent.parseFieldByName(chosenNameOfFieldsFirstEvent) );
	343	}
	344	}