/*

* 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 "ttime_blr.h"

#include <stdlib.h>

const TInt KMaxParamLength=100;

//----------------------Local declaration of thread funcs-------------------

void* asctime_thread_1( void* aParam );

void* asctime_thread_2( void* aParam );

void* localtime_thread_1( void* aParam );

void* localtime_thread_2( void* aParam );

void* gmtime_thread_1( void* aParam );

void* gmtime_thread_2( void* aParam );

void* ctime_thread_1( void* aParam );

void* ctime_thread_2( void* aParam );

CTestTimeBlr::~CTestTimeBlr() 

	{ 

	}  

CTestTimeBlr::CTestTimeBlr(const TDesC& aStepName)

	{

	// MANDATORY Call to base class method to set up the human readable name for logging.

	SetTestStepName(aStepName);		

	}

TVerdict CTestTimeBlr::doTestStepPreambleL()

	{

	__UHEAP_MARK;	

	iParamCnt=0;

	iRandomizerSeed = 1234567890;

	SetTestStepResult(EPass);

	return TestStepResult();

	}

TVerdict CTestTimeBlr::doTestStepPostambleL()

	{

	__UHEAP_MARKEND;	

	return TestStepResult();

	}

TVerdict CTestTimeBlr::doTestStepL()

	{

	int err;

	if(TestStepName() == Kasctime_test_all)

		{

   		INFO_PRINTF1(_L("asctime_test_all():"));

   		err = asctime_test_all();

   		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   		}

   	else if(TestStepName() == Kasctime_test_null)

		{

   		INFO_PRINTF1(_L("asctime_test_null():"));

   		err = asctime_test_null();

   		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   		}

   	else if(TestStepName() == Klocaltime_test_all)

		{

   		INFO_PRINTF1(_L("localtime_test_all():"));

   		err = localtime_test_all();

   		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   		}

   	else if(TestStepName() == Kgmtime_test_all)

		{

   		INFO_PRINTF1(_L("gmtime_test_all():"));

   		err = gmtime_test_all();

   		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   		}

   	else if(TestStepName() == Kmktime_test_null)

		{

   		INFO_PRINTF1(_L("mktime_test_null():"));

   		err = mktime_test_null();

   		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   		}

   	else if(TestStepName() == Kmktime_test_epoch)

		{

   		INFO_PRINTF1(_L("mktime_test_epoch():"));

   		err = mktime_test_epoch();

   		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   		}

   	else if(TestStepName() == Kmktime_test_extreme)

		{

   		INFO_PRINTF1(_L("mktime_test_extreme():"));

   		err = mktime_test_extreme();

   		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   		}

   	else if(TestStepName() == Kctime_test_all)

		{

   		INFO_PRINTF1(_L("ctime_test_all():"));

   		err = ctime_test_all();

   		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   		}

   	else if(TestStepName() == Kdifftime_test_all)

		{

   		INFO_PRINTF1(_L("difftime_test_all():"));

   		err = difftime_test_all();

   		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   		}

   	else if(TestStepName() == Kdifftime_test_extreme)

		{

   		INFO_PRINTF1(_L("difftime_test_extreme():"));

   		err = difftime_test_extreme();

   		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   		}

   	else if(TestStepName() == Ktzset_test)

		{

   		INFO_PRINTF1(_L("tzset_test():"));

   		err = tzset_test();

   		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   		}

   	else if(TestStepName() == Kasctime_r_all)

		{

   		INFO_PRINTF1(_L("asctime_r_all():"));

   		err = asctime_r_all();

   		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   		}

   	else if(TestStepName() == Kasctime_r_null)

		{

   		INFO_PRINTF1(_L("asctime_r_null():"));

   		err = asctime_r_null();

   		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   		}

   	else if(TestStepName() == Klocaltime_r_all)

		{

   		INFO_PRINTF1(_L("localtime_r_all():"));

   		err = localtime_r_all();

   		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   		}

   	else if(TestStepName() == Kgmtime_r_all)

		{

   		INFO_PRINTF1(_L("gmtime_r_all():"));

   		err = gmtime_r_all();

   		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   		}

   	else if(TestStepName() == Kctime_r_all)

		{

   		INFO_PRINTF1(_L("ctime_r_all():"));

   		err = ctime_r_all();

   		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   		}

   	else if(TestStepName() == Kmultithread_asctime_r)

		{

   		INFO_PRINTF1(_L("multithread_asctime_r():"));

   		err = multithread_asctime_r();

   		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   		}

   	else if(TestStepName() == Kmultithread_localtime_r)

		{

   		INFO_PRINTF1(_L("multithread_localtime_r():"));

   		err = multithread_localtime_r();

   		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   		}

   	else if(TestStepName() == Kmultithread_ctime_r)

		{

   		INFO_PRINTF1(_L("multithread_ctime_r():"));

   		err = multithread_ctime_r();

   		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   		}

   	else if(TestStepName() == Kmultithread_gmtime_r)

		{

   		INFO_PRINTF1(_L("multithread_gmtime_r():"));

   		err = multithread_gmtime_r();

   		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   		}

   	else if(TestStepName() == Kclock_getres_pos_test)

		{

   		INFO_PRINTF1(_L("clock_getres_pos_test():"));

   		err = clock_getres_pos_test();

   		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   		}

   	else if(TestStepName() == Kclock_gettime_pos_test)

		{

   		INFO_PRINTF1(_L("clock_gettime_pos_test():"));

   		err = clock_gettime_pos_test();

   		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   		}

   	else if(TestStepName() == Kclock_settime_pos_test)

		{

   		INFO_PRINTF1(_L("clock_settime_pos_test():"));

   		err = clock_settime_pos_test();

   		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   		}

   	else if(TestStepName() == Kclock_getcpuid_pos_test)

		{

   		INFO_PRINTF1(_L("clock_getcpuid_pos_test():"));

   		err = clock_getcpuid_pos_test();

   		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   		}

   	else if(TestStepName() == Kclock_getres_neg_test)

		{

   		INFO_PRINTF1(_L("clock_getres_neg_test():"));

   		err = clock_getres_neg_test();

   		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   		}

   	else if(TestStepName() == Kclock_gettime_neg_test)

		{

   		INFO_PRINTF1(_L("clock_gettime_neg_test():"));

   		err = clock_gettime_neg_test();

   		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   		}

   	else if(TestStepName() == Kclock_settime_neg_test)

		{

   		INFO_PRINTF1(_L("clock_settime_neg_test():"));

   		err = clock_settime_neg_test();

   		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   		}

   	else if(TestStepName() == Kclock_getcpuid_neg_test)

		{

   		INFO_PRINTF1(_L("clock_getcpuid_neg_test():"));

   		err = clock_getcpuid_neg_test();

   		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   		}

   	else if(TestStepName() == Kadjtime_pos_test)

		{

   		INFO_PRINTF1(_L("adjtime_pos_test():"));

   		err = adjtime_pos_test();

   		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   		}

   	else if(TestStepName() == Kadjtime_neg_test)

		{

   		INFO_PRINTF1(_L("adjtime_neg_test():"));

   		err = adjtime_neg_test();

   		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   		}

   else if(TestStepName() == Kgetoffset_test)

		{

   		INFO_PRINTF1(_L("getoffset_test:"));

   		err = getoffset_test();

   		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   		}

   else if(TestStepName() == Kgetrule_test)

		{

   		INFO_PRINTF1(_L("getrule_test:"));

   		err = getrule_test();

   		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   		}

   	else if(TestStepName() == Ktzset1)

		{

   		INFO_PRINTF1(_L("tzset1():"));

   		err = tzset1();

   		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   		}

   	else if(TestStepName() == Ktimegm_Test)

   			{

   	   		INFO_PRINTF1(_L("timegm_Test():"));

   	   		err = timegm_Test();

   	   		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   	   		}

   	else if(TestStepName() == Kclock_getres_null_test)

		{

   		INFO_PRINTF1(_L("clock_getres_null_test():"));

   		err = clock_getres_null_test();

   		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   		}

   	else if(TestStepName() == Kadjtime_null_test)

		{

   		INFO_PRINTF1(_L("adjtime_null_test():"));

   		err = adjtime_null_test();

   		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   		}

   	else if(TestStepName() == Kadjtime_range_test)

		{

   		INFO_PRINTF1(_L("adjtime_range_test():"));

   		err = adjtime_range_test();

   		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   		}

   	else if(TestStepName() == Kclock_gettime_null_test)

		{

   		INFO_PRINTF1(_L("clock_gettime_null_test():"));

   		err = clock_gettime_null_test();

   		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   		}

   	else if(TestStepName() == Kclock_settime_null_test)

		{

   		INFO_PRINTF1(_L("clock_settime_null_test():"));

   		err = clock_settime_null_test();

   		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   		}

   	else if(TestStepName() == Kclock_settime_range1_test)

		{

   		INFO_PRINTF1(_L("clock_settime_range1_test():"));

   		err = clock_settime_range1_test();

   		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   		}

   	else if(TestStepName() == Kclock_settime_range2_test)

		{

   		INFO_PRINTF1(_L("clock_settime_range2_test():"));

   		err = clock_settime_range2_test();

   		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   		}

   	else if(TestStepName() == Kmktime_test_extreme1)

		{

   		INFO_PRINTF1(_L("mktime_test_extreme1():"));

   		err = mktime_test_extreme1();

   		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   		}

	else if(TestStepName() == Klocal_and_mktime)

		{

   		INFO_PRINTF1(_L("local_and_mktime():"));

   		err = local_and_mktime();

   		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   		}

   	return TestStepResult(); 

	}

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

// Utility functions for testing.

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

TBool CTestTimeBlr::SameString(char *aString1, char *aString2)

	{

	TInt i;

	for ( i=0; ( (aString1[i]!=0) && (aString2[i]!=0) && (aString2[i] == aString1[i]) ); i++)

		{

		} // Go through the strings

	if ( aString2[i] != aString1[i] )	// If the scanning ended because of a difference between the strings

		{

		return EFalse;

		}

	else	// else

		{

		return ETrue;

		}

	}

void CTestTimeBlr::StringToDes(char *aString, TDes &aDescriptor)

	{

	aDescriptor.Zero();

	for ( TInt i=0; aString[i]!=0; i++ )

		{

		aDescriptor.Append(aString[i]);

		}

	}

void CTestTimeBlr::RandomizeString(char *aString, TInt aLength)

	{

	TInt16 integer;

	TInt i;

	for (i=0; i<aLength; i++)

		{

		Math::Int(integer, Math::FRand(iRandomizerSeed)*255);

		aString[i] = integer;

		}

	aString[i] = 0;

 	}

void CTestTimeBlr::ReadStringParam(char* expected)

	{

	_LIT( KaKey, "Param%d" );

    TBuf<8> pNameBuf;

    TPtrC string;

    pNameBuf.Format(KaKey,++iParamCnt);

	TBool res = GetStringFromConfig(ConfigSection(), pNameBuf, string);

	if(!res)

	 	{

	 	_LIT(Kerr , "Unable to retrieve string parameter") ;

	 	INFO_PRINTF1(Kerr);

	  	}

	TBuf8<256> bufstring;

	bufstring.Copy(string);

	TInt paramLength=string.Length();

	char* text=(char *)(bufstring.Ptr());

	*(text+paramLength)='\0';

	strcpy(expected,text);

	return;

	}

void CTestTimeBlr::ReadIntParam(TInt &aInt)

	{

	_LIT( Kparam, "Param%d" );

    TBuf<8> pNameBuf;

    TPtrC string;

    pNameBuf.Format(Kparam,++iParamCnt);

	TBool res = GetIntFromConfig(ConfigSection(), pNameBuf, aInt);

	if(!res)

	 	{

	 	_LIT(Kerr , "Unable to retrieve integer parameter") ;

	 	INFO_PRINTF1(Kerr);

	  	}

	return;

}

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

// Test methods

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

//                  

TInt CTestTimeBlr::asctime_test_all()

    {

    __UHEAP_MARK;

    TInt ret;

  	// Create temporary variables in stack

  	struct tm *timeptr=(struct tm*)malloc(sizeof(struct tm));

	char expected[KMaxParamLength];

  	// Read parameters

  	ReadStringParam(expected);

  	strcat(expected,"\n");

    timeptr->tm_sec=0;		

	timeptr->tm_min=0;		

	timeptr->tm_hour=0;	

	timeptr->tm_mday=0;	

	timeptr->tm_mon=0;	

	timeptr->tm_year=0;	

	timeptr->tm_wday=0;	

	timeptr->tm_yday=0;	

	timeptr->tm_isdst=0;

	timeptr->tm_gmtoff=0;

    // Do some testing

	char *s=asctime(timeptr);    

    // Set test result

    if(SameString(expected,s))

    	{

		INFO_PRINTF1(_L("Test passed."));

       	ret = KErrNone;

    	}

    else

    	{

    	ERR_PRINTF1(_L("Test Failed."));

    	ret = KErrGeneral;

    	}

    free(timeptr);

    __UHEAP_MARKEND;    

    return ret;

    }  

TInt CTestTimeBlr::asctime_test_null()

    {

    __UHEAP_MARK;

  	// Create temporary variables in stack

  	TInt ret=KErrGeneral;

  	// Read parameters

    // Do some testing

	char *s=asctime(NULL);    

    // Set test result

    if(s==NULL)

    	{

		INFO_PRINTF1(_L("Test passed."));

       	ret = KErrNone;

    	}

    else

    	{

    	ERR_PRINTF1(_L("Test Failed."));

    	ret = KErrGeneral;

    	}

    __UHEAP_MARKEND;

    return ret;

    }

TInt CTestTimeBlr::getConfigString(const char *aLabel, char *aData)

    {

    TPtrC8 pLabel((TUint8*)aLabel);

    TBuf<20> pNameBuf;

    pNameBuf.Copy(pLabel);

    TPtrC string;

    TBool res = GetStringFromConfig(ConfigSection(), pNameBuf, string);

    if(!res)

        {

        _LIT(Kerr , "Unable to retrieve string parameter") ;

        INFO_PRINTF1(Kerr);

        return KErrGeneral;

        }

    TBuf8<50> bufstring;

    bufstring.Copy(string);

    char* text=(char *)(bufstring.PtrZ());

    strcpy(aData,text);

    return KErrNone;

    }

TInt CTestTimeBlr::getConfigIntParam(const char *aLabel, TInt &aInt)

    {

    TPtrC8 pLabel((TUint8*)aLabel);

    TBuf<20> pNameBuf;

    pNameBuf.Copy(pLabel);

    TBool res = GetIntFromConfig(ConfigSection(), pNameBuf, aInt);

    if(!res)

        {

        _LIT(Kerr , "Unable to retrieve integer parameter") ;

        INFO_PRINTF1(Kerr);

        return KErrGeneral;

        }

    return KErrNone;

}

TInt CTestTimeBlr::timeTestWithTzset()

    {

    __UHEAP_MARK;

    char timeZoneRule[50];