diff -r 000000000000 -r 08ec8eefde2f persistentstorage/centralrepository/test/t_cenrep.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/persistentstorage/centralrepository/test/t_cenrep.cpp Fri Jan 22 11:06:30 2010 +0200 @@ -0,0 +1,2456 @@ +// Copyright (c) 2004-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 "t_cenrep_helper.h" +#include +#include +#include +#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); + + //set 16-bit string with int + r = repository->Set(KString1,i); + TEST2(r, KErrArgument); + //checks if a string was modified + r = repository->Get(KString1, str); + TEST2(r, KErrNone); + TEST(str==KString1_UpdatedValue); + + //set 16-bit string with real + r = repository->Set(KString1,y); + TEST2(r, KErrArgument); + //checks if a string was modified + r = repository->Get(KString1, str); + TEST2(r, KErrNone); + TEST(str==KString1_UpdatedValue); + + const TInt KStringLengthTooBig = KMaxUnicodeStringLength + 1; + TBuf tooBig; + tooBig.SetLength(KStringLengthTooBig); + r = repository->Set(KString1, tooBig); + TEST2(r, KErrArgument); + + //- Test null descriptors + r = repository->Set(KString1, KNullDesC); + TEST2(r, KErrNone); + + CleanupStack::PopAndDestroy(repository); + User::LeaveIfNull(repository = CRepository::NewLC(aUid)); + + r = repository->Get(KString1, str); + TEST2(r, KErrNone); + TEST(str==KNullDesC); + + 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); + //- + + // Check that the SetGetParameters interface returns KErrNotSupported in the default macro configuration +#if !defined(__CENTREP_SERVER_PERFTEST__) && !defined(__CENTREP_SERVER_MEMTEST__) && !defined(__CENTREP_SERVER_CACHETEST__) + TIpcArgs args; + r = SetGetParameters(args); + TEST2(r, KErrNotSupported); +#endif + + CleanupStack::PopAndDestroy(repository); + } + +/** +@SYMTestCaseID SYSLIB-CENTRALREPOSITORY-CT-1299 +@SYMTestCaseDesc Tests for CRepository class's find operations +@SYMTestPriority High +@SYMTestActions Tests for CRepository::FindL(),CRepository::FindEqL(),CRepository::FindNeqL() functions +@SYMTestExpectedResults Test must not fail +@SYMREQ REQ0000 +*/ +LOCAL_C void FindL() + { + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-CENTRALREPOSITORY-CT-1299 ")); + CRepository* repository; + User::LeaveIfNull(repository = CRepository::NewLC(KUidTestRepository1)); + + RArray foundIds; + + TInt r = KErrNone; + TInt leaveCode = KErrNone; + TRAP(leaveCode, r = repository->FindL(0, 0, foundIds)); + if (leaveCode != KErrNone) + r = leaveCode ; + + if(OomTesting && r==KErrNoMemory) + { + foundIds.Close(); + User::Leave(KErrNoMemory); + } + + TEST2(r, KErrNone); + TEST(foundIds.Count()==KNumSettings); + foundIds.Reset(); + + /***************************************************************************************/ + //Tests for FindL + /***************************************************************************************/ + TRAP(leaveCode, r = repository->FindL(23, 0, foundIds)); // 23 - just a random number, value is not important + if (leaveCode != KErrNone) + r = leaveCode ; + if(OomTesting && r==KErrNoMemory) + { + foundIds.Close(); + User::Leave(KErrNoMemory); + } + TEST2(r, KErrNone); + TEST(foundIds.Count()==KNumSettings); + foundIds.Reset(); + + + TRAP(leaveCode, r=repository->FindL(0, 2, foundIds)); + if (leaveCode != KErrNone) + r = leaveCode ; + if(OomTesting && r==KErrNoMemory) + { + foundIds.Close(); + User::Leave(KErrNoMemory); + } + TEST2(r, KErrNone); + TEST(foundIds.Count()==6); + foundIds.Reset(); + + + TRAP(leaveCode, r=repository->FindL(4, 6, foundIds)); + if (leaveCode != KErrNone) + r = leaveCode ; + if(OomTesting && r==KErrNoMemory) + { + foundIds.Close(); + User::Leave(KErrNoMemory); + } + TEST2(r, KErrNone); + TEST(foundIds.Count()==2); + foundIds.Reset(); + + + + TRAP(leaveCode, r= repository->FindL(15, 15, foundIds)); + if (leaveCode != KErrNone) + r = leaveCode ; + if(OomTesting && r==KErrNoMemory) + { + foundIds.Close(); + User::Leave(KErrNoMemory); + } + TEST2(r, KErrNotFound); + TEST(foundIds.Count()==0); + + + /***************************************************************************************/ + //Tests for FindEqL for Int + /***************************************************************************************/ + TRAP(leaveCode, r= repository->FindEqL(0, 0, KInt1_UpdatedValue, foundIds)); + if (leaveCode != KErrNone) + r = leaveCode ; + if(OomTesting && r==KErrNoMemory) + { + foundIds.Close(); + User::Leave(KErrNoMemory); + } + TEST2(r, KErrNone); + TEST(foundIds.Count()==1); + TEST(foundIds[0]==KInt1); + foundIds.Reset(); + + + TRAP(leaveCode, r= repository->FindEqL(0, 0, 0, foundIds)); + if (leaveCode != KErrNone) + r = leaveCode ; + if(OomTesting && r==KErrNoMemory) + { + foundIds.Close(); + User::Leave(KErrNoMemory); + } + TEST2(r, KErrNotFound); + TEST(foundIds.Count()==0); + + + /***************************************************************************************/ + //Tests for FindEqL for Real + /***************************************************************************************/ + TRAP(leaveCode, r= repository->FindEqL(0, 0, KReal2_InitialValue, foundIds)); + if (leaveCode != KErrNone) + r = leaveCode ; + if(OomTesting && r==KErrNoMemory) + { + foundIds.Close(); + User::Leave(KErrNoMemory); + } + TEST2(r, KErrNone); + TEST(foundIds.Count()==2); + TEST(foundIds[0]==KReal2); + TEST(foundIds[1]==KReal3); + foundIds.Reset(); + + + TRAP(leaveCode, r= repository->FindEqL(0, 0, 7.7, foundIds)); + if (leaveCode != KErrNone) + r = leaveCode ; + if(OomTesting && r==KErrNoMemory) + { + foundIds.Close(); + User::Leave(KErrNoMemory); + } + TEST2(r, KErrNotFound); + TEST(foundIds.Count()==0); + + + /***************************************************************************************/ + //Tests for FindEqL for String + /***************************************************************************************/ + TRAP(leaveCode, r= repository->FindEqL(0, 0, KString1_UpdatedValue, foundIds)); + if (leaveCode != KErrNone) + r = leaveCode ; + if(OomTesting && r==KErrNoMemory) + { + foundIds.Close(); + User::Leave(KErrNoMemory); + } + TEST2(r, KErrNone); + TEST(foundIds.Count()==1); + TEST(foundIds[0]==KString1); + foundIds.Reset(); + + _LIT(KFoo, "foo"); + + TRAP(leaveCode, r= repository->FindEqL(0, 0, KFoo, foundIds)); + if (leaveCode != KErrNone) + r = leaveCode ; + if(OomTesting && r==KErrNoMemory) + { + foundIds.Close(); + User::Leave(KErrNoMemory); + } + TEST2(r, KErrNotFound); + TEST(foundIds.Count()==0); + + /***************************************************************************************/ + //Tests for FindEqL for String8 + /***************************************************************************************/ + TRAP(leaveCode, r= repository->FindEqL(0, 0, KString2_8BitValue, foundIds)); + if (leaveCode != KErrNone) + r = leaveCode ; + if(OomTesting && r==KErrNoMemory) + { + foundIds.Close(); + User::Leave(KErrNoMemory); + } + TEST2(r, KErrNone); + TEST(foundIds.Count()==1); + TEST(foundIds[0]==KString2); + foundIds.Reset(); + + _LIT8(KFoo8, "foo"); + + TRAP(leaveCode, r= repository->FindEqL(0, 0, KFoo8, foundIds)); + if (leaveCode != KErrNone) + r = leaveCode ; + if(OomTesting && r==KErrNoMemory) + { + foundIds.Close(); + User::Leave(KErrNoMemory); + } + TEST2(r, KErrNotFound); + TEST(foundIds.Count()==0); + + /***************************************************************************************/ + //Tests for FindNeqL for Int + /***************************************************************************************/ + TRAP(leaveCode, r= repository->FindNeqL(0, 0, KInt1_UpdatedValue, foundIds)); + if (leaveCode != KErrNone) + r = leaveCode ; + if(OomTesting && r==KErrNoMemory) + { + foundIds.Close(); + User::Leave(KErrNoMemory); + } + TEST2(r, KErrNone); + TEST(foundIds.Count()==8); + TEST2(foundIds.Find(KInt1), KErrNotFound); + foundIds.Reset(); + + + TRAP(leaveCode, r= repository->FindNeqL(25, 25, KInt1_UpdatedValue, foundIds)); + if (leaveCode != KErrNone) + r = leaveCode ; + if(OomTesting && r==KErrNoMemory) + { + foundIds.Close(); + User::Leave(KErrNoMemory); + } + TEST2(r, KErrNotFound); + TEST(foundIds.Count()==0); + + + /***************************************************************************************/ + //Tests for FindNeqL for Real + /***************************************************************************************/ + TRAP(leaveCode, r= repository->FindNeqL(0, 0, KReal1_UpdatedValue, foundIds)); + if (leaveCode != KErrNone) + r = leaveCode ; + if(OomTesting && r==KErrNoMemory) + { + foundIds.Close(); + User::Leave(KErrNoMemory); + } + TEST2(r, KErrNone); + TEST(foundIds.Count()==8); + TEST2(foundIds.Find(KReal1), KErrNotFound); + foundIds.Reset(); + + + TRAP(leaveCode,r= repository->FindNeqL(25, 25, KReal1_UpdatedValue, foundIds)); + if (leaveCode != KErrNone) + r = leaveCode ; + if(OomTesting && r==KErrNoMemory) + { + foundIds.Close(); + User::Leave(KErrNoMemory); + } + TEST2(r, KErrNotFound); + TEST(foundIds.Count()==0); + + + /***************************************************************************************/ + //Tests for FindNeqL for String + /***************************************************************************************/ + TRAP(leaveCode, r= repository->FindNeqL(0, 0, KString1_UpdatedValue, foundIds)); + if (leaveCode != KErrNone) + r = leaveCode ; + if(OomTesting && r==KErrNoMemory) + { + foundIds.Close(); + User::Leave(KErrNoMemory); + } + TEST2(r, KErrNone); + TEST(foundIds.Count()==8); + TEST2(foundIds.Find(KString1), KErrNotFound); + foundIds.Reset(); + + + TRAP(leaveCode, r= repository->FindNeqL(25, 25, KString1_UpdatedValue, foundIds)); + if (leaveCode != KErrNone) + r = leaveCode ; + if(OomTesting && r==KErrNoMemory) + { + foundIds.Close(); + User::Leave(KErrNoMemory); + } + TEST2(r, KErrNotFound); + TEST(foundIds.Count()==0); + + /***************************************************************************************/ + //Tests for FindNeqL for String8 + /***************************************************************************************/ + TRAP(leaveCode, r= repository->FindNeqL(0, 0, KString2_8BitValue, foundIds)); + if (leaveCode != KErrNone) + r = leaveCode ; + if(OomTesting && r==KErrNoMemory) + { + foundIds.Close(); + User::Leave(KErrNoMemory); + } + TEST2(r, KErrNone); + TEST(foundIds.Count()==8); + TEST2(foundIds.Find(KString2), KErrNotFound); + foundIds.Reset(); + + + TRAP(leaveCode, r= repository->FindNeqL(25, 25, KString2_8BitValue, foundIds)); + if (leaveCode != KErrNone) + r = leaveCode ; + if(OomTesting && r==KErrNoMemory) + { + foundIds.Close(); + User::Leave(KErrNoMemory); + } + TEST2(r, KErrNotFound); + TEST(foundIds.Count()==0); + + CleanupStack::PopAndDestroy(repository); + } + +/** +@SYMTestCaseID SYSLIB-CENTRALREPOSITORY-CT-1300 +@SYMTestCaseDesc CRepository class functionality test +@SYMTestPriority High +@SYMTestActions Test for CRepository::NotifyRequest() functions +@SYMTestExpectedResults Test must not fail +@SYMREQ REQ0000 +*/ +LOCAL_C void NotifyL() + { + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-CENTRALREPOSITORY-CT-1300 ")); + CRepository* repository; + User::LeaveIfNull(repository = CRepository::NewLC(KUidTestRepository1)); + + TInt r = KErrNone; + TInt intval; + TRequestStatus intStatus; + TRequestStatus realStatus; + TRequestStatus stringStatus; + RThread thisThread; + + // + // Notification on non-existent setting + // + r = repository->NotifyRequest(KNonExisitentSetting, intStatus); + TEST2(r, KErrNotFound); + + // + // Basic notification + // + r = repository->NotifyRequest(KInt1, intStatus); + TEST2(r, KErrNone); + + r = repository->NotifyRequest(KReal1, realStatus); + TEST2(r, KErrNone); + + r = repository->NotifyRequest(KString1, stringStatus); + TEST2(r, KErrNone); + + + // Setting to the same value should not cause a notification + r = repository->Get(KInt1, intval); + TEST2(r, KErrNone); + r = repository->Set(KInt1, intval); + TEST2(r, KErrNone); + TEST(intStatus==KRequestPending); + TEST(realStatus==KRequestPending); + TEST(stringStatus==KRequestPending); + TEST(thisThread.RequestCount()==0); + + // First change to setting should cause notification + r = repository->Set(KInt1, 0); + TEST2(r, KErrNone); + User::WaitForAnyRequest(); + TEST(intStatus==KInt1); + TEST(realStatus==KRequestPending); + TEST(stringStatus==KRequestPending); + + // Second change to setting should not cause notification + intStatus = 7777; + r = repository->Set(KInt1, 0); + TEST2(r, KErrNone); + TEST(intStatus==7777); + TEST(realStatus==KRequestPending); + TEST(stringStatus==KRequestPending); + TEST(thisThread.RequestCount()==0); + + + // Setting to the same value should not cause a notification + TReal realval; + r = repository->Get(KReal1, realval); + TEST2(r, KErrNone); + r = repository->Set(KReal1, realval); + TEST2(r, KErrNone); + TEST(intStatus==7777); + TEST(realStatus==KRequestPending); + TEST(stringStatus==KRequestPending); + TEST(thisThread.RequestCount()==0); + + r = repository->Set(KReal1, 0.0); + TEST2(r, KErrNone); + User::WaitForAnyRequest(); + TEST(intStatus==7777); + TEST(realStatus==KReal1); + TEST(stringStatus==KRequestPending); + + + // Setting to the same value should not cause a notification + realStatus = 8888; + TBuf<20> stringval; + r = repository->Get(KString1, stringval); + TEST2(r, KErrNone); + r = repository->Set(KString1, stringval); + TEST2(r, KErrNone); + TEST(intStatus==7777); + TEST(realStatus==8888); + TEST(stringStatus==KRequestPending); + TEST(thisThread.RequestCount()==0); + + _LIT(KStringValue2, "string2"); + r = repository->Set(KString1, KStringValue2); + TEST2(r, KErrNone); + User::WaitForAnyRequest(); + TEST(intStatus==7777); + TEST(realStatus==8888); + TEST(stringStatus==KString1); + + + // + // Cancelling single notifications + // + r = repository->NotifyRequest(KInt1, intStatus); + TEST2(r, KErrNone); + r = repository->NotifyCancel(KInt1); + TEST2(r, KErrNone); + User::WaitForAnyRequest(); + TEST(intStatus==KUnspecifiedKey); + + intStatus = 7777; + r = repository->NotifyRequest(KReal1, realStatus); + TEST2(r, KErrNone); + r = repository->Set(KInt1, 1); + TEST2(r, KErrNone); + r = repository->Set(KReal1, 1.1); + TEST2(r, KErrNone); + User::WaitForAnyRequest(); + TEST(intStatus==7777); + TEST(realStatus==KReal1); + TEST(thisThread.RequestCount()==0); + + + // + // Cancelling all notifications + // + realStatus = 8888; + r = repository->NotifyRequest(KInt1, intStatus); + TEST2(r, KErrNone); + r = repository->NotifyRequest(KReal1, realStatus); + TEST2(r, KErrNone); + + r = repository->NotifyCancelAll(); + TEST2(r, KErrNone); + User::WaitForAnyRequest(); + User::WaitForAnyRequest(); + TEST(intStatus==KUnspecifiedKey); + TEST(realStatus==KUnspecifiedKey); + + intStatus = 7777; + realStatus = 8888; + r = repository->Set(KInt1, 2); + TEST2(r, KErrNone); + r = repository->Set(KReal1, 2.2); + TEST2(r, KErrNone); + TEST(intStatus==7777); + TEST(realStatus==8888); + TEST(thisThread.RequestCount()==0); + + + // + // Group notifications + // + r = repository->NotifyRequest(0, ~(KInt1+KReal1), intStatus); + TEST2(r, KErrNone); + + r = repository->Set(KInt3, 3); + TEST2(r, KErrNone); + TEST(intStatus==KRequestPending); + TEST(thisThread.RequestCount()==0); + + r = repository->Set(KInt1, 3); + TEST2(r, KErrNone); + User::WaitForAnyRequest(); + TEST(intStatus==KInt1); + + r = repository->NotifyRequest(0, ~(KInt1+KReal1), intStatus); + TEST2(r, KErrNone); + + r = repository->Set(KReal1, 3.3); + TEST2(r, KErrNone); + User::WaitForAnyRequest(); + TEST(intStatus==KReal1); + + + // + // Cancelling group notifications + // + r = repository->NotifyRequest(0, ~(KInt1+KReal1), intStatus); + TEST2(r, KErrNone); + r = repository->NotifyCancel(0, ~(KInt1+KReal1)); + TEST2(r, KErrNone); + User::WaitForAnyRequest(); + TEST(intStatus==KUnspecifiedKey); + + r = repository->Set(KInt1, 3); + TEST2(r, KErrNone); + TEST(intStatus==KUnspecifiedKey); + TEST(thisThread.RequestCount()==0); + + r = repository->NotifyRequest(KInt1, intStatus); + TEST2(r, KErrNone); + r = repository->NotifyRequest(0, ~(KInt1+KReal1), realStatus); + TEST2(r, KErrNone); + r = repository->NotifyCancelAll(); + TEST2(r, KErrNone); + User::WaitForAnyRequest(); + User::WaitForAnyRequest(); + TEST(intStatus==KUnspecifiedKey); + TEST(realStatus==KUnspecifiedKey); + + r = repository->Set(KInt1, 4); + TEST2(r, KErrNone); + TEST(intStatus==KUnspecifiedKey); + TEST(realStatus==KUnspecifiedKey); + TEST(thisThread.RequestCount()==0); + + CleanupStack::PopAndDestroy(repository); + } + +/** +@SYMTestCaseID SYSLIB-CENTRALREPOSITORY-CT-3400 +@SYMTestCaseDesc CRepository class functionality test +@SYMTestPriority High +@SYMTestActions Negative tests exercising CRepository::NotifyCancel() functions + Tests check that central repository notifier works properly when + client cancels multiple, non-existent notifications, and also + multiple and non-existent group notificatins in a variety of combinations. +@SYMTestExpectedResults There are 2 main points that we need to check in this test: + 1) when we are cancelling multiple notifications server-side function should + always return KErrNone or KErrNotFound preventing client requests from waitng + indefinitely + 2) IPC handling function should convert any error returned from the server + to KErrNone so that the client-side function NotifyCancel always returns KErrNone + (for more nformation on this requirement see DEF061504) +@SYMDEF INC102413 +*/ +LOCAL_C void CancelNotificationsL() + { + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-CENTRALREPOSITORY-CT-3400 ")); + CRepository* repository; + User::LeaveIfNull(repository = CRepository::NewLC(KUidTestRepository1)); + + TInt r = KErrNone; + TRequestStatus intStatus; + TRequestStatus realStatus1; + TRequestStatus realStatus2; + TRequestStatus realStatus3; + RThread thisThread; + + // + // Cancelling non-existent notifications + // + r = repository->NotifyCancel(KInt1); + TEST2(r, KErrNone); + + // + // Cancelling multiple notifications + // This test step checks that NotifyCancel function returns correct + // value KErrNone regardless of the number of registered notifiers + // + r = repository->NotifyRequest(KReal1, realStatus1); + TEST2(r, KErrNone); + r = repository->NotifyRequest(KReal2, realStatus2); + TEST2(r, KErrNone); + r = repository->NotifyRequest(KReal3, realStatus3); + TEST2(r, KErrNone); + + r = repository->NotifyCancel(KReal3); + TEST2(r, KErrNone); + r = repository->NotifyCancel(KReal2); + TEST2(r, KErrNone); + r = repository->NotifyCancel(KReal1); + TEST2(r, KErrNone); + TEST2(thisThread.RequestCount(),3); + User::WaitForAnyRequest(); + TEST(realStatus3==KUnspecifiedKey); + User::WaitForAnyRequest(); + TEST(realStatus2==KUnspecifiedKey); + User::WaitForAnyRequest(); + TEST(realStatus1==KUnspecifiedKey); + TEST2(thisThread.RequestCount(),0); + + // check that all notificatioins were actually cancelled and we will not + // get a notification when we change the settings + realStatus1 = 7777; + realStatus2 = 8888; + realStatus3 = 9999; + r = repository->NotifyRequest(KInt1, intStatus); + TEST2(r, KErrNone); + r = repository->Set(KReal1, 1.0); + TEST2(r, KErrNone); + r = repository->Set(KReal2, 2.0); + TEST2(r, KErrNone); + r = repository->Set(KReal3, 3.0); + TEST2(r, KErrNone); + r = repository->Set(KInt1, 2); + TEST2(r, KErrNone); + User::WaitForAnyRequest(); + TEST(realStatus1==7777); + TEST(realStatus2==8888); + TEST(realStatus3==9999); + TEST(intStatus==KInt1); + TEST2(thisThread.RequestCount(),0); + + // + // Cancelling all notifications when no notifications exist + // + r = repository->NotifyCancelAll(); + TEST2(r, KErrNone); + + // + // Cancelling group notifications where some of the notifications have not been set up + // + //first make sure that all the settings exist + r = repository->Set(KReal1, 2.0); + r = repository->Set(KReal2, 3.0); + r = repository->Set(KReal3, 4.0); + //This mask notify request sets up notifies for a number of keys including KReal1 and KReal2 + r = repository->NotifyRequest(0, ~(KReal1+KReal2), realStatus1); + TEST2(r, KErrNone); + //This mask notify request cancels notifies for a number of keys including KReal1 and KReal3 + r = repository->NotifyCancel(0, ~(KReal1+KReal3)); + TEST2(r, KErrNone); + //check that notification request for the setting KReal1 has not been cancelled + r = repository->Set(KReal1, 1.0); + User::WaitForAnyRequest(); + TEST2(r, KErrNone); + TEST(realStatus1==KReal1); + + // + // Cancelling multiple group notifications + // + //set up notification requests for 2 different groups of settings and then cancel them + // one by one in the reverse order checking that we get an expected return value + //This mask notify request sets up notifies for a number of keys including KInt1 and KReal3 + r = repository->NotifyRequest(0, ~(KInt1+KReal3), realStatus1); + TEST2(r, KErrNone); + //This mask notify request sets up notifies for a number of keys including KReal1 and KReal2 + r = repository->NotifyRequest(0, ~(KReal1+KReal2), realStatus2); + TEST2(r, KErrNone); + + //This mask notify request cancels notifies for a number of keys including KReal1 and KReal2 + r = repository->NotifyCancel(0, ~(KReal1+KReal2)); + TEST2(r, KErrNone); + //This mask notify request cancels notifies for a number of keys including KInt1 and KReal3 + r = repository->NotifyCancel(0, ~(KInt1+KReal3)); + TEST2(r, KErrNone); + User::WaitForAnyRequest(); + User::WaitForAnyRequest(); + TEST(realStatus1==KUnspecifiedKey); + TEST(realStatus2==KUnspecifiedKey); + + // + // Cancelling non-existent group notifications + // + r = repository->NotifyCancel(0, ~(KInt1+KReal3)); + TEST2(r, KErrNone); + + //restore the repository value for the later tests to use + r = repository->Set(KInt1, 1); + TEST2(r, KErrNone); + + CleanupStack::PopAndDestroy(repository); + } + +/** +@SYMTestCaseID SYSLIB-CENTRALREPOSITORY-CT-1301 +@SYMTestCaseDesc Tests for creation and deletion of new settings for CRepository class +@SYMTestPriority High +@SYMTestActions Test for CRepository::Create(),CRepository::Delete() functions +@SYMTestExpectedResults Test must not fail +@SYMREQ REQ0000 +*/ +LOCAL_C void CreateDeleteL(const TUid& aUid) + { + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-CENTRALREPOSITORY-CT-1301 ")); + CRepository* repository; + User::LeaveIfNull(repository = CRepository::NewLC(aUid)); + + TInt x; + TReal y; + TBuf8<20> z8; + TBuf16<20> z16; + + /***************************************************************************************/ + //test int create + /***************************************************************************************/ + TInt r = repository->Get(KNewInt, x); + TEST2(r, KErrNotFound); + + const TInt KIntValue = 1234; + r = repository->Create(KNewInt, KIntValue); + TEST2(r, KErrNone); + + //close and reopen rep to check create is persisted + CleanupStack::PopAndDestroy(repository); + User::LeaveIfNull(repository = CRepository::NewLC(aUid)); + + r = repository->Get(KNewInt, x); + TEST2(r, KErrNone); + TEST(x==KIntValue); + + r = repository->Delete(KNewInt); + TEST2(r, KErrNone); + + r = repository->Get(KNewInt, x); + TEST2(r, KErrNotFound); + + // close and reopen rep to check delete is persisted + CleanupStack::PopAndDestroy(repository); + User::LeaveIfNull(repository = CRepository::NewLC(aUid)); + r = repository->Get(KNewInt, x); + TEST2(r, KErrNotFound); + + + // test int create - second run + r = repository->Create(KNewInt, KIntValue); + TEST2(r, KErrNone); + + //close and reopen rep to check create is persisted + CleanupStack::PopAndDestroy(repository); + User::LeaveIfNull(repository = CRepository::NewLC(aUid)); + + r = repository->Get(KNewInt, x); + TEST2(r, KErrNone); + TEST(x==KIntValue); + + r = repository->Delete(KNewInt); + TEST2(r, KErrNone); + + // close and reopen rep to check delete is persisted + CleanupStack::PopAndDestroy(repository); + User::LeaveIfNull(repository = CRepository::NewLC(aUid)); + + r = repository->Get(KNewInt, x); + TEST2(r, KErrNotFound); + + + /***************************************************************************************/ + //test real create + /***************************************************************************************/ + + r = repository->Get(KNewReal, y); + TEST2(r, KErrNotFound); + + const TReal KRealValue = 5678.0; + r = repository->Create(KNewReal, KRealValue); + TEST2(r, KErrNone); + + //close and reopen rep to check create is persisted + CleanupStack::PopAndDestroy(repository); + User::LeaveIfNull(repository = CRepository::NewLC(aUid)); + + r = repository->Get(KNewReal, y); + TEST2(r, KErrNone); + TEST(y==KRealValue); + + r = repository->Delete(KNewReal); + TEST2(r, KErrNone); + + // close and reopen rep to check delete is persisted + CleanupStack::PopAndDestroy(repository); + User::LeaveIfNull(repository = CRepository::NewLC(aUid)); + + r = repository->Get(KNewReal, y); + TEST2(r, KErrNotFound); + + //create real - second run + r = repository->Create(KNewReal, KRealValue); + TEST2(r, KErrNone); + + //close and reopen rep to check create is persisted + CleanupStack::PopAndDestroy(repository); + User::LeaveIfNull(repository = CRepository::NewLC(aUid)); + + r = repository->Get(KNewReal, y); + TEST2(r, KErrNone); + TEST(y==KRealValue); + + r = repository->Delete(KNewReal); + TEST2(r, KErrNone); + + // close and reopen rep to check delete is persisted + CleanupStack::PopAndDestroy(repository); + User::LeaveIfNull(repository = CRepository::NewLC(aUid)); + + r = repository->Get(KNewReal, x); + TEST2(r, KErrNotFound); + + /***************************************************************************************/ + //test string8 create + /***************************************************************************************/ + + r = repository->Get(KNewString8, z8); + TEST2(r, KErrNotFound); + + _LIT8(KString8Value, "ABCDEF"); + r = repository->Create(KNewString8, KString8Value); + TEST2(r, KErrNone); + + //close and reopen rep to check create is persisted + CleanupStack::PopAndDestroy(repository); + User::LeaveIfNull(repository = CRepository::NewLC(aUid)); + + r = repository->Get(KNewString8, z8); + TEST2(r, KErrNone); + TEST(z8==KString8Value); + + r = repository->Delete(KNewString8); + TEST2(r, KErrNone); + + // close and reopen rep to check delete is persisted + CleanupStack::PopAndDestroy(repository); + User::LeaveIfNull(repository = CRepository::NewLC(aUid)); + + r = repository->Get(KNewString8, z8); + TEST2(r, KErrNotFound); + + r = repository->Create(KNewString8, KString8Value); + TEST2(r, KErrNone); + + //close and reopen rep to check create is persisted + CleanupStack::PopAndDestroy(repository); + User::LeaveIfNull(repository = CRepository::NewLC(aUid)); + + r = repository->Get(KNewString8, z8); + TEST2(r, KErrNone); + TEST(z8==KString8Value); + + r = repository->Delete(KNewString8); + TEST2(r, KErrNone); + + // close and reopen rep to check delete is persisted + CleanupStack::PopAndDestroy(repository); + User::LeaveIfNull(repository = CRepository::NewLC(aUid)); + + //second run + r = repository->Get(KNewString8, x); + TEST2(r, KErrNotFound); + + /***************************************************************************************/ + //test string16 create + /***************************************************************************************/ + + r = repository->Get(KNewString16, z16); + TEST2(r, KErrNotFound); + + _LIT(KString16Value, "ghijklmn"); + r = repository->Create(KNewString16, KString16Value); + TEST2(r, KErrNone); + + //close and reopen rep to check create is persisted + CleanupStack::PopAndDestroy(repository); + User::LeaveIfNull(repository = CRepository::NewLC(aUid)); + + r = repository->Get(KNewString16, z16); + TEST2(r, KErrNone); + TEST(z16==KString16Value); + + r = repository->Delete(KNewString16); + TEST2(r, KErrNone); + + // close and reopen rep to check delete is persisted + CleanupStack::PopAndDestroy(repository); + User::LeaveIfNull(repository = CRepository::NewLC(aUid)); + + r = repository->Get(KNewString16, z16); + TEST2(r, KErrNotFound); + + r = repository->Create(KNewString16, KString16Value); + TEST2(r, KErrNone); + + //close and reopen rep to check create is persisted + CleanupStack::PopAndDestroy(repository); + User::LeaveIfNull(repository = CRepository::NewLC(aUid)); + + r = repository->Get(KNewString16, z16); + TEST2(r, KErrNone); + TEST(z16==KString16Value); + + r = repository->Delete(KNewString16); + TEST2(r, KErrNone); + + CleanupStack::PopAndDestroy(repository); + User::LeaveIfNull(repository = CRepository::NewLC(aUid)); + + r = repository->Get(KNewString16, x); + TEST2(r, KErrNotFound); + + CleanupStack::PopAndDestroy(repository); + + /***************************************************************************************/ + //test create all kinds and delete with mask + /***************************************************************************************/ + + User::LeaveIfNull(repository = CRepository::NewLC(aUid)); + + //first check that none of the settings exist in the repository + r = repository->Get(KNewSetting1, x); + TEST2(r, KErrNotFound); + + r = repository->Get(KNewSetting2, y); + TEST2(r, KErrNotFound); + + r = repository->Get(KNewSetting3, z8); + TEST2(r, KErrNotFound); + + r = repository->Get(KNewSetting4, z16); + TEST2(r, KErrNotFound); + + r = repository->Get(KNewSetting5, x); + TEST2(r, KErrNotFound); + + r = repository->Get(KNewSetting6, y); + TEST2(r, KErrNotFound); + + r = repository->Get(KNewSetting7, z8); + TEST2(r, KErrNotFound); + + r = repository->Get(KNewSetting8, z16); + TEST2(r, KErrNotFound); + + //now create all of the new settings + x = KNewSetting1Value; + r = repository->Create(KNewSetting1, x); + TEST2(r, KErrNone); + + r = repository->Create(KNewSetting2, KNewSetting2Value); + TEST2(r, KErrNone); + + r = repository->Create(KNewSetting3, KNewSetting3Value); + TEST2(r, KErrNone); + + r = repository->Create(KNewSetting4, KNewSetting4Value); + TEST2(r, KErrNone); + + x = KNewSetting5Value; + r = repository->Create(KNewSetting5, x); + TEST2(r, KErrNone); + + r = repository->Create(KNewSetting6, KNewSetting6Value); + TEST2(r, KErrNone); + + r = repository->Create(KNewSetting7, KNewSetting7Value); + TEST2(r, KErrNone); + + r = repository->Create(KNewSetting8, KNewSetting8Value); + TEST2(r, KErrNone); + + //close and reopen rep to check create is persisted + CleanupStack::PopAndDestroy(repository); + User::LeaveIfNull(repository = CRepository::NewLC(aUid)); + + //check that the new settings exist in the repository + r = repository->Get(KNewSetting1, x); + TEST(x == KNewSetting1Value); + TEST2(r, KErrNone); + + r = repository->Get(KNewSetting2, y); + TEST(y == KNewSetting2Value); + TEST2(r, KErrNone); + + r = repository->Get(KNewSetting3, z16); + TEST(z16 == KNewSetting3Value); + TEST2(r, KErrNone); + + r = repository->Get(KNewSetting4, z8); + TEST(z8 == KNewSetting4Value); + TEST2(r, KErrNone); + + r = repository->Get(KNewSetting5, x); + TEST(x == KNewSetting5Value); + TEST2(r, KErrNone); + + r = repository->Get(KNewSetting6, y); + TEST(y == KNewSetting6Value); + TEST2(r, KErrNone); + + r = repository->Get(KNewSetting7, z16); + TEST(z16 == KNewSetting7Value); + TEST2(r, KErrNone); + + r = repository->Get(KNewSetting8, z8); + TEST(z8 == KNewSetting8Value); + TEST2(r, KErrNone); + + // delete the settings + TUint32 errorKey = 0; + r = repository->Delete(0x00002000, 0xFFFFFF00, errorKey); + TEST2(errorKey, KUnspecifiedKey); + TEST2(r, KErrNone); + + // close and reopen rep to check delete is persisted + CleanupStack::PopAndDestroy(repository); + User::LeaveIfNull(repository = CRepository::NewLC(aUid)); + + //check that none of the settings exist in the repository + r = repository->Get(KNewSetting1, x); + TEST2(r, KErrNotFound); + + r = repository->Get(KNewSetting2, y); + TEST2(r, KErrNotFound); + + r = repository->Get(KNewSetting3, z16); + TEST2(r, KErrNotFound); + + r = repository->Get(KNewSetting4, z8); + TEST2(r, KErrNotFound); + + r = repository->Get(KNewSetting5, x); + TEST2(r, KErrNotFound); + + r = repository->Get(KNewSetting6, y); + TEST2(r, KErrNotFound); + + r = repository->Get(KNewSetting7, z16); + TEST2(r, KErrNotFound); + + r = repository->Get(KNewSetting8, z8); + TEST2(r, KErrNotFound); + + CleanupStack::PopAndDestroy(repository); + } + +/** +@SYMTestCaseID SYSLIB-CENTRALREPOSITORY-CT-1302 +@SYMTestCaseDesc Multi client test +@SYMTestPriority High +@SYMTestActions Tests for CRepository::Get(),CRepository::Set() functions +@SYMTestExpectedResults Test must not fail +@SYMREQ REQ0000 +*/ +LOCAL_C void MultiClientL() + { + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-CENTRALREPOSITORY-CT-1302 ")); + CRepository* repository1; + User::LeaveIfNull(repository1 = CRepository::NewLC(KUidTestRepository1)); + CRepository* repository2; + User::LeaveIfNull(repository2 = CRepository::NewLC(KUidTestRepository1)); + + // + // Get/Set + // + TInt i; + TInt r = repository1->Set(KInt1, 0); + TEST2(r, KErrNone); + r = repository2->Get(KInt1, i); + TEST2(r, KErrNone); + TEST(i==0); + + r = repository2->Set(KInt1, 123); + TEST2(r, KErrNone); + r = repository1->Get(KInt1, i); + TEST2(r, KErrNone); + TEST(i==123); + + // + // Notification + // + TRequestStatus status; + r = repository1->NotifyRequest(KInt1, status); + TEST2(r, KErrNone); + + r = repository2->Set(KInt1, 0); + TEST2(r, KErrNone); + User::WaitForAnyRequest(); + TEST(status==KInt1); + + CleanupStack::PopAndDestroy(2); + } + +/** +@SYMTestCaseID SYSLIB-CENTRALREPOSITORY-CT-1303 +@SYMTestCaseDesc Tests for resetting the new changes on CRepository +@SYMTestPriority High +@SYMTestActions Tests for CRepository::Reset() function + Tests for reset on a single setting that exists in the original ROM-based settings. + Tests for reset for a single setting that does not exist in the original ROM-based settings. + Tests for repository-wide reset for a repository that exists on ROM. + Tests for repository-wide reset for a repository that does not exist on ROM. +@SYMTestExpectedResults Test must not fail +@SYMREQ REQ0000 +*/ +LOCAL_C void ResetL() + { + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-CENTRALREPOSITORY-CT-1303 ")); + CRepository* repositoryA; + User::LeaveIfNull(repositoryA = CRepository::NewLC(KUidTestRepository1)); + + // + // Test reset on a single setting that exists in the + // original ROM-based settings (we'll use KInt1) + // + + // Ensure KInt1 is set to a different value to its initial value + TInt r = repositoryA->Set(KInt1, KInt1_InitialValue+10); + TEST2(r, KErrNone); + + // We're testing we get a notification on a reset as well + TRequestStatus s; + r = repositoryA->NotifyRequest(KInt1, s); + TEST2(r, KErrNone); + + r = repositoryA->Reset(KInt1); + TEST2(r, KErrNone); + + // Check we got a notifiation + RThread thisThread; + + TEST2(thisThread.RequestCount(), 1); + User::WaitForAnyRequest(); + TEST(s==KInt1); + + // Check KInt1 now has the right value + TInt x; + r = repositoryA->Get(KInt1, x); + TEST2(r, KErrNone); + TEST(x==KInt1_InitialValue); + + // A second reset should not generate notification + // as value has not changed + r = repositoryA->NotifyRequest(KInt1, s); + TEST2(r, KErrNone); + r = repositoryA->Reset(KInt1); + TEST2(r, KErrNone); + + // + // Test reset for a single setting that does not exist + // in the original ROM-based settings. + // + const TInt KIntValue = 1234; + r = repositoryA->Create(KNewInt, KIntValue); + TEST2(r, KErrNone); + + // We're testing we get a notification on a reset as well + r = repositoryA->NotifyRequest(KNewInt, s); + TEST2(r, KErrNone); + + r = repositoryA->Reset(KNewInt); + TEST2(r, KErrNone); + + // Check we got a notifiation + TEST2(thisThread.RequestCount(), 1); + User::WaitForAnyRequest(); + TEST(s==KNewInt); + + // Check KNewInt has been deleted + r = repositoryA->Get(KNewInt, x); + TEST2(r, KErrNotFound); + + CleanupStack::PopAndDestroy(repositoryA); + User::WaitForAnyRequest(); //cancellation of request + TEST2(thisThread.RequestCount(), 0); + + // + // Test reset for a single setting in a repository that + // does not exist on ROM. + // + const TInt KSettingKey = KNonExisitentSetting; + const TInt KInitialValue = 10; + + CRepository* repositoryB; + User::LeaveIfNull(repositoryB = CRepository::NewLC(KUidDriveCOnlyRepository)); + + r = repositoryB->Create(KSettingKey, KInitialValue); + TEST2(r, KErrNone); + + // We're testing we get a notification on a reset as well + r = repositoryB->NotifyRequest(KSettingKey, s); + TEST2(r, KErrNone); + + r = repositoryB->Reset(KSettingKey); + TEST2(r, KErrNone); + + // Check we got a notifiation + TEST2(thisThread.RequestCount(), 1); + User::WaitForAnyRequest(); + TEST(s==KSettingKey); + + // Check KSettingKey has been deleted + r = repositoryB->Get(KSettingKey, x); + TEST2(r, KErrNotFound); + + CleanupStack::PopAndDestroy(repositoryB); + // + // Test repository-wide reset for a repository + // that exists on ROM. + // + CRepository* repositoryC; + User::LeaveIfNull(repositoryC = CRepository::NewLC(KUidResetTestRepository)); + + const TInt KNewSetting1 = 5; + const TInt KNewSetting2 = 6; + r = repositoryC->Create(KNewSetting1, 0); + TEST2(r, KErrNone); + r = repositoryC->Create(KNewSetting2, 0); + TEST2(r, KErrNone); + + r = repositoryC->Create(65, 1); + TEST2(r, KErrNone); + + r = repositoryC->Set(70, 1); + TEST2(r, KErrNone); + + r = repositoryC->Create(80, 1); + TEST2(r, KErrNone); + + r = repositoryC->Create(90, 1); + TEST2(r, KErrNone); + + r = repositoryC->NotifyRequest(0, 0, s); + TEST2(r, KErrNone); + + r = repositoryC->Reset(); + TEST2(r, KErrNone); + TEST(thisThread.RequestCount()==1); + User::WaitForAnyRequest(); + TEST(s==KUnspecifiedKey); + + r = repositoryC->Get(10, x); + TEST2(r, KErrNone); + TEST(x==10); + + r = repositoryC->Get(40, x); + TEST2(r, KErrNone); + TEST(x==0); + + r = repositoryC->Get(50, x); + TEST2(r, KErrNone); + TEST(x==0); + + r = repositoryC->Get(60, x); + TEST2(r, KErrNone); + TEST(x==0); + + r = repositoryC->Get(70, x); + TEST2(r, KErrNone); + TEST(x==0); + + TBuf<10> z; + r = repositoryC->Get(20, z); + TEST2(r, KErrNone); + TEST(z==_L("string")); + + TReal y; + r = repositoryC->Get(30, y); + TEST2(r, KErrNone); + TEST(y==1); + + r = repositoryC->Get(5, x); + TEST2(r, KErrNotFound); + r = repositoryC->Get(6, x); + TEST2(r, KErrNotFound); + r = repositoryC->Get(65, x); + TEST2(r, KErrNotFound); + r = repositoryC->Get(80, x); + TEST2(r, KErrNotFound); + r = repositoryC->Get(90, x); + TEST2(r, KErrNotFound); + + CleanupStack::PopAndDestroy(repositoryC); + + // + // Test repository-wide reset for a repository + // that does not exist on ROM. + // + CRepository* repositoryD; + User::LeaveIfNull(repositoryD = CRepository::NewLC(KUidDriveCOnlyRepository)); + + r = repositoryD->Create(KSettingKey, KInitialValue); + TEST2(r, KErrNone); + + // We're testing we get a notification on a reset as well + r = repositoryD->NotifyRequest(KSettingKey, s); + TEST2(r, KErrNone); + + r = repositoryD->Reset(); + TEST2(r, KErrNone); + + // Check we got a notifiation + TEST(thisThread.RequestCount()==1); + User::WaitForAnyRequest(); + TEST(s==KUnspecifiedKey); + + // Check KSettingKey has been deleted + r = repositoryD->Get(KSettingKey, x); + TEST2(r, KErrNotFound); + + // Recreate KSettingKey + r = repositoryD->Create(KSettingKey, 10); + TEST2(r, KErrNone); + + // Reset KSettingKey only + r = repositoryD->Reset(KSettingKey); + TEST2(r, KErrNone); + + // Check KSettingKey has been deleted + r = repositoryD->Get(KSettingKey, x); + TEST2(r, KErrNotFound); + + CleanupStack::PopAndDestroy(repositoryD); + } + +LOCAL_C void ResetCreL() + { + CRepository* repositoryA; + TInt r = KErrNone; + TRequestStatus s; + TInt x; + RThread thisThread; + + User::LeaveIfNull(repositoryA = CRepository::NewLC(KUidCreTestRepository1)); + + // test for .cre file + // Test reset on a single setting that exists in the + // original ROM-based settings (we'll use KInt1) + // + + // Ensure KInt1 is set to a different value to its initial value + r = repositoryA->Set(KInt1, KInt1_InitialValue+10); + TEST2(r, KErrNone); + + CleanupStack::PopAndDestroy(repositoryA); + User::LeaveIfNull(repositoryA = CRepository::NewLC(KUidCreTestRepository1)); + + // We're testing we get a notification on a reset as well + r = repositoryA->NotifyRequest(KInt1, s); + TEST2(r, KErrNone); + + r = repositoryA->Reset(KInt1); + TEST2(r, KErrNone); + + // Check we got a notifiation + TEST2(thisThread.RequestCount(), 1); + User::WaitForAnyRequest(); + TEST(s == KInt1); + + CleanupStack::PopAndDestroy(repositoryA); + User::LeaveIfNull(repositoryA = CRepository::NewLC(KUidCreTestRepository1)); + + // Check KInt1 now has the right value + r = repositoryA->Get(KInt1, x); + TEST2(r, KErrNone); + TEST2(x, KInt1_InitialValue); + + // A second reset should not generate notification + // as value has not changed + r = repositoryA->NotifyRequest(KInt1, s); + TEST2(r, KErrNone); + + r = repositoryA->Reset(KInt1); + TEST2(r, KErrNone); + TEST2(thisThread.RequestCount(), 0); + + CleanupStack::PopAndDestroy(repositoryA); + User::LeaveIfNull(repositoryA = CRepository::NewLC(KUidCreTestRepository1)); + // + // Test reset for a single setting that does not exist + // in the original ROM-based settings. + // + const TInt KIntValue = 1234; + r = repositoryA->Create(KNewInt, KIntValue); + TEST2(r, KErrNone); + + CleanupStack::PopAndDestroy(repositoryA); + User::WaitForAnyRequest();//this is the cancellation of last notify request + TEST2(thisThread.RequestCount(), 0); + + User::LeaveIfNull(repositoryA = CRepository::NewLC(KUidCreTestRepository1)); + + // We're testing we get a notification on a reset as well + r = repositoryA->NotifyRequest(KNewInt, s); + TEST2(r, KErrNone); + + r = repositoryA->Reset(KNewInt); + TEST2(r, KErrNone); + + // Check we got a notifiation + TEST2(thisThread.RequestCount(), 1); + User::WaitForAnyRequest(); + TEST(s == KNewInt); + + CleanupStack::PopAndDestroy(repositoryA); + User::LeaveIfNull(repositoryA = CRepository::NewLC(KUidCreTestRepository1)); + + // Check KNewInt has been deleted + r = repositoryA->Get(KNewInt, x); + TEST2(r, KErrNotFound); + + CleanupStack::PopAndDestroy(repositoryA); + User::LeaveIfNull(repositoryA = CRepository::NewLC(KUidCreTestRepository1)); + + // Reset entire repository + r = repositoryA->Reset(); + TEST2(r, KErrNone); + + CleanupStack::PopAndDestroy(repositoryA); + } + +/** +@SYMTestCaseID SYSLIB-CENTRALREPOSITORY-CT-1304 +@SYMTestCaseDesc Tests for initialising file searching +@SYMTestPriority High +@SYMTestActions Tests for CRepository::Get() function +@SYMTestExpectedResults Test must not fail +@SYMREQ REQ0000 +*/ +LOCAL_C void IniFileSearching() + { + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-CENTRALREPOSITORY-CT-1304 ")); + const TInt KSettingKey = 1; + + _LIT(KDriveZ, "drive z"); + + const TInt KBufLen = 7; // = Max of 3 above string lengths + + // + // File on drive C should take precedence + // + CRepository* repository = CRepository::NewL(KUidDriveCRepository); + + TBuf str; + TInt r = repository->Get(KSettingKey, str); + TEST2(r, KErrNone); + TEST(str==KDriveZ); + + delete repository; + } + +/** +@SYMTestCaseID SYSLIB-CENTRALREPOSITORY-CT-1305 +@SYMTestCaseDesc Tests for creating new repository on drive C: +@SYMTestPriority High +@SYMTestActions Tests for CRepository::NewL() function +@SYMTestExpectedResults Test must not fail +@SYMREQ REQ0000 +*/ +LOCAL_C void RepositoryOnDriveC() + { + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-CENTRALREPOSITORY-CT-1305 ")); + const TInt KSettingKey = KNonExisitentSetting; + const TInt KInitialValue = 10; + + CRepository* repository = CRepository::NewL(KUidDriveCOnlyRepository); + CleanupStack::PushL(repository); + + TInt val; + TInt r = repository->Get(KSettingKey, val); + TEST2(r, KErrNotFound); + + r = repository->Create(KSettingKey, KInitialValue); + TEST2(r, KErrNone); + + r = repository->Get(KSettingKey, val); + TEST2(r, KErrNone); + TEST(val==KInitialValue); + + CleanupStack::PopAndDestroy(repository); + repository = CRepository::NewL(KUidDriveCOnlyRepository); + CleanupStack::PushL(repository); + + r = repository->Get(KSettingKey, val); + TEST2(r, KErrNone); + TEST(val==KInitialValue); + + r = repository->Set(KSettingKey, KInitialValue+1); + TEST2(r, KErrNone); + + r = repository->Get(KSettingKey, val); + TEST2(r, KErrNone); + TEST(val==KInitialValue+1); + + r = repository->Delete(KSettingKey); + TEST2(r, KErrNone); + + CleanupStack::PopAndDestroy(repository); + repository = CRepository::NewL(KUidDriveCOnlyRepository); + CleanupStack::PushL(repository); + + r = repository->Get(KSettingKey, val); + TEST2(r, KErrNotFound); + + CleanupStack::PopAndDestroy(repository); + } + +/** +@SYMTestCaseID SYSLIB-CENTRALREPOSITORY-CT-1656 +@SYMTestCaseDesc Notify-only client optimization test +@SYMTestPriority High +@SYMTestActions Tests for on-demand loading in API calls after in-session + unloading of repositories. Also tests for notification functionality. +@SYMTestExpectedResults Test must not fail +@SYMPREQ PREQ1228 +*/ +LOCAL_C void NotifyOnlyL() + { + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-CENTRALREPOSITORY-CT-1656 ")); + CRepository* repository1; + User::LeaveIfNull(repository1 = CRepository::NewLC(KUidTestRepository1)); + + // check that functions work + TInt i; + TInt r = repository1->Get(KInt1, i); + TEST2(r, KErrNone); + TEST(i==1); + + CleanupStack::PopAndDestroy(); + // Kill the server to force clearing the cache + KillCentRepServerL(); + User::LeaveIfNull(repository1 = CRepository::NewLC(KUidTestRepository1)); + + r = repository1->Set(KInt1, i); + TEST2(r, KErrNone); + + CleanupStack::PopAndDestroy(); + // Kill the server to force clearing the cache + KillCentRepServerL(); + User::LeaveIfNull(repository1 = CRepository::NewLC(KUidTestRepository1)); + + const TInt KIntValue = 1234; + r = repository1->Create(KNewInt, KIntValue); + TEST2(r, KErrNone); + + CleanupStack::PopAndDestroy(); + // Kill the server to force clearing the cache + KillCentRepServerL(); + User::LeaveIfNull(repository1 = CRepository::NewLC(KUidTestRepository1)); + + RArray foundIds; + TInt leaveCode = KErrNone; + TRAP(leaveCode, r= repository1->FindEqL(0, 0, KIntValue, foundIds)); + if (leaveCode != KErrNone) + r = leaveCode ; + if(OomTesting && r==KErrNoMemory) + { + foundIds.Close(); + User::Leave(KErrNoMemory); + } + TEST2(r, KErrNone); + TEST(foundIds.Count()==1); + TEST(foundIds[0]==KNewInt); + foundIds.Reset(); + + CleanupStack::PopAndDestroy(); + // Kill the server to force clearing the cache + KillCentRepServerL(); + User::LeaveIfNull(repository1 = CRepository::NewLC(KUidTestRepository1)); + + r = repository1->Delete(KNewInt); + TEST2(r, KErrNone); + + CleanupStack::PopAndDestroy(); + + // check that multiple clients work + User::LeaveIfNull(repository1 = CRepository::NewLC(KUidTestRepository1)); + + r = repository1->Get(KInt1, i); + TEST2(r, KErrNone); + TEST(i==1); + + CleanupStack::PopAndDestroy(); + // Kill the server to force clearing the cache + KillCentRepServerL(); + User::LeaveIfNull(repository1 = CRepository::NewLC(KUidTestRepository1)); + + CRepository* repository2; + User::LeaveIfNull(repository2 = CRepository::NewLC(KUidTestRepository1)); + + r = repository2->Get(KInt1, i); + TEST2(r, KErrNone); + TEST(i==1); + + r = repository1->Get(KInt1, i); + TEST2(r, KErrNone); + TEST(i==1); + + CleanupStack::PopAndDestroy(2); + + // check that notifications work + User::LeaveIfNull(repository1 = CRepository::NewLC(KUidTestRepository1)); + TRequestStatus status1; + r = repository1->NotifyRequest(KInt1, status1); + TEST2(r, KErrNone); + + User::LeaveIfNull(repository2 = CRepository::NewLC(KUidTestRepository1)); + r = repository2->Set(KInt1, 0); + TEST2(r, KErrNone); + User::WaitForAnyRequest(); + TEST(status1==KInt1); + + r = repository1->NotifyRequest(KInt1, status1); + TEST2(r, KErrNone); + + CleanupRepositoryCache(); + + r = repository2->Set(KInt1, 2); + TEST2(r, KErrNone); + User::WaitForAnyRequest(); + TEST(status1==KInt1); + + r = repository1->NotifyRequest(KInt1, status1); + TEST2(r, KErrNone); + + CRepository* repository3; + User::LeaveIfNull(repository3 = CRepository::NewLC(KUidTestRepository1)); + TRequestStatus status3; + r = repository3->NotifyRequest(KInt1, status3); + TEST2(r, KErrNone); + + r = repository2->Set(KInt1, 0); + TEST2(r, KErrNone); + User::WaitForAnyRequest(); + TEST(status1==KInt1); + TEST(status3==KInt1); + + r = repository1->NotifyRequest(KInt1, status1); + TEST2(r, KErrNone); + r = repository3->NotifyRequest(KInt1, status3); + TEST2(r, KErrNone); + + CleanupRepositoryCache(); + + r = repository2->Set(KInt1, 1); + TEST2(r, KErrNone); + User::WaitForAnyRequest(); + TEST(status1==KInt1); + TEST(status3==KInt1); + + CleanupStack::PopAndDestroy(3); + // Kill the server to force clearing the cache + KillCentRepServerL(); + User::LeaveIfNull(repository3 = CRepository::NewLC(KUidTestRepository1)); + + r = repository3->Get(KInt1, i); + TEST2(r, KErrNone); + TEST(i==1); + + CleanupStack::PopAndDestroy(); + } +/** +@SYMTestCaseID SYSLIB-CENTRALREPOSITORY-CT-0494 +@SYMTestCaseDesc Tests the various functions on CentralRepository +@SYMTestPriority High +@SYMTestActions Tests the get/set,find,notify,create/delete, + file searching in repository,the repository on drive c only + Tests for multiple clients,for restoring factory settings. +@SYMTestExpectedResults Test must not fail +@SYMREQ REQ0000 +*/ +LOCAL_C void FuncTestsL() + { + TheTest.Start(_L(" @SYMTestCaseID:SYSLIB-CENTRALREPOSITORY-CT-0494 Open/Close repository ")); + OpenRepositoryL(); + + TheTest.Next(_L("Get/Set .ini")); + GetSetL(KUidTestRepository1); + + TheTest.Next(_L("Get/Set .cre")); + GetSetL(KUidCreTestRepository1); + + TheTest.Next(_L("Find")); + FindL(); + + TheTest.Next(_L("Notify")); + NotifyL(); + + TheTest.Next(_L("Create/Delete .ini")); + CreateDeleteL(KUidTestRepository1); + + TheTest.Next(_L("Create/Delete .cre")); + CreateDeleteL(KUidCreTestRepository1); + + TheTest.Next(_L("Initialisation file searching")); + IniFileSearching(); + + TheTest.Next(_L("Repository on Drive C only")); + RepositoryOnDriveC(); + + TheTest.Next(_L("Multiple clients")); + MultiClientL(); + + TheTest.Next(_L("Restore factory settings")); + ResetL(); + + TheTest.Next(_L("Restore factory settings from binary based rep")); + ResetCreL(); + + TheTest.Next(_L("Negative testing for the notification cancelling")); + CancelNotificationsL(); + + TheTest.Next(_L("Notify-only client optimizations")); + NotifyOnlyL(); + + TheTest.End(); + } + +/** +OomTest +Function to convert a test into an OOM test + +@SYMTestCaseID SYSLIB-CENTRALREPOSITORY-CT-0495 +@SYMTestCaseDesc Out of memory test +@SYMTestPriority High +@SYMTestActions Tests for running out of memory +@SYMTestExpectedResults Test must not fail +@SYMREQ REQ0000 +*/ +LOCAL_C void OomTest(void (*testFuncL)()) + { + TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-CENTRALREPOSITORY-CT-0495 ")); + TInt error; + TInt count = 0; + + do + { + User::__DbgSetAllocFail(RHeap::EUser, RHeap::EFailNext, ++count); + User::__DbgMarkStart(RHeap::EUser); + + // find out the number of open handles + TInt startProcessHandleCount; + TInt startThreadHandleCount; + RThread().HandleCount(startProcessHandleCount, startThreadHandleCount); + + TRAP(error, (testFuncL)()); + + // check that no handles have leaked + TInt endProcessHandleCount; + TInt endThreadHandleCount; + RThread().HandleCount(endProcessHandleCount, endThreadHandleCount); + + TEST2(endProcessHandleCount, startProcessHandleCount); + TEST2(endThreadHandleCount, startThreadHandleCount); + + User::__DbgMarkEnd(RHeap::EUser, 0); + } while(error == KErrNoMemory); + + _LIT(KTestFailed, "Out of memory test failure on iteration %d\n"); + __ASSERT_ALWAYS(error==KErrNone, TheTest.Panic(error, KTestFailed, count)); + + User::__DbgSetAllocFail(RHeap::EUser, RHeap::ENone, 1); + } + +LOCAL_C void OomTestsL() + { + TheTest.Start(_L("Open/Close repository")); + OomTest(OpenRepositoryL); + + TheTest.Next(_L("GetSet for KUidTestRepository1")); + GetSetL(KUidTestRepository1); + TheTest.Next(_L("GetSet for KUidCreTestRepository1")); + GetSetL(KUidCreTestRepository1); + + TheTest.Next(_L("Find")); + OomTest(FindL); + + TheTest.End(); + } + +//This function tests the replacement of RFile with RFileBuf in CIniFileOut class (inifile.h) +//It shows that there is approx. 20% (LUBBOCK) performance boost when using simple "Set" +//operations. It may be even better when using "Commit" functionality. +static void PerformanceTestL() + { + CRepository* repository = CRepository::NewL(KUidDriveCOnlyRepository); + CleanupStack::PushL(repository); + //Test settings IDs + const TUint KIntId = 101; + const TUint KRealId = 102; + const TUint KDes16Id = 103; + const TUint KDes8Id = 104; + //Create test settings + TInt err = repository->Create(KIntId, 1); + TEST2(err, KErrNone); + err = repository->Create(KRealId, 1.1); + TEST2(err, KErrNone); + err = repository->Create(KDes16Id, _L16("DES16")); + TEST2(err, KErrNone); + err = repository->Create(KDes8Id, _L8("DES8")); + TEST2(err, KErrNone); + //Performance test + TBuf16<32> buf16; + TBuf8<32> buf8; + TUint timeStart = User::TickCount(); + for(TInt i=0;i<500;++i) + { + buf16.Zero(); + buf16.AppendNum(i); + buf8.Zero(); + buf8.AppendNum(i); + + TInt err = repository->Set(KIntId, i); + TEST2(err, KErrNone); + err = repository->Set(KRealId, (TReal)i); + TEST2(err, KErrNone); + err = repository->Set(KDes16Id, buf16); + TEST2(err, KErrNone); + err = repository->Set(KDes8Id, buf8); + TEST2(err, KErrNone); + } + TUint timeEnd = User::TickCount(); + CleanupStack::PopAndDestroy(repository); + TheTest.Printf(_L("\nPerformanceTestL - %d ticks\n"), timeEnd-timeStart); + } + +/** +@SYMTestCaseID SYSLIB-CENTRALREPOSITORY-CT-0497 +@SYMTestCaseDesc CentralRepository functionality test +@SYMTestPriority High +@SYMTestActions Wrapper function calling up test functions +@SYMTestExpectedResults Test must not fail +@SYMREQ REQ0000 +*/ +LOCAL_C void MainL() + { + TheTest.Start(_L(" @SYMTestCaseID:SYSLIB-CENTRALREPOSITORY-CT-0497 Functional tests ")); + OomTesting = EFalse; + // Existance of caching functionality invalidates some tests and + // makes them fail. So cleanup cace. + RestoreTestFilesL(); + FuncTestsL(); + + TheTest.Next(_L("Out-of-memory tests")); + OomTesting = ETrue; + //Reset the KUidTestRepository1 which was modified by the previous test + //and is used in the next test. + ResetTestRepositoryL(); + OomTestsL(); + + TheTest.Next(_L("Performance test")); + PerformanceTestL(); + + TheTest.Next(_L("Clean out C: files")); + CleanupCDriveL(); + + TheTest.End(); + TheTest.Close(); + } + +TInt E32Main() + { + __UHEAP_MARK; + CTrapCleanup* cleanup = CTrapCleanup::New(); + if(!cleanup) + return KErrNoMemory; + + TRAPD(err, MainL()); + if (err != KErrNone) + User::Panic(_L("Testing failed: "), err); + + delete cleanup; + __UHEAP_MARKEND; + + return 0; + }