// 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 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:

// Tests the functionality of the SCM Libraries

// 

//

#include "t_crashmonitor.h"

#include <crashlogwalker.h>

using namespace Debug;

/**

 * Test suite version

 */

const TVersion testVersion(1,1,0);

/**

 * Constructor

 */

CSCMLibraryClient::CSCMLibraryClient():

	iNonCachedWriter(iBuffer, EFalse),

	iCachedWriter(iBuffer, EFalse),

	iWriter(NULL),

	iReader(iBuffer)	

	{

	}

/**

 * First phase constructor

 */

CSCMLibraryClient* CSCMLibraryClient::NewL()

	{

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

  	self->ConstructL();

	return self;

	}

/**

 * Destructor

 */

CSCMLibraryClient::~CSCMLibraryClient()

	{

	}

/**

 * ConstructL

 */

void CSCMLibraryClient::ConstructL()

	{}

/**

 * Prints usage of this test suite

 */

void CSCMLibraryClient::PrintUsage()

	{

	test.Printf(_L("Invoke with arguments:\n"));

	test.Printf(_L("-r: run specified tests in reverse order\n"));

	test.Printf(_L("-h: display usage information\n"));

	test.Printf(_L("-v: display version\n"));

	test.Printf(_L("<number>: test number to run, can specify more than one from the following list:\n"));

	test.Printf(_L("Press any key for list...\n"));

	test.Getch();

	// if there are too many of these they won't fit on the screen! Stick another Getch() in if there get too many

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

		{

		test.Printf(_L("%2d: %S\n"), i, &(iTestArray[i].iFunctionName));

		}

	test.Printf(_L("Press any key...\n"));

	test.Getch();

	}

/**

 * Parses arguments from command line

 * @param aMode Argument mode

 * @param aTests Array of tests

 */

void CSCMLibraryClient::ParseCommandLineL(TUint32& aMode, RArray<TInt>& aTests)

	{

	// get the length of the command line arguments

	TInt argc = User::CommandLineLength();

	// allocate a buffer for the command line arguments and extract the data to it

	HBufC* commandLine = HBufC::NewLC(argc);

	TPtr commandLineBuffer = commandLine->Des();

	User::CommandLine(commandLineBuffer);

	// reset mode

	aMode = (TTestMode)0;

	// create a lexer and read through the command line

	TLex lex(*commandLine);

	while (!lex.Eos())

		{

		// expecting the first character to be a '-'

		if (lex.Get() == '-')

			{

			TChar arg = lex.Get();

			switch (arg)

				{

				case 'v':

					//print out the help

					aMode |= EModeVersion;

					break;

				case 'h':

					//print out the help

					aMode |= EModeHelp;

					break;

				case 'r':

					//store the fact that we want to run in reverse

					aMode |= EModeReverse;

					break;

				default:

					// unknown argument so leave

					User::Leave(KErrArgument);

				}

			}

		else

			{

			lex.UnGet();

			TInt testNumber;

			User::LeaveIfError(lex.Val(testNumber));

			if( (testNumber<0) || (testNumber>=KMaxTests) )

				{

				User::Leave(KErrArgument);

				}

			aTests.AppendL(testNumber);

			}

		lex.SkipSpace();

		}

	// if no tests specified then run them all

	if(aTests.Count() == 0)

		{

		aMode |= EModeAll;

		}

	// do clean up

	CleanupStack::PopAndDestroy(commandLine);

	}

/**

 * This will run all tests in the suite

 */

void CSCMLibraryClient::ClientAppL()

	{	

	FillArray();

	test.Start(_L("ClientAppL"));

	RArray<TInt> testsToRun;

	TUint32 testMode = 0;

	ParseCommandLineL(testMode, testsToRun);

	//if help or version mode specified then just print out the relevant stuff and quit

	if((testMode & EModeHelp) || (testMode & EModeVersion))

		{

		if(testMode & EModeHelp)

			{

			PrintUsage();

			}

		if(testMode & EModeVersion)

			{

			PrintVersion();

			}

		test.End();

		return;

		}

	if(testMode & EModeAll)

		{

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

			{

			testsToRun.AppendL(i);

			}

		}

	// if EModeReverse specified then reverse the array elements

	TInt numberOfTests = testsToRun.Count();

	if(testMode & EModeReverse)

		{

		for(TInt i=0; i<(numberOfTests>>1); i++)

			{

			TInt temp = testsToRun[i];

			testsToRun[i] = testsToRun[numberOfTests - (i+1)];

			testsToRun[numberOfTests - (i+1)] = temp;

			}

		}

	HelpStartTestTimer();

	// first run al tests with non cached writer

	iWriter = &iNonCachedWriter;

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

		{

		RunTest(testsToRun[i]);

		}

	iWriter = &iCachedWriter;	

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

		{

		RunTest(testsToRun[i]);

		}

	testsToRun.Close();

	HelpStopTestTimer();

	ReportPerformance();

	test.End();

	}

/**

 * This fills our array of test functions with function pointers to tests

 */

void CSCMLibraryClient::FillArray() 

	{

	//iTestArray[0] = new TFunctionData();

	iTestArray[0].iFunctionPtr = &CSCMLibraryClient::TestCheckSum;

	iTestArray[0].iFunctionName = _L("TestCheckSum");

	iTestArray[1].iFunctionPtr = &CSCMLibraryClient::TestLockDataSerialization;

	iTestArray[1].iFunctionName = _L("TestLockDataSerialization");

	iTestArray[2].iFunctionPtr = &CSCMLibraryClient::TestOffsetsHeaderSerialization;

	iTestArray[2].iFunctionName = _L("TestOffsetsHeaderSerialization");

	iTestArray[3].iFunctionPtr = &CSCMLibraryClient::TestInfoHeaderSerialization;

	iTestArray[3].iFunctionName = _L("TestInfoHeaderSerialization");

	iTestArray[4].iFunctionPtr = &CSCMLibraryClient::TestRawData;

	iTestArray[4].iFunctionName = _L("TestRawData");

	iTestArray[5].iFunctionPtr = &CSCMLibraryClient::TestProcessData;

	iTestArray[5].iFunctionName = _L("TestProcessData");

	iTestArray[6].iFunctionPtr = &CSCMLibraryClient::TestThreadData;

	iTestArray[6].iFunctionName = _L("TestThreadData");

	iTestArray[7].iFunctionPtr = &CSCMLibraryClient::TestThreadStack;

	iTestArray[7].iFunctionName = _L("TestThreadStack");

	iTestArray[8].iFunctionPtr = &CSCMLibraryClient::TestRegisterValue;

	iTestArray[8].iFunctionName = _L("TestRegisterValue");

	iTestArray[9].iFunctionPtr = &CSCMLibraryClient::TestRegisterSet;

	iTestArray[9].iFunctionName = _L("TestRegisterSet");

	iTestArray[10].iFunctionPtr = &CSCMLibraryClient::TestMemoryDump;

	iTestArray[10].iFunctionName = _L("TestMemoryDump");

	iTestArray[11].iFunctionPtr = &CSCMLibraryClient::TestCodeSegmentSet;

	iTestArray[11].iFunctionName = _L("TestCodeSegmentSet");

	iTestArray[12].iFunctionPtr = &CSCMLibraryClient::TestCodeSegment;

	iTestArray[12].iFunctionName = _L("TestCodeSegment");

	iTestArray[13].iFunctionPtr = &CSCMLibraryClient::TestTraceDump;

	iTestArray[13].iFunctionName = _L("TestTraceDump");

	iTestArray[14].iFunctionPtr = &CSCMLibraryClient::TestVariantSpecificData;

	iTestArray[14].iFunctionName = _L("TestVariantSpecificData");

	iTestArray[15].iFunctionPtr = &CSCMLibraryClient::TestRomHeaderData;

	iTestArray[15].iFunctionName = _L("TestRomHeaderData");

	iTestArray[16].iFunctionPtr = & CSCMLibraryClient::TestSCMLockData;

	iTestArray[16].iFunctionName = _L("TestSCMLockData");

	};

/**

 * Entry point for crash monitor tests

 */

GLDEF_C TInt E32Main()

	{

	TInt ret = KErrNone;

	CTrapCleanup* trap = CTrapCleanup::New();

	if (!trap)

		return KErrNoMemory;

   	test.Title();

   	CSCMLibraryClient* tester = CSCMLibraryClient::NewL();

   	if (tester != NULL)

       {

        __UHEAP_MARK;

	    TRAP(ret,tester->ClientAppL());

	    __UHEAP_MARKEND;

	   delete tester;

       }

	delete trap;

	return ret;

	}

/**

 * Runs a given test identified by argument

 * @param aTestNumber Test to run

 */

void CSCMLibraryClient::RunTest(TInt aTestNumber)

	{

	if( (aTestNumber<0) || (aTestNumber>=KMaxTests) )

		{

		User::Panic(_L("Test number out of range"), aTestNumber);

		}

	__UHEAP_MARK;

	if(iTestArray[aTestNumber].iFunctionPtr)

		{

		test.Printf(_L("pre-run test %d"), aTestNumber);

		(this->*(iTestArray[aTestNumber].iFunctionPtr))();

		test.Printf(_L("post-run test %d"), aTestNumber);

		}

	__UHEAP_MARKEND;

	}

/**

 * Prints the version of this test suite

 */

void CSCMLibraryClient::PrintVersion()

	{

	test.Printf(_L("\nt_crashmonitor_lib.exe\nVersion: %S\n"), &(testVersion.Name()));

	test.Printf(_L("Press any key...\n"));

	test.Getch();

	}

/**

 * Reports performance metrics from all the tests

 */

void CSCMLibraryClient::ReportPerformance(void)

	{

	test.Printf(_L("\nPerformance\n"));

	test.Printf(_L("========================\n"));

	// Runtime

	TInt ticks = HelpGetTestTicks();

#ifndef __WINS__

	test (ticks != 0);  

#endif

	TInt nkTicksPerSecond = HelpTicksPerSecond();

#ifndef __WINS__

	test (nkTicksPerSecond != 0);

#endif

	test.Printf(_L("Total test runtime: %d seconds\n"),ticks/nkTicksPerSecond);

	test.Printf(_L("\n"));

	}

/**

 * Returns the number of nanokernel ticks in one second

 * @return Number of nanokernel ticks. 0 if unsuccesful

 */

TInt CSCMLibraryClient::HelpTicksPerSecond(void)

	{

	TInt nanokernel_tick_period;

	HAL::Get(HAL::ENanoTickPeriod, nanokernel_tick_period);

	ASSERT(nanokernel_tick_period != 0);

	static const TInt KOneMillion = 1000000;

	return KOneMillion/nanokernel_tick_period;

	}

void CSCMLibraryClient::DoWrite(MByteStreamSerializable& aObjectToWrite, TInt aPosition)

	{

	if(iWriter == &iCachedWriter)

		{

		iCachedWriter.SetPosition(aPosition);

		test(aObjectToWrite.Serialize(iCachedWriter) == KErrNone);

		iCachedWriter.FlushCache();	

		}

	else if(iWriter == &iNonCachedWriter)

		{

		iNonCachedWriter.SetPosition(aPosition);		

		test(aObjectToWrite.Serialize(iNonCachedWriter) == KErrNone);	

		}

	else

		{

		// no writer

		test(EFalse);

		}

	}

// BASE granted test id's 2364 to 2394

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

// !@SYMTestCaseID KBASE-T_SCMLIB-2364

//! @SYMTestType

//! @SYMPREQ PREQ1700

//! @SYMTestCaseDesc Ensures we can serialise and deserialise the TScmChecksum structure 

//! @SYMTestActions TScmChecksum serialized & then deserialized

//! @SYMTestExpectedResults TScmChecksum structure serialized / deserialized ok

//! @SYMTestPriority High

//! @SYMTestStatus Implemented

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

void CSCMLibraryClient::TestCheckSum()

	{

	test.Next(_L("TestCheckSum\n"));

	TScmChecksum chksm1;

	chksm1.Reset();

	TInt blocksize1 = 123;

	TInt blocksize2 = 166;

	TScmChecksum chksm2;

	chksm2.Reset();

	test(ChecksumHelper(chksm1, blocksize1, iBuffer, KBufLen));

	test(ChecksumHelper(chksm2, blocksize2, iBuffer, KBufLen));

	test(chksm1  == chksm2);

	}

TBool CSCMLibraryClient::ChecksumHelper(TScmChecksum& aChecksum, TUint aBlocksize, TUint8* aBuffer, TUint aBufferLen) 

	{

	if( aBlocksize == 0 || aBufferLen == 0 )

		{

		return EFalse;

		}

	TInt remaining = aBufferLen;

	TInt pos = 0;

	while(remaining > aBlocksize)

		{		

		aChecksum.ChecksumBlock(aBuffer + pos, aBlocksize);

		pos += aBlocksize;

		remaining -= aBlocksize;

		}

	aChecksum.ChecksumBlock(aBuffer + pos, remaining);

	pos += remaining;

	return (pos == aBufferLen);

	}

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

//! @SYMTestCaseID KBASE-T_SCMLIB-2365

//! @SYMTestType

//! @SYMPREQ PREQ1700

//! @SYMTestCaseDesc Ensures we can serialise and deserialise the TSCMLockData structure 

//! @SYMTestActions TSCMLockData serialized & then deserialized

//! @SYMTestExpectedResults TSCMLockData structure serialized / deserialized ok

//! @SYMTestPriority High

//! @SYMTestStatus Implemented

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

void CSCMLibraryClient::TestLockDataSerialization()

	{	

	test.Next(_L("TestLockDataSerialization\n"));	

	TSCMLockData lockData1;

	//Arbitrary values

	lockData1.SetLockCount(10);

	lockData1.SetMutexHoldCount(17);

	lockData1.SetMutexThreadWaitCount(36);

	DoWrite(lockData1);

	iReader.SetPosition(0);

	//Test deserialisation works

	TSCMLockData lockData2;	

	test(lockData2.Deserialize(iReader) == KErrNone);

	//Test we got back the correct object

	test(lockData1 == lockData2);

	}

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

//! //! @SYMTestCaseID KBASE-T_SCMLIB-2366

//! @SYMTestType

//! @SYMPREQ PREQ1700

//! @SYMTestCaseDesc Ensures we can serialise and deserialise the TCrashOffsetsHeader structure 

//! @SYMTestActions TCrashOffsetsHeader serialized & then deserialized

//! @SYMTestExpectedResults TCrashOffsetsHeader structure serialized / deserialized ok

//! @SYMTestPriority High

//! @SYMTestStatus Implemented

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

void CSCMLibraryClient::TestOffsetsHeaderSerialization()

	{

	test.Next(_L("TestOffsetsHeaderSer ialization\n"));	

	TCrashOffsetsHeader header1;

	header1.iCTFullRegOffset = 123; 

	header1.iCTUsrStkOffset = 456;

	header1.iCTSvrStkOffset = 789;

	header1.iCPMetaOffset = 1001;

	header1.iCTMetaOffset = 99;		

	header1.iCPCodeSegOffset = 1234;

	header1.iSysUsrStkOffset = 3456;

	header1.iSysSvrStkOffset = 255;

	header1.iSysUsrRegOffset = 999;

	header1.iSysSvrRegOffset = 2002;

	header1.iTLstOffset = 3003;

	header1.iPLstOffset = 4004;

	header1.iSysCodeSegOffset = 5005;

	header1.iExcStkOffset = 6006;

	header1.iTraceOffset = 1233;

	header1.iScmLocksOffset = 3421;

	header1.iKernelHeapOffset = 89;

	header1.iVarSpecInfOffset = 0;

	header1.iRomInfoOffset = 123;

	DoWrite(header1);