// Copyright (c) 2005-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 <centralrepository.h>
#include "t_cenrep_helper.h"
#include "srvPerf.h"
#include "srvreqs.h"
#include "TE_MemTestStep.h"

#ifdef __CENTREP_SERVER_MEMTEST__
// Method used for TIdentityRelation for TMemTestResult arrays
TBool MatchMemTestResult(const TMemTestResult& aKey, const TMemTestResult& aIndexItem)
	{
	return aIndexItem.iLocation   == aKey.iLocation   && 
		   aIndexItem.iIdentifier == aKey.iIdentifier && 
		   aIndexItem.iIsComplete == aKey.iIsComplete;
	}

void CMemTestStep::ProcessMemTestResults(TAny* aRawData, TInt32 aRawCount, RArray<TMemTestResult>& aMemTestResults)
	{
	ASSERT(aRawCount);
	ASSERT(aRawCount>=3);
	
	for(TInt i=0; i+2<aRawCount;)
		{
		TInt32 value1 = static_cast<TInt32*>(aRawData)[i++];
		TInt32 value2 = static_cast<TInt32*>(aRawData)[i++];
		TInt32 value3 = static_cast<TInt32*>(aRawData)[i++];
		
		if(value1 == KMagicMemTestOutOfBounds && value2 == KMagicMemTestOutOfBounds && value2 == KMagicMemTestOutOfBounds)
			{
			WARN_PRINTF1(_L("Memory test was not able to store all the requested values. Only the stored values will be reported."));
			}
		else
			{
			TMemTestResult result(value1, value2, EFalse);
			//look for not completed memTestResult that match the criteria
			TIdentityRelation<TMemTestResult> identity(MatchMemTestResult);
			
			TInt idx = aMemTestResults.Find(result, identity);
			if(idx == KErrNotFound)
				{
				result.iInitHeapSize = value3;
				aMemTestResults.Append(result);
				}
			else
				{
				TMemTestResult& foundResult = aMemTestResults[idx];
				foundResult.iFinalHeapSize = value3;
				foundResult.iIsComplete = ETrue;
				}
			}
		}
	}
#endif //__CENTREP_SERVER_MEMTEST__

CMemTestStep::CMemTestStep()
	{
	SetTestStepName(KMemTestName);
	}
	
// doTestStepL
// This test fetches the memory data collected by
// CentRep server, processes it and reports the result.
TVerdict CMemTestStep::doTestStepL()
	{
#ifdef __CENTREP_SERVER_MEMTEST__
	SetTestStepResult(EFail);
	// Pause a few seconds to ensure startup sequence is finished.
#ifdef __WINS__
 	const TTimeIntervalMicroSeconds32 interval = 12000000;
#else
 	const TTimeIntervalMicroSeconds32 interval = 4000000;
#endif
 	User::After(interval);

	TAny* buf = User::AllocL((KMemBufMaxEntry) * sizeof(TInt32));
	CleanupStack::PushL(buf);
	TPtr8 pBuf(static_cast<TUint8*>(buf), (KMemBufMaxEntry) * sizeof(TInt32));
	TInt numEntries;
	TPckg<TInt> pNumEntries(numEntries);
	TInt error = SetGetParameters(TIpcArgs(EGetMemResults, &pNumEntries, &pBuf));

	if(error == KErrNone && numEntries > 0)
		{
		RArray<TMemTestResult> memTestResults;
		
		ProcessMemTestResults(buf, numEntries, memTestResults);
		
		TInt count = memTestResults.Count();
		for(TInt i=0; i<count; i++)
			{
			TMemTestResult& result = memTestResults[i];
			if(result.iIsComplete)
				{
				if(result.iLocation == EMemLcnRepositoryOpen)
					{
					Logger().WriteFormat(_L("Memory usage for repository [%08X]: %d"), 
										 result.iIdentifier, 
										 result.iFinalHeapSize - result.iInitHeapSize);
					}
				else if(result.iLocation == EMemLcnOnDemand)
					{
					Logger().WriteFormat(_L("Heap memory usage of Centrep server at step %d: %d"), 
										 result.iIdentifier, 					
										 result.iFinalHeapSize);
					static TInt prevResult;
					switch (result.iIdentifier)
						{
						case 1: TESTL(result.iFinalHeapSize > prevResult); break;
						case 3: TESTL(result.iFinalHeapSize < prevResult); break;
						case 4: TESTL(result.iFinalHeapSize > prevResult); break;						
						}
					prevResult = result.iFinalHeapSize;
					}
				else
					{
					Logger().WriteFormat(_L("Memory usage at location[%d] for identifier[%d]: %d"),
										 result.iLocation, 
										 result.iIdentifier, 
										 result.iFinalHeapSize - result.iInitHeapSize);
					}
				}
			else
				{
				Logger().WriteFormat(_L("Incomplete memory reading at location[%d] for identifier[%d]"),
									 result.iLocation, 
									 result.iIdentifier);
				}
			}
		}
	
    CleanupStack::PopAndDestroy();

	if(error == KErrNone)
		{
		SetTestStepResult(EPass);
		}
#else
	WARN_PRINTF1(_L("Memory test macro __CENTREP_SERVER_MEMTEST__ is not defined. Test was not run."));
#endif //__CENTREP_SERVER_MEMTEST__

	return TestStepResult();
	}