[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 org.eclipse.linuxtools.lttng.jni.JniEvent;
import org.eclipse.linuxtools.lttng.jni.JniException;
import org.eclipse.linuxtools.lttng.jni.JniTime;
import org.eclipse.linuxtools.lttng.jni.JniTrace;
import org.eclipse.linuxtools.lttng.jni.JniTracefile;
import org.eclipse.linuxtools.lttng.jni.Jni_C_Pointer;

import junit.framework.TestCase;

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