/*

* Copyright (c) 1998-2010 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of the License "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 "tScriptTests.h"

#include "t_testhandler.h"

#include "t_certstoretests.h"

#include "t_certstoreactions.h"

#include <e32std.h>

#include <f32file.h>

#include <ecom/ecom.h>

///////////////

#include "t_testsetup.h"

#include "t_testactionspec.h"

#include "t_input.h"

#include "t_certstoreactionmemfail.h"

#include "tcancel.h"

#include "t_message.h"

#include "tScriptSetup.h"

#include "tHardcodedSetup.h"

#include "t_testhandler.h"

#include "t_output.h"

#include "tTestSpec.h"

#include "Ttesthandlersettings.h"

/**

*	--------------------------------------

*	How this test works:

*	--------------------------------------

*

*	RUN THIS TEST IN CONFIGURATION 1 (FILECERTSTORE.DLL SHOULD BE THE ONLY 

*	ECOM PLUGIN IN Z:\SYSTEM\LIBS\PLUGINS).  IF WAPCERTSTORE.DLL IS PRESENT

*	THIS TEST WILL HANG!!!

*

*	This test is designed to stress concurrent access to the filecertstore

*	by multiple threads, and to check that the integrity of the store is

*	retained.

*

*	The test consists of 3 scripts (certstoreconcurrent1-3.txt) which test various

*	possible accesses to the filebased store (cert add, delete, set trust, applications

*	and certificate retreival.  There are 27 possible ways to combine the 3 scripts.

*	For each of these combinations, 3 threads are started and each is assigned a

*	separate test handler and one of the scripts for that combination.  The threads

*	then run together, accessing the store concurrently. 

*	

*	BECAUSE THE THREADS ARE RUNNING CONCURRENTLY, IT IS NOT POSSIBLE TO PREDICT

*	THE RESULTS OF EACH TEST, EG IT IS NOT POSSIBLE TO DETERMINE WHETHER THE 

*	CERTIFICATE THAT ONE THREAD WISHES TO DELETE IS ACTUALLY PRESENT IN THE STORE

*	AT THAT TIME, SINCE ANOTHER THREAD MAY HAVE REMOVED IT.  BECAUSE OF THIS 

*	THE SCRIPTS ARE MARKED WITH A testconcurrent FLAG TO INDICATE THAT THE FAIL

*	RESULTS SHOULD BE DISREGARDED.  The results for each script are written to a

*	separate file in EPOC directory \tcertstoreconcurrent\ on system drive thus by the end of the

*	the test there are 81 such log files in the directory.

*

*	Following the 27 combinations of 3 threads, the test then runs a standard

*	tcertstore test using one of the scripts used in general certstore testing

*	(the script is determined by the command line for the entire test).  This

*	runs in a single thread so results can be predicted.  Thus we check that 

*	filecertstore integrity is maintained.  The log file for these tests are

*	placed in EPOC system drive and should be inspected for errors as part of the

*	testing procedure.

*

*	Thus to run these tests, the following command line should be used:

*	tcertstoreconcurrent \tcertstore\scripts\unifiedcertstore2-conf1.txt \tcertstoreconcurrent1.log

*	,the script and log file being on system drive.This runs script unifiedcertstore2-conf1 after the 

*	threaded tests and logs	the test results to tcertstoreconcurrent1.log

*/

//	3 scripts available, switch between them

const static TText* scripts[] = {	_S("dummy for zero element"),

									_S("\\tcertstoreconcurrent\\scripts\\certstoreconcurrent1.txt"), 

									_S("\\tcertstoreconcurrent\\scripts\\certstoreconcurrent2.txt"),

									_S("\\tcertstoreconcurrent\\scripts\\certstoreconcurrent3.txt")};

const TInt KMaxIterations = 27;

const TInt scriptCombinations[] = {	1,1,1,	1,1,2,	1,1,3,

									1,2,1,	1,2,2,	1,2,3,

									1,3,1,	1,3,2,	1,3,3,

									2,1,1,	2,1,2,	2,1,3,

									2,2,1,	2,2,2,	2,2,3,

									2,3,1,	2,3,2,	2,3,3,

									3,1,1,	3,1,2,	3,1,3,

									3,2,1,	3,2,2,	3,2,3,

									3,3,1,	3,3,2,	3,3,3};

class TThreadData

	{

public:

	void InitialiseL(TInt aIteration, TInt aScriptNum);

public:	

	TPtrC iScriptFile;

	TFileName iLogFile;

	};

void TThreadData::InitialiseL(TInt aIteration, TInt aThreadNum)

	{

	ASSERT(aIteration >= 0 && aIteration < KMaxIterations);

	ASSERT(aThreadNum >= 1 && aThreadNum <= 3);

	TInt script = scriptCombinations[aIteration * 3 + aThreadNum - 1];		

	// Set script file

	TDriveUnit sysDrive (RFs::GetSystemDrive());

	TDriveName sysdriveName (sysDrive.Name());

	TBuf <60> scriptFile (sysdriveName);

	scriptFile.Append(scripts[script]);

	iScriptFile.Set(scriptFile);

	// Set log file

	iLogFile.Zero();

	TBuf<80> scriptName (sysdriveName);

	scriptName.Append(_L("\\tcertstoreconcurrent\\iteration%02d_thread%d_script%d.txt"));

	TBuf<80> buf ;

	buf.Format(scriptName,aIteration, aThreadNum, script); 

	iLogFile.Append(buf);

	}

LOCAL_C TInt ThreadEntryPoint(TAny* aArg)

{

	__UHEAP_MARK;

	CTrapCleanup* cleanup=CTrapCleanup::New();

	TThreadData* data = static_cast<TThreadData*>(aArg);

	ASSERT(data);

	TRAPD(r, DoTests(data->iScriptFile, data->iLogFile, ETrue));

	//TRAPD(r, PerformTests(TestTypes(), data->iScriptFile, data->iLogFile));

	ASSERT( (r==KErrNone) || (r==KErrInUse) );

	delete cleanup;

	__UHEAP_MARKEND;

	return (r);

}

/** Start a thread. */

LOCAL_D void StartThreadL(RThread& aThread, TThreadData& aData, TInt aIteration, TInt aThreadNum, TRequestStatus& aStatus)

	{

	aData.InitialiseL(aIteration, aThreadNum);

	TBuf<32> threadName;

	threadName.Format(_L("iteration%02d_thread%d"), aIteration, aThreadNum);

	RHeap* heap = User::ChunkHeap(NULL, KMinHeapSize, 0x100000);

	User::LeaveIfNull(heap);

	User::LeaveIfError(aThread.Create(threadName, ThreadEntryPoint, KDefaultStackSize, heap, (TAny*)&aData));	

	aStatus = KRequestPending;

	aThread.Logon(aStatus);

	aThread.Resume();

	}

//	Kicks off each thread for multiple concurrent certstore access

LOCAL_D TBool DoThreadedTestsL(CConsoleBase* console, HBufC* logFileName, TBool wait)

{

 	RFs myfs;

 	CleanupClosePushL(myfs);

 	RFile logfile;

 	CleanupClosePushL(logfile);

 	Output* out;

 	User::LeaveIfError(myfs.Connect());

 	User::LeaveIfError(logfile.Replace(myfs, *logFileName, EFileWrite));

 	out = new (ELeave) FileOutput(logfile);

 	CleanupStack::PushL(out);

	TInt failureCount = 0;

	for (TInt i = 0 ; i < KMaxIterations; ++i)

		{

		console->Printf(_L("Iteration %d \n"), i);

		out->writeNewLine();

		out->writeString(_L("Iteration "));

		out->writeNum(i);

		out->writeNewLine();

		RThread thread1;

		TThreadData data1;

		TRequestStatus status1;

		StartThreadL(thread1, data1, i, 1, status1);

		RThread thread2;

		TThreadData data2;

		TRequestStatus status2;

		StartThreadL(thread2, data2, i, 2, status2);

		RThread thread3;

		TThreadData data3;

		TRequestStatus status3;

		StartThreadL(thread3, data3, i, 3, status3);

		User::WaitForRequest(status1);

		User::WaitForRequest(status2);

		User::WaitForRequest(status3);

		TExitType exit1 = thread1.ExitType();

		TExitType exit2 = thread2.ExitType();

		TExitType exit3 = thread3.ExitType();

		if (exit1 != EExitKill) 

			{

			console->Printf(_L("ERROR: Thread 1 exited with exit type: %d \n"), exit1);

 			out->writeString(_L("ERROR: Thread 1 exited with exit type: "));

			out->writeNum(exit1);

	 		out->writeNewLine();

			failureCount++;

			}

		if (exit2 != EExitKill) 		

			{

			console->Printf(_L("ERROR: Thread 2 exited with exit type: %d \n"), exit2);

 			out->writeString(_L("ERROR: Thread 2 exited with exit type: "));

			out->writeNum(exit2);

	 		out->writeNewLine();			

			failureCount++;

			}

		if (exit3 != EExitKill) 

			{

			console->Printf(_L("ERROR: Thread 3 exited with exit type: %d \n"), exit3);

 			out->writeString(_L("ERROR: Thread 2 exited with exit type: "));

			out->writeNum(exit3);

	 		out->writeNewLine();			

			failureCount++;

			}

		thread1.Heap()->Close();

		thread2.Heap()->Close();

		thread3.Heap()->Close();

		thread1.Close();

		thread2.Close();

		thread3.Close(); 

		User::LeaveIfError(status1.Int());

		User::LeaveIfError(status2.Int());

		User::LeaveIfError(status3.Int());		

	}

	if (failureCount > 0) 

 		{

 		out->writeNewLine();

		console->Printf(_L("\n %d tests failed out of %d \n"), failureCount, (KMaxIterations*3));

 		out->writeNewLine();

 		out->writeNum(failureCount);

 		out->writeString(_L(" tests failed out of "));

 		out->writeNum(KMaxIterations*3);

 		out->writeNewLine();		

 		}

 	if (wait) 

 		{

		console->Printf(_L("\n Press any key to continue \n"));		

		console->Getch();

 		}

 	CleanupStack::PopAndDestroy(out);

 	CleanupStack::PopAndDestroy(&logfile);

 	CleanupStack::PopAndDestroy(&myfs); 	

 	if (failureCount>0) 

 		{

 		return EFalse;

 		}

 	return ETrue;

}

/**

 * Extracts the nPos command line argument.

 */

LOCAL_D HBufC* GetArgument(TInt nPos)

	{

	HBufC *argv = HBufC::NewLC(User::CommandLineLength());

	TPtr cmd(argv->Des());

	User::CommandLine(cmd);

	TLex arguments(cmd);

	// finds nth parameter 

	while(nPos && !arguments.Eos())

		{

		TPtrC token = arguments.NextToken();

		if(token.Length() > 0)		

			nPos--;

		}

	HBufC* result = NULL;

	if(!arguments.Eos())

		{

		TPtrC testfile(arguments.NextToken());

		if(testfile.Length() > 0)

			result = testfile.AllocL();

		};

	// no parameter found, but must return something so..

	if(!result)

		result = HBufC::NewL(0);

	CleanupStack::PopAndDestroy(argv);

	return result;

	}

/**

 * This function sets up a console, a log file and checks

 * whether we need to wait for a key pressed after test 

 * completion.

 * First DoThreadedTestsL is called, if everything is ok

 * it return ETrue and we move on to the standard tests.

 * If something went amiss (return EFalse) we skip 

 * the standard test and return. 

 */

LOCAL_D void SetupAndRunTests() 

{

	CConsoleBase* console = Console::NewL(_L("Test code"), TSize(KConsFullScreen, KConsFullScreen));

	HBufC* logFile = GetArgument(1);

	if (logFile->Length()==0) 

		{

		_LIT(defaultLog, "\\tcertstore.log");

		TDriveUnit sysDrive (RFs::GetSystemDrive());

		TDriveName sysdriveName (sysDrive.Name());

		TBuf <18> fileName (sysdriveName);

		fileName.Append(defaultLog);

		logFile->ReAlloc(18);

		TPtr16 plog = logFile->Des();

		plog.Append(fileName);

		}

	HBufC* wait = GetArgument(2);

	TBool waitAfterCompletion = EFalse;

	if (wait->Find(_L("-w")) != KErrNotFound) 

		{

		waitAfterCompletion = ETrue;

		}

	TBool res = EFalse;	

	TRAPD(err, res = DoThreadedTestsL(console, logFile, waitAfterCompletion));

	if (res) 

		{

		// Now run a normal tcertstore test to check store integrity

		TRAP(err, DoTests());

		}

	delete console;

	delete wait;

	delete logFile;

}

GLDEF_C TInt E32Main()

{

	__UHEAP_MARK;

	CTrapCleanup* cleanup=CTrapCleanup::New();

	TRAPD(err, SetupAndRunTests());

	REComSession::FinalClose();

	delete cleanup;

	__UHEAP_MARKEND;

	return 0;

}