// Copyright (c) 2008-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:

 //

 /**

  @file

  @test

  @internalComponent

 */

 #include "utils.h"

 #include "panic.h"

 /*************************************************************************************

  class TRnd

  */

 /**

 Math::Rand() degenerates to approx seed*3.3+38 for the first numbers generated 

 with a low seed, which isn't very random. To illustrate: The random numbers generated 

 by the seeds {0..9} are {38, 41, 45, 48, 51, 54, 58, 61, 64, 68}.

 */

 const TInt64 KMinSeed = 1000000000;

 TInt64 TRnd::iSeed = KMinSeed; // Need to change CComparison::StartL() to use this value

 CExecutionContext::CLogMediator* TRnd::iMediator 			= NULL;

 CExecutionContext* 				 TRnd::iExecutionContext	= NULL;

 TInt64 TRnd::Seed()

 	{

 	return iSeed;

 	}

 void TRnd::SetSeed(TInt64 aSeed)

 	{

 	iSeed = aSeed;

 	}

 void TRnd::SetLogMediator(CExecutionContext::CLogMediator* aMediator)

 	{

 	iMediator = aMediator;

 	}

 void TRnd::SetExecutionContext(CExecutionContext* aExecutionContext)

 	{

 	iExecutionContext = aExecutionContext;

 	}

 TInt TRnd::GenRand(TInt x)

 	{

 	TInt res = Math::Rand( iSeed );

 	if (x)

 		{

 		res = res % x;

 		}

 	return res;

 	}

 TInt TRnd::rnd(TInt x)

 	{

 	TInt res;

 	switch ( iExecutionContext->ContextMode() )

 	{

 	case CExecutionContext::ECtxPlayback:	

 		res = iMediator->PlaybackInt();

 		break;

 	case CExecutionContext::ECtxRandomAndRecord:

 		res = GenRand(x);

 		iMediator->RecordInt( res );

 		break;

 	case CExecutionContext::ECtxRandom:		// fallthrough

 	default:

 		res = GenRand(x);

 		break;

 	}

 	return res; 

 	}

 /*************************************************************************************

  class CExecutionContext

  */

 TInt CExecutionContext::CLogMediator::PlaybackInt()

 	{

 	TInt res = 0;

 	if ( !iStalled )

 		{

 		TBool failed = ETrue;

 		TBuf8<1024> logRec;

 		TInt readRes;

 		readRes = iLog.Read( logRec, 3 ); // 'Num'

 		if ( readRes == KErrNone && logRec == _L8("Num") )

 			{

 			iLog.Read( logRec, 16 ); // EntryNo, 16 characters	

 			TLex8 strLex;		

 			strLex.Assign( logRec );		

 			TInt64 readVal64 = 0;		

 			readRes = strLex.Val( readVal64, EDecimal );		

 			if ( KErrNone == readRes && readVal64 == iEntryNo )

 				{

 				readRes = iLog.Read( logRec, 3 ); // ' = '

 				if ( readRes == KErrNone && logRec == _L8(" = ")  )

 					{

 					readRes = iLog.Read( logRec, 13 ); // value 12 + eol

 					strLex.Assign( logRec );		

 					TUint32 readVal32;

 					readRes = strLex.Val( readVal32, EDecimal );		

 					if ( KErrNone == readRes )

 						{  // finally we got a number

 						res = (TInt) readVal32;

 						failed = EFalse;

 						}

 					}							

 				}

 			}

 		if ( failed )

 			{

 			iExecutionContext.MediatorEmptied( this );

 			res = 0;

 			iStalled = ETrue;

 			}

 		}

 	iEntryNo++;

 	return res;

 	}

 void CExecutionContext::CLogMediator::RecordInt(TInt aIntToBeRecorded)

 	{

 	if ( !iStalled )

 		{

 		TBuf8<1024> logRec;

 		logRec.Format( _L8("Num%016Ld = %012d\n"), iEntryNo, aIntToBeRecorded );

 		iLog.Write( logRec );	

 		}

 	iEntryNo++;

 	}

 CExecutionContext::CLogMediator::CLogMediator(CExecutionContext&	aExecutionContext):

 	iExecutionContext( aExecutionContext )

 	{ }

 CExecutionContext::CLogMediator::~CLogMediator()

 	{

 	iLog.Close();

 	iExecutionContext.MediatorDestroyed ( this );

 	}

 void CExecutionContext::CLogMediator::ConstructL( RFs& aFs, const TDesC& aFileName )

 	{

 	TInt fileErr;

 	switch ( iExecutionContext.ContextMode() )

 	{

 	case CExecutionContext::ECtxPlayback:

 		fileErr = iLog.Open( aFs, aFileName, EFileRead );

 		break;

 	case CExecutionContext::ECtxRandomAndRecord:

 		fileErr = iLog.Create( aFs, aFileName, EFileWrite );

 		if(fileErr == KErrAlreadyExists)

 			{

 			fileErr = iLog.Replace( aFs, aFileName, EFileWrite );		

 			}

 		else if(fileErr == KErrPathNotFound)

 			{

 			User::LeaveIfError(aFs.CreatePrivatePath(EDriveC));

 			fileErr = iLog.Create( aFs, aFileName, EFileWrite );

 			}

 		__ASSERT_ALWAYS(KErrNone == fileErr, User::Panic(_L("t_stress utils.cpp"), EPanic2));

 		break;

 	default:										

 		fileErr = KErrGeneral;

 		break;

 	}

 	User::LeaveIfError( fileErr );

 	}

 CExecutionContext::CLogMediator* CExecutionContext::CLogMediator::NewLC(CExecutionContext& aExecutionContext, RFs& aFs, const TDesC& aFileName )

 	{

 	CExecutionContext::CLogMediator* self = new (ELeave) CExecutionContext::CLogMediator( aExecutionContext );

 	CleanupStack::PushL ( self );

 	self->ConstructL( aFs, aFileName );

 	return self; 

 	}

 CExecutionContext* CExecutionContext::NewL(CExecutionContext::TExecutionMode aExecutionMode, CTestExecWatchCat&	aWatchCat)

 	{

 	CExecutionContext* self = new (ELeave) CExecutionContext( aExecutionMode, aWatchCat );

 	CleanupStack::PushL ( self );

 	self->ConstructL( );

 	CleanupStack::Pop( self );

 	return self;

 	}

 CExecutionContext::TExecutionMode CExecutionContext::ContextMode()

 	{

 	return iContextMode;

 	}

 CExecutionContext::CLogMediator&	CExecutionContext::CreateLogMediatorL(const TDesC& aLogName)

 	{

 	CExecutionContext::CLogMediator* mediator = CExecutionContext::CLogMediator::NewLC( *this, iFs, aLogName );

 	iMediators.AppendL( mediator );

 	CleanupStack::Pop(mediator);

 	return *mediator;

 	}

 void CExecutionContext::MediatorDestroyed(CLogMediator* aMediator)

 	{

 	TInt pos = iMediators.Find( aMediator );

 	iMediators.Remove ( pos );

 	}

 void CExecutionContext::MediatorEmptied(CLogMediator* aMediator)

 	{

 	(void)aMediator;

 	iWatchCat.ExecutionContextRunOut( this );

 	}

 void CExecutionContext::ConstructL()

 	{

 	TInt conResult = iFs.Connect();

 	User::LeaveIfError( conResult );	

 	}

 CExecutionContext::CExecutionContext(CExecutionContext::TExecutionMode aExecutionMode, CTestExecWatchCat&	aWatchCat):

 	iWatchCat(aWatchCat),

 	iContextMode(aExecutionMode)

 	{ } // empty

 CExecutionContext::~CExecutionContext()

 	{

 	while ( iMediators.Count() > 0 )

 		{

 			delete iMediators[0]; // this will remove the mediator from the list

 		}

 	iMediators.Close();

 	iFs.Close();

 	}

 /*************************************************************************************

  class CTestExecWatchCat

  */

 CTestExecWatchCat* CTestExecWatchCat::NewL(CExecutionContext::TExecutionMode aExecutionMode)

 	{

 	CTestExecWatchCat* self = new (ELeave) CTestExecWatchCat();

 	CleanupStack::PushL( self );	

 	self->ConstructL( aExecutionMode );

 	// finally hook into TRnd

 	TRnd::SetExecutionContext(self->iExecutionContext);

 	CleanupStack::Pop(self); 

 	return self;

 	}

 void CTestExecWatchCat::ConstructL( CExecutionContext::TExecutionMode aExecutionMode )

 	{

 	iExecutionContext = CExecutionContext::NewL( aExecutionMode, *this );

 	}

 CTestExecWatchCat::CTestExecWatchCat()

 	{ } // empty

 CTestExecWatchCat::~CTestExecWatchCat()

 	{

 	delete iExecutionContext;

 	}

 void CTestExecWatchCat::ExecutionContextRunOut(CExecutionContext* /*aContext*/)

 	{ }

 /**

  Sets the path where the logging file will be created, then constructs the mediator

  */

 void CTestExecWatchCat::SetLoggingPathL(const TDesC& aPath)

 	{

 	RBuf path;

 	path.CleanupClosePushL();

 	path.CreateL(aPath.Length() + 16);

 	if (aPath.Length())

 		{

 		path.Copy(aPath);

 		if (aPath[aPath.Length()-1] != '\\')

 			{

 			path.Append('\\');

 			}

 		}

 	path.Append(KLogFileName);

 	// now construct log mediator

 	CExecutionContext::CLogMediator& mediator = iExecutionContext->CreateLogMediatorL( path );

 	TRnd::SetLogMediator(&mediator);

 	CleanupStack::PopAndDestroy(&path);

 	}

 /*************************************************************************************

  class TTickUtils

  */

 TUint32 TTickUtils::CalcTickDelta(TUint32 tick1, TUint32 tick2)

 	{

 	TInt32 res;

 	if ( tick1 > tick2 )

 		{

 		res = tick1 - tick2;

 		}

 	else

 		{

 		res = tick2 - tick1;		

 		}

 	return res;

 	}