[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.JniTracefile;
import org.eclipse.linuxtools.lttng.jni.common.JniTime;
import org.eclipse.linuxtools.lttng.jni.common.Jni_C_Pointer;
import org.eclipse.linuxtools.lttng.jni.exception.JniException;
import org.eclipse.linuxtools.lttng.jni.factory.JniTraceFactory;

import junit.framework.TestCase;

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