/*

* Copyright (c) 2002-2009 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of "Eclipse Public License v1.0"

* which accompanies this distribution, and is available

* at the URL "http://www.eclipse.org/legal/epl-v10.html".

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description:

*

*/

#include "tpthread.h"

// Forward declarations of thread entry functions

void* ThreadEntryPoint(void* aParam);

void* SocketReadThreadEntryPoint( void* aParam );

void* SocketWriteThreadEntryPoint( void* aParam );

void* FileReadThreadEntryPoint( void* aParam );

void* FileWriteThreadEntryPoint( void* aParam );

void *ThreadEntryPointDummy(void* aParam ); 

//static functions used for PThreadJoinTest case

static void *first(void *arg); 

static void *second(void *arg); 

static void *third(void *arg);

// -----------------------------------------------------------------------------

// CTPThreadBasicApis::PThreadBasicApisTest

// Description: This function does most of the basic pthread api testing

// This test function can be called with below syntax from INI file:

// PThreadBasicAPITest <API> <TestType> [<State> <StackSize>]

// API is an integer which can be any of the below:

// 		PTHREAD_SELF (1)

// 		PTHREAD_CREATE (2)

// 		PTHREAD_DETACH (3)

// 		PTHREAD_JOIN (4)

// 		PTHREAD_EXIT (5)

// TestType is an integer which can be any of the below:

// 		POSITIVE_TEST (1)

// 		NEGATIVE_TEST (2)

// State is an integer which can be any of the below:

// 		JOIN_THREAD (0)

// 		DETACH_THREAD (1)

// StackSize is the size of the stack whic is an integer

// PThreadBasicAPITest PTHREAD_SELF NEGATIVE_TEST

// -----------------------------------------------------------------------------

//

TInt CTestPThread::PThreadBasicApisTest()

    {

    INFO_PRINTF1(_L("In TPThreadBasicApis"));

    TInt retVal = KErrNone;

    TInt apiType = 1;

    _LIT( KParameter1, "Parameter1" );

	TBool res = GetIntFromConfig(ConfigSection(), KParameter1, apiType);

    TInt testType = 1;

    _LIT( KParameter2, "Parameter2" );

	res = GetIntFromConfig(ConfigSection(), KParameter2, testType);

    switch(apiType)

    	{

    	case EPThreadSelf:

    		{

    		retVal = PThreadSelfApiTest();

    		break;

    		}

    	case EPThreadCreate:

    		{

    		retVal = PThreadCreateApiTest( (TTestType)testType );

    		break;

    		}

    	case EPThreadJoin:

    		{

    		retVal = PThreadJoinApiTest(  (TTestType)testType );

    		break;

    		}

    	case EPThreadDetach:

    		{

    		retVal = PThreadDetachApiTest(  (TTestType)testType );

    		break;

    		}

    	case EPThreadExit:

    		{

    		//Read Exit Reasson from INI file

    		TInt exitReason = 0;

    		_LIT( KParameter3, "Parameter3" );

			res = GetIntFromConfig(ConfigSection(), KParameter3, exitReason);

			if(!res)

			{

			 	_LIT(Kerr , "Failed to read parameter exit reason from ini file") ;

			 	ERR_PRINTF1(Kerr) ;

			 	return KErrGeneral ;

			}

    		retVal = PThreadExitApiTest( exitReason );

    		break;

    		}

    	default:

    		{

    		INFO_PRINTF2(_L("Invalid arguments from ini file : %d"), apiType);

    		retVal = KErrArgument;

    		break;

    		}

    	}

    return retVal;

    }

// -----------------------------------------------------------------------------

// CTPThreadBasicApis::PThreadSelfApiTest

// Description: This function tests pthread_self API

// returns KErrNone or error code depending on the test

// -----------------------------------------------------------------------------

//

TInt CTestPThread::PThreadSelfApiTest()

	{

	TInt retVal = KErrNone;

    pthread_t selfID = pthread_self();

    if( selfID == 0 )

    	{

	    INFO_PRINTF2(_L("Wrong return Value from pthread_self() : %d"), selfID);

		retVal = KErrPThreadSelf;

    	}

    else

    	{

   		pthread_t threadID = 0;

		pthread_attr_t threadAttr;

		pthread_attr_init( &threadAttr );

		retVal = pthread_create( &threadID, &threadAttr, ThreadEntryPoint,

			(void*)KErrNone );

		if( KErrNone != retVal )

			{

			INFO_PRINTF2(_L("pthread_create FAILED with %d"), retVal );

			retVal = KErrPThreadCreate;

			}

		else

			{

			//Testing pthread self aswell.....

			if(pthread_equal(selfID,selfID) == 0)

				{

				retVal += KErrPThreadSelf;

				}

			if(pthread_equal(selfID,threadID))

				{	

				retVal += KErrPThreadSelf;

				}

			//get the thread id again, if it does not match.. ERROR

			pthread_t selfID1 = pthread_self();

			if( selfID1 != selfID )

				{

				INFO_PRINTF1(_L("undefined behaviour from pthread_self!!"));

				retVal += KErrPThreadSelf;

				}

			else

				{

		    	TBuf<20> apiName(KPThreadSelf);

				INFO_PRINTF2(_L("API %S returned 1"),&apiName);

				}

			}

		int threadRetVal = 0;

		TInt ret = pthread_join(threadID, (void**)threadRetVal);

    	}

    return retVal;

	}

// -----------------------------------------------------------------------------

// CTPThreadBasicApis::PThreadCreateApiTest

// Description: This function tests pthread_create and

// pthread attr related APIs

// returns KErrNone or error code depending on the test

// -----------------------------------------------------------------------------

//

TInt CTestPThread::PThreadCreateApiTest(TTestType aTestType )

	{

    TInt retVal = KErrNone;

	pthread_t threadID = 0;

	pthread_attr_t threadAttr;

	pthread_t selfID = pthread_self();

	INFO_PRINTF2(_L("Thread Id is : %d"), selfID);

	if( aTestType == EPositive )

		{

		//Read Attributes like detatch state and stack size from INI file

		TInt threadState = PTHREAD_CREATE_DETACHED;

		TInt stackSize = KDefaultPThreadStackSize;

        TUint stkSize;

		ReadThreadAttributes( threadState, stackSize, aTestType);

		//Set all attributes as 0

		memset(&threadAttr, 0, sizeof(threadAttr));

		pthread_attr_init( &threadAttr );

		pthread_attr_setdetachstate( &threadAttr, threadState );

		if (pthread_attr_setstacksize( &threadAttr, stackSize ) == EINVAL)

            {

            // Test case passed

            return KErrNone;

            }

        //This has been added to cover getstack size test case

        if (pthread_attr_getstacksize( &threadAttr, &stkSize ) != 0)

            {

            return KErrPThreadCreate;

            }

        if (stackSize != stkSize)

            {

            return KErrPThreadCreate;

            }

		}

    //Create a thread now

	retVal = pthread_create( &threadID, &threadAttr, ThreadEntryPoint,

			(void*)KErrNone );

	selfID = pthread_self();

	INFO_PRINTF2(_L("Thread Id is : %d"), selfID);

	if( aTestType == ENegative && EINVAL != retVal )

		{

		// As we have sent some wrong parameters, this should return with EINVAL

		INFO_PRINTF2(_L("Wrong return Value from pthread_create() : %d"), retVal);

		retVal = KErrPThreadCreate;

		}

	else if( aTestType == EPositive && KErrNone != retVal )

		{

		// As we have sent some wrong parameters,

		// this should return with EINVAL

		INFO_PRINTF2(_L("pthread_create() Failed with : %d !!"), retVal);

		retVal = KErrPThreadCreate;

		}

	else

		{

    	TBuf<20> apiName(KPThreadCreate);

		INFO_PRINTF3(_L("API Test %S of type %d passed"),&apiName,aTestType);

		retVal = KErrNone;

		}

	pthread_attr_destroy( &threadAttr );

    return retVal;

	}

// -----------------------------------------------------------------------------

// CTPThreadBasicApis::PThreadJoinApiTest

// Description: This function tests pthread_join API

// returns KErrNone or error code depending on the test

// -----------------------------------------------------------------------------

//

TInt CTestPThread::PThreadJoinApiTest(TTestType aTestType )

	{

    TInt retVal = KErrNone;

	pthread_t threadID = 0;

    pthread_attr_t threadAttr;

	TInt threadState = PTHREAD_CREATE_DETACHED;

	TInt stackSize = KDefaultPThreadStackSize;

	TInt moreFlag = 0;

    if( aTestType == EPositive )

    	{

		//Read Attributes like detatch state and stack size from INI file

		ReadThreadAttributes( threadState, stackSize, aTestType);

		_LIT( KParameter5, "Parameter5" );

		TBool res = GetIntFromConfig(ConfigSection(), KParameter5, moreFlag);

		if( PTHREAD_CREATE_DETACHED == threadState )

			{

			aTestType = ENegative;

			}

		pthread_attr_init( &threadAttr );

		pthread_attr_setdetachstate( &threadAttr, threadState );

		pthread_attr_setstacksize( &threadAttr, stackSize );

	    //Create a thread now

		retVal = pthread_create( &threadID, &threadAttr, ThreadEntryPoint,

			(void*)KErrNone );

    	}

	if( KErrNone != retVal )

		{

		// pthread_Create Failed!!

		INFO_PRINTF2(_L("pthread_create() Failed with : %d"), retVal);

		retVal = KErrPThreadCreate;

		}

	else

		{

		int threadRetVal = 0;

		TInt ret = pthread_join(threadID, (void**)threadRetVal);

		if( ENegative == aTestType )

			{

			//If thread id is 0, then return should be ESRCH

			if( 0 == threadID )

				{

				if(ESRCH != ret )

					{

					INFO_PRINTF2(_L("Unexpected return value from pthread_join: %d"), retVal);

					INFO_PRINTF1(_L("Expected ESRCH as return error code"));

					retVal = KErrPThreadJoin;

					}

				}

			//If thread state is not joinable, then return should be EINVAL

			else if ( PTHREAD_CREATE_JOINABLE == threadState )

				{

				if( EINVAL != ret )

					{

					INFO_PRINTF2(_L("Unexpected return value from pthread_join: %d"), retVal);

					INFO_PRINTF1(_L("Expected EINVAL as return error code"));

					retVal = KErrPThreadJoin;

					}

				}

			}

	    //If its positive test, then return should be 0

	    else if( KErrNone != ret )

	    	{

	    	INFO_PRINTF2(_L("Unexpected return value from pthread_join: %d"), retVal);

	    	INFO_PRINTF1(_L("Expected pthread_join to return successfully"));

			retVal = KErrPThreadJoin;

	    	}

	    else if( moreFlag )

	    	{

	    	//issue pthread_join again on same thread which is terminated already

	    	if( ESRCH != (ret = pthread_join(threadID, (void**)threadRetVal)) )

	    		{

				INFO_PRINTF2(_L("Unexpected return value from pthread_join: %d"), ret);

				INFO_PRINTF1(_L("Expected ESRCH as return error code"));

				retVal = KErrPThreadJoin;

	    		}

	    	}

	    if( KErrNone == retVal )

	    	{

	    	TBuf<20> apiName(KPThreadJoin);

			LogResult(aTestType, apiName);

	    	}

		}

    return retVal;

	}

// -----------------------------------------------------------------------------

// CTPThreadBasicApis::PThreadDetachApiTest

// Description: This function tests pthread_detach API

// returns KErrNone or error code depending on the test

// -----------------------------------------------------------------------------

//

TInt CTestPThread::PThreadDetachApiTest( TTestType aTestType )

	{

    TInt retVal = KErrNone;

	pthread_t threadID = 0;

    pthread_attr_t threadAttr;

	TInt threadState = PTHREAD_CREATE_JOINABLE;

	TInt thrState;

	TInt stackSize = KDefaultPThreadStackSize;

	TInt moreFlag = 0;

    if( aTestType == EPositive )

    	{

		//Read Attributes like detatch state and stack size from INI file

		ReadThreadAttributes( threadState, stackSize, aTestType);

		_LIT( KParameter5, "Parameter5" );

		TBool res = GetIntFromConfig(ConfigSection(), KParameter5, moreFlag);

		if( PTHREAD_CREATE_DETACHED == threadState )

			{

			aTestType = ENegative;

			}

		pthread_attr_init( &threadAttr );

		pthread_attr_setdetachstate( &threadAttr, threadState );

		//testing getdetachstate aswell....

		if(pthread_attr_getdetachstate(&threadAttr, &thrState))

			{

		    retVal += KErrPThreadDetach;

			}

		if(threadState != thrState)

			{

		    retVal += KErrPThreadDetach;

			}

		pthread_attr_setstacksize( &threadAttr, stackSize );

	    //Create a thread now

		retVal += pthread_create( &threadID, &threadAttr, ThreadEntryPoint,

			(void*)KErrNone );

    	}

	if( KErrNone != retVal )

		{

		// pthread_Create Failed!!

		INFO_PRINTF2(_L("pthread_create() Failed with : %d"), retVal);

		retVal = KErrPThreadCreate;

		}

	else

		{

		TInt ret = pthread_detach( threadID );

		if( ENegative == aTestType )

			{

			//If thread id is 0, then return should be ESRCH

			if( 0 == threadID )

				{

				if( ESRCH != ret )

					{

					INFO_PRINTF2(_L("Unexpected return value from pthread_detach: %d"), retVal);

					INFO_PRINTF1(_L("Expected ESRCH as return error code"));

					retVal = KErrPThreadDetach;

					}

				}

			//If thread state is not joinable, then return should be EINVAL

			else if ( PTHREAD_CREATE_JOINABLE == threadState )

				{

				if( EINVAL != ret )

					{

					INFO_PRINTF2(_L("Unexpected return value from pthread_detach: %d"), retVal);

					INFO_PRINTF1(_L("Expected EINVAL as return error code"));

					retVal = KErrPThreadDetach;

					}

				}

			}

	    //If its positive test, and return should be 0

	    else if( ret != KErrNone )

	    	{

	    	INFO_PRINTF2(_L("Unexpected return value from pthread_detach: %d"), retVal);

	    	INFO_PRINTF1(_L("Expected pthread_detach to return successfully"));

			retVal = KErrPThreadDetach;

	    	}

	    else if( moreFlag )

	    	{

	    	//issue pthread_detach again on same thread, which is no more joinable

	    	//return should be EINVAL

	    	ret = pthread_detach( threadID );

	    	if( (EINVAL != ret ) &&  (ESRCH != ret))

	    		{

				INFO_PRINTF2(_L("Unexpected return value from pthread_detach: %d"), ret);

				INFO_PRINTF1(_L("Expected ESRCH as return error code"));

				retVal = KErrPThreadDetach;

	    		}

	    	}

	    if( KErrNone == retVal )

	    	{

	    	TBuf<20> apiName(KPThreadDetach);

			LogResult(aTestType, apiName);

	    	}

		}

    return retVal;

	}

// -----------------------------------------------------------------------------

// CTPThreadBasicApis::PThreadExitApiTest

// Description: This function tests pthread_exit API

// returns KErrNone or error code depending on the test

// -----------------------------------------------------------------------------

//

TInt CTestPThread::PThreadExitApiTest( TInt aExitReason )

	{

    TInt retVal = KErrNone;

	pthread_t threadID = 0;

	pthread_attr_t threadAttr;

	pthread_attr_init( &threadAttr );

	pthread_attr_setdetachstate( &threadAttr, PTHREAD_CREATE_JOINABLE );

    //Create a thread now

	retVal = pthread_create( &threadID, &threadAttr, ThreadEntryPoint,

		(void*)aExitReason );

	if( KErrNone != retVal )

		{

		// pthread_Create Failed!!

		INFO_PRINTF2(_L("pthread_create() Failed with : %d"), retVal);

		retVal = KErrPThreadCreate;

		}

	else

		{

		//Wait for the completion of thread

		TInt exitReason = 0;

		TInt ret = pthread_join( threadID, (void**) &exitReason );

		if( KErrNone != ret )

			{

			INFO_PRINTF2(_L("pthread_join returned with %d!!"), ret);

			retVal = KErrPThreadJoin;

			}

		else if( exitReason != aExitReason )

			{

			INFO_PRINTF2(_L("unexpected return with pthread_exit-> %d!!"), exitReason);

			retVal = KErrPThreadExit;

			}

		}

    if( KErrNone == retVal )

    	{

    	TBuf<20> apiName(KPThreadExit);

		LogResult(EPositive, apiName);

    	}

    return retVal;

	}

// -----------------------------------------------------------------------------

// CTestPThread::ReadThreadAttributes

// Description: Reads Thread Attributes from INI file

// -----------------------------------------------------------------------------

//

void CTestPThread::ReadThreadAttributes(TInt& aThreadState,

        		TInt& aStackSize, TTestType& aTestType)

	{

	_LIT( KParameter3, "Parameter3" );