// 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 "TE_DefectTestStep.h"

#include "TE_PerfTestUtilities.h"

#include <centralrepository.h>

#include "t_cenrep_helper.h"

#include "srvdefs.h"

#include "srvreqs.h"

#include <bautils.h>

#include "cachemgr.h"

#ifdef __CENTREP_SERVER_CACHETEST__

const TUid KUidLargeRepository          = { 0xCCCCCC01 };

const TUid KUidRep1						= { 0x00000100 };

const TUid KUidLargeCreRepository       = { 0xCCCCCC02 };

const TUint32 KNewInt = 1000;

const TInt KIntValue = 1234;

const TInt KNumOfAttempts = 10;

_LIT(KZRep1File, 				"z:\\private\\10202BE9\\00000100.txt");

_LIT(KCRep1TxtFile,				"c:\\private\\10202BE9\\persists\\00000100.txt");

_LIT(KCRep1CreFile,				"c:\\private\\10202BE9\\persists\\00000100.cre");

#endif

CPerfTestDefectStep057491::CPerfTestDefectStep057491()

	{

	SetTestStepName(KPerfTestDefectStepDEF057491);

	}

TVerdict CPerfTestDefectStep057491::doTestStepL()

	{

#ifndef __CENTREP_SERVER_CACHETEST__

	return EPass;

#else	

	SetTestStepResult(EFail);

	CRepository* rep;

	TInt64 totalRomMs=0;

	TInt64 totalCreMs=0;

	TInt64 totalRepWriteMs=0;

   	TUint32 startFastCounter;	

   	TUint64 fastCounterromOpenMicroseconds;

   	TUint64 fastCounterrepWriteMicroseconds;

   	TUint64 fastCountercreOpenMicroseconds;

	// Flush and disable cache for this test

	TInt r;

	r = SetGetParameters(TIpcArgs(EDisableCache));

	TEST(r==KErrNone);

	// Time opening and writing repository

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

		{

		// Get start time for ROM file

	    startFastCounter = User::FastCounter();

		User::LeaveIfNull(rep = CRepository::NewLC(KUidLargeRepository));

		// Get finish time for ROM file

		fastCounterromOpenMicroseconds = FastCountToMicrosecondsInInt(User::FastCounter() - startFastCounter);

		totalRomMs+=fastCounterromOpenMicroseconds;

		Logger().WriteFormat(_L("Time to open large repos from ROM      file = %lu microseconds\n"), fastCounterromOpenMicroseconds);

	    startFastCounter = User::FastCounter();

		TInt r = rep->Create(KNewInt, KIntValue);

		fastCounterrepWriteMicroseconds = FastCountToMicrosecondsInInt(User::FastCounter() - startFastCounter);

		totalRepWriteMs+=fastCounterrepWriteMicroseconds;

		Logger().WriteFormat(_L("Time to write large repos              file = %lu microseconds\n"), fastCounterrepWriteMicroseconds);

		TEST(r==KErrNone);

		// Close repository

		CleanupStack::PopAndDestroy(rep);

		// Get start time and ticks for .cre file

	    startFastCounter = User::FastCounter();

		// Open repository 

		User::LeaveIfNull(rep = CRepository::NewLC(KUidLargeRepository));

		// Get finish time and ticks for .cre file

		fastCountercreOpenMicroseconds  = FastCountToMicrosecondsInInt(User::FastCounter() - startFastCounter);

		totalCreMs+=fastCountercreOpenMicroseconds;

		Logger().WriteFormat(_L("Time to open large repos from persists file = %lu microseconds\n"), fastCountercreOpenMicroseconds);

#if !defined(__WINS__) && !defined(__WINSCW__)

		TEST(fastCounterromOpenMicroseconds>fastCountercreOpenMicroseconds);

#endif		

		const TUint32 	KIntKey1 		= 8847616;

		const TInt 		KIntKey1Value 	= 1;

		const TUint32 	KIntKey2 		= 139068928;

		const TInt 		KIntKey2Value 	= 30;

		const TUint32 	KIntKey3 		= 2373975808UL;

		const TInt 		KIntKey3Value 	= -1920991488;

		// Test 3 random int key values from repository

		TInt keyValue;

		r=rep->Get(KIntKey1, keyValue);

		TEST(r == KErrNone);

		TEST(keyValue == KIntKey1Value);

		r=rep->Get(KIntKey2, keyValue);

		TEST(r == KErrNone);

		TEST(keyValue == KIntKey2Value);

		r=rep->Get(KIntKey3, keyValue);

		TEST(r == KErrNone);

		TEST(keyValue == KIntKey3Value);

		// Close repository

		CleanupStack::PopAndDestroy(rep);

		CleanupFileFromCDriveL(KUidLargeRepository);

		}

	Logger().WriteFormat(_L("Average time to open large repos from ROM      file = %lu ms\n"), totalRomMs/KNumOfAttempts);

	Logger().WriteFormat(_L("Average time to open large repos from persists file = %lu ms\n"), totalCreMs/KNumOfAttempts);		

	Logger().WriteFormat(_L("Average time to write large repos to  persists file = %lu ms\n"), totalRepWriteMs/KNumOfAttempts);		

	RFs fs;			

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

	CleanupClosePushL(fs);

	CFileMan* fm = CFileMan::NewL(fs);

	CleanupStack::PushL(fm);

	// Copy a repository txt file to the C:

	User::LeaveIfError(fm->Copy(KZRep1File, KCPersistsDir));

	// Reset read-only bit

	User::LeaveIfError(fm->Attribs(KCRep1TxtFile,0,KEntryAttReadOnly,TTime(0)));

	// Check it exists

	TEST( BaflUtils::FileExists (fs, KCRep1TxtFile));	

	// Open repository

	User::LeaveIfNull(rep = CRepository::NewLC(KUidRep1));

	// Create a setting

	r = rep->Create(KNewInt, KIntValue);

	TEST(r == KErrNone);

	// Check persists file exists

	TEST(BaflUtils::FileExists (fs, KCRep1CreFile));	

	// Check that .txt file is gone	

	TEST(BaflUtils::FileExists (fs, KCRep1TxtFile) == EFalse);	

	// Close the repository

	CleanupStack::PopAndDestroy(rep);

	CleanupStack::PopAndDestroy(2);		// fm, fs

	CleanupFileFromCDriveL(KUidRep1);

	// Enable cache

	r = SetGetParameters(TIpcArgs(EEnableCache, KDefaultEvictionTimeout, KDefaultCacheSize));

	TEST(r==KErrNone);

	SetTestStepResult(EPass);

	return TestStepResult();

#endif

	}

CPerfTestDefectStep059633::CPerfTestDefectStep059633()

	{

	SetTestStepName(KPerfTestDefectStepDEF059633);

	}

TVerdict CPerfTestDefectStep059633::doTestStepL()

	{

#ifndef __CENTREP_SERVER_CACHETEST__

	return EPass;

#else	

	SetTestStepResult(EFail);

	// Flush and disable cache for this test

	TInt r;

	r = SetGetParameters(TIpcArgs(EDisableCache));

	TEST(r==KErrNone);

	CleanupFileFromCDriveL(KUidLargeRepository);

	CleanupFileFromCDriveL(KUidLargeCreRepository);

   	CRepository* rep; 

   	TUint32 startFastCounter;

   	TUint64 fastCountertimeToOpenLargeIniRep;

   	TUint64 fastCountertimeToOpenLargeCreRep;

   	TUint64 fastCountertimeToOpenXLargeInis;

   	TUint64 fastCountertimeToOpenXLargeCres;

    //=========================================================================================

   	//Single .ini - opening

    startFastCounter = User::FastCounter();

	User::LeaveIfNull(rep = CRepository::NewLC(KUidLargeRepository));

	fastCountertimeToOpenLargeIniRep = FastCountToMicrosecondsInInt(User::FastCounter() - startFastCounter);

	Logger().WriteFormat(_L("Time to open text based rep from ROM = %lu microseconds\n\n"), fastCountertimeToOpenLargeIniRep);

	CleanupStack::PopAndDestroy(rep);

    //=========================================================================================

	//KNumOfAttempts .ini

	startFastCounter = User::FastCounter();	

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

	    {

	    User::LeaveIfNull(rep = CRepository::NewLC(KUidLargeRepository));

	    CleanupStack::PopAndDestroy(rep);

	    }

	fastCountertimeToOpenXLargeInis = FastCountToMicrosecondsInInt(User::FastCounter() - startFastCounter);

	//=========================================================================================

	//single .cre

	startFastCounter = User::FastCounter();	

	User::LeaveIfNull(rep = CRepository::NewLC(KUidLargeCreRepository));

	fastCountertimeToOpenLargeCreRep = FastCountToMicrosecondsInInt(User::FastCounter() - startFastCounter);

	Logger().WriteFormat(_L("Time to open binary rep from ROM = %lu microseconds\n\n"), fastCountertimeToOpenLargeCreRep);

	CleanupStack::PopAndDestroy(rep);

	//=========================================================================================

	//KNumOfAttempts .cre

	startFastCounter = User::FastCounter();	

	for (TInt j=0; j<KNumOfAttempts; j++)

	    {	    

  	    User::LeaveIfNull(rep = CRepository::NewLC(KUidLargeCreRepository));

  	    CleanupStack::PopAndDestroy(rep);

	    }

	fastCountertimeToOpenXLargeCres = FastCountToMicrosecondsInInt(User::FastCounter() - startFastCounter);

    //=========================================================================================	    

	//average 

	TInt64 averageFastCounterTimeToOpenIni = fastCountertimeToOpenXLargeInis / KNumOfAttempts;

	Logger().WriteFormat(_L("Average time to open text based rep from ROM = %lu  microseconds\n\n"), averageFastCounterTimeToOpenIni);

	TInt64 averageFastCounterTimeToOpenCre = fastCountertimeToOpenXLargeCres / KNumOfAttempts;

	Logger().WriteFormat(_L("Average time to open binary rep from ROM = %lu  microseconds\n\n"), averageFastCounterTimeToOpenCre);

  	//=========================================================================================

    //prove that opening .ini is slower than opening .cre files 

    // (even though the difference is now much less after the performance 

    // improvements of PREQ 1192, the test is now much more precise by using fastcounter)

#if !defined(__WINS__) && !defined(__WINSCW__)

    TEST(fastCountertimeToOpenLargeIniRep > fastCountertimeToOpenLargeCreRep);

    TEST(fastCountertimeToOpenXLargeInis > fastCountertimeToOpenXLargeCres);

    TEST(averageFastCounterTimeToOpenIni > averageFastCounterTimeToOpenCre);

#endif		

    //==========================================================================================

    //benchmarks - open

	#if !defined(__WINS__) && !defined(__WINSCW__)

	    #ifdef _DEBUG

      	  	const TInt64 KOpenCreTime  = 150000; //armv5 debug

	    #else

      	   const TInt64 KOpenCreTime  = 75000;  //armv5 urel

      	#endif

	TEST(averageFastCounterTimeToOpenCre < KOpenCreTime);      	

    #endif//!defined(__WINS__) && !defined(__WINSCW__)

    //========================================================================

	CleanupFileFromCDriveL(KUidLargeRepository);

	CleanupFileFromCDriveL(KUidLargeCreRepository);

	// Enable cache

	r = SetGetParameters(TIpcArgs(EEnableCache, KDefaultEvictionTimeout, KDefaultCacheSize));

	TEST(r==KErrNone);

	SetTestStepResult(EPass);

	return TestStepResult();

#endif

	}