[deliverable/tracecompass.git] / org.eclipse.linuxtools.lttng.core.tests / src / org / eclipse / linuxtools / lttng / core / 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.core.tests.jni;


import junit.framework.TestCase;

import org.eclipse.linuxtools.internal.lttng.jni.common.JniTime;
import org.eclipse.linuxtools.internal.lttng.jni.exception.JniException;
import org.eclipse.linuxtools.lttng.jni.JniEvent;
import org.eclipse.linuxtools.lttng.jni.JniTracefile;
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;
                
                // This trace should be valid and will be used in test
                try {
                        testTracefile = JniTraceFactory.getJniTrace(tracepath, null, printLttDebug).requestTracefileByName(eventName);
                }
                catch( JniException e) {
                    fail("Could not get trace file");
                }
                
                
                // Test constructor on a wrong marker HashMap
                try {
                        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 {
                        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 {
                        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
6c13869b	31	package org.eclipse.linuxtools.lttng.core.tests.jni;
03c71d1e	32
9c841e9c	33
8b63111e WB	34	import junit.framework.TestCase;
8b63111e WB	35
ce38c104 FC	36	import org.eclipse.linuxtools.internal.lttng.jni.common.JniTime;
ce38c104 FC	37	import org.eclipse.linuxtools.internal.lttng.jni.exception.JniException;
03c71d1e ASL	38	import org.eclipse.linuxtools.lttng.jni.JniEvent;
03c71d1e ASL	39	import org.eclipse.linuxtools.lttng.jni.JniTracefile;
9c841e9c	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
03c71d1e ASL	97	// This trace should be valid and will be used in test
03c71d1e ASL	98	try {
a3767fd9	99	testTracefile = JniTraceFactory.getJniTrace(tracepath, null, printLttDebug).requestTracefileByName(eventName);
03c71d1e	100	}
f9a8715c FC	101	catch( JniException e) {
	102	fail("Could not get trace file");
	103	}
03c71d1e ASL	104
	105
	106	// Test constructor on a wrong marker HashMap
	107	try {
f9a8715c	108	testTracefile.allocateNewJniEvent( testTracefile.getCurrentEvent().getEventPtr(), null, testTracefile );
03c71d1e ASL	109	fail("Construction with wrong marker hashmap should fail!");
	110	}
	111	catch( JniException e) {
	112	}
	113
	114	// Test constructor on a wrong tracefile reference
	115	try {
f9a8715c	116	testTracefile.allocateNewJniEvent( testTracefile.getCurrentEvent().getEventPtr(), testTracefile.getTracefileMarkersMap(), null );
03c71d1e ASL	117	fail("Construction with wrong tracefile reference should fail!");
	118	}
	119	catch( JniException e) {
	120	}
	121
03c71d1e ASL	122	// Finally, test constructor with correct information
03c71d1e ASL	123	try {
f9a8715c	124	testTracefile.allocateNewJniEvent( testTracefile.getCurrentEvent().getEventPtr(), testTracefile.getTracefileMarkersMap(), testTracefile );
03c71d1e ASL	125	}
	126	catch( JniException e) {
	127	fail("Construction with correct information failed!");
	128	}
	129
9c841e9c	130	/*
03c71d1e ASL	131	// Test copy constructor
	132	try {
	133	testEvent1 = new JniEvent( testTracefile.getCurrentEvent() );
	134	testEvent2 = new JniEvent( testEvent1);
	135	}
	136	catch( Exception e) {
	137	fail("Copy constructor failed!");
	138	}
	139	assertEquals("JniEvent timestamp not same after using copy constructor", testEvent1.getEventTime().getTime() , testEvent2.getEventTime().getTime() );
9c841e9c	140	*/
03c71d1e ASL	141
	142	}
	143
	144	public void testPrintAndToString() {
	145
	146	JniEvent testEvent = prepareEventToTest();
	147
	148	// Test printEventInformation
	149	try {
	150	testEvent.printEventInformation();
	151	}
	152	catch( Exception e) {
	153	fail("printEventInformation failed!");
	154	}
	155
	156	// Test ToString()
	157	assertNotSame("toString returned empty data","",testEvent.toString() );
	158
	159	}
	160
	161	public void testEventDisplacement() {
	162
	163	int readValue = -1;
	164	int seekValue = -1;
	165	JniEvent testEvent = prepareEventToTest();
	166
	167	// Test #1 readNextEvent()
	168	readValue = testEvent.readNextEvent();
	169	assertSame("readNextEvent() returned error (test #1)",0,readValue);
	170	assertEquals("readNextEvent() event timestamp is incoherent (test #1)",secondEventTimestamp,testEvent.getEventTime().getTime() );
	171
	172	// Test #2 readNextEvent()
	173	readValue = testEvent.readNextEvent();
	174	assertSame("readNextEvent() returned error (test #1)",0,readValue);
	175	assertEquals("readNextEvent() event timestamp is incoherent (test #1)",thirdEventTimestamp,testEvent.getEventTime().getTime() );
	176
	177
	178	// Test #1 of seekToTime()
	179	seekValue = testEvent.seekToTime(new JniTime(timestampToSeekTest1) );
	180	assertSame("seekToTime() returned error (test #1)",0,seekValue);
	181	// Read SHOULD NOT be performed after a seek!
	182	assertEquals("readNextEvent() event timestamp is incoherent (test #1)",timestampToSeekTest1,testEvent.getEventTime().getTime() );
	183
	184	readValue = testEvent.readNextEvent();
	185	assertEquals("readNextEvent() event timestamp is incoherent (test #1)",timestampAfterSeekTest1,testEvent.getEventTime().getTime() );
	186
	187
	188	// Test #2 of seekToTime()
	189	seekValue = testEvent.seekToTime(new JniTime(timestampToSeekLast) );
	190	assertSame("seekToTime() returned error (test #2)",0,seekValue);
	191	// Read SHOULD NOT be performed after a seek!
	192	assertEquals("readNextEvent() event timestamp is incoherent (test #2)",timestampToSeekLast,testEvent.getEventTime().getTime() );
	193
	194	// Read AFTER the last event should bring an error
	195	readValue = testEvent.readNextEvent();
	196	assertNotSame("readNextEvent() AFTER last event should return error (test #2)",0,readValue);
	197
	198
	199	// Test to see if we can seek back
	200	seekValue = testEvent.seekToTime(new JniTime(firstEventTimestamp) );
	201	assertSame("seekToTime() returned error (test seek back)",0,seekValue);
	202	// Read SHOULD NOT be performed after a seek!
	203	assertEquals("readNextEvent() event timestamp is incoherent (test seek back)",firstEventTimestamp,testEvent.getEventTime().getTime() );
	204
205
206	// Test #1 of seekOrFallBack() (seek within range)
207	seekValue = testEvent.seekOrFallBack(new JniTime(timestampToSeekTest1) );
208	assertSame("seekToTime() returned error (test #1)",0,seekValue);
209	// Read SHOULD NOT be performed after a seek!
210	assertEquals("readNextEvent() event timestamp is incoherent (test #1)",timestampToSeekTest1,testEvent.getEventTime().getTime() );
211
212	// Test #2 of seekOrFallBack() (seek out of range, should fall back)
213	seekValue = testEvent.seekOrFallBack(new JniTime(timestampToSeekTooFarAway) );
214	assertNotSame("seekOrFallBack() should return an error (test #2)",0,seekValue);
215	// The read should return the "last" value as we seek back
216	assertEquals("readNextEvent() event timestamp is incoherent (test #2)",timestampToSeekTest1,testEvent.getEventTime().getTime() );
217	}
218
219	public void testGetSet() {
220
221	JniEvent testEvent = prepareEventToTest();
222
223	// Test that all Get/Set return data
224	assertNotSame("getEventMarkerId is 0",0,testEvent.getEventMarkerId() );
225
226	// JniTime should never be null
227	assertNotNull("getEventTime returned null", testEvent.getEventTime() );
228
229	assertNotSame("getEventDataSize is 0",0,testEvent.getEventDataSize() );
230
231	// Test that the marker map is not null
232	assertNotSame("getMarkersMap is null",null,testEvent.getMarkersMap() );
233	// Also check that the map contain some data
234	assertSame("getMarkersMap returned an unexpected number of markers",numberOfMarkersInTracefile,testEvent.getMarkersMap().size() );
235
236	assertNotSame("getTracefilePtr is 0",0,testEvent.getTracefilePtr() );
237	assertNotSame("getEventPtr is 0",0,testEvent.getEventPtr() );
238	// State 0 (EOK) means the event is in a sane state
239	assertSame("getEventState is not EOK",0,testEvent.getEventState() );
240
241	// ParentTracefile should never be null
242	assertNotNull("getParentTracefile returned null", testEvent.getParentTracefile() );
243	}
244
245	public void testRequestFunctions() {
246
247	JniEvent testEvent = prepareEventToTest();
248
249	// Test requestEventMarker(). Should return an unique marker
250	assertNotNull("requestEventMarker returned null",testEvent.requestEventMarker() );
251
252	// Test requestEventSource()
253	assertNotSame("requestEventSource is empty","",testEvent.requestEventSource() );
254
255	// Test requestEventContent()
256	assertNotNull("requestEventContent returned null",testEvent.requestEventContent() );
257
258	// Also check that the byte array contain some data
259	assertSame("requestEventContent returned an unexpected number of markers",numberOfByteInContent,testEvent.requestEventContent().length );
260
261	}
262
263	public void testParseAllFieldsFunctions() {
264
265	JniEvent testEvent = prepareEventToTest();
266
267	// Test parse()
268	assertNotNull("parseAllFields returned null",testEvent.parseAllFields() );
269	// Parse shouldn't be empty
270	assertSame("parseAllFields returned an unexpected number of parsed fields",numberOfparsedFieldsFirstEvent,testEvent.parseAllFields().size() );
271
272	// MORE PARSING TESTS
273	// We will perform several more unit tests about parsing as it is very important
274	// All those below use the same call as in the displacement test
275	// Test #1 readNextEvent()
276	testEvent.readNextEvent();
277	assertNotNull("parseAllFields returned null",testEvent.parseAllFields() );
278	assertSame("parseAllFields returned an unexpected number of parsed fields",numberOfparsedFieldsSecondEvent,testEvent.parseAllFields().size() );
279	// Test #2 readNextEvent()
280	testEvent.readNextEvent();
281	assertNotNull("parseAllFields returned null",testEvent.parseAllFields() );
282
283	// Test #1 of seekToTime()
284	testEvent.seekToTime(new JniTime(timestampToSeekTest1) );
285	// Read need to be perform after a seek!
286	testEvent.readNextEvent();
287	assertNotNull("parseAllFields returned null",testEvent.parseAllFields() );
288	testEvent.readNextEvent();
289	assertNotNull("parseAllFields returned null",testEvent.parseAllFields() );
290
291	// Test #2 of seekToTime()
292	testEvent.seekToTime(new JniTime(timestampToSeekLast) );
293	// Read need to be perform after a seek!
294	testEvent.readNextEvent();
295	assertNotNull("parseAllFields returned null",testEvent.parseAllFields() );
296
297	// Test to see if we can seek back
298	testEvent.seekToTime(new JniTime(firstEventTimestamp) );
299	// Read need to be perform after a seek!
300	testEvent.readNextEvent();
301	assertNotNull("parseAllFields returned null",testEvent.parseAllFields() );
302	}
303
304	public void testParseFieldByIdFunctions() {
305	JniEvent testEvent = prepareEventToTest();
306
307	// Test parse()
308	assertNotNull("parseFieldById returned null",testEvent.parseFieldById(0) );
309
310	testEvent.readNextEvent();
311	assertNotNull("parseFieldById returned null",testEvent.parseFieldById(chosenPositionOfFieldsFirstEvent) );
312	assertEquals("Content return by parseFieldById is invalid",contentOfFieldsFirstEvent, testEvent.parseFieldById(chosenPositionOfFieldsFirstEvent) );
313	assertEquals("Content return by parseFieldByName is invalid",contentOfFieldsFirstEvent, testEvent.parseFieldByName(chosenNameOfFieldsFirstEvent) );
314
315	// MORE PARSING TESTS
316	// We will perform several more unit tests about parsing as it is very important
317	// All those below use the same call as in the displacement test
318	// Test #1 readNextEvent()
319	testEvent.readNextEvent();
320	assertNotNull("parseFieldById returned null",testEvent.parseFieldById(chosenPositionOfFieldsSecondEvent) );
1c859a36 WB	321	assertEquals("Content return by parseFieldById is invalid", contentOfFieldsSecondEvent, testEvent.parseFieldById(chosenPositionOfFieldsSecondEvent).toString() );
1c859a36 WB	322	assertEquals("Content return by parseFieldByName is invalid",contentOfFieldsSecondEvent, testEvent.parseFieldByName(chosenNameOfFieldsSecondEvent).toString() );
03c71d1e ASL	323
	324	// Test #1 of seekToTime()
	325	testEvent.seekToTime(new JniTime(timestampToSeekTest1) );
	326	// Read need to be perform after a seek!
	327	testEvent.readNextEvent();
	328	assertNotNull("parseFieldById returned null",testEvent.parseFieldById(chosenPositionOfFieldsAfterSeekEvent) );
	329	assertEquals("Content return by parseFieldById is invalid",contentOfFieldsThirdEvent, testEvent.parseFieldById(chosenPositionOfFieldsAfterSeekEvent) );
	330	assertEquals("Content return by parseFieldByName is invalid",contentOfFieldsThirdEvent, testEvent.parseFieldByName(chosenNameOfFieldsThirdEvent) );
	331
	332	// Test to see if we can seek back
	333	testEvent.seekToTime(new JniTime(firstEventTimestamp) );
	334	// Read need to be perform after a seek!
	335	testEvent.readNextEvent();
	336	assertNotNull("parseFieldById returned null",testEvent.parseFieldById(chosenPositionOfFieldsFirstEvent) );
	337	assertEquals("Content return by parseFieldById is invalid",contentOfFieldsFirstEvent, testEvent.parseFieldById(chosenPositionOfFieldsFirstEvent) );
	338	assertEquals("Content return by parseFieldByName is invalid",contentOfFieldsFirstEvent, testEvent.parseFieldByName(chosenNameOfFieldsFirstEvent) );
	339	}
	340	}