diff -r 000000000000 -r bde4ae8d615e os/persistentdata/persistentstorage/centralrepository/test/t_cenrep_rfs.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/os/persistentdata/persistentstorage/centralrepository/test/t_cenrep_rfs.cpp Fri Jun 15 03:10:57 2012 +0200 @@ -0,0 +1,664 @@ +// 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 // RTest +#include // RDebug::Printf +#include // RFs + +#include "../cenrepsrv/srvparams.h" //KServerUid3 + +//using namespace NCentralRepositoryConstants; + +_LIT(KSoftReset, "--SoftReset"); + +RTest TheTest(_L("Central Repository RFS Test")); + +const TUid KUidRfsRepository = { 0xffffffff }; +const TUid KUidRfsRepositoryInstallOnlyDefaultFile = { 0xfffffffe }; +const TUid KUidRfsRepositoryDefaultRfsOn = { 0xfffffffa }; + +typedef enum + { + ERomOnly = 0x01, + ERomAndInstall, + EInstallOnly, + ENoRomOrInstall + } TRepositoryFileState; + +const TUint32 KInt1 = 1; +const TInt KInt1_UpdatedValue = 73; +const TReal KReal1_InitialValue = 2.732; +const TUint32 KNewInt = 1000; +const TUint32 KNewInt2 = 0x0FFF; // outside range meta (in default meta) +const TUint32 KNewInt3 = 0x1000; // inside range meta +const TUint32 KReal1 = 2; +const TReal KReal1_InstallValue = 4.53; +const TReal KReal1_UpdatedValue = 7.32; +const TUint32 KString1 = 5; +_LIT(KString1_InitialValue, "test\\\"string\""); +_LIT(KString1_UpdatedValue, "another one"); + + +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__) + +// This function kills the C32exe.exe process. This commsdat process will +// interfere with the test if not killed. In a nutshell, some of the test cases +// will kill and then wait for 2 seconds and restart the centrep server +// with --SoftReset option. During that 2 seconds wait sometimes C32exe.exe +// will use centrep API, thus starting the server normally without --SoftReset. +LOCAL_C void KillC32Exe() + { + _LIT( KC32ServerName, "c32exe"); + KillProcess(KC32ServerName); // Don't need to check the return code, it always return KErrNone anyway. + User::After(KGeneralDelay); + } + +//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 RestoreRFSTestFilesL(TRepositoryFileState aState) + { + //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\\ffffffff.txt"); + _LIT(KInstallTargetPath, "C:\\private\\10202BE9\\ffffffff.txt"); + _LIT(KPersistTargetPath1,"C:\\private\\10202BE9\\persists\\fffffffe.txt"); + _LIT(KPersistTargetPath2,"C:\\private\\10202BE9\\persists\\fffffffd.txt"); + _LIT(KInstallTargetPath1,"C:\\private\\10202BE9\\fffffffe.txt"); + _LIT(KRFSTestFileSourcePath, "Z:\\private\\10202BE9\\ffffffff.txc"); + + switch(aState) + { + case ERomOnly: + CopyTestFilesL(*fm,KRFSTestFileSourcePath, KPersistTargetPath); + break; + + case ERomAndInstall: + CopyTestFilesL(*fm,KRFSTestFileSourcePath, KPersistTargetPath); + CopyTestFilesL(*fm,KRFSTestFileSourcePath, KInstallTargetPath); + break; + + case EInstallOnly: + CopyTestFilesL(*fm,KRFSTestFileSourcePath, KPersistTargetPath1); + CopyTestFilesL(*fm,KRFSTestFileSourcePath, KInstallTargetPath1); + break; + + case ENoRomOrInstall: + CopyTestFilesL(*fm,KRFSTestFileSourcePath, KPersistTargetPath2); + break; + + default: + break; + } + + CleanupStack::PopAndDestroy(2); + + } + +// +// Start the server process or thread +// +LOCAL_C TInt ReStartServerInSoftResetMode() + { + const TUidType serverUid(KNullUid, KNullUid, KServerUid3); + + // + // EPOC and EKA2 is easy, we just create a new server process. Simultaneous + // launching of two such processes should be detected when the second one + // attempts to create the server object, failing with KErrAlreadyExists. + // + RProcess server; + TInt r=server.Create(KServerImg, + KSoftReset, + serverUid); + + if (r != KErrNone) + { + return r; + } + + TRequestStatus stat; + server.Rendezvous(stat); + + if (stat != KRequestPending) + { + server.Kill(0); // abort startup + } + else + { + server.Resume(); // logon OK - start the server + } + + User::WaitForRequest(stat); // wait for start or death + // we can't use the 'exit reason' if the server panicked as this + // is the panic 'reason' and may be '0' which cannot be distinguished + // from KErrNone + r = (server.ExitType() == EExitPanic) ? KErrGeneral : stat.Int(); + + server.Close(); + return r; + } + + +LOCAL_C void RestoreFactorySettingsTestL() + { + TheTest.Start(_L("ResetAllRepositoriesTestL")); + TInt r; + TInt i; + TBuf<20> str; + + TheTest.Next(_L("Open repository to ensure server is running")); + CRepository* repository = CRepository::NewLC(KUidRfsRepository); + + TheTest.Next(_L("Add a Setting")); + const TInt KIntValue = 1234; + r = repository->Create(KNewInt, KIntValue); + TEST2(r, KErrNone); + + TheTest.Next(_L("Delete a Setting")); + r = repository->Delete(KReal1); + TEST2(r, KErrNone); + + TheTest.Next(_L("Modify a Setting")); + r = repository->Set(KInt1, KInt1_UpdatedValue); + TEST2(r, KErrNone); + + TheTest.Next(_L("Modify a String Setting")); + r = repository->Set(KString1, KString1_UpdatedValue); + + TEST2(r, KErrNone); + // Close repository + CleanupStack::PopAndDestroy(repository); + + TheTest.Next(_L("Kill the server process")); + _LIT( KCentralRepositoryServerName, "Centralrepositorysrv"); + r = KillProcess(KCentralRepositoryServerName); + TEST2(r,KErrNone); + + User::After(KGeneralDelay); + + TheTest.Next(_L("Manually start central respository")); + ReStartServerInSoftResetMode(); + + TheTest.Next(_L("Re-create the repository to ensure server is running")); + repository = CRepository::NewLC(KUidRfsRepository); + + TheTest.Next(_L("Get 'Added' value")); + r = repository->Get(KNewInt, i); + TEST2(r, KErrNone); + + TReal real; + TheTest.Next(_L("Get 'Deleted' value")); + r = repository->Get(KReal1, real); + TEST2(r, KErrNone); + TEST(real == KReal1_InitialValue); + + TheTest.Next(_L("Get 'Modified' value")); + r = repository->Get(KInt1, i); + TEST2(r, KErrNone); + TEST(i == KInt1_UpdatedValue); + + r = repository->Get(KString1, str); + TEST2(r, KErrNone); + TEST(str==KString1_InitialValue); + + // Close repository + CleanupStack::PopAndDestroy(repository); + + TheTest.End(); + } + + + +/** +@SYMTestCaseID SYSLIB-CENTRALREPOSITORY-CT-3341 +@SYMTestCaseDesc Restore factory Settings from Rom file. +@SYMTestPriority High +@SYMTestActions Ensure that the repository file only exists on the Rom. + Open the repository and modify a setting. Force RFS + and check that the repository is restored against the ROM file +@SYMTestExpectedResults The test repository should be reset against the ROM file +@SYMDEF PDEF099108 +*/ +LOCAL_C void RFSRomOnlyL() + { + + //restore all test files - this ensures we have a repository file + //only on the z: + RestoreRFSTestFilesL(ERomOnly); + + TheTest.Start(_L(" @SYMTestCaseID:SYSLIB-CENTRALREPOSITORY-CT-3341 ResetAllRepositoriesTestL ")); + TInt r, intVal; + TReal realVal; + + TheTest.Next(_L("Open repository to ensure server is running")); + CRepository* repository = CRepository::NewLC(KUidRfsRepository); + + TheTest.Next(_L("Modify a Setting")); + r = repository->Set(KInt1, KInt1_UpdatedValue); + TEST2(r, KErrNone); + + //verify the update + r = repository->Get(KInt1, intVal); + TEST2(r, KErrNone); + TEST(intVal == KInt1_UpdatedValue); + + TheTest.Next(_L("Modify a Setting")); + r = repository->Set(KReal1, KReal1_UpdatedValue); + TEST2(r, KErrNone); + + //verify the update + r = repository->Get(KReal1, realVal); + TEST2(r, KErrNone); + TEST(realVal == KReal1_UpdatedValue); + + // Close repository + CleanupStack::PopAndDestroy(repository); + + //Kill the server + TheTest.Next(_L("Kill the server process")); + _LIT( KCentralRepositoryServerName, "Centralrepositorysrv"); + r = KillProcess(KCentralRepositoryServerName); + TEST2(r,KErrNone); + + User::After(KGeneralDelay); + + //Restart the server in soft reset mode to force a + //repository reset + TheTest.Next(_L("Manually start central respository")); + ReStartServerInSoftResetMode(); + + //Open the repository + repository = CRepository::NewLC(KUidRfsRepository); + + //Verify that the real value is reset against the value in the Rom version of + //the repository file + TheTest.Next(_L("Get 'Modified' value")); + r = repository->Get(KReal1, realVal); + TEST2(r, KErrNone); + TEST(realVal == KReal1_InitialValue); + + // Close repository + CleanupStack::PopAndDestroy(repository); + + TheTest.End(); + } + + + +/** +@SYMTestCaseID SYSLIB-CENTRALREPOSITORY-CT-3342 +@SYMTestCaseDesc Restore factory Settings from merged repository. +@SYMTestPriority High +@SYMTestActions Ensure that the repository file exists in both the Rom and install + directories. + Open the repository and modify a setting. Force RFS + and check that the repository is restored against the merged repository +@SYMTestExpectedResults The test repository should be reset against the merged repository +@SYMDEF PDEF099108 +*/ +LOCAL_C void RFSRomAndInstallL() + { + + //restore all test files - this ensures we have a c: and z: file + //for the test repository which causes a repository merge + RestoreRFSTestFilesL(ERomAndInstall); + + TheTest.Start(_L(" @SYMTestCaseID:SYSLIB-CENTRALREPOSITORY-CT-3342 ResetAllRepositoriesTestL ")); + TInt r; + TReal realVal; + TBuf<20> strVal; + + TheTest.Next(_L("Open repository to ensure server is running")); + CRepository* repository = CRepository::NewLC(KUidRfsRepository); + + TheTest.Next(_L("Modify a Setting")); + r = repository->Set(KReal1, KReal1_UpdatedValue); + TEST2(r, KErrNone); + + //verify the update + r = repository->Get(KReal1, realVal); + TEST2(r, KErrNone); + TEST(realVal == KReal1_UpdatedValue); + + // Close repository + CleanupStack::PopAndDestroy(repository); + + //Kill the server + TheTest.Next(_L("Kill the server process")); + _LIT( KCentralRepositoryServerName, "Centralrepositorysrv"); + r = KillProcess(KCentralRepositoryServerName); + TEST2(r,KErrNone); + + User::After(KGeneralDelay); + + //Restart the server in soft reset mode to force a + //repository reset + TheTest.Next(_L("Manually start central respository")); + ReStartServerInSoftResetMode(); + + //Open the repository + repository = CRepository::NewLC(KUidRfsRepository); + + //Verify that the string value, which is only found in the ROM file is + //present in the merged repository + r = repository->Get(KString1, strVal); + TEST2(r, KErrNone); + TEST(strVal==KString1_InitialValue); + + //verify that the Real value has been reset against the value in the install + //repository file + TheTest.Next(_L("Get 'Modified' value")); + r = repository->Get(KReal1, realVal); + TEST2(r, KErrNone); + TEST(realVal == KReal1_InstallValue); + + // Close repository + CleanupStack::PopAndDestroy(repository); + + TheTest.End(); + } + + +/** +@SYMTestCaseID SYSLIB-CENTRALREPOSITORY-CT-3343 +@SYMTestCaseDesc Restore factory Settings from Install file. +@SYMTestPriority High +@SYMTestActions Ensure that the repository file only exists in the Install directory. + Open the repository and modify a setting. Force RFS + and check that the repository is restored against the Install file +@SYMTestExpectedResults The test repository should be reset against the Install file +@SYMDEF PDEF099108 +*/ +LOCAL_C void RFSInstallOnlyL() + { + + TheTest.Start(_L(" @SYMTestCaseID:SYSLIB-CENTRALREPOSITORY-CT-3343 ResetAllRepositoriesTestL ")); + TInt r; + TReal realVal; + TBuf<20> strVal; + + //restore all test files - this ensures we have a repository file + //only on the c: + RestoreRFSTestFilesL(EInstallOnly); + + TheTest.Next(_L("Open repository to ensure server is running")); + CRepository* repository = CRepository::NewLC(KUidRfsRepositoryInstallOnlyDefaultFile); + + TheTest.Next(_L("Modify a Setting")); + r = repository->Set(KReal1, KReal1_UpdatedValue); + TEST2(r, KErrNone); + + //verify the update + r = repository->Get(KReal1, realVal); + TEST2(r, KErrNone); + TEST(realVal == KReal1_UpdatedValue); + + // Close repository + CleanupStack::PopAndDestroy(repository); + + //Kill the server + TheTest.Next(_L("Kill the server process")); + _LIT( KCentralRepositoryServerName, "Centralrepositorysrv"); + r = KillProcess(KCentralRepositoryServerName); + TEST2(r,KErrNone); + + User::After(KGeneralDelay); + + //Restart the server in soft reset mode to force a + //repository reset + TheTest.Next(_L("Manually start central respository")); + ReStartServerInSoftResetMode(); + + //Open the repository + repository = CRepository::NewLC(KUidRfsRepositoryInstallOnlyDefaultFile); + + //verify that the Real value has been reset against the value in the install + //repository file + TheTest.Next(_L("Get 'Modified' value")); + r = repository->Get(KReal1, realVal); + TEST2(r, KErrNone); + TEST(realVal == KReal1_InstallValue); + + // Close repository + CleanupStack::PopAndDestroy(repository); + + TheTest.End(); + } + +/** +@SYMTestCaseID SYSLIB-CENTRALREPOSITORY-CT-3435 +@SYMTestCaseDesc PDEF105203: Start-up Settings: New access point remains after restoring factory setting +@SYMTestPriority High +@SYMTestActions Create a new setting inside a range with range meta RFS bit set, create another setting + outside the range, restart server in RFS mode, check to see the setting created outside + the range still exists, check to see the setting created inside the range has been deleted. + Repeat same steps with another repository which has default meta having RFS on and range meta + having RFS off, check to see the setting created outside the range has been deleted, check to + see the setting created inside the range still exists. +@SYMTestExpectedResults Test must not fail +@SYMDEF PDEF105203 +*/ +LOCAL_C void PDEF105203() + { + TheTest.Start(_L(" @SYMTestCaseID:SYSLIB-CENTRALREPOSITORY-CT-3435 PDEF105203: Start-up Settings: New access point remains after restoring factory setting ")); + TInt r; + TInt i; + + TheTest.Next(_L("Open repository to ensure server is running")); + CRepository* repository = CRepository::NewLC(KUidRfsRepository); + + TheTest.Next(_L("Create a new setting outside RFSable range meta area")); + const TInt KIntValue = 999; + r = repository->Create(KNewInt2, KIntValue); + TEST2(r, KErrNone); + + TheTest.Next(_L("Create a new setting in RFSable range meta area")); + r = repository->Create(KNewInt3, KIntValue); + TEST2(r, KErrNone); + + // Close repository + CleanupStack::PopAndDestroy(repository); + + TheTest.Next(_L("Kill the server process")); + _LIT( KCentralRepositoryServerName, "Centralrepositorysrv"); + r = KillProcess(KCentralRepositoryServerName); + TEST2(r,KErrNone); + + User::After(KGeneralDelay); + + TheTest.Next(_L("Manually start central respository")); + ReStartServerInSoftResetMode(); + + TheTest.Next(_L("Re-create the repository to ensure server is running")); + repository = CRepository::NewLC(KUidRfsRepository); + + TheTest.Next(_L("Get 'created' value outside range meta")); + r = repository->Get(KNewInt2, i); + TEST2(r, KErrNone); // should still exist + TEST(i == KIntValue); + + TheTest.Next(_L("Get 'created' value inside range meta")); + r = repository->Get(KNewInt3, i); + TEST2(r, KErrNotFound); // should have been deleted + + // Close repository + CleanupStack::PopAndDestroy(repository); + + repository = CRepository::NewLC(KUidRfsRepositoryDefaultRfsOn); + + TheTest.Next(_L("Create a new setting in RFSable default meta area")); + const TInt KIntValue2 = 990; + r = repository->Create(KNewInt2, KIntValue2); + TEST2(r, KErrNone); + + TheTest.Next(_L("Create a new setting in non-RFSable range meta area")); + r = repository->Create(KNewInt3, KIntValue2); + TEST2(r, KErrNone); + + // Close repository + CleanupStack::PopAndDestroy(repository); + + TheTest.Next(_L("Kill the server process")); + r = KillProcess(KCentralRepositoryServerName); + TEST2(r,KErrNone); + + User::After(KGeneralDelay); + + TheTest.Next(_L("Manually start central respository")); + ReStartServerInSoftResetMode(); + + TheTest.Next(_L("Re-create the repository to ensure server is running")); + repository = CRepository::NewLC(KUidRfsRepositoryDefaultRfsOn); + + TheTest.Next(_L("Get 'created' value outside range meta")); + r = repository->Get(KNewInt2, i); + TEST2(r, KErrNotFound); // should have been deleted + + TheTest.Next(_L("Get 'created' value inside range meta")); + r = repository->Get(KNewInt3, i); + TEST2(r, KErrNone); // should still exist + TEST(i == KIntValue2); + + // Close repository + CleanupStack::PopAndDestroy(repository); + + TheTest.End(); + } + +/** +@SYMTestCaseID PDS-CENTRALREPOSITORY-CT-4082 +@SYMTestCaseDesc Test for PDEF133672: Cannot remove restored access points +@SYMTestPriority High +@SYMTestActions Create a repository, delete settings with RFS meta and reset repository, + then try to delete the settings again. +@SYMTestExpectedResults When deleting settings after reset, KErrAlreadyExists should not return. +@SYMDEF PDEF133672 +*/ +LOCAL_C void PDEF133672L() + { + TheTest.Start(_L("Test for PDEF133671")); + + const TUid KReposUid = {0xCCCCCC99}; + + const TInt KTestId1 = {0x00000001}; + const TInt KTestId2 = {0x0000000A}; + + CRepository* repos=NULL; + + repos = CRepository::NewLC(KReposUid); + + User::LeaveIfNull(repos); + + TInt r; + + r = repos->Delete(KTestId1); + TEST2(r, KErrNone); + r = repos->Delete(KTestId2); + TEST2(r, KErrNone); + + TheTest.Next(_L("try reset single settings")); + r = repos->Reset(KTestId1); + TEST2(r, KErrNone); + r = repos->Reset(KTestId2); + TEST2(r, KErrNone); + + r = repos->Delete(KTestId1); + TEST2(r, KErrNone); + r = repos->Delete(KTestId2); + TEST2(r, KErrNone); + + TheTest.Next(_L("try reset whole repository")); + r = repos->Reset(); + + r = repos->Delete(KTestId1); + TEST2(r, KErrNone); + r = repos->Delete(KTestId2); + TEST2(r, KErrNone); + + CleanupStack::PopAndDestroy(); + + TheTest.End(); + } + +/** +@SYMTestCaseID SYSLIB-CENTRALREPOSITORY-CT-0497-0001 +@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-0001 Restore Factory Settings tests ")); + CleanupCDriveL(); + KillC32Exe(); //Need to kill C32Exe as it is interfering with the test. + RestoreFactorySettingsTestL(); + PDEF105203(); + RFSRomOnlyL(); + RFSRomAndInstallL(); + RFSInstallOnlyL(); + PDEF133672L(); + 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; + }