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

#include <centralrepository.h>

#include <e32test.h>

#include <f32file.h>

#include "../cenrepsrv/srvreqs.h"

#include "../common/inc/srvdefs.h"

#include "../cenrepsrv/srvparams.h"

using namespace NCentralRepositoryConstants;

RTest TheTest(_L("Central Repository Tests"));

TBool OomTesting;

const TUid KUidTestRepository1 = { 0x00000001 };

const TUid KUidCreTestRepository1 = { 0x22222221 };

const TUid KUidTestRepository2 = { 0x00000002 };

const TUid KUidCorruptRepository = { 0x00000003 };

const TUid KUidResetTestRepository = { 0x00000004 };

const TUid KUidDriveCRepository = { 0x00000010 };

const TUid KUidDriveCOnlyRepository = { 0x00000013 };

//

// Test repository 1

//

const TUint32 KNonExisitentSetting = 0;

const TInt KNumSettings = 9;

const TUint32 KInt1 = 1;

const TInt KInt1_InitialValue = 1;

const TInt KInt1_UpdatedValue = 73;

const TUint32 KInt3 = 257;

const TUint32 KNewInt = 1000;

const TUint32 KReal1 = 2;

const TReal KReal1_InitialValue = 2.732;

const TReal KReal1_UpdatedValue = 72.8;

const TUint32 KReal2 = 8;

const TReal KReal2_InitialValue = 1.5;

const TUint32 KReal3 = 17;

const TUint32 KNewReal = 2000;

const TUint32 KString1 = 5;

_LIT(KString1_InitialValue, "test\\\"string\"");

_LIT(KString1_UpdatedValue, "another one");

const TUint32 KString2 = 12;

_LIT8(KString2_8BitValue, "string");

const TUint32 KString12 = 12;

const TUint32 KNewString8 = 3000;

const TUint32 KNewString16 = 4000;

const TUint32 KNewSetting1 = 0x2001;

const TUint32 KNewSetting2 = 0x2002;

const TUint32 KNewSetting3 = 0x2003;

const TUint32 KNewSetting4 = 0x2004;

const TUint32 KNewSetting5 = 0x2005;

const TUint32 KNewSetting6 = 0x2006;

const TUint32 KNewSetting7 = 0x2007;

const TUint32 KNewSetting8 = 0x2008;

const TInt32 KNewSetting1Value = 4567;

const TReal KNewSetting2Value = 45.67;

_LIT(KNewSetting3Value, "a unicode str");

_LIT8(KNewSetting4Value, "an ascii str");

const TInt32 KNewSetting5Value = 2389;

const TReal KNewSetting6Value = 23.89;

_LIT(KNewSetting7Value, "another unicode str");

_LIT8(KNewSetting8Value, "another ascii str");

//

// Test repository 2

//

const TInt KIntB1 = 807;

const TInt KIntB1_InitialValue = 100;

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

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

//Test macroses and functions

LOCAL_C void CheckL(TInt aValue, TInt aLine)

	{

	if(!aValue)

		{

		CleanupCDriveL();

		TheTest(EFalse, aLine);

		}

	}

LOCAL_C void CheckL(TInt aValue, TInt aExpected, TInt aLine)

	{

	if(aValue != aExpected)

		{

		CleanupCDriveL();

		RDebug::Print(_L("*** Expected error: %d, got: %d\r\n"), aExpected, aValue);

		TheTest(EFalse, aLine);

		}

	}

#define TEST(arg) ::CheckL((arg), __LINE__)

#define TEST2(aValue, aExpected) ::CheckL(aValue, aExpected, __LINE__)

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

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

LOCAL_C void KillCentRepServerL()

	{

	_LIT(KCentralRepositoryServerName, "Centralrepositorysrv");

	_LIT(KProcessKillProcess, "t_processkillprocess.exe");

	TRequestStatus stat;    

	RProcess p;

	User::LeaveIfError(p.Create(KProcessKillProcess, KCentralRepositoryServerName));

	// Asynchronous logon: completes when process terminates with process 

	// exit code

	p.Logon(stat);

	p.Resume();

	User::WaitForRequest(stat);

	TExitType exitType = p.ExitType();

	TInt exitReason = p.ExitReason();

	_LIT(KKillServerFailed, "Killing Central Repository Server Failed");

	__ASSERT_ALWAYS(exitType == EExitKill, User::Panic(KKillServerFailed, exitReason));

	p.Close();

	User::LeaveIfError(exitReason);

	}

//This function resets the KUidTestRepository1 repository

//to its intial state to remove any changes made to the repository during

//previous tests

LOCAL_C void ResetTestRepositoryL()

	{

	CRepository* repository;

	User::LeaveIfNull(repository = CRepository::NewLC(KUidTestRepository1));

	TInt r = repository->Reset();

	TEST2(r, KErrNone);

	CleanupStack::PopAndDestroy(repository);

	}

//This function restores the state of the files required for this test

//Existing files are deleted and then the required files are copied

//back from the Z drive to the c drive

LOCAL_C void RestoreTestFilesL()

	{

	//Delete all files from C:\\private\\10202BE9\\persists\\ dir

	//and C:\\private\\10202BE9\\ dir

	CleanupCDriveL();

	RFs fs;

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

	CleanupClosePushL(fs);

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

	CleanupStack::PushL(fm);

//	_LIT(KPersistTargetPath, "c:\\private\\10202BE9\\persists\\*.txt");

	_LIT(KPersistTargetPath, "z:\\private\\10202BE9\\*.txt");

	_LIT(KPersistSourcePath, "Z:\\private\\10202BE9\\*.txc");

	_LIT(KInstallTargetPath, "C:\\private\\10202BE9\\*.txt");

	_LIT(KInstallSourcePath, "Z:\\private\\10202BE9\\*.txi");

	//copy test files from Z: to C:

	CopyTestFilesL(*fm,KPersistSourcePath, KPersistTargetPath);

	CopyTestFilesL(*fm,KInstallSourcePath, KInstallTargetPath);

	CleanupStack::PopAndDestroy(2);

	}

/**

@SYMTestCaseID			SYSLIB-CENTRALREPOSITORY-CT-1297

@SYMTestCaseDesc		Tests for creation and opening a central repository

@SYMTestPriority		High

@SYMTestActions			Tests for CRepository::NewLC(),CRepository::Get() functions

@SYMTestExpectedResults Test must not fail

@SYMREQ					REQ0000

*/

LOCAL_C void OpenRepositoryL()

	{

	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-CENTRALREPOSITORY-CT-1297 "));

	CRepository* repositoryA;

	CRepository* repositoryB;

	TInt r;

	// When an attempt is made to open a central repository in this test the result will

	// be that a new session (+ subsession) will be created with the server. For subsequent

	// central repository openings subsessions are then created under the same server.

	// Note that by placing the CRepository creation calls in the following order we

	// are exercising among other things the following scenarios:

	// 1. Session is opened and first subsession is created. Error occurs, whole session

	// is pulled down.

	// 2. Session is opened and first subsession is successfully created. 2nd subsession

	// is opened. Error occurs with 2nd subsession. 2nd subsession is pulled down. Session

	// and first sub-sesssion remain up. (DEF105089)

	TRAP(r, CRepository::NewL(TUid::Null()));

	if(OomTesting && r==KErrNoMemory)

		User::Leave(KErrNoMemory);

	TEST2(r, KErrNotFound);

	repositoryB = CRepository::NewLC(KUidTestRepository2);

	TRAP(r, CRepository::NewL(KUidCorruptRepository));

	if(OomTesting && r==KErrNoMemory)

		User::Leave(KErrNoMemory);

	TEST2(r, KErrCorrupt);

 	repositoryA = CRepository::NewLC(KUidTestRepository1);

	TInt a;

	r = repositoryA->Get(KInt1, a);

	TEST2(r, KErrNone);

	TEST(a==KInt1_InitialValue);

	r = repositoryB->Get(KIntB1, a);

	TEST2(r, KErrNone);

	TEST(a==KIntB1_InitialValue);

	CleanupStack::PopAndDestroy(repositoryA);

	r = repositoryB->Get(KIntB1, a);

	TEST2(r, KErrNone);

	TEST(a==KIntB1_InitialValue);

	CleanupStack::PopAndDestroy(repositoryB);

	}

/**

@SYMTestCaseID			SYSLIB-CENTRALREPOSITORY-CT-1298

@SYMTestCaseDesc		Tests for CRepository's Integer,Real,String's Get and Set functions

@SYMTestPriority		High

@SYMTestActions			Tests for CRepository::Get(),CRepository::Set() functions

@SYMTestExpectedResults Test must not fail

@SYMREQ					REQ0000

*/

LOCAL_C void GetSetL(const TUid& aUid)

	{

	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-CENTRALREPOSITORY-CT-1298 "));

	CRepository* repository;

	User::LeaveIfNull(repository = CRepository::NewLC(aUid));

	_LIT8(KString12_InitialValue, "string");

	TPtrC8 p8(KString12_InitialValue);

	_LIT(KString11_InitialValue, "string");

	TPtrC p16(KString11_InitialValue);

	TBuf8<20> str8;

	TBuf<20> str;

	TInt i = 0;

	//

	// Integer get/set

	//

	TInt r = repository->Get(KNonExisitentSetting, i);

	TEST2(r, KErrNotFound);

	TEST(i==0);

	r = repository->Get(KReal1, i);

	TEST2(r, KErrArgument);

	TEST(i==0);

	r = repository->Get(KInt1, i);

	TEST2(r, KErrNone);

	TEST(i==KInt1_InitialValue);

	r = repository->Get(KNonExisitentSetting, i);

	TEST2(r, KErrNotFound);

	r = repository->Set(KNonExisitentSetting, 10);

	TEST2(r, KErrNone);

	//close and reopen rep to check set is persisted

	CleanupStack::PopAndDestroy(repository);

	User::LeaveIfNull(repository = CRepository::NewLC(aUid));

	r = repository->Get(KNonExisitentSetting, i);

	TEST2(r, KErrNone);

	TEST(i==10);

	r = repository->Delete(KNonExisitentSetting);

	TEST2(r, KErrNone);

	r = repository->Set(KReal1, 0);

	TEST2(r, KErrArgument);

	r = repository->Set(KInt1, KInt1_UpdatedValue);

	TEST2(r, KErrNone);

	//close and reopen rep to check set is persisted

	CleanupStack::PopAndDestroy(repository);

	User::LeaveIfNull(repository = CRepository::NewLC(aUid));

	r = repository->Get(KInt1, i);

	TEST2(r, KErrNone);

	TEST(i==KInt1_UpdatedValue);

	r = repository->Get(KInt1,str8);

	TEST2(r, KErrArgument);

	//checks if KInt was modified

	r = repository->Get(KInt1, i);

	TEST2(r, KErrNone);

	TEST(i==KInt1_UpdatedValue);

	r = repository->Set(KInt1, KString12_InitialValue);

	TEST2(r, KErrArgument);

	r = repository->Get(KInt1, i);

	TEST2(r, KErrNone);

	TEST(i==KInt1_UpdatedValue);

	r = repository->Get(KInt1,str);

	TEST2(r, KErrArgument);

	//checks if KInt was modified

	r = repository->Get(KInt1, i);

	TEST2(r, KErrNone);

	TEST(i==KInt1_UpdatedValue);

	r = repository->Set(KInt1, KString11_InitialValue);

	TEST2(r, KErrArgument);

	r = repository->Get(KInt1, i);

	TEST2(r, KErrNone);

	TEST(i==KInt1_UpdatedValue);

	//

	// Real get/set

	//

	TReal y = 0;

	r = repository->Get(KNonExisitentSetting, y);

	TEST2(r, KErrNotFound);

	TEST(y==0);

	r = repository->Get(KInt1, y);

	TEST2(r, KErrArgument);

	TEST(y==0);

	r = repository->Get(KReal1, y);

	TEST2(r, KErrNone);

	TEST(y==KReal1_InitialValue);

	r = repository->Get(KNonExisitentSetting, y);

	TEST2(r, KErrNotFound);

	r = repository->Set(KNonExisitentSetting, 0.0);

	TEST2(r, KErrNone);

	//close and reopen rep to check set is persisted

	CleanupStack::PopAndDestroy(repository);

	User::LeaveIfNull(repository = CRepository::NewLC(aUid));

	r = repository->Get(KNonExisitentSetting, y);

	TEST2(r, KErrNone);

	TEST(y == 0.0);

	r = repository->Delete(KNonExisitentSetting);

	TEST2(r, KErrNone);

	r = repository->Set(KInt1, 0.0);

	TEST2(r, KErrArgument);

	r = repository->Set(KReal1, KReal1_UpdatedValue);

	TEST2(r, KErrNone);

	//close and reopen rep to check set is persisted

	CleanupStack::PopAndDestroy(repository);

	User::LeaveIfNull(repository = CRepository::NewLC(aUid));

	r = repository->Get(KReal1, y);

	TEST2(r, KErrNone);

	TEST(y==KReal1_UpdatedValue);

	r = repository->Get(KReal1,str8);

	TEST2(r, KErrArgument);

	//checks if KInt was modified

	r = repository->Get(KReal1, y);

	TEST2(r, KErrNone);

	TEST(y==KReal1_UpdatedValue);

	r = repository->Get(KReal1,str);

	TEST2(r, KErrArgument);

	//checks if KInt was modified

	r = repository->Get(KReal1, y);

	TEST2(r, KErrNone);

	TEST(y==KReal1_UpdatedValue);

	r = repository->Set(KReal1, KString12_InitialValue);

	TEST2(r, KErrArgument);

	r = repository->Get(KReal1, y);

	TEST2(r, KErrNone);

	TEST(y==KReal1_UpdatedValue);

	r = repository->Set(KReal1, KString11_InitialValue);

	TEST2(r, KErrArgument);

	r = repository->Get(KReal1, y);

	TEST2(r, KErrNone);

	TEST(y==KReal1_UpdatedValue);

	//

	// String get/set

	//

	r = repository->Get(KNonExisitentSetting, str);

	TEST2(r, KErrNotFound);

	TEST(str.Length()==0);

	r = repository->Get(KInt1, str);

	TEST2(r, KErrArgument);

	TEST(str.Length()==0);

	r = repository->Get(KString1, str);

	TEST2(r, KErrNone);

	TEST(str==KString1_InitialValue);

	TBuf<10> tooShort;

	r = repository->Get(KString1, tooShort);

	TEST2(r, KErrOverflow);

	TEST(tooShort.Length()==10);

	r = repository->Get(KNonExisitentSetting, str);

	TEST2(r, KErrNotFound);

	r = repository->Set(KNonExisitentSetting, KString1_UpdatedValue);

	TEST2(r, KErrNone);

	//close and reopen rep to check set is persisted

	CleanupStack::PopAndDestroy(repository);

	User::LeaveIfNull(repository = CRepository::NewLC(aUid));

	r = repository->Get(KNonExisitentSetting, str);

	TEST2(r, KErrNone);

	TEST(str==KString1_UpdatedValue);

	r = repository->Delete(KNonExisitentSetting);

	TEST2(r, KErrNone);

	r = repository->Set(KInt1, str);

	TEST2(r, KErrArgument);

	r = repository->Set(KString1, KString1_UpdatedValue);

	TEST2(r, KErrNone);

	//close and reopen rep to check set is persisted

	CleanupStack::PopAndDestroy(repository);

	User::LeaveIfNull(repository = CRepository::NewLC(aUid));

	r = repository->Get(KString1, str);

	TEST2(r, KErrNone);

	TEST(str==KString1_UpdatedValue);

	//testing the new feature: creating an 8 bit string from ini file.

	r = repository->Get(KString12, str8);

	TEST2(r, KErrNone);

	TEST(str8==KString12_InitialValue);

	//get 8-bit string with int

	r = repository->Get(KString12, i);

	TEST2(r, KErrArgument);

	r = repository->Get(KString12, str8);

	TEST2(r, KErrNone);

	TEST(str8==KString12_InitialValue);

	//get 8-bit string with real

	r = repository->Get(KString12, y);

	TEST2(r, KErrArgument);

	r = repository->Get(KString12, str8);

	TEST2(r, KErrNone);

	TEST(str8==KString12_InitialValue);

	//set 8-bit string with int

	r = repository->Set(KString12, i);

	TEST2(r, KErrArgument);

	r = repository->Get(KString12, str8);

	TEST2(r, KErrNone);

	TEST(str8==KString12_InitialValue);

	//set 8-bit string with real

	r = repository->Set(KString12, y);

	TEST2(r, KErrArgument);

	r = repository->Get(KString12, str8);

	TEST2(r, KErrNone);

	TEST(str8==KString12_InitialValue);

	//get 16-bit string with int

	r = repository->Get(KString1,i);

	TEST2(r, KErrArgument);

	//checks if a string was modified

	r = repository->Get(KString1, str);

	TEST2(r, KErrNone);

	TEST(str==KString1_UpdatedValue);

	//get 16-bit string with real

	r = repository->Get(KString1,y);

	TEST2(r, KErrArgument);

	//checks if a string was modified

	r = repository->Get(KString1, str);

	TEST2(r, KErrNone);

	TEST(str==KString1_UpdatedValue);