sl@0: // Copyright (c) 2004-2009 Nokia Corporation and/or its subsidiary(-ies). sl@0: // All rights reserved. sl@0: // This component and the accompanying materials are made available sl@0: // under the terms of "Eclipse Public License v1.0" sl@0: // which accompanies this distribution, and is available sl@0: // at the URL "http://www.eclipse.org/legal/epl-v10.html". sl@0: // sl@0: // Initial Contributors: sl@0: // Nokia Corporation - initial contribution. sl@0: // sl@0: // Contributors: sl@0: // sl@0: // Description: sl@0: // sl@0: sl@0: #include "t_cenrep_helper.h" sl@0: #include sl@0: #include sl@0: #include sl@0: #include sl@0: #include sl@0: #include sl@0: sl@0: #include "e32math.h" sl@0: #include "srvparams.h" sl@0: #include "srvreqs.h" sl@0: #include "srvdefs.h" sl@0: #include "transstate.h" sl@0: #include "obsrvr_noc.h" sl@0: #include "shrepos.h" sl@0: #include "install.h" sl@0: sl@0: using namespace NCentralRepositoryConstants; sl@0: sl@0: RTest TheTest(_L("Central Repository Defect Tests")); sl@0: sl@0: _LIT( KCentralRepositoryServerName, "Centralrepositorysrv"); sl@0: sl@0: const TUid KUidDEF060843LRepository1 = { 0x00000001 }; sl@0: const TUid KUidRep1 = { 0x00000100 }; sl@0: const TUid KUidDEF053500LTestRepository = { 0x00000102 }; sl@0: const TUid KUidDEF054368TestRepository = { 0x00000103 }; sl@0: const TUid KUidINC054688TestRepository = { 0x100058db }; sl@0: const TUid KUidDEF054632TestRepository = { 0x10054632 }; sl@0: const TUid KUidDEF054633TestRepository = { 0x10054633 }; sl@0: const TUid KUidLargeRepository = { 0xCCCCCC01 }; sl@0: const TUid KUidDEF055661TestRepository = { 0x10055661 }; sl@0: const TUid KUidINC056194TestRepository = { 0x00056194 }; sl@0: const TUid KUidDEF057778TestRepository = { 0x00057778 }; sl@0: const TUid KUidDEF057470TestRepository = { 0x10057470 }; sl@0: const TUid KUidDEF058900TestRepository = { 0x10058900 }; sl@0: const TUid KUidINC069013TestRepository = { 0x00000104 }; sl@0: const TUid KUidPDEF098500LRepository = { 0x10098500 }; sl@0: sl@0: const TUint32 KRangeDeletePartialKey = 0x04010000 ; sl@0: const TUint32 KDeleteKeyDoesntExist = 0x07000000 ; sl@0: const TUint32 KDeleteForbidden = 0x03010000 ; sl@0: const TUint32 KTransactionRangeDeletePartialKey = 0x02010000 ; sl@0: const TUint32 KRangeDeleteMask = 0x0F0F0000 ; sl@0: const TUint32 KNullKey = 0x00000000 ; sl@0: sl@0: const TUint32 KNotifyBannedKey = static_cast(KRequestPending) ; sl@0: const TUint32 KNotificationKey1 = 0x80000101; sl@0: const TUint32 KNotificationKey2 = 0x80000201; sl@0: const TUint32 KNotificationKey3 = 0x80000301; sl@0: const TUint32 KNotificationKey4 = 0x80000401; sl@0: sl@0: // sl@0: // Repository A sl@0: // sl@0: sl@0: const TUint32 KNewInt = 1000; sl@0: const TInt KIntValue = 1234; sl@0: sl@0: sl@0: // Definitions for test DEF116629L() sl@0: // The structure to construct a TServerSetting object with a TInt value. sl@0: struct ServerSettingStruct sl@0: { sl@0: TUint32 key; sl@0: TUint32 meta; sl@0: TInt value; sl@0: }; sl@0: // The merge types to be tested sl@0: const TMergeType KMergerTypes[] = {ETransactionMerge,ERestoreMerge, ESWIUpgradeMerge, ESWIDowngradeMerge, ERomFlash}; sl@0: sl@0: sl@0: /////////////////////////////////////////////////////////////////////////////////////// sl@0: /////////////////////////////////////////////////////////////////////////////////////// sl@0: //Test macroses and functions sl@0: LOCAL_C void CheckL(TInt aValue, TInt aLine) sl@0: { sl@0: if(!aValue) sl@0: { sl@0: CleanupCDriveL(); sl@0: TheTest(EFalse, aLine); sl@0: } sl@0: } sl@0: LOCAL_C void CheckL(TInt aValue, TInt aExpected, TInt aLine) sl@0: { sl@0: if(aValue != aExpected) sl@0: { sl@0: RDebug::Print(_L("*** Expected error: %d, got: %d\r\n"), aExpected, aValue); sl@0: CleanupCDriveL(); sl@0: TheTest(EFalse, aLine); sl@0: } sl@0: } sl@0: sl@0: #define TEST(arg) ::CheckL((arg), __LINE__) sl@0: #define TEST2(aValue, aExpected) ::CheckL(aValue, aExpected, __LINE__) sl@0: sl@0: /////////////////////////////////////////////////////////////////////////////////////// sl@0: /////////////////////////////////////////////////////////////////////////////////////// sl@0: sl@0: /** sl@0: @SYMTestCaseID SYSLIB-CENTRALREPOSITORY-CT-4015 sl@0: @SYMTestCaseDesc When having multiple connections to a particular repository, starting a sl@0: transaction and then killing that connection, should not cause a reset. sl@0: @SYMTestPriority High sl@0: @SYMTestActions sl@0: Essentially - this deals with multiple connections, the lack of cancelling a transaction, sl@0: either by shutting the sub-session to the CR server directly (or by a crashing application sl@0: where all open sub-sessions to CR from that application are closed) and the cache manager sl@0: inside CR. sl@0: sl@0: Previously, CR's cache manager would reclaim repository memory regardless of the state sl@0: of the repository (in transaction or not). However, if a repository is closed and its sl@0: no longer an open repository (cache manager reclaimed the memory), it would not remove sl@0: references to the sub-session for this repository in the transaction queue. Simply put, sl@0: the sub-session's data would be deleted but there would still be references to that sl@0: deleted data. When you established a new connection (any operation would cause this) you'd sl@0: walk down an invalid pointer. Most of the time this would cause the server to crash. sl@0: sl@0: Now, if you're in an active transaction, the cache manager does not reclaim the data. sl@0: Which means that there will always be valid references in the transaction queue. sl@0: sl@0: ThreadA CR CR Cache Manager sl@0: Connection 1. sl@0: CRepository::NewLC(X) ---------------> EInitialize sl@0: sl@0: Connection 2. sl@0: CRepository::NewLC(X) ---------------> EInitialize sl@0: sl@0: Connection 2, Start Transaction sl@0: StartTransaction ----------------> ETransactionStart sl@0: sl@0: Before sl@0: ---------------------------------------------------------------------------------- sl@0: Wait 10 seconds sl@0: sl@0: <--------------------------- Evict(X) sl@0: sl@0: Connection 2. Close sl@0: delete connection2 ------------------> EClose (would leave invalid references) sl@0: sl@0: Connection 1. sl@0: GetInt ------------------> EGetInt (would attach to repository, derefence sl@0: invalid pointer, CR would crash) sl@0: sl@0: ----------------------------------------------------------------------------------- sl@0: Now sl@0: sl@0: Wait 10 seconds sl@0: sl@0: Reschedule sl@0: (CR cache manager sees that Repository X sl@0: is in a transaction and just reschedules sl@0: it) sl@0: Connection 2. Close sl@0: delete connection2 --------------------> EClose (memory is now available so it cancels sl@0: the active transaction) sl@0: sl@0: GetInt --------------------> EGetInt (attaches to the open repository, all is sl@0: fine) sl@0: delete connection2 --------------------> EClose (repository X has no more observers so sl@0: it is scheduled to have its memory reclaimed sl@0: by CR cache manager) sl@0: sl@0: @SYMTestExpectedResults The test must not fail. sl@0: @SYMDEF DEF111734 sl@0: */ sl@0: sl@0: LOCAL_C void DEF111734L() sl@0: { sl@0: /* first establish a connection. this is important because if there are no observers sl@0: * on a repository, the repository's shared data is deleted directly */ sl@0: CRepository* rep; sl@0: User::LeaveIfNull(rep = CRepository::NewLC(KUidDEF054368TestRepository)); sl@0: sl@0: /* second establish a second connection. this will be used to start a transaction */ sl@0: CRepository* rep2; sl@0: User::LeaveIfNull(rep2 = CRepository::NewLC(KUidDEF054368TestRepository)); sl@0: sl@0: /* establish a transaction, this manipulates the transaction queue for this repository */ sl@0: rep2->StartTransaction(CRepository::EConcurrentReadWriteTransaction); sl@0: sl@0: /* now wait. this should be plenty of time to allow cache manager in CR to reclaim sl@0: * the data for this repository */ sl@0: User::After(5050000 + 9500000); sl@0: sl@0: TInt i = 0; sl@0: const TInt KInt1_InitialValue = 100; sl@0: const TUint32 KInt1 = 0x1; sl@0: sl@0: /* destory the connection - this will cause a "close" operation in CR */ sl@0: CleanupStack::PopAndDestroy(rep2); sl@0: sl@0: /* attempt to reconnect to the repository. */ sl@0: TInt r = rep->Get(KInt1, i); sl@0: sl@0: /* if the fix is not in the build, then CR will crash. sl@0: * Errcode will be KErrServerTerminated */ sl@0: TEST2(r, KErrNone); sl@0: sl@0: /* just for completion's sake, check the return value */ sl@0: TEST(i == KInt1_InitialValue); sl@0: sl@0: // Close repository sl@0: sl@0: CleanupStack::PopAndDestroy(rep); sl@0: } sl@0: sl@0: sl@0: LOCAL_C void DEF053500L() sl@0: { sl@0: CRepository* rep; sl@0: // Open repository with hex key value setting sl@0: User::LeaveIfNull(rep = CRepository::NewLC(KUidDEF053500LTestRepository)); sl@0: // Close repository sl@0: CleanupStack::PopAndDestroy(rep); sl@0: } sl@0: sl@0: LOCAL_C void DEF054368L() sl@0: { sl@0: CRepository* rep; sl@0: User::LeaveIfNull(rep = CRepository::NewLC(KUidDEF054368TestRepository)); sl@0: sl@0: TInt i = 0; sl@0: const TInt KInt1_InitialValue = 100; sl@0: const TInt KInt2_InitialValue = 200; sl@0: const TInt KInt3_InitialValue = -100; sl@0: const TInt KInt4_InitialValue = -200; sl@0: const TInt KInt5_InitialValue = 0xc8; sl@0: sl@0: const TUint32 KInt1 = 0x1; sl@0: const TUint32 KInt2 = 0x2; sl@0: const TUint32 KInt3 = 0x3; sl@0: const TUint32 KInt4 = 0x4; sl@0: const TUint32 KInt5 = 0x5; sl@0: sl@0: TInt r = rep->Get(KInt1, i); sl@0: TEST2(r, KErrNone); sl@0: TEST(i==KInt1_InitialValue); sl@0: sl@0: r = rep->Get(KInt2, i); sl@0: TEST2(r, KErrNone); sl@0: TEST(i==KInt2_InitialValue); sl@0: sl@0: r = rep->Get(KInt3, i); sl@0: TEST2(r, KErrNone); sl@0: TEST(i==KInt3_InitialValue); sl@0: sl@0: r = rep->Get(KInt4, i); sl@0: TEST2(r, KErrNone); sl@0: TEST(i==KInt4_InitialValue); sl@0: sl@0: r = rep->Get(KInt5, i); sl@0: TEST2(r, KErrNone); sl@0: TEST(i==KInt5_InitialValue); sl@0: sl@0: // Close repository sl@0: CleanupStack::PopAndDestroy(rep); sl@0: } sl@0: sl@0: LOCAL_C void DEF055680L() sl@0: { sl@0: CRepository* rep; sl@0: // Open repository sl@0: User::LeaveIfNull(rep = CRepository::NewLC(KUidLargeRepository)); sl@0: sl@0: // Find setting whose value the test doesn't have permission to look at sl@0: RArray foundIds; sl@0: TInt r = KErrNone; sl@0: r = rep->FindL(0x810100, 0xFFFFFFFF, foundIds); sl@0: TEST2(r, KErrNone); sl@0: TEST2(foundIds.Count(), 1); sl@0: sl@0: TInt val; sl@0: r = rep->Get(foundIds[0], val); sl@0: TEST2(r, KErrPermissionDenied); sl@0: foundIds.Reset(); sl@0: sl@0: r = rep->Create(KNewInt, KIntValue); sl@0: TEST2(r, KErrNone); sl@0: sl@0: //Reset repository to remove any changes made during this test sl@0: r = rep->Reset(); sl@0: TEST2(r, KErrNone); sl@0: sl@0: // Close repository sl@0: CleanupStack::PopAndDestroy(rep); sl@0: sl@0: } sl@0: sl@0: LOCAL_C void DEF054632L() sl@0: { sl@0: CRepository* rep; sl@0: sl@0: //----------Testing for correct default policy behaviour--------------- sl@0: /*---------------------10054632.txt------------------------------------ sl@0: [platsec] sl@0: cap_rd=ReadDeviceData cap_wr=WriteDeviceData sl@0: 0x3 0x4 cap_wr=NetworkServices sl@0: [Main] sl@0: 0x1 int 1 0 cap_rd=CommDD sl@0: 0x2 int 2 1 cap_wr=CommDD sl@0: 0x3 int 3 0 sl@0: 0x4 int 4 0 sl@0: 0x5 int 5 0 cap_rd=CommDD sl@0: ---------------------------------------------------------------------*/ sl@0: User::LeaveIfNull(rep = CRepository::NewLC(KUidDEF054632TestRepository)); sl@0: sl@0: //testing single policies sl@0: TInt err=KErrNone; sl@0: const TInt key_2=2; sl@0: const TInt key_1=1; sl@0: TInt value=0; sl@0: sl@0: err=rep->Get(key_2,value); sl@0: TEST2(err,KErrNone); sl@0: sl@0: err=rep->Set(key_1,value); sl@0: TEST2(err,KErrNone); sl@0: sl@0: //testing range policies sl@0: const TInt key_3=3; sl@0: err=rep->Get(key_3,value); sl@0: TEST2(err,KErrNone); sl@0: sl@0: CleanupStack::PopAndDestroy(rep); sl@0: sl@0: //------Testing for correct policy behaviour with no default policies----- sl@0: /*--------------------------10054633.txt---------------------------------- sl@0: [platsec] sl@0: 0x3 0x4 cap_rd=CommDD sl@0: [Main] sl@0: 0x1 int 1 0 cap_rd=CommDD sl@0: 0x2 int 2 1 cap_wr=CommDD sl@0: 0x3 int 3 0 sl@0: 0x4 int 4 0 sl@0: ------------------------------------------------------------------------*/ sl@0: User::LeaveIfNull(rep=CRepository::NewLC(KUidDEF054633TestRepository)); sl@0: sl@0: //testing single policies sl@0: err=rep->Get(key_1,value); sl@0: TEST2(err,KErrPermissionDenied); sl@0: err=rep->Set(key_1,value); sl@0: TEST2(err,KErrPermissionDenied); sl@0: sl@0: err=rep->Set(key_2,value); sl@0: TEST2(err,KErrPermissionDenied); sl@0: err=rep->Get(key_2,value); sl@0: TEST2(err,KErrPermissionDenied); sl@0: sl@0: //testing range policies sl@0: err=rep->Get(key_3,value); sl@0: TEST2(err,KErrPermissionDenied); sl@0: const TInt key_4=4; sl@0: err=rep->Set(key_4,value); sl@0: TEST2(err,KErrPermissionDenied); sl@0: err=rep->Get(key_4,value); sl@0: TEST2(err,KErrPermissionDenied); sl@0: sl@0: CleanupStack::PopAndDestroy(rep); sl@0: } sl@0: sl@0: /** sl@0: This test will be checking the robustness of the modified array structure sl@0: for the single policies, range policies. sl@0: */ sl@0: LOCAL_C void INC054688L() sl@0: { sl@0: CRepository* rep; sl@0: User::LeaveIfNull(rep = CRepository::NewLC(KUidINC054688TestRepository)); sl@0: sl@0: //--------------CHECKING THE SINGLE POLICIES ARRAY---------------------- sl@0: //The ini file has been structured so that the key will be equal to the sl@0: //key value so we can test it using a loop. sl@0: //and also to check some policy checking, we set all the even entries to sl@0: //be non accessible due to insufficient capabilities sl@0: //The key tested for the single policies are from 1 to 24 sl@0: const TInt KMaxKeyEntry=24; sl@0: TInt err=KErrNone; sl@0: TInt key_value=0; sl@0: for (TInt i=1;i<=KMaxKeyEntry;i++) sl@0: { sl@0: err=rep->Get(i,key_value); sl@0: //even entries alway not accessible due to insufficient caps sl@0: if (i%2==0) sl@0: TEST2(err,KErrPermissionDenied); sl@0: else sl@0: { sl@0: TEST2(err,KErrNone); sl@0: TEST2(i,key_value); sl@0: } sl@0: } sl@0: sl@0: //--------------CHECKING THE RANGE POLICIES ARRAY---------------------- sl@0: //The range policies in the [platsec] section are arranged in key pairs sl@0: //e.g 25-26,27-28.For testing purpose, the odd pairs(e.g 25-26 is the sl@0: //first pair) will require capabilities that the test lacks off hence sl@0: //causing KErrPermissionDenied when trying to read those range. sl@0: //The key tested for the arary policies are from 25-38 and the value sl@0: //matches the key sl@0: sl@0: const TInt startRangeKey=25; sl@0: const TInt KMaxRangeKey=38; sl@0: TInt numberOfPairs=(KMaxRangeKey-startRangeKey+1)/2; sl@0: TInt key_value1=0; sl@0: TInt err1=KErrNone; sl@0: for (TInt j=0;jGet(startRangeKey+(2*j),key_value); sl@0: //Get second key of the pair sl@0: err1=rep->Get(startRangeKey+(2*j)+1,key_value1); sl@0: //start from j=0(first pair) sl@0: if ((j+1)%2==0) sl@0: { sl@0: TEST2(err,KErrNone); sl@0: TEST2(err1,KErrNone); sl@0: TEST2(startRangeKey+(2*j),key_value); sl@0: TEST2(startRangeKey+(2*j)+1,key_value1); sl@0: } sl@0: //only odd pairs are non-accessible due to insufficient caps sl@0: else sl@0: { sl@0: TEST2(err,KErrPermissionDenied); sl@0: TEST2(err1,KErrPermissionDenied); sl@0: } sl@0: } sl@0: sl@0: //Before closing the repository, modify one of the key to see whether sl@0: //the policy array behaves similarly after a rewrite of the ini file sl@0: const TInt keyToChange=3; sl@0: const TInt modifiedValue=3; sl@0: err=rep->Set(keyToChange,modifiedValue); sl@0: TEST2(err,KErrNone); sl@0: sl@0: // Close repository sl@0: CleanupStack::PopAndDestroy(rep); sl@0: User::After(KGeneralDelay); sl@0: sl@0: //Reopen the repository again after that minor update which will cause sl@0: //all the entry in the ini file to be reversed sl@0: User::LeaveIfNull(rep = CRepository::NewLC(KUidINC054688TestRepository)); sl@0: sl@0: //---------RECHECKING THE POLICY ARRAY AFTER UPDATE-------------------- sl@0: for (TInt i=1;i<=KMaxKeyEntry;i++) sl@0: { sl@0: err=rep->Get(i,key_value); sl@0: //even entries alway not accessible due to insufficient caps sl@0: if (i%2==0) sl@0: TEST2(err,KErrPermissionDenied); sl@0: else sl@0: { sl@0: TEST2(err,KErrNone); sl@0: TEST2(i,key_value); sl@0: } sl@0: } sl@0: sl@0: sl@0: //---------RECHECKING THE RANGE POLICY ARRAY AFTER UPDATE------------- sl@0: for (TInt j=0;jGet(startRangeKey+(2*j),key_value); sl@0: //Get second key of the pair sl@0: err1=rep->Get(startRangeKey+(2*j)+1,key_value1); sl@0: //start from j=0(first pair) sl@0: if ((j+1)%2==0) sl@0: { sl@0: TEST2(err,KErrNone); sl@0: TEST2(err1,KErrNone); sl@0: TEST2(startRangeKey+(2*j),key_value); sl@0: TEST2(startRangeKey+(2*j)+1,key_value1); sl@0: } sl@0: //only odd pairs are non-accessible due to insufficient caps sl@0: else sl@0: { sl@0: TEST2(err,KErrPermissionDenied); sl@0: TEST2(err1,KErrPermissionDenied); sl@0: } sl@0: } sl@0: sl@0: CleanupStack::PopAndDestroy(rep); sl@0: } sl@0: sl@0: LOCAL_C void DEF055661L() sl@0: { sl@0: /*--------------------10055661.txt---------------------------------------- sl@0: [platsec] sl@0: cap_rd=ReadDeviceData cap_wr=AlwaysFail sl@0: 0x3 0x4 cap_wr=NetworkServices sl@0: [Main] sl@0: 0x1 int 1 0 cap_rd=AlwaysPass sl@0: 0x2 int 2 1 cap_rd=AlwaysFail sl@0: 0x3 int 3 0 sl@0: 0x4 int 4 0 cap_rd=AlwaysFail sl@0: 0x5 int 5 0 cap_wr=AlwaysPass sl@0: -------------------------------------------------------------------------*/ sl@0: CRepository* rep; sl@0: User::LeaveIfNull(rep = CRepository::NewLC(KUidDEF055661TestRepository)); sl@0: sl@0: TInt err=KErrNone; sl@0: TInt keyValue=0; sl@0: sl@0: //Key 1 sl@0: err=rep->Get(1,keyValue); sl@0: TEST2(err,KErrNone); sl@0: TEST2(keyValue,1); sl@0: err=rep->Set(1,keyValue); sl@0: TEST2(err,KErrPermissionDenied); sl@0: sl@0: //Key 2 sl@0: err=rep->Get(2,keyValue); sl@0: TEST2(err,KErrPermissionDenied); sl@0: err=rep->Set(2,keyValue); sl@0: TEST2(err,KErrPermissionDenied); sl@0: sl@0: //Key 3 sl@0: err=rep->Get(3,keyValue); sl@0: TEST2(err,KErrNone); sl@0: TEST2(keyValue,3); sl@0: err=rep->Set(3,keyValue); sl@0: TEST2(err,KErrPermissionDenied); sl@0: sl@0: //Key 4 sl@0: err=rep->Get(4,keyValue); sl@0: TEST2(err,KErrPermissionDenied); sl@0: err=rep->Set(4,keyValue); sl@0: TEST2(err,KErrPermissionDenied); sl@0: sl@0: //Key 5 sl@0: err=rep->Get(5,keyValue); sl@0: TEST2(err,KErrNone); sl@0: err=rep->Set(5,keyValue); sl@0: TEST2(err,KErrNone); sl@0: sl@0: CleanupStack::PopAndDestroy(rep); sl@0: } sl@0: sl@0: LOCAL_C void DEF055267L() sl@0: { sl@0: CRepository* rep; sl@0: // Open repository sl@0: User::LeaveIfNull(rep = CRepository::NewLC(KUidLargeRepository)); sl@0: sl@0: TInt r; sl@0: TUint32 errorId; sl@0: // The following loop creates enough settings to blow the server heap sl@0: // when it's 1 M. If it passes it proves that the server heap is > 1M sl@0: // Increasing the server heap allows the messaging test to pass sl@0: _LIT(KString, "Long test string !!!!!!!!!!!"); sl@0: const TInt KNumTransactions=25; sl@0: const TInt KNumSettingsInTrans=100; sl@0: for(TInt numTransactions=0; numTransactionsStartTransaction(CRepository::EReadWriteTransaction); sl@0: TEST2(r, KErrNone); sl@0: for(TInt numSettingsInTrans=0; numSettingsInTransCreate((numTransactions*KNumSettingsInTrans)+numSettingsInTrans, KString); sl@0: TEST2(r, KErrNone); sl@0: } sl@0: r = rep->CommitTransaction(errorId); sl@0: TEST2(r, KErrNone); sl@0: } sl@0: sl@0: //Reset repository to remove any changes made during this test sl@0: r = rep->Reset(); sl@0: TEST2(r, KErrNone); sl@0: sl@0: // Close repository sl@0: CleanupStack::PopAndDestroy(rep); sl@0: } sl@0: sl@0: LOCAL_C void INC056194L() sl@0: { sl@0: CRepository* repository; sl@0: // Open repository sl@0: User::LeaveIfNull(repository = CRepository::NewLC(KUidINC056194TestRepository)); sl@0: sl@0: const TUint32 KInt1 = 1; sl@0: TRequestStatus intStatus; sl@0: sl@0: TInt r = repository->NotifyRequest(KInt1, intStatus); sl@0: TEST2(r, KErrNone); sl@0: r = repository->NotifyCancel(KInt1); sl@0: TEST2(r, KErrNone); sl@0: User::WaitForAnyRequest(); sl@0: TEST(intStatus==KUnspecifiedKey); sl@0: sl@0: r = repository->NotifyRequest(KInt1, intStatus); sl@0: TEST2(r, KErrNone); sl@0: r = repository->NotifyCancelAll(); sl@0: TEST2(r, KErrNone); sl@0: User::WaitForAnyRequest(); sl@0: TEST(intStatus==KUnspecifiedKey); sl@0: sl@0: r = repository->NotifyRequest(0, KInt1, intStatus); sl@0: TEST2(r, KErrNone); sl@0: r = repository->NotifyCancel(0, KInt1); sl@0: TEST2(r, KErrNone); sl@0: User::WaitForAnyRequest(); sl@0: TEST(intStatus==KUnspecifiedKey); sl@0: sl@0: RThread thisThread; sl@0: TEST(thisThread.RequestCount()==0); sl@0: sl@0: // Close repository sl@0: CleanupStack::PopAndDestroy(repository); sl@0: } sl@0: sl@0: LOCAL_C void DEF057145L() sl@0: { sl@0: TInt err=KErrNone; sl@0: const TUid testUid={0x10057145}; sl@0: RArray idArray; sl@0: CRepository* repository; sl@0: User::LeaveIfNull(repository = CRepository::NewLC(testUid)); sl@0: sl@0: //Start Transaction sl@0: err=repository->StartTransaction(CRepository::EReadWriteTransaction); sl@0: TEST2(err,KErrNone); sl@0: sl@0: //Before creating new entries get the number of persistent settings sl@0: err=repository->FindL(0,0xFFFFF000,idArray); sl@0: TEST2(err,KErrNone); sl@0: TInt persistentSettingsCount=idArray.Count(); sl@0: idArray.Close(); sl@0: sl@0: //Try creating new entries during transaction between the two extreme points sl@0: //ROM persistent file has low key of 1 and high key of 201 sl@0: //We try creating new entries in between during transaction sl@0: for (TInt i=100;i<150;i++) sl@0: { sl@0: err=repository->Create(i,i); sl@0: TEST2(err,KErrNone); sl@0: } sl@0: sl@0: //Now check the merge with the persistent settings is fine by checking sl@0: //the array count after the merge. sl@0: err=repository->FindL(0x000,0xFFFFF000,idArray); sl@0: TEST2(err,KErrNone); sl@0: TEST(idArray.Count()==(persistentSettingsCount+50)); sl@0: idArray.Close(); sl@0: sl@0: TUint32 errId; sl@0: err=repository->CommitTransaction(errId); sl@0: TEST2(err,KErrNone); sl@0: sl@0: idArray.Close(); sl@0: CleanupStack::PopAndDestroy(repository); sl@0: } sl@0: sl@0: sl@0: LOCAL_C void DEF057778L() sl@0: { sl@0: TInt r; sl@0: CRepository* repository; sl@0: // Open repository sl@0: User::LeaveIfNull(repository = CRepository::NewLC(KUidDEF057778TestRepository)); sl@0: sl@0: const TUint32 KInt14=14; sl@0: const TInt KInt14NewValue=0; sl@0: sl@0: r=repository->Set(KInt14,KInt14NewValue); sl@0: TEST2(r, KErrNone); sl@0: sl@0: // Reset setting that has a single policy sl@0: r=repository->Reset(KInt14); sl@0: TEST2(r, KErrNone); sl@0: sl@0: // Attempt to access and write setting sl@0: r=repository->Set(KInt14,KInt14NewValue); sl@0: TEST2(r, KErrNone); sl@0: sl@0: // Reset entire repository sl@0: r=repository->Reset(); sl@0: TEST2(r, KErrNone); sl@0: sl@0: // Attempt to access and write setting sl@0: r=repository->Set(KInt14,KInt14NewValue); sl@0: TEST2(r, KErrNone); sl@0: sl@0: // Reset entire repository sl@0: r=repository->Reset(); sl@0: TEST2(r, KErrNone); sl@0: sl@0: // Close repository sl@0: CleanupStack::PopAndDestroy(repository); sl@0: } sl@0: sl@0: sl@0: LOCAL_C void DEF057999L() sl@0: { sl@0: sl@0: TInt err=KErrNone; sl@0: TInt retValue=0; sl@0: const TUid testUid={0x10057145}; sl@0: RArray idArray; sl@0: sl@0: CRepository* repository; sl@0: User::LeaveIfNull(repository = CRepository::NewLC(testUid)); sl@0: sl@0: //--------------Start Transaction------------------------------------ sl@0: err=repository->StartTransaction(CRepository::EReadWriteTransaction); sl@0: TEST2(err,KErrNone); sl@0: sl@0: //--------------Create follow by delete----------------------------- sl@0: err=repository->Create(3400,3400); sl@0: TEST2(err,KErrNone); sl@0: err=repository->Delete(3400); sl@0: TEST2(err,KErrNone); sl@0: err=repository->Delete(3400); sl@0: TEST2(err,KErrNotFound); sl@0: sl@0: //--------------Deleting existing romkey----------------------------- sl@0: err=repository->Delete(200); sl@0: TEST2(err,KErrNone); sl@0: sl@0: err=repository->FindL(200,0xFFFFFFFF,idArray); sl@0: TEST2(err,KErrNotFound); sl@0: sl@0: //--------------Commit Transaction------------------------------------ sl@0: TUint32 errId; sl@0: err=repository->CommitTransaction(errId); sl@0: TEST2(err,KErrNone); sl@0: sl@0: idArray.Close(); sl@0: CleanupStack::PopAndDestroy(repository); sl@0: sl@0: //--------------Reopen and check the deleted keys are gone------------- sl@0: User::LeaveIfNull(repository = CRepository::NewLC(testUid)); sl@0: sl@0: //Check for the key created and deleted during transaction sl@0: err=repository->FindL(3400,0xFFFFFFFF,idArray); sl@0: TEST2(err,KErrNotFound); sl@0: sl@0: //Check for the rom key deleted during transaction sl@0: err=repository->Get(200,retValue); sl@0: TEST2(err,KErrNotFound); sl@0: sl@0: //--------------Start Transaction------------------------------------ sl@0: err=repository->StartTransaction(CRepository::EReadWriteTransaction); sl@0: TEST2(err,KErrNone); sl@0: sl@0: //--------------Delete follow by create----------------------------- sl@0: err=repository->Delete(201); sl@0: TEST2(err,KErrNone); sl@0: err=repository->Create(201, 201); sl@0: TEST2(err,KErrNone); sl@0: sl@0: //--------------Commit Transaction------------------------------------ sl@0: err=repository->CommitTransaction(errId); sl@0: TEST2(err,KErrNone); sl@0: sl@0: err=repository->Get(201,retValue); sl@0: TEST2(err,KErrNone); sl@0: TEST2(retValue, 201); sl@0: sl@0: CleanupStack::PopAndDestroy(repository); sl@0: } sl@0: sl@0: LOCAL_C void DEF057522L() sl@0: { sl@0: TInt r=KErrNone; sl@0: CRepository* repository; sl@0: TUid testUidRepository={0x10057522}; sl@0: sl@0: //Opening a repository with Max number of capabilities supported should not return KErrCorrupt sl@0: User::LeaveIfNull(repository = CRepository::NewLC(testUidRepository)); sl@0: sl@0: //Test reading some of the settings with the max capabilities defined sl@0: TInt retVal=0; sl@0: r=repository->Get(17,retVal); sl@0: TEST2(r,KErrNone); sl@0: r=repository->Set(17,retVal); sl@0: TEST2(r,KErrNone); sl@0: sl@0: r=repository->Get(18,retVal); sl@0: TEST2(r,KErrPermissionDenied); sl@0: r=repository->Set(18,retVal); sl@0: TEST2(r,KErrNone); sl@0: sl@0: //Test that AlwaysPass and AlwaysFail behave as expected when not followed by sid sl@0: r=repository->Get(21,retVal); sl@0: TEST2(r,KErrPermissionDenied); sl@0: r=repository->Set(21,retVal); sl@0: TEST2(r,KErrPermissionDenied); sl@0: r=repository->Get(22,retVal); sl@0: TEST2(r,KErrNone); sl@0: r=repository->Set(22,retVal); sl@0: TEST2(r,KErrNone); sl@0: sl@0: sl@0: //Test that AlwaysPass and AlwaysFail behave as expected when followed by sid sl@0: r=repository->Get(19,retVal); sl@0: TEST2(r,KErrPermissionDenied); sl@0: r=repository->Set(19,retVal); sl@0: TEST2(r,KErrNone); sl@0: sl@0: //Additional test cases sl@0: //Test single policies with max 3 caps for both read and write sl@0: r=repository->Get(28,retVal); sl@0: TEST2(r,KErrPermissionDenied); sl@0: r=repository->Set(28,retVal); sl@0: TEST2(r,KErrNone); sl@0: sl@0: //Test single policies with max 7 caps for both read and write sl@0: r=repository->Get(33,retVal); sl@0: TEST2(r,KErrPermissionDenied); sl@0: r=repository->Set(33,retVal); sl@0: TEST2(r,KErrPermissionDenied); sl@0: sl@0: //Test range policies with max 3 caps when followed by sid sl@0: r=repository->Get(201,retVal); sl@0: TEST2(r,KErrPermissionDenied); sl@0: r=repository->Set(201,retVal); sl@0: TEST2(r,KErrNone); sl@0: sl@0: //Test range policies with max 7 caps not with sid sl@0: r=repository->Get(300,retVal); sl@0: TEST2(r,KErrPermissionDenied); sl@0: r=repository->Set(300,retVal); sl@0: TEST2(r,KErrPermissionDenied); sl@0: sl@0: //Test behaviour when single policies are specified with just sid sl@0: r=repository->Get(400,retVal); sl@0: TEST2(r,KErrNone); sl@0: r=repository->Set(400,retVal); sl@0: TEST2(r,KErrPermissionDenied); // default read cap for sid 0 is AlwaysFail sl@0: sl@0: r=repository->Get(401,retVal); sl@0: TEST2(r,KErrNone); // default write cap for sid 0 is AlwaysPass sl@0: r=repository->Set(401,retVal); sl@0: TEST2(r,KErrNone); sl@0: sl@0: //Test that default policies are picked up when no policies are specified sl@0: r=repository->Get(500,retVal); sl@0: TEST2(r,KErrNone); sl@0: sl@0: r=repository->Set(500,retVal); sl@0: TEST2(r,KErrPermissionDenied); sl@0: sl@0: CleanupStack::PopAndDestroy(repository); sl@0: } sl@0: sl@0: LOCAL_C void DEF057470L() sl@0: { sl@0: sl@0: TInt r=KErrNone; sl@0: TUint32 errId=0; sl@0: CRepository* repository; sl@0: sl@0: User::LeaveIfNull(repository = CRepository::NewLC(KUidDEF057470TestRepository)); sl@0: sl@0: //-------------- 1. Simple Range Delete Operation----------------------------- sl@0: // Confirm that keys exist sl@0: RArray foundIds; sl@0: r = repository->FindL(KRangeDeletePartialKey, KRangeDeleteMask, foundIds); sl@0: TEST2(r, KErrNone); sl@0: TEST(foundIds.Count()==5); sl@0: foundIds.Reset(); sl@0: // Delete a set of keys sl@0: r = repository->Delete(KRangeDeletePartialKey, KRangeDeleteMask, errId) ; sl@0: TEST2(r, KErrNone); sl@0: // Confirm that deleted keys do not exist sl@0: r = repository->FindL(KRangeDeletePartialKey, KRangeDeleteMask, foundIds); sl@0: TEST2(r, KErrNotFound); sl@0: TEST(foundIds.Count()==0); sl@0: foundIds.Reset(); sl@0: CleanupStack::PopAndDestroy(repository); sl@0: // Try to find keys again just to double check whether the changes have persisted sl@0: User::LeaveIfNull(repository = CRepository::NewLC(KUidDEF057470TestRepository)); sl@0: r = repository->FindL(KRangeDeletePartialKey, KRangeDeleteMask, foundIds); sl@0: TEST2(r, KErrNotFound); sl@0: TEST(foundIds.Count()==0); sl@0: foundIds.Reset(); sl@0: sl@0: sl@0: //--------------- 2. Range Delete Operation where keys don't exist-------------- sl@0: // Confirm that keys don't exist. sl@0: r = repository->FindL(KDeleteKeyDoesntExist, KRangeDeleteMask, foundIds); sl@0: TEST2(r, KErrNotFound); sl@0: TEST(foundIds.Count()==0); sl@0: foundIds.Reset(); sl@0: // Attempt delete and check result sl@0: r = repository->Delete(KDeleteKeyDoesntExist, KRangeDeleteMask, errId) ; sl@0: TEST2(r, KErrNotFound); sl@0: errId &= KRangeDeleteMask ; sl@0: TEST2(errId, KDeleteKeyDoesntExist) ; sl@0: sl@0: sl@0: //-------3. Range Delete Operation where client doesn't have write capabilities for key range.---- sl@0: // Attempt delete and check result sl@0: r = repository->Delete(KDeleteForbidden, KRangeDeleteMask, errId) ; sl@0: TEST2(r, KErrPermissionDenied); sl@0: errId &= KRangeDeleteMask ; sl@0: TEST2(errId, KDeleteForbidden) ; sl@0: // Close repository sl@0: CleanupStack::PopAndDestroy(repository); sl@0: sl@0: //------ 4. Range Delete Operation which deletes all the keys and Resets the entire repository back its original state. sl@0: TInt numberOfIds; sl@0: User::LeaveIfNull(repository = CRepository::NewLC(KUidLargeRepository)); sl@0: // Find how many keys are originally present sl@0: r = repository->FindL(KNullKey, KNullKey, foundIds); sl@0: TEST2(r, KErrNone); sl@0: numberOfIds = foundIds.Count(); sl@0: TEST(foundIds.Count()!=0); sl@0: foundIds.Reset(); sl@0: // Range delete all the keys in the repository sl@0: r = repository->Delete(KNullKey, KNullKey, errId); sl@0: TEST2(r, KErrNone); sl@0: // Check all the keys have been deleted from cache sl@0: r = repository->FindL(KNullKey, KNullKey, foundIds); sl@0: TEST2(r, KErrNotFound); sl@0: TEST(foundIds.Count()==0); sl@0: foundIds.Reset(); sl@0: // Close and re-open the repository to check if the deleted keys have persisted. sl@0: CleanupStack::PopAndDestroy(repository); sl@0: // Existance of caching functionality invalidates some tests and sl@0: // makes them fail, so kill the server to force clearing the cache sl@0: r = KillProcess(KCentralRepositoryServerName); sl@0: TEST2(r,KErrNone); sl@0: User::LeaveIfNull(repository = CRepository::NewLC(KUidLargeRepository)); sl@0: // Check all the deleted keys have persisted. sl@0: r = repository->FindL(KNullKey, KNullKey, foundIds); sl@0: TEST2(r, KErrNotFound); sl@0: TEST(foundIds.Count()==0); sl@0: foundIds.Reset(); sl@0: // Reset repository back to its original state from ROM sl@0: r = repository->Reset(); sl@0: TEST2(r, KErrNone); sl@0: // Check that number of keys is same as when we started. sl@0: r = repository->FindL(KNullKey, KNullKey, foundIds); sl@0: TEST2(r, KErrNone); sl@0: TEST(foundIds.Count()==numberOfIds); sl@0: foundIds.Reset(); sl@0: // Close the repository sl@0: CleanupStack::PopAndDestroy(repository); sl@0: sl@0: //**********************Delete Range within Transacrions********************** sl@0: //--------- 5. Range Delete within a transaction where key's don't exist.------------ sl@0: User::LeaveIfNull(repository = CRepository::NewLC(KUidDEF057470TestRepository)); sl@0: // Begin read write transaction. sl@0: r = repository->StartTransaction(CRepository::EReadWriteTransaction); sl@0: TEST2(r, KErrNone); sl@0: r = TransactionState(repository); sl@0: TEST2(r, EReadWriteTransaction); sl@0: r = repository->Delete(KDeleteKeyDoesntExist, KRangeDeleteMask, errId) ; sl@0: TEST2(r, KErrNotFound); sl@0: // Check that transaction hasn't failed. sl@0: r = TransactionState(repository); sl@0: TEST2(r, EReadWriteTransaction); sl@0: // Fail transaction. sl@0: repository->FailTransaction(); sl@0: r = TransactionState(repository); sl@0: TEST2(r, EReadWriteTransaction | EFailedBit); sl@0: repository->RollbackTransaction(); sl@0: r = TransactionState(repository); sl@0: TEST2(r, ENoTransaction); sl@0: sl@0: sl@0: //---------- 6. Range delete within a transaction where client doesn't have capabilities to write to key range. sl@0: // Begin read write transaction. sl@0: r = repository->StartTransaction(CRepository::EReadWriteTransaction); sl@0: TEST2(r, KErrNone); sl@0: r = repository->Delete(KDeleteForbidden, KRangeDeleteMask, errId) ; sl@0: TEST2(r, KErrPermissionDenied); sl@0: errId &= KRangeDeleteMask ; sl@0: TEST2(errId, KDeleteForbidden) ; sl@0: // check that transaction has failed. sl@0: r = TransactionState(repository); sl@0: TEST2(r, EReadWriteTransaction | EFailedBit); sl@0: // Rollback the failed transaction. sl@0: repository->RollbackTransaction(); sl@0: r = TransactionState(repository); sl@0: TEST2(r, ENoTransaction); sl@0: sl@0: sl@0: //---------- 7. Range delete while not in transaction fails other session's transaction with KErrLocked. sl@0: // Open another repository sl@0: CRepository* repository2; sl@0: User::LeaveIfNull(repository2 = CRepository::NewLC(KUidDEF057470TestRepository)); sl@0: // Begin read write transaction sl@0: r = repository->StartTransaction(CRepository::EReadWriteTransaction); sl@0: TEST2(r, KErrNone); sl@0: r = TransactionState(repository); sl@0: TEST2(r, EReadWriteTransaction); sl@0: // Delete keys in the first session. sl@0: r = repository->Delete(KTransactionRangeDeletePartialKey, KRangeDeleteMask, errId) ; sl@0: TEST2(r, KErrNone); sl@0: // Delete keys in the second session. sl@0: r = repository2->Delete(KTransactionRangeDeletePartialKey, KRangeDeleteMask, errId) ; sl@0: TEST2(r, KErrNone); sl@0: // first session's transaction should have failed with KErrLocked sl@0: TInt state = TransactionState(repository); sl@0: TEST2(state, EReadWriteTransaction | EFailedBit); sl@0: // Commit transaction should report failure reason: sl@0: TUint32 keyInfo; sl@0: r = repository->CommitTransaction(keyInfo); sl@0: TEST2(r, KErrLocked); sl@0: TEST(keyInfo == KUnspecifiedKey); sl@0: r = TransactionState(repository); sl@0: TEST2(r, ENoTransaction); sl@0: // Close the repositories sl@0: CleanupStack::PopAndDestroy(repository2); sl@0: sl@0: sl@0: //----------- 8. Range Delete within a Transaction and Commit.----------------------- sl@0: //Before doing this we need to reset from the ROM first to restore the deleted keys in sl@0: //non transaction test earlier sl@0: r=repository->Reset(); sl@0: TEST2(r,KErrNone); sl@0: r = repository->FindL(KRangeDeletePartialKey, KRangeDeleteMask, foundIds); sl@0: TEST2(r,KErrNone); sl@0: TEST(foundIds.Count()==5); sl@0: foundIds.Reset(); sl@0: // Begin read write transaction sl@0: r = repository->StartTransaction(CRepository::EReadWriteTransaction); sl@0: TEST2(r, KErrNone); sl@0: r = repository->Delete(KTransactionRangeDeletePartialKey, KRangeDeleteMask, errId) ; sl@0: TEST2(r, KErrNone); sl@0: // Commit transaction sl@0: r = repository->CommitTransaction(errId); sl@0: TEST2(r, KErrNone); sl@0: //The number of keys changed should be equal to the number of keys deleted sl@0: TEST(errId==5); sl@0: sl@0: //Reset repository to remove any changes made during this test sl@0: r=repository->Reset(); sl@0: TEST2(r, KErrNone); sl@0: sl@0: // Close the repositories sl@0: CleanupStack::PopAndDestroy(repository); sl@0: } sl@0: sl@0: LOCAL_C void INC058229L() sl@0: { sl@0: RFs fs; sl@0: User::LeaveIfError(fs.Connect()); sl@0: CleanupClosePushL(fs); sl@0: sl@0: CFileMan* fm = CFileMan::NewL(fs); sl@0: CleanupStack::PushL(fm); sl@0: sl@0: // Open repository to ensure server is running sl@0: CRepository* rep; sl@0: User::LeaveIfNull(rep = CRepository::NewLC(KUidLargeRepository)); sl@0: // Close repository sl@0: CleanupStack::PopAndDestroy(rep); sl@0: sl@0: // Remove install dir sl@0: TInt r = fm->RmDir(KCInstallDir); sl@0: if(r!=KErrNone && r!=KErrNotFound && r!=KErrPathNotFound) sl@0: User::Leave(r); sl@0: // Wait so that watcher will see directory is gone sl@0: User::After(KGeneralDelay); sl@0: sl@0: // Kill server so that next test will reconnect and recreate resources sl@0: r=KillProcess(KCentralRepositoryServerName); sl@0: TEST2(r,KErrNone); sl@0: sl@0: // Open repository to ensure directories are restored sl@0: User::LeaveIfNull(rep = CRepository::NewLC(KUidLargeRepository)); sl@0: // Close repository sl@0: CleanupStack::PopAndDestroy(3); // rep, fs, fm sl@0: } sl@0: sl@0: LOCAL_C void DEF058900L() sl@0: { sl@0: sl@0: CRepository* repository; sl@0: User::LeaveIfNull(repository = CRepository::NewLC(KUidDEF058900TestRepository)); sl@0: TRequestStatus intStatus; sl@0: RThread thisThread; sl@0: sl@0: // sl@0: // Basic notification to test notification for one banned key sl@0: // sl@0: TInt r = repository->NotifyRequest(KNotifyBannedKey, intStatus); sl@0: TEST2(r, KErrNone); sl@0: TEST(intStatus == KRequestPending); sl@0: sl@0: // First change to setting should cause notification sl@0: r = repository->Set(KNotifyBannedKey, 100); sl@0: TEST2(r, KErrNone); sl@0: User::WaitForAnyRequest(); sl@0: TEST(intStatus==KUnspecifiedKey); sl@0: sl@0: // sl@0: // Group notification to test notification when the banned key is in a range sl@0: // sl@0: r = repository->NotifyRequest(KNullKey, KNullKey, intStatus); sl@0: TEST2(r, KErrNone); sl@0: sl@0: r = repository->Set(KNotifyBannedKey, 50); sl@0: TEST2(r, KErrNone); sl@0: User::WaitForAnyRequest(); sl@0: TEST(intStatus==KUnspecifiedKey); sl@0: TEST(thisThread.RequestCount()==0); sl@0: sl@0: // sl@0: // Group notification to test notification when many keys including the banned key change sl@0: // i.e. a repository wide reset sl@0: // sl@0: // First change values for alot of the keys before a reset. sl@0: r = repository->Set(KNotificationKey1, 80); sl@0: TEST2(r, KErrNone); sl@0: r = repository->Set(KNotifyBannedKey, 50); sl@0: TEST2(r, KErrNone); sl@0: r = repository->Set(KNotificationKey2, 70); sl@0: TEST2(r, KErrNone); sl@0: r = repository->Set(KNotificationKey3, 60); sl@0: TEST2(r, KErrNone); sl@0: r = repository->Set(KNotificationKey4, 30); sl@0: TEST2(r, KErrNone); sl@0: sl@0: r = repository->NotifyRequest(KNullKey, KNullKey, intStatus); // Request notification sl@0: // for all keys in repository. sl@0: TEST2(r, KErrNone); sl@0: sl@0: //Reset the whole repository to original settings sl@0: r = repository->Reset(); sl@0: TEST2(r, KErrNone); sl@0: sl@0: User::WaitForAnyRequest(); sl@0: TEST(intStatus==KUnspecifiedKey); sl@0: TEST(thisThread.RequestCount()==0); sl@0: sl@0: sl@0: CleanupStack::PopAndDestroy(repository); sl@0: } sl@0: sl@0: LOCAL_C void DEF061087L() sl@0: { sl@0: TInt r=KErrNone; sl@0: TUid testUid={0x10061087}; sl@0: CRepository* repository; sl@0: User::LeaveIfNull(repository = CRepository::NewLC(testUid)); sl@0: sl@0: /*--------------Scenario 1--------------------- sl@0: 100 300 cap_wr=ReadDeviceData sl@0: 100 200 cap_wr=TCB */ sl@0: r=repository->Create(150,100); sl@0: TEST2(r,KErrPermissionDenied); sl@0: r=repository->Create(201,201); sl@0: TEST2(r,KErrNone); sl@0: sl@0: /*--------------Scenario 2--------------------- sl@0: 400 500 cap_wr=ReadDeviceData sl@0: 400 500 cap_wr=TCB */ sl@0: r=repository->Create(500,100); sl@0: TEST2(r,KErrPermissionDenied); sl@0: sl@0: /*--------------Scenario 3--------------------- sl@0: 0x600 0x700 cap_wr=ReadDeviceData sl@0: # Odd entry from 600-700 sl@0: 0x601 mask=0xF01 cap_wr=TCB*/ sl@0: r=repository->Create(0x601,601); sl@0: TEST2(r,KErrPermissionDenied); sl@0: r=repository->Create(0x657,647); sl@0: TEST2(r,KErrPermissionDenied); sl@0: //0x602 will be even so it will check agains the next matched range policies sl@0: //which is 0x600 0x700 cap_wr=ReadDeviceData sl@0: r=repository->Create(0x602,600); sl@0: TEST2(r,KErrNone); sl@0: sl@0: /*--------------Scenario 4--------------------- sl@0: # protected data sl@0: 0x00000100 mask=0x00000100 cap_wr=NetworkControl sl@0: # private data sl@0: 0x000000F0 mask=0x00000080 cap_rd=ReadDeviceData */ sl@0: r=repository->Create(0x01000100,123); sl@0: TEST2(r,KErrPermissionDenied); sl@0: r=repository->Create(0x03450700,123); sl@0: TEST2(r,KErrPermissionDenied); sl@0: r=repository->Create(0x00450080,123); sl@0: TEST2(r,KErrNone); sl@0: r=repository->Create(0x06450081,123); sl@0: TEST2(r,KErrNone); sl@0: sl@0: sl@0: CleanupStack::PopAndDestroy(repository); sl@0: } sl@0: sl@0: sl@0: LOCAL_C void DEF060843L() sl@0: { sl@0: CRepository* repository; sl@0: User::LeaveIfNull(repository = CRepository::NewLC(KUidDEF060843LRepository1)); sl@0: sl@0: _LIT8(KString12_InitialValue, "string"); sl@0: TPtrC8 p8(KString12_InitialValue); sl@0: TInt len8 = p8.Length(); sl@0: sl@0: _LIT(KString11_InitialValue, "string"); sl@0: TPtrC p16(KString11_InitialValue); sl@0: TInt len16 = p16.Length(); sl@0: sl@0: //setting ids in a test repository sl@0: const TUint32 KReal1 = 2; sl@0: const TUint32 KString11 = 11; sl@0: const TUint32 KString12 = 12; sl@0: sl@0: TInt r; sl@0: TInt i(0); sl@0: sl@0: TBuf<15> str; sl@0: TInt strLen; sl@0: sl@0: TBuf8<15> str8; sl@0: TInt strLen8; sl@0: sl@0: //================read real using int ======================== sl@0: r = repository->Get(KReal1, i); sl@0: TEST2(r, KErrArgument); sl@0: TEST(i==0); sl@0: sl@0: //================read TDes16 using TDes8===================== sl@0: r = repository->Get(KString11, str8); sl@0: TEST2(r, KErrNone); sl@0: sl@0: //8-bit descriptor holding the same data as 16-bit descriptor sl@0: //should twice as long as 16-bit des. sl@0: strLen8 = str8.Length(); sl@0: TEST2(strLen8,len16*2); sl@0: sl@0: const TUint16* p16a = (TUint16*)str8.Ptr(); sl@0: const TUint16* p16b = p16.Ptr(); sl@0: //compares content of descriptors byte by byte sl@0: r = Mem::Compare(p16a,strLen8/2,p16b,len16); sl@0: TEST2(r,KErrNone); sl@0: sl@0: //=================read TDes8 using TDes16===================== sl@0: r = repository->Get(KString12, str); sl@0: TEST2(r, KErrNone); sl@0: sl@0: //16-bit descriptor holding the same data as 8-bit descriptor sl@0: //should be half a length of a 8-bit desc sl@0: strLen = str.Length(); sl@0: TEST2(strLen,len8/2); sl@0: sl@0: const TUint8* p8a = (TUint8*)str.Ptr(); sl@0: const TUint8* p8b = p8.Ptr(); sl@0: //compares content of descriptors byte by byte sl@0: r = Mem::Compare(p8a,strLen*2,p8b,len8); sl@0: TEST2(r,KErrNone); sl@0: sl@0: //================writting to TDes16 using TDes8=============== sl@0: r = repository->Set(KString11,KString12_InitialValue); sl@0: TEST2(r, KErrNone); sl@0: CleanupStack::PopAndDestroy(repository); sl@0: User::LeaveIfNull(repository = CRepository::NewLC(KUidDEF060843LRepository1)); sl@0: r = repository->Get(KString11, str8); sl@0: strLen8 = str8.Length(); sl@0: TEST2(strLen8,len8); sl@0: TEST(str8==KString12_InitialValue); sl@0: sl@0: //================writting to TDes8 using TDes16=============== sl@0: r = repository->Set(KString12,KString11_InitialValue); sl@0: TEST2(r, KErrNone); sl@0: CleanupStack::PopAndDestroy(repository); sl@0: User::LeaveIfNull(repository = CRepository::NewLC(KUidDEF060843LRepository1)); sl@0: r = repository->Get(KString12, str); sl@0: strLen = str.Length(); sl@0: TEST2(strLen,len16); sl@0: TEST(str==KString11_InitialValue); sl@0: CleanupStack::PopAndDestroy(repository); sl@0: } sl@0: sl@0: /** sl@0: @SYMTestCaseID SYSLIB-CENTRALREPOSITORY-CT-1433 sl@0: @SYMTestCaseDesc Central repository panics the client when trying to read 8-bit descriptor with uneven length sl@0: @SYMTestPriority High sl@0: @SYMTestActions Read 8-bit descriptor with uneven length sl@0: @SYMTestExpectedResults The test must not fail or panic . sl@0: @SYMDEF INC069013 sl@0: */ sl@0: LOCAL_C void INC069013L() sl@0: { sl@0: CRepository* repository; sl@0: User::LeaveIfNull(repository = CRepository::NewLC(KUidINC069013TestRepository)); sl@0: sl@0: _LIT(KString16, "16BitString"); sl@0: _LIT8(KString8Odd, "8BitOddString"); sl@0: _LIT8(KString8Even, "8BitEvenString"); sl@0: sl@0: const TUint32 KString16ID = 1; sl@0: const TUint32 KString8OddID = 2; sl@0: const TUint32 KString8EvenID = 3; sl@0: sl@0: TBuf<20> buf; sl@0: TInt r = KErrNone; sl@0: TInt actualLength = 0; sl@0: sl@0: //test for string stored as 16 bit sl@0: r = repository->Get(KString16ID, buf); sl@0: TEST2(r, KErrNone); sl@0: sl@0: r = repository->Get(KString16ID, buf, actualLength); sl@0: TEST2(r, KErrNone); sl@0: TEST2(actualLength, KString16().Length()); sl@0: sl@0: //test for string stored as 8 bit with odd length sl@0: r = repository->Get(KString8OddID, buf); sl@0: TEST2(r, KErrNone); sl@0: sl@0: r = repository->Get(KString8OddID, buf, actualLength); sl@0: TEST2(r, KErrNone); sl@0: TEST2(actualLength, (KString8Odd().Length() + 1) / 2); sl@0: sl@0: //test for string stored as 8 bit with even length sl@0: r = repository->Get(KString8EvenID, buf); sl@0: TEST2(r, KErrNone); sl@0: sl@0: r = repository->Get(KString8EvenID, buf, actualLength); sl@0: TEST2(r, KErrNone); sl@0: TEST2(actualLength, (KString8Even().Length() + 1) / 2); sl@0: sl@0: CleanupStack::PopAndDestroy(repository); sl@0: } sl@0: sl@0: /** sl@0: @SYMTestCaseID SYSLIB-CENTRALREPOSITORY-CT-1434 sl@0: @SYMTestCaseDesc Central repository doesn't handle corrupt .cre files correctly. sl@0: @SYMTestPriority High sl@0: @SYMTestActions Open corrupt files from ROM and persists sl@0: @SYMTestExpectedResults The test must not fail. sl@0: @SYMDEF DEF070731 sl@0: */ sl@0: const TUid KUidCorruptEOF = { 0x00000e0f }; sl@0: const TUid KUidCorrupt = { 0x00000bad }; sl@0: sl@0: _LIT(KCRep1File, "c:\\private\\10202BE9\\persists\\00000100.cre"); sl@0: _LIT(KZCorruptEOFFile, "z:\\private\\10202BE9\\00000e0f.cre"); sl@0: _LIT(KZCorruptFile, "z:\\private\\10202BE9\\00000bad.cre"); sl@0: sl@0: LOCAL_C void DEF070731L() sl@0: { sl@0: RFs fs; sl@0: User::LeaveIfError(fs.Connect()); sl@0: CleanupClosePushL(fs); sl@0: sl@0: CFileMan* fm = CFileMan::NewL(fs); sl@0: CleanupStack::PushL(fm); sl@0: sl@0: CRepository* rep; sl@0: sl@0: // Open ROM cre file with EOF corruption sl@0: TheTest.Printf(_L("\nOpen ROM cre file with EOF corruption\n")); sl@0: TRAPD(errH, rep=CRepository::NewLC(KUidCorruptEOF)); sl@0: TEST2(errH, KErrCorrupt); sl@0: sl@0: // Open corrupt ROM file sl@0: TheTest.Printf(_L("\nOpen corrupt ROM file\n")); sl@0: TRAPD(errS,rep=CRepository::NewLC(KUidCorrupt)); sl@0: TEST2(errS, KErrCorrupt); sl@0: sl@0: // Edit repos with new setting sl@0: TheTest.Printf(_L("\nEdit repos with new setting\n")); sl@0: User::LeaveIfNull(rep = CRepository::NewLC(KUidRep1)); sl@0: TInt r = rep->Create(KNewInt, KIntValue); sl@0: TEST2(r, KErrNone); sl@0: CleanupStack::PopAndDestroy(rep); sl@0: sl@0: // Reopen repos to read from persists file sl@0: User::LeaveIfNull(rep = CRepository::NewLC(KUidRep1)); sl@0: TInt newInt; sl@0: r=rep->Get(KNewInt, newInt); sl@0: TEST2(r, KErrNone); sl@0: CleanupStack::PopAndDestroy(rep); sl@0: sl@0: // Existance of caching functionality invalidates some tests and sl@0: // makes them fail, so kill the server to force clearing the cache sl@0: r=KillProcess(KCentralRepositoryServerName); sl@0: TEST2(r,KErrNone); sl@0: sl@0: // Copy corrupt EOF file into persists sl@0: TheTest.Printf(_L("\nCopy corrupt EOF file into persists dir\n")); sl@0: User::LeaveIfError(fm->Copy(KZCorruptEOFFile, KCRep1File)); sl@0: // Reset read-only bit sl@0: User::LeaveIfError(fm->Attribs(KCRep1File,0,KEntryAttReadOnly,TTime(0))); sl@0: User::After(KGeneralDelay); sl@0: // Open repos, should find corrupt file and use ROM file sl@0: User::LeaveIfNull(rep = CRepository::NewLC(KUidRep1)); sl@0: // If we can't find KNewInt, this proves that we are using ROM file sl@0: r=rep->Get(KNewInt, newInt); sl@0: TEST2(r, KErrNotFound); sl@0: // Test that persists file is deleted sl@0: TheTest.Printf(_L("\nCheck corrupt EOF file deleted from persists dir\n")); sl@0: TEST2 (BaflUtils::FileExists (fs, KCRep1File), EFalse); sl@0: // Close repository sl@0: CleanupStack::PopAndDestroy(rep); sl@0: sl@0: // Existance of caching functionality invalidates some tests and sl@0: // makes them fail, so kill the server to force clearing the cache sl@0: r=KillProcess(KCentralRepositoryServerName); sl@0: TEST2(r,KErrNone); sl@0: sl@0: // Copy corrupt file into persists sl@0: TheTest.Printf(_L("\nCopy corrupt file into persists dir\n")); sl@0: User::LeaveIfError(fm->Copy(KZCorruptFile, KCRep1File)); sl@0: // Reset read-only bit sl@0: User::LeaveIfError(fm->Attribs(KCRep1File,0,KEntryAttReadOnly,TTime(0))); sl@0: User::After(KGeneralDelay); sl@0: // Open repos, should find corrupt file and use ROM file sl@0: User::LeaveIfNull(rep = CRepository::NewLC(KUidRep1)); sl@0: // Test that file is deleted sl@0: TheTest.Printf(_L("\nCheck corrupt file deleted from persists dir\n")); sl@0: TEST2 (BaflUtils::FileExists (fs, KCRep1File), EFalse); sl@0: sl@0: // Close repository sl@0: CleanupStack::PopAndDestroy(3);// rep, fs,fm sl@0: sl@0: } sl@0: sl@0: // Helper function for DEF084700L sl@0: LOCAL_C void ConnectAndCommitSuicideL(void) sl@0: { sl@0: CRepository* repository; sl@0: User::LeaveIfNull(repository = CRepository::NewLC(KUidDEF060843LRepository1)); sl@0: sl@0: RThread currentThread; sl@0: currentThread.Kill(KErrDied); sl@0: sl@0: // Should never get executed sl@0: CleanupStack::PopAndDestroy(repository); sl@0: } sl@0: sl@0: // Helper function for DEF084700L sl@0: LOCAL_C TInt SuicidalThread(TAny*) sl@0: { sl@0: CTrapCleanup* cleanup = CTrapCleanup::New(); sl@0: if(!cleanup) sl@0: return KErrNoMemory; sl@0: sl@0: TRAP_IGNORE(ConnectAndCommitSuicideL()); sl@0: sl@0: // Should never get executed sl@0: delete cleanup; sl@0: return KErrNone; sl@0: } sl@0: sl@0: // Helper function for DEF084700L sl@0: LOCAL_C void ConnectAndDisconnectL(void) sl@0: { sl@0: CRepository* repository; sl@0: User::LeaveIfNull(repository = CRepository::NewLC(KUidDEF060843LRepository1)); sl@0: sl@0: CleanupStack::PopAndDestroy(repository); sl@0: } sl@0: sl@0: // Helper function for DEF084700L sl@0: LOCAL_C TInt WellBehavedThread(TAny*) sl@0: { sl@0: CTrapCleanup* cleanup = CTrapCleanup::New(); sl@0: if(!cleanup) sl@0: return KErrNoMemory; sl@0: sl@0: TRAP_IGNORE(ConnectAndDisconnectL()); sl@0: sl@0: delete cleanup; sl@0: return KErrNone; sl@0: } sl@0: sl@0: /** sl@0: @SYMTestCaseID SYSLIB-CENTRALREPOSITORY-CT-1683 sl@0: @SYMTestCaseDesc UIF automated tests crash H4 board sl@0: @SYMTestPriority High sl@0: @SYMTestActions Open a repository, create a thread, open same repository from that thread, kill the thread sl@0: before closing repository, update a setting from main body (trigger notifications). Do the same sl@0: thing for a thread which terminates normally for making sure the previous behaviour is maintained sl@0: @SYMTestExpectedResults The test must not panic or fail. sl@0: @SYMDEF DEF084700 sl@0: */ sl@0: LOCAL_C void DEF084700L() sl@0: { sl@0: CRepository* repository; sl@0: User::LeaveIfNull(repository = CRepository::NewLC(KUidDEF060843LRepository1)); sl@0: sl@0: RThread testThread; sl@0: _LIT(KThreadName1, "SuicidalTestThread"); sl@0: sl@0: testThread.Create(KThreadName1, SuicidalThread, KDefaultStackSize, KMinHeapSize, 0x100000, NULL); sl@0: sl@0: TRequestStatus requestStatus; sl@0: // Request notification when the thread kills itself sl@0: testThread.Logon(requestStatus); sl@0: // Let the thread execute sl@0: testThread.Resume(); sl@0: sl@0: // Wait for suicide sl@0: User::WaitForRequest(requestStatus); sl@0: // Make sure it's dead sl@0: TEST2(requestStatus.Int(), KErrDied); sl@0: sl@0: const TUint32 KInt1 = 0x1; sl@0: TInt i, r = KErrNone; sl@0: sl@0: r = repository->Get(KInt1, i); sl@0: TEST2(r, KErrNone); sl@0: r = repository->Set(KInt1, i+1); sl@0: // Fails here with KErrServerTerminated before fix because server crashes sl@0: TEST2(r, KErrNone); sl@0: sl@0: // Create another thread which accesses the repository but terminates normally sl@0: _LIT(KThreadName2, "WellBehavedTestThread"); sl@0: sl@0: testThread.Create(KThreadName2, WellBehavedThread, KDefaultStackSize, KMinHeapSize, 0x100000, NULL); sl@0: sl@0: // Request notification when the thread terminates normally sl@0: testThread.Logon(requestStatus); sl@0: // Let the thread execute sl@0: testThread.Resume(); sl@0: sl@0: // Wait for old age sl@0: User::WaitForRequest(requestStatus); sl@0: // Make sure the cause of death is natural sl@0: TEST2(requestStatus.Int(), KErrNone); sl@0: sl@0: r = repository->Get(KInt1, i); sl@0: TEST2(r, KErrNone); sl@0: r = repository->Set(KInt1, i+1); sl@0: sl@0: TEST2(r, KErrNone); sl@0: sl@0: //Reset repository to remove any changes made during this test sl@0: r = repository->Reset(); sl@0: TEST2(r, KErrNone); sl@0: sl@0: CleanupStack::PopAndDestroy(repository); sl@0: } sl@0: sl@0: /** sl@0: @SYMTestCaseID SYSLIB-CENTRALREPOSITORY-CT-1862 sl@0: @SYMTestCaseDesc [AQP] CommitTransaction returns incorrect error code if Find~L methods run OOM sl@0: @SYMTestPriority High sl@0: @SYMTestActions Open a repository, start a transaction, then simulate a OOM failure in a TRAPPED sl@0: FindL, this will result in client side error and this error should be the returned sl@0: error of CommitTransaction. sl@0: @SYMTestExpectedResults The test must not panic or fail. sl@0: @SYMDEF DEF089945 sl@0: */ sl@0: LOCAL_C void DEF089945L() sl@0: { sl@0: TInt err=KErrNone; sl@0: const TUid testUid={0x10057145}; sl@0: RArray idArray; sl@0: sl@0: CRepository* repository; sl@0: User::LeaveIfNull(repository = CRepository::NewLC(testUid)); sl@0: sl@0: //-----------SIMULATE CLIENT SIDE TRANSACTION ERROR------------------------------ sl@0: err=repository->StartTransaction(CRepository::EReadWriteTransaction); sl@0: TEST2(err,KErrNone); sl@0: sl@0: //set the next allocation to fail in the FindL method sl@0: __UHEAP_FAILNEXT(1); sl@0: TRAP(err,repository->FindL(1,0xFFFFFFFF,idArray)); sl@0: __UHEAP_TOTAL_RESET; sl@0: //uheap failure only happens in debug build sl@0: #ifdef _DEBUG sl@0: TEST2(err,KErrNoMemory); sl@0: #else sl@0: TEST2(err,KErrNone); sl@0: #endif sl@0: sl@0: TUint32 errId; sl@0: //ensure that the returned code from Commit is same as the last failure error in client sl@0: err=repository->CommitTransaction(errId); sl@0: #ifdef _DEBUG sl@0: TEST2(err,KErrNoMemory); sl@0: TEST2(errId,KUnspecifiedKey); sl@0: #else sl@0: TEST2(err,KErrNone); sl@0: #endif sl@0: idArray.Reset(); sl@0: sl@0: //----------SIMULATE CLIENT SIDE TRANSACTION ERROR FOLLOWED BY ADDITIONAL OPERATION----- sl@0: err=repository->StartTransaction(CRepository::EReadWriteTransaction); sl@0: TEST2(err,KErrNone); sl@0: //set the next allocation to fail in the FindL method sl@0: __UHEAP_FAILNEXT(1); sl@0: TRAP(err,repository->FindL(1,0xFFFFFFFF,idArray)); sl@0: __UHEAP_TOTAL_RESET; sl@0: #ifdef _DEBUG sl@0: TEST2(err,KErrNoMemory); sl@0: #else sl@0: TEST2(err,KErrNone); sl@0: #endif sl@0: sl@0: //now try to execute another operation following the failure sl@0: TReal realValue; sl@0: err=repository->Set(1,realValue); sl@0: #ifdef _DEBUG sl@0: TEST2(err,KErrAbort); sl@0: #else sl@0: TEST2(err,KErrArgument); sl@0: #endif sl@0: sl@0: err=repository->CommitTransaction(errId); sl@0: //confirms that the error returned is the last failure in client side sl@0: #ifdef _DEBUG sl@0: TEST2(err,KErrNoMemory); sl@0: TEST2(errId,KUnspecifiedKey); sl@0: #else sl@0: TEST2(err,KErrArgument); sl@0: #endif sl@0: idArray.Reset(); sl@0: sl@0: //---------SIMULATE SERVER SIDE ERROR FOLLOWED BY CLIENT SIDE ERROR------------------- sl@0: err=repository->StartTransaction(CRepository::EReadWriteTransaction); sl@0: TEST2(err,KErrNone); sl@0: sl@0: //server error sl@0: err=repository->Set(1,realValue); sl@0: TEST2(err,KErrArgument); sl@0: sl@0: //client error sl@0: __UHEAP_FAILNEXT(1); sl@0: TInt ret=KErrNone; sl@0: TRAP(err,ret=repository->FindL(1,0xFFFFFFFF,idArray)); sl@0: __UHEAP_TOTAL_RESET; sl@0: TEST2(ret,KErrAbort); sl@0: sl@0: err=repository->CommitTransaction(errId); sl@0: //confirms that the error returned is the last failure in server side sl@0: TEST2(err,KErrArgument); sl@0: TEST2(errId,1); sl@0: idArray.Reset(); sl@0: sl@0: //clean up stuff sl@0: idArray.Close(); sl@0: CleanupStack::PopAndDestroy(repository); sl@0: } sl@0: sl@0: /** sl@0: @SYMTestCaseID SYSLIB-CENTRALREPOSITORY-CT-3242 sl@0: @SYMTestCaseDesc Memory card: Backup to memory card causes phone freeze. sl@0: @SYMTestPriority High sl@0: @SYMTestActions Open a repository with a corrupt ini file and check that sl@0: the call to CRepository::NewLC leaves with KErrCorrupt and does not panic. sl@0: @SYMTestExpectedResults The call to CRepository::NewLC should return with KErrCorrupt and sl@0: the test must not panic or fail. sl@0: @SYMDEF PDEF098500 sl@0: */ sl@0: LOCAL_C void PDEF098500() sl@0: { sl@0: CRepository* repository = NULL; sl@0: sl@0: TRAPD(err,repository = CRepository::NewLC(KUidPDEF098500LRepository)); sl@0: sl@0: //We expect the above call to leave with KErrCorrupt so repository should be NULL sl@0: TEST(repository == NULL); sl@0: TEST2(err, KErrCorrupt); sl@0: sl@0: //No PopAndDestroy required as above call is expected to leave sl@0: sl@0: } sl@0: sl@0: /** sl@0: @SYMTestCaseID SYSLIB-CENTRALREPOSITORY-CT-1884 sl@0: @SYMTestCaseDesc DEF093855: CenRep cancels transactions if they exceed 5 seconds... sl@0: @SYMTestPriority High sl@0: @SYMTestActions Open a repository, start a transaction, then wait more than default cache timeout sl@0: to let the normal eviction clean out the cache, call a function to reload the repository, sl@0: check that the transaction is still valid, rollback the transaction to check the sl@0: repository unload/reload during an open transaction doesn't cause a panic when transaction is rolled back. sl@0: @SYMTestExpectedResults The test must not panic or fail. sl@0: @SYMDEF DEF093855 sl@0: */ sl@0: LOCAL_C void DEF093855L() sl@0: { sl@0: TInt err=KErrNone; sl@0: sl@0: // make sure no items are in the cache sl@0: KillProcess(KCentralRepositoryServerName); sl@0: sl@0: // connect sl@0: CRepository* repository; sl@0: User::LeaveIfNull(repository = CRepository::NewLC(KUidRep1)); sl@0: sl@0: // Begin concurrent read write transaction sl@0: err = repository->StartTransaction(CRepository::EConcurrentReadWriteTransaction); sl@0: TEST2(err, KErrNone); sl@0: sl@0: TInt val; sl@0: const TInt KIntTestValue = 10; sl@0: // get test value, make sure it is KIntTestValue sl@0: err = repository->Get(0x02010100,val); sl@0: TEST2(err, KErrNone); sl@0: TEST2(val, KIntTestValue); sl@0: sl@0: // change the value in transaction sl@0: TInt r = repository->Set(0x02010100, KIntValue); sl@0: TEST2(r, KErrNone); sl@0: sl@0: // wait for the repository to be removed from memory sl@0: CleanupRepositoryCache(); sl@0: sl@0: // check that the transaction is not aborted, still in memory and keeps the value set during the transaction sl@0: err = repository->Get(0x02010100,val); sl@0: TEST2(err, KErrNone); sl@0: TEST2(val, KIntValue); sl@0: sl@0: // rollback to check if RollbackTransaction works, and to reset the value to KIntTestValue sl@0: repository->RollbackTransaction(); sl@0: sl@0: // Begin another transaction sl@0: err = repository->StartTransaction(CRepository::EConcurrentReadWriteTransaction); sl@0: TEST2(err, KErrNone); sl@0: sl@0: // get test value, make sure it is still KIntTestValue (successfully rolled back) sl@0: err = repository->Get(0x02010100,val); sl@0: TEST2(err, KErrNone); sl@0: TEST2(val, KIntTestValue); sl@0: sl@0: // change the value in transaction sl@0: r = repository->Set(0x02010100, KIntValue); sl@0: TEST2(r, KErrNone); sl@0: sl@0: // wait for the repository to be removed from memory sl@0: CleanupRepositoryCache(); sl@0: sl@0: // check that the transaction is not aborted, still in memory and keeps the value set during the transaction sl@0: err = repository->Get(0x02010100,val); sl@0: TEST2(err, KErrNone); sl@0: TEST2(val, KIntValue); sl@0: sl@0: // commit to check if CommitTransaction works sl@0: TUint32 keyInfo; sl@0: repository->CommitTransaction(keyInfo); sl@0: TEST2(err, KErrNone); sl@0: TEST2(keyInfo, 1); sl@0: sl@0: // check that the value is set during the transaction (in shared rep settings) sl@0: err = repository->Get(0x02010100,val); sl@0: TEST2(err, KErrNone); sl@0: TEST2(val, KIntValue); sl@0: sl@0: // close repository sl@0: CleanupStack::PopAndDestroy(repository); sl@0: sl@0: // make sure the repository is unloaded from cache sl@0: KillProcess(KCentralRepositoryServerName); sl@0: sl@0: // reopen the repository sl@0: User::LeaveIfNull(repository = CRepository::NewLC(KUidRep1)); sl@0: sl@0: // get test value, to check if it had been successfully persisted sl@0: err = repository->Get(0x02010100,val); sl@0: TEST2(err, KErrNone); sl@0: TEST2(val, KIntValue); sl@0: sl@0: // reset the setting back to the original value sl@0: r = repository->Set(0x02010100, KIntTestValue); sl@0: TEST2(r, KErrNone); sl@0: sl@0: //Reset repository to remove any changes made during this test sl@0: r = repository->Reset(); sl@0: TEST2(r, KErrNone); sl@0: sl@0: // close repository sl@0: CleanupStack::PopAndDestroy(repository); sl@0: } sl@0: sl@0: /** sl@0: @SYMTestCaseID SYSLIB-CENTRALREPOSITORY-CT-3477 sl@0: @SYMTestCaseDesc PDEF106507: Central repository doesn't handle corruption of the installdir.bin file properly sl@0: @SYMTestPriority High sl@0: @SYMTestActions Replaces installdir.bin file with a corrupted version, then shuts down the server and restarts it (with CRepository::NewL) This causes the file to be re-read, and as it is corrupt it should get deleted and re-created. The test checks that the server does not panic. sl@0: @SYMTestExpectedResults The Server should not panic when trying to read the corrupt file, and should return KErrNone sl@0: @SYMDEF PDEF106507 sl@0: */ sl@0: LOCAL_C void PDEF106507L() sl@0: { sl@0: _LIT(KInstallDirFile, "C:\\private\\10202be9\\persists\\installdir.bin"); sl@0: _LIT(KInstallDirFileBad1, "Z:\\private\\10202be9\\installdir_corrupt1.bin"); sl@0: _LIT(KInstallDirFileBad2, "Z:\\private\\10202be9\\installdir_corrupt2.bin"); sl@0: RFs fs; sl@0: User::LeaveIfError(fs.Connect()); sl@0: CleanupClosePushL(fs); sl@0: sl@0: CFileMan* fm = CFileMan::NewL(fs); sl@0: CleanupStack::PushL(fm); sl@0: sl@0: // copy first corrupt file into centrep private directory (this file has data area corrupted) sl@0: TheTest.Printf(_L("\nCopy first corrupt installdir.bin file into persists dir\n")); sl@0: User::LeaveIfError(fm->Copy(KInstallDirFileBad1, KInstallDirFile)); sl@0: // Reset read-only bit sl@0: User::LeaveIfError(fm->Attribs(KInstallDirFile,0,KEntryAttReadOnly,TTime(0))); sl@0: sl@0: // Kill server so that next test will restart and internalize file sl@0: TInt error = KillProcess(KCentralRepositoryServerName); sl@0: TEST2(error, KErrNone); sl@0: sl@0: // Start server and check it does not panic sl@0: CRepository* repository = NULL; sl@0: TRAP(error, repository = CRepository::NewL(KUidRep1)); sl@0: TEST2(error, KErrNone); sl@0: delete repository; sl@0: sl@0: // test the second corrupted file (this file has header information corrupted) sl@0: TheTest.Printf(_L("\nCopy second corrupt installdir.bin file into persists dir\n")); sl@0: User::LeaveIfError(fm->Copy(KInstallDirFileBad2, KInstallDirFile)); sl@0: // Reset read-only bit sl@0: User::LeaveIfError(fm->Attribs(KInstallDirFile,0,KEntryAttReadOnly,TTime(0))); sl@0: sl@0: // Kill server so that next test will reconnect and recreate resources sl@0: error = KillProcess(KCentralRepositoryServerName); sl@0: TEST2(error, KErrNone); sl@0: sl@0: // Start server and check it does not panic sl@0: TRAP(error, repository = CRepository::NewL(KUidRep1)); sl@0: TEST2(error, KErrNone); sl@0: delete repository; sl@0: sl@0: CleanupStack::PopAndDestroy(2); //fs, fm sl@0: } sl@0: sl@0: /** sl@0: @SYMTestCaseID SYSLIB-CENTRALREPOSITORY-CT-3517 sl@0: @SYMTestCaseDesc R3.2 stability problems: CentralRepositorySrv crash sl@0: @SYMTestPriority High sl@0: @SYMTestActions Attempt to open a .cre file which has a corrupt UID. Ensure that sl@0: the error is dealt with properly. sl@0: @SYMTestExpectedResults The test must not fail. sl@0: @SYMDEF INC108803 sl@0: */ sl@0: sl@0: _LIT(KZCorruptFile1, "z:\\private\\10202BE9\\101f8764.cre"); sl@0: _LIT(KCCorruptFile1, "c:\\private\\10202BE9\\persists\\101f8764.cre"); sl@0: _LIT(KCCorruptFile2, "c:\\private\\10202BE9\\persists\\101f8765.cre"); sl@0: sl@0: const TUid KUidCorruptUid1 = { 0x101f8764 }; sl@0: const TUid KUidCorruptUid2 = { 0x101f8765 }; sl@0: sl@0: LOCAL_C void INC108803L() sl@0: { sl@0: sl@0: TInt err = KErrNone; sl@0: sl@0: RFs fs; sl@0: User::LeaveIfError(fs.Connect()); sl@0: CleanupClosePushL(fs); sl@0: sl@0: CFileMan* fm = CFileMan::NewL(fs); sl@0: CleanupStack::PushL(fm); sl@0: sl@0: CRepository* rep = NULL; sl@0: sl@0: // Attempt to open a repository from a .cre file which has a corrupt UID sl@0: // The .cre file exists on the Z drive only. This test ensures that sl@0: // the corruption of the .cre file is detected and that the correct error sl@0: // code, KErrCorrupt, is returned to the client. sl@0: // This test will sl@0: // 1. Look on c drive, be unable to find the file sl@0: // 2. Look in z drive, find the file with the specified UID, sl@0: // determine that the file is corrupt and return KErrCorupt. sl@0: sl@0: TheTest.Printf(_L("\nAttempt to open ROM cre file with UID corruption\n")); sl@0: TRAP(err, rep = CRepository::NewLC(KUidCorruptUid1); CleanupStack::Pop(rep);); sl@0: TEST2(err, KErrCorrupt); sl@0: sl@0: // Copy the corrupt .cre file into the persists directory for the next test sl@0: User::LeaveIfError(fm->Copy(KZCorruptFile1, KCCorruptFile1 )); sl@0: // Reset read-only bit sl@0: User::LeaveIfError(fm->Attribs(KCCorruptFile1,0,KEntryAttReadOnly,TTime(0))); sl@0: User::After(KGeneralDelay); sl@0: sl@0: // Attempt to open a repository which has a .cre file with a corrupt UID. sl@0: // The .cre file exists on the C and Z drives. (This test ensures that the sl@0: // corrupt .cre file on the C Drive is deleted). sl@0: // This test will sl@0: // 1.Look in the C Drive, find the file with the specified UID sl@0: // determine that the file is corrupt and delete the file sl@0: // 2. Look in the Z Drive, find the file with the specified UID, sl@0: // determine that the file is corrupt and return KErrCorupt. sl@0: sl@0: TheTest.Printf(_L("\nAttempt to open persists cre file with UID corruption\n")); sl@0: TRAP (err, rep = CRepository::NewLC(KUidCorruptUid1); CleanupStack::Pop(rep);); sl@0: TEST2(err, KErrCorrupt); sl@0: TheTest.Printf(_L("\nCheck corrupt file deleted from persists dir\n")); sl@0: TEST2 (BaflUtils::FileExists (fs, KCCorruptFile1), EFalse); sl@0: sl@0: // Copy a second corrupt .cre file into the persists directory sl@0: // (Note that an associated ini file sl@0: // z:\\private\\10202BE9\\101f8765.txt exists and is not corrupt) sl@0: sl@0: User::LeaveIfError(fm->Copy(KZCorruptFile1, KCCorruptFile2)); sl@0: TEST2 (BaflUtils::FileExists (fs, KCCorruptFile2), ETrue); sl@0: // Reset read-only bit sl@0: User::LeaveIfError(fm->Attribs(KCCorruptFile2,0,KEntryAttReadOnly,TTime(0))); sl@0: User::After(KGeneralDelay); sl@0: sl@0: // Attempt to open a corrupt repository. This will fail and the .cre file on the sl@0: // C Drive will be deleted. Fall-back to the Z drive occurs. The associated ini file sl@0: // is found. sl@0: // Attempt to use the resulting repository by using a Reset operation. No panics should sl@0: // occur. sl@0: TheTest.Printf(_L("\nAttempt to open corrupt persists cre file, re-create from txt file\n")); sl@0: TRAP (err, rep = CRepository::NewLC(KUidCorruptUid2); CleanupStack::Pop(rep);); sl@0: TEST2 (BaflUtils::FileExists (fs, KCCorruptFile2), EFalse); sl@0: TEST2(err, KErrNone); sl@0: ASSERT(rep != NULL); sl@0: rep->Reset(); sl@0: sl@0: // Clean up any files created on the C Drive sl@0: CleanupFileFromCDriveL(KUidCorruptUid1); sl@0: CleanupFileFromCDriveL(KUidCorruptUid2); sl@0: sl@0: delete rep; sl@0: CleanupStack::PopAndDestroy(2, &fs); // fm, fs sl@0: } sl@0: sl@0: sl@0: /** sl@0: @SYMTestCaseID SYSLIB-CENTRALREPOSITORY-CT-3545 sl@0: @SYMTestCaseDesc The corrupted Cache ini file should cause CentralRepositorySrv panic in debug mode sl@0: but keep running with the default values in release mode. sl@0: @SYMTestPriority High sl@0: @SYMTestActions Kill CentralRepositorySrv and restart it with the corrupted Cache ini file. sl@0: Ensure that: sl@0: . in debug mode, the client will fail to create a CRepository pointer because sl@0: the server has panicked. sl@0: . in release mode, the client will be able to create a CRepository pointer because sl@0: the server keeps running with the default values. sl@0: @SYMTestExpectedResults The test must not fail. sl@0: @SYMDEF DEF109390 sl@0: */ sl@0: sl@0: _LIT(KZCorruptIniFile, "z:\\private\\10202BE9\\cache_corrupt.ini"); sl@0: _LIT(KCCorruptIniFile, "c:\\private\\10202BE9\\centrep.ini"); sl@0: _LIT(KZRepFile, "z:\\private\\10202BE9\\00000001.txt"); sl@0: _LIT(KCRepFile, "c:\\private\\10202BE9\\persists\\00000001.txt"); sl@0: sl@0: const TUid KTestRepUid = { 0x00000001}; sl@0: sl@0: LOCAL_C void DEF109390L() sl@0: { sl@0: TInt err(KErrNone); sl@0: sl@0: RFs fs; sl@0: User::LeaveIfError(fs.Connect()); sl@0: CleanupClosePushL(fs); sl@0: sl@0: CFileMan* fm = CFileMan::NewL(fs); sl@0: CleanupStack::PushL(fm); sl@0: sl@0: // Copy the corrupted Cache ini file to install directory. sl@0: TheTest.Printf(_L("\nCopy the corrupted Cache ini file to install directory.\n")); sl@0: User::LeaveIfError(fm->Copy(KZCorruptIniFile, KCCorruptIniFile)); sl@0: // Reset read-only bit sl@0: User::LeaveIfError(fm->Attribs(KCCorruptIniFile,0,KEntryAttReadOnly,TTime(0))); sl@0: sl@0: // Copy a good repository file to persist directory to verify whether the cenrep server is sl@0: // able to start up. sl@0: TheTest.Printf(_L("\nCopy the repository file to persist directory.\n")); sl@0: User::LeaveIfError(fm->Copy(KZRepFile, KCRepFile)); sl@0: // Reset read-only bit sl@0: User::LeaveIfError(fm->Attribs(KCRepFile,0,KEntryAttReadOnly,TTime(0))); sl@0: sl@0: // Kill server so that next test will restart it. sl@0: err=KillProcess(KCentralRepositoryServerName); sl@0: TEST2(err,KErrNone); sl@0: sl@0: User::After(KGeneralDelay); sl@0: sl@0: CRepository* rep = NULL; sl@0: TRAP(err, rep = CRepository::NewLC(KTestRepUid); CleanupStack::PopAndDestroy(rep);); sl@0: sl@0: #ifdef _DEBUG sl@0: // in debug mode, CRepository::NewLC should leave with leave code KErrGeneral. sl@0: TheTest.Printf(_L("Debug mode err = %d.\n"),err); sl@0: TEST2(err, KErrGeneral); sl@0: #else sl@0: // in release mode, CRepository::NewLC should return a valid CRepository pointer successfully. sl@0: TheTest.Printf(_L("Release mode err = %d.\n"),err); sl@0: TEST2(err, KErrNone); sl@0: #endif sl@0: sl@0: // Clean up the repository files created on the C Drive sl@0: CleanupFileFromCDriveL(KTestRepUid); sl@0: sl@0: // Clean up the corrupted ini file on the C Drive sl@0: User::LeaveIfError(fm->Delete(KCCorruptIniFile)); sl@0: sl@0: // pop the cleanup stack for fm & fs sl@0: CleanupStack::PopAndDestroy(2, &fs); sl@0: sl@0: // Kill the Cenrep server so that it can it can be restarted by the client sl@0: // without the corrupted Cache ini file. sl@0: err=KillProcess(KCentralRepositoryServerName); sl@0: TEST2(err,KErrNone); sl@0: } sl@0: sl@0: /** sl@0: @SYMTestCaseID SYSLIB-CENTRALREPOSITORY-UT-4024 sl@0: @SYMTestCaseDesc sl@0: Test that the UID compare function works properly with large UID's. Since sl@0: CObservable::CompareTUidValues() is a private function and cannot be accessed sl@0: directly, CObservable::AddObserverL()and CObservable::FindConnectedRepository() sl@0: are used to infer the correct operation. sl@0: @SYMTestPriority High sl@0: @SYMTestActions sl@0: -Compare a large positive UID and a very negative UID sl@0: -Compare a large positive UID and a large positive UID sl@0: -Compare a very negative UID and a very negative UID sl@0: -Compare two very large but equivalent UID's. sl@0: @SYMTestExpectedResults All UID's added to a sorted list can be found later, regardless of size and sign. sl@0: @SYMDEF DEF116043 sl@0: @SYMUnit CObservable::CompareTUidValues() sl@0: */ sl@0: LOCAL_C void DEF116043L() sl@0: { sl@0: const TUid KLargePositive1 = {0x7FFFFFFF}; sl@0: const TUid KLargePositive2 = {0x7FFFFFFE}; sl@0: const TUid KLargeNegative = {0x8FFFFFFF}; sl@0: sl@0: CObservable* ob = CObservable::NewLC(); sl@0: sl@0: // Add a variety of UID's to work with, including large positives, a very negative, sl@0: // and duplicates sl@0: ob->AddObserverL(KLargePositive1, NULL); sl@0: ob->AddObserverL(KLargeNegative, NULL); sl@0: ob->AddObserverL(KLargePositive2, NULL); sl@0: ob->AddObserverL(KLargePositive1, NULL); sl@0: sl@0: // Look for a large positive and expect a non-negative index sl@0: TEST(ob->FindConnectedRepository(KLargePositive1) >= 0); sl@0: sl@0: // Look for another large positive and expect a non-negative index sl@0: TEST(ob->FindConnectedRepository(KLargePositive2) >= 0); sl@0: sl@0: // Look for a very negative and expect a non-negative index. sl@0: // This will fail under 'UID1 - UID2' implementations. sl@0: TEST(ob->FindConnectedRepository(KLargeNegative) >= 0); sl@0: sl@0: CleanupStack::PopAndDestroy(ob); sl@0: } sl@0: sl@0: /** sl@0: @SYMTestCaseID PDS-CENTRALREPOSITORY-UT-4081 sl@0: @SYMTestCaseDesc sl@0: Test that the Observer compare function works properly with large UID's sl@0: @SYMTestPriority High sl@0: @SYMTestActions The test will insert a set of pointers with very big and small unsigned address sl@0: and ensure that the correct order is inserted in the list sl@0: @SYMTestExpectedResults the pointer is inserted in the correct order sl@0: @SYMDEF DEF132807 sl@0: */ sl@0: LOCAL_C void DEF132807L() sl@0: { sl@0: CObservable* ob = CObservable::NewLC(); sl@0: sl@0: const TUid KReposUid={0x87654321}; sl@0: sl@0: ob->AddObserverL(KReposUid,(CServerRepository*)0x7FFFFFFF); sl@0: ob->AddObserverL(KReposUid,(CServerRepository*)0x7FFFFFFE); sl@0: ob->AddObserverL(KReposUid,(CServerRepository*)0x8FFFFFFF); sl@0: ob->AddObserverL(KReposUid,(CServerRepository*)0x00000001); sl@0: sl@0: TEST(ob->iObservers.Count()==4); sl@0: CObservable::TRepositoryObserverInfo pos1=ob->iObservers[0]; sl@0: TEST(pos1.iRepositoryPointer==(CServerRepository*)0x00000001); sl@0: CObservable::TRepositoryObserverInfo pos2=ob->iObservers[1]; sl@0: TEST(pos2.iRepositoryPointer==(CServerRepository*)0x7FFFFFFE); sl@0: CObservable::TRepositoryObserverInfo pos3=ob->iObservers[2]; sl@0: TEST(pos3.iRepositoryPointer==(CServerRepository*)0x7FFFFFFF); sl@0: CObservable::TRepositoryObserverInfo pos4=ob->iObservers[3]; sl@0: TEST(pos4.iRepositoryPointer==(CServerRepository*)0x8FFFFFFF); sl@0: CleanupStack::PopAndDestroy(ob); sl@0: } sl@0: sl@0: //a test class notify handler sl@0: //the notify handler will check the value for different test case sl@0: static TInt currentTestCaseID=0; sl@0: sl@0: class CTestNotifyHandler : public CBase, public MCenRepNotifyHandlerCallback sl@0: { sl@0: public: sl@0: static CTestNotifyHandler* NewL() sl@0: { sl@0: return new (ELeave)CTestNotifyHandler; sl@0: } sl@0: ~CTestNotifyHandler(){} sl@0: // Notification handlers sl@0: void HandleNotifyInt(TUint32 aId, TInt aNewValue) sl@0: { sl@0: if (currentTestCaseID==0) sl@0: return; sl@0: else if(currentTestCaseID==1) sl@0: TEST(aId==1 && aNewValue==208); sl@0: } sl@0: void HandleNotifyReal(TUint32 aId, TReal /*aNewValue*/) sl@0: { sl@0: if (currentTestCaseID==2) sl@0: { sl@0: TEST(aId==1); sl@0: CActiveScheduler::Stop(); sl@0: } sl@0: } sl@0: void HandleNotifyString(TUint32 /*aId*/, const TDesC16& /*aNewValue*/) sl@0: { sl@0: } sl@0: void HandleNotifyBinary(TUint32 /*aId*/, const TDesC8& /*aNewValue*/) sl@0: { sl@0: } sl@0: void HandleNotifyGeneric(TUint32 /*aId*/) sl@0: { sl@0: } sl@0: void HandleNotifyError(TUint32 aId, TInt error, CCenRepNotifyHandler* /*aHandler*/) sl@0: { sl@0: if (currentTestCaseID==0) sl@0: return; sl@0: else if (currentTestCaseID==1) sl@0: TEST((TInt)aId==-11 && error==KErrArgument); sl@0: else if (currentTestCaseID==2) sl@0: TEST(aId==1 && error==KErrArgument); sl@0: else if (currentTestCaseID==3) sl@0: TEST(aId== 10000 && error==KErrPermissionDenied); sl@0: sl@0: CActiveScheduler::Stop(); sl@0: } sl@0: private: sl@0: CTestNotifyHandler(){} sl@0: }; sl@0: sl@0: /** sl@0: @SYMTestCaseID SYSLIB-CENTRALREPOSITORY-CT-4035 sl@0: @SYMTestCaseDesc Notify Handling in centralrepository under different error conditions sl@0: @SYMTestPriority High sl@0: @SYMTestActions Testing the CRepository::NotifyRequest under different error condition sl@0: Testing the CCenrepNotifierHandler under different error condition sl@0: @SYMTestExpectedResults Test should pass and exhibit the expected behaviour sl@0: @SYMDEF DEF117987 sl@0: */ sl@0: LOCAL_C void DEF117987L() sl@0: { sl@0: __UHEAP_MARK; sl@0: sl@0: CActiveScheduler* s=new(ELeave) CActiveScheduler; sl@0: CleanupStack::PushL(s); sl@0: CActiveScheduler::Install(s); sl@0: sl@0: const TUid KCDUid = {0xF0000001}; sl@0: CRepository* rep=CRepository::NewL(KCDUid); sl@0: sl@0: TRequestStatus ts,ts1; sl@0: sl@0: //-----------------single notification test----------------------- sl@0: //Negative testing for Double notification on same setting sl@0: TInt ret=rep->NotifyRequest(1,ts); sl@0: TEST(ret==KErrNone); sl@0: ret=rep->NotifyRequest(1,ts1); sl@0: TEST(ret==KErrNone); sl@0: ret=rep->Set(1,123); sl@0: User::WaitForRequest(ts); sl@0: User::WaitForRequest(ts1); sl@0: TEST(ts==1); sl@0: TEST(ts1==KErrAlreadyExists); sl@0: sl@0: //Negative testing for non-existent key--------------------------- sl@0: ts=KRequestPending; sl@0: ret=rep->NotifyRequest(10303,ts); sl@0: TEST(ret==KErrNotFound); sl@0: TEST(ts==KRequestPending); sl@0: sl@0: //Negative testing for key we dont have permission---------------- sl@0: ret=rep->NotifyRequest(10000,ts); sl@0: TEST(ret==KErrPermissionDenied); sl@0: TEST(ts==KRequestPending); sl@0: sl@0: //---------------------group notification test-------------------------- sl@0: ts=KRequestPending; sl@0: ts1=KRequestPending; sl@0: sl@0: //Negative testing for double notification on the same setting range sl@0: //set partial key 0 and mask 0xFFFFFF00 to filter only 0-255 sl@0: ret=rep->NotifyRequest(0,0xFFFFFF00,ts); sl@0: TEST(ret==KErrNone); sl@0: //second notification request on the same partial key and mask should not fail sl@0: ret=rep->NotifyRequest(0,0xFFFFFF00,ts1); sl@0: TEST(ret==KErrNone); sl@0: ret=rep->Set(1,246); sl@0: User::WaitForRequest(ts); sl@0: User::WaitForRequest(ts1); sl@0: TEST(ts==1); sl@0: TEST(ts1==1); sl@0: sl@0: //Negative testing for unknown range------------------------------ sl@0: //this will not return error code for range notification as it is intended for sl@0: //to cover keys created later in the future. sl@0: ts=KRequestPending; sl@0: ret=rep->NotifyRequest(100000,0xFFFFFFFF,ts); sl@0: TEST(ret==KErrNone); sl@0: ret=rep->NotifyCancel(100000,0xFFFFFFFF); sl@0: User::WaitForAnyRequest(); sl@0: TEST(ret==KErrNone); sl@0: TEST(ts==KUnspecifiedKey); sl@0: sl@0: //Negative testing for key we dont have permission------------------------------ sl@0: ts=KRequestPending; sl@0: ret=rep->NotifyRequest(10000,0xFFFFFFFF,ts); sl@0: TEST(ret==KErrNone); sl@0: User::WaitForRequest(ts); sl@0: TEST(ts==KErrPermissionDenied); sl@0: sl@0: delete rep; sl@0: sl@0: //----------------single notification using cenrepnotifhandler----------- sl@0: currentTestCaseID=1; sl@0: rep=CRepository::NewL(KCDUid); sl@0: //create the handler callback sl@0: CTestNotifyHandler* callback=CTestNotifyHandler::NewL(); sl@0: sl@0: //now setup the handler sl@0: CCenRepNotifyHandler* handler=CCenRepNotifyHandler::NewLC(*callback,*rep,CCenRepNotifyHandler::EIntKey,1); sl@0: CCenRepNotifyHandler* handler2=CCenRepNotifyHandler::NewLC(*callback,*rep,CCenRepNotifyHandler::EIntKey,1); sl@0: sl@0: handler->StartListeningL(); sl@0: handler2->StartListeningL(); sl@0: sl@0: ret=rep->Set(1,208); sl@0: TEST(ret==KErrNone); sl@0: sl@0: CActiveScheduler::Start(); sl@0: sl@0: User::After(1000000); sl@0: CleanupStack::PopAndDestroy(2); sl@0: sl@0: delete callback; sl@0: delete rep; sl@0: sl@0: CleanupStack::PopAndDestroy(); sl@0: sl@0: __UHEAP_MARKEND; sl@0: } sl@0: sl@0: /** sl@0: @SYMTestCaseID SYSLIB-CENTRALREPOSITORY-CT-4034 sl@0: @SYMTestCaseDesc Centrep notifier handler does not check return codes sl@0: @SYMTestPriority High sl@0: @SYMTestActions Test that error code encountered during handling of notification sl@0: results in the HandleNotifyError being invoked sl@0: @SYMTestExpectedResults Test should pass and exhibit the expected behaviour sl@0: @SYMDEF DEF117848 sl@0: */ sl@0: LOCAL_C void DEF117848L() sl@0: { sl@0: __UHEAP_MARK; sl@0: sl@0: CActiveScheduler* s=new(ELeave) CActiveScheduler; sl@0: CleanupStack::PushL(s); sl@0: CActiveScheduler::Install(s); sl@0: sl@0: const TUid KCDUid = {0xF0000001}; sl@0: sl@0: //create the handler callback sl@0: CTestNotifyHandler* callback=CTestNotifyHandler::NewL(); sl@0: sl@0: //----------------notify handle error test case------------------------------ sl@0: currentTestCaseID=2; sl@0: CRepository* rep=CRepository::NewL(KCDUid); sl@0: sl@0: //purposely set the notify handler for a key but specifying the wrong type sl@0: //this will only be detected during the notification sl@0: CCenRepNotifyHandler* handler=CCenRepNotifyHandler::NewLC(*callback,*rep,CCenRepNotifyHandler::ERealKey,1); sl@0: handler->StartListeningL(); sl@0: TInt ret=rep->Set(1,199); sl@0: TEST(ret==KErrNone); sl@0: sl@0: CActiveScheduler::Start(); sl@0: //handlenotify error will be called and validate the error code and then stop the scheduler sl@0: handler->StopListening(); sl@0: sl@0: CleanupStack::PopAndDestroy(); sl@0: sl@0: //test for other type of settings sl@0: handler=CCenRepNotifyHandler::NewLC(*callback,*rep,CCenRepNotifyHandler::EStringKey,1); sl@0: handler->StartListeningL(); sl@0: ret=rep->Set(1,209); sl@0: TEST(ret==KErrNone); sl@0: CActiveScheduler::Start(); sl@0: handler->StopListening(); sl@0: CleanupStack::PopAndDestroy(); sl@0: sl@0: //test for other type of settings sl@0: handler=CCenRepNotifyHandler::NewLC(*callback,*rep,CCenRepNotifyHandler::EBinaryKey,1); sl@0: handler->StartListeningL(); sl@0: ret=rep->Set(1,309); sl@0: TEST(ret==KErrNone); sl@0: sl@0: CActiveScheduler::Start(); sl@0: handler->StopListening(); sl@0: CleanupStack::PopAndDestroy(); sl@0: sl@0: delete callback; sl@0: delete rep; sl@0: sl@0: CleanupStack::PopAndDestroy(); sl@0: sl@0: __UHEAP_MARKEND; sl@0: } sl@0: sl@0: /** sl@0: @SYMTestCaseID SYSLIB-CENTRALREPOSITORY-CT-4036 sl@0: @SYMTestCaseDesc Central Repository Notification Handler flooded with notifications sl@0: @SYMTestPriority High sl@0: @SYMTestActions Testing the CCenrepNotifierHandler when the client does not have sl@0: enough permission when setting up the whole repository notifier. sl@0: @SYMTestExpectedResults Test should pass and exhibit the expected behaviour sl@0: @SYMDEF DEF118107 sl@0: */ sl@0: LOCAL_C void DEF118107L() sl@0: { sl@0: __UHEAP_MARK; sl@0: sl@0: currentTestCaseID = 3; sl@0: CActiveScheduler* s=new(ELeave) CActiveScheduler; sl@0: CleanupStack::PushL(s); sl@0: CActiveScheduler::Install(s); sl@0: sl@0: const TUid KCDUid = {0xF0000001}; sl@0: CRepository* rep=CRepository::NewL(KCDUid); sl@0: sl@0: //create the handler callback sl@0: CTestNotifyHandler* callback=CTestNotifyHandler::NewL(); sl@0: sl@0: //create a handler to listen to the whole repository sl@0: CCenRepNotifyHandler* handler=CCenRepNotifyHandler::NewLC(*callback,*rep); sl@0: sl@0: //Start listening as a fail should occur as one of repository entries does not sl@0: //have the correct capabilities sl@0: handler->StartListeningL(); sl@0: sl@0: //This causes the handlenotifyerror to be called which checks that sl@0: //KErrPermissionDenied has occured and stops the scheduler. sl@0: CActiveScheduler::Start(); sl@0: handler->StopListening(); sl@0: sl@0: //Cleanup sl@0: CleanupStack::PopAndDestroy(); sl@0: sl@0: delete callback; sl@0: delete rep; sl@0: sl@0: CleanupStack::PopAndDestroy(); sl@0: sl@0: __UHEAP_MARKEND; sl@0: } sl@0: sl@0: sl@0: // This function creates TServerSetting objects with the data in the ServerSettingStruct array and then sl@0: // appends them to the specified RSettingsArray object. sl@0: LOCAL_C void SetupSettingsArrayL(RSettingsArray& aSettingsArray,const ServerSettingStruct aSettingStructArr[], TInt aSettingStructArrSize) sl@0: { sl@0: for(TInt i = 0; i < aSettingStructArrSize; i++) sl@0: { sl@0: TServerSetting newSetting(aSettingStructArr[i].key); sl@0: TInt error; sl@0: newSetting.SetIntValue(aSettingStructArr[i].value); sl@0: newSetting.SetType(aSettingStructArr[i].meta); sl@0: newSetting.SetMeta(aSettingStructArr[i].meta); sl@0: sl@0: error = aSettingsArray.OrderedInsert(newSetting); sl@0: sl@0: if(KErrNone != error) sl@0: { sl@0: newSetting.Reset(); // for safety in case of newSetting is not TInt type. sl@0: User::Leave(error); sl@0: } sl@0: } sl@0: } sl@0: sl@0: // This function compares 2 RSettingsArray arrays. Panics if they are not identical sl@0: LOCAL_C void CompareSettingsArrays(const RSettingsArray& aArr1, const RSettingsArray& aArr2) sl@0: { sl@0: TEST2(aArr1.Count(), aArr2.Count()); sl@0: for(TInt i = 0; i < aArr2.Count(); i++) sl@0: { sl@0: if(aArr1[i].IsDeleted()) sl@0: { sl@0: TEST(aArr2[i].IsDeleted()); sl@0: } sl@0: else sl@0: { sl@0: TEST(aArr1[i] == aArr2[i]); sl@0: } sl@0: } sl@0: } sl@0: sl@0: // This function compares 2 RArray arrays. Panics if they are not identical sl@0: LOCAL_C void CompareUint32Arrays(const RArray& aArr1, const RArray& aArr2) sl@0: { sl@0: TEST2(aArr1.Count(), aArr2.Count()); sl@0: for(TInt i = 0; i < aArr2.Count(); i++) sl@0: { sl@0: TEST(aArr1[i] == aArr2[i]); sl@0: } sl@0: } sl@0: sl@0: // This function calls MergerArray() with the pre-set parameters for each merge type and compares the results to sl@0: // the reference arrays. sl@0: // Also used as the OOM test if aOOMMode is ETrue. sl@0: LOCAL_C void MergerArrayTestL(const RSettingsArray aPersistRef[], const RSettingsArray aChangeRef[], const RArray aDeletedRef[], TBool aOOMMode) sl@0: sl@0: { sl@0: // Data used to construct the persistence array for all merge types sl@0: static const ServerSettingStruct settingStructPersist[] = {{1,0,1}, {3,KMetaBackup,3}, {5,0,5}, {7,0,7}, {9,KMetaDefaultValue,9}, {11,0,11}, {13,KMetaDefaultValue,13}}; sl@0: sl@0: // Data used to construct the changes array for merge type: ETransactionMerge. Some are marked as deleted. sl@0: static const ServerSettingStruct settingStructChangeTrans[] = {{1,TServerSetting::EDeleted,1}, {2,TServerSetting::EDeleted,2}, \ sl@0: {3,TServerSetting::EDeleted,3}, {4,0,4}, {5,0,5}, {6,0,6}, {7,0,8}, {9,0,10}}; sl@0: sl@0: // Data used to construct the changes array for all other merge types than ETransactionMerge. No deleted items. sl@0: static const ServerSettingStruct settingStructChange[] = {{1,0,1}, {2,0,2}, {3,0,3}, {4,0,4}, {5,0,5}, {6,0,6}, {7,0,8}, {9,0,10}}; sl@0: sl@0: for(TInt i = 0; i < sizeof(KMergerTypes) / sizeof(TMergeType); i++) sl@0: { sl@0: RSettingsArray persist; sl@0: RSettingsArray change; sl@0: RArray deleted; sl@0: TInt error = KErrNone ; sl@0: TInt count = 0; sl@0: sl@0: do sl@0: { sl@0: __UHEAP_MARK; sl@0: sl@0: // Sets up arrays passed into MergeArray() sl@0: SetupSettingsArrayL(persist,settingStructPersist, sizeof(settingStructPersist)/sizeof(ServerSettingStruct)); sl@0: if( ETransactionMerge == KMergerTypes[i] ) sl@0: { sl@0: SetupSettingsArrayL(change,settingStructChangeTrans, sizeof(settingStructChangeTrans)/sizeof(ServerSettingStruct)); sl@0: } sl@0: else sl@0: { sl@0: SetupSettingsArrayL(change,settingStructChange, sizeof(settingStructChange)/sizeof(ServerSettingStruct)); sl@0: } sl@0: sl@0: deleted.InsertInUnsignedKeyOrderL(4); sl@0: sl@0: if(aOOMMode) sl@0: { sl@0: __UHEAP_SETFAIL(RHeap::EFailNext, ++count); sl@0: } sl@0: sl@0: error = persist.MergeArray(change, deleted, KMergerTypes[i]); sl@0: sl@0: if (aOOMMode) sl@0: { sl@0: TEST(KErrNone == error || KErrNoMemory == error); sl@0: __UHEAP_SETFAIL(RHeap::ENone, 0); sl@0: } sl@0: else sl@0: { sl@0: TEST(KErrNone == error); sl@0: // Verifies affected arrays. sl@0: CompareSettingsArrays(persist, aPersistRef[i]); sl@0: CompareSettingsArrays(change, aChangeRef[i]); sl@0: CompareUint32Arrays(deleted, aDeletedRef[i]); sl@0: } sl@0: sl@0: // Resets the arrays. sl@0: persist.Reset(); sl@0: change.Reset(); sl@0: deleted.Reset(); sl@0: sl@0: __UHEAP_MARKEND; sl@0: } while(KErrNoMemory == error); sl@0: if (aOOMMode) sl@0: { sl@0: TheTest.Printf(_L("- MergeArray for type %d succeeded at heap failure rate of %i\n"), KMergerTypes[i], count); sl@0: } sl@0: } sl@0: } sl@0: sl@0: /** sl@0: @SYMTestCaseID SYSLIB-CENTRALREPOSITORY-UT-4037 sl@0: @SYMTestCaseDesc This test case verifies the re-factored CentralRepository internal merge function (MergeArray). sl@0: @SYMTestPriority High sl@0: @SYMTestActions For each merger type, calls MergeArray() with the pre-defined arrays: this, aChanges, aDeleted, sl@0: which would be changed by the function. Verifies these 3 arrays with the reference arrays as well as sl@0: the return code after MergeArray() returns. sl@0: This case also carries out the OOM test for function MergeArray(). sl@0: @SYMTestExpectedResults MergeArray() should return no error and these 3 arrays should be identical with the reference sl@0: arrays. In OOM mode, only KErrNoMemory or KErrNone should be returned. sl@0: @SYMDEF DEF116629 sl@0: */ sl@0: LOCAL_C void DEF116629L() sl@0: { sl@0: sl@0: // Data used to construct the reference arrays of each merge type: sl@0: // ETransactionMerge sl@0: const ServerSettingStruct settingStructPersistAfterTrans[] = {{4,0,4}, {5,0,5}, {6,0,6}, {7,0,8}, {9,0,10}, {11,0,11}, {13,0,13}}; sl@0: const ServerSettingStruct settingStructChangeAfterTrans[] = {{1,TServerSetting::EDeleted,1}, sl@0: {3,TServerSetting::EDeleted,3}, {4,0,4}, {6,0,6}, {7,0,8}, {9,0,10}}; sl@0: sl@0: // ERestoreMerge sl@0: const ServerSettingStruct settingStructPersistAfterRest[] = {{1,0,1}, {2,0,2}, {3,KMetaBackup,3}, {4,0,4}, {5,0,5}, {6,0,6}, {7,0,8}, {9,0,10}, {11,0,11}, {13,0,13}}; sl@0: const ServerSettingStruct settingStructChangeAfterRest[] = {{2,0,2}, {4,0,4}, {6,0,6}, {7,0,8}, {9,0,10}}; sl@0: sl@0: // ESWIUpgradeMerge sl@0: const ServerSettingStruct settingStructPersistAfterSWIUp[] = {{1,0,1}, {2,0,2}, {3,KMetaBackup,3}, {4,0,4}, {5,0,5}, {6,0,6}, {7,0,7}, {9,0,10}, {11,0,11}, {13,0,13}}; sl@0: const ServerSettingStruct settingStructChangeAfterSWIUp[] = {{2,0,2}, {4,0,4}, {6,0,6}, {9,0,10}}; sl@0: sl@0: // ESWIDowngradeMerge sl@0: const ServerSettingStruct settingStructPersistAfterSWIDown[] = {{1,0,1}, {2,0,2}, {3,KMetaBackup,3}, {4,0,4}, {5,0,5}, {6,0,6}, {7,0,7}, {9,0,10}, {11,0,11}}; sl@0: const ServerSettingStruct settingStructChangeAfterSWIDown[] = {{2,0,2}, {4,0,4}, {6,0,6}, {9,0,10}, {13,0,0}}; sl@0: sl@0: // ERomFlash sl@0: const ServerSettingStruct settingStructPersistAfterRomFlash[] = {{1,0,1}, {2,0,2}, {3,KMetaBackup,3}, {4,0,4}, {5,0,5}, {6,0,6}, {7,0,7}, {9,0,10}, {11,0,11}}; sl@0: const ServerSettingStruct settingStructChangeAfterRomFlash[] = {{1,0,1}, {2,0,2}, {3,0,3}, {4,0,4}, {5,0,5}, {6,0,6}, {7,0,8}, {9,0,10}}; sl@0: sl@0: // Reference arrays sl@0: RSettingsArray persistAfter[5]; sl@0: RSettingsArray changeAfter[5]; sl@0: RArray deletedAfter[5]; sl@0: sl@0: // Sets up the reference arrays for each merge type: sl@0: // ETransactionMerge sl@0: SetupSettingsArrayL(persistAfter[0],settingStructPersistAfterTrans, sizeof(settingStructPersistAfterTrans)/sizeof(ServerSettingStruct)); sl@0: SetupSettingsArrayL(changeAfter[0],settingStructChangeAfterTrans, sizeof(settingStructChangeAfterTrans)/sizeof(ServerSettingStruct)); sl@0: deletedAfter[0].InsertInUnsignedKeyOrderL(3); sl@0: sl@0: // ERestoreMerge sl@0: SetupSettingsArrayL(persistAfter[1],settingStructPersistAfterRest, sizeof(settingStructPersistAfterRest)/sizeof(ServerSettingStruct)); sl@0: SetupSettingsArrayL(changeAfter[1],settingStructChangeAfterRest, sizeof(settingStructChangeAfterRest)/sizeof(ServerSettingStruct)); sl@0: //deletedAfter[1] should be empty because Restore Merge should not delete any setting. sl@0: sl@0: // ESWIUpgradeMerge sl@0: SetupSettingsArrayL(persistAfter[2],settingStructPersistAfterSWIUp, sizeof(settingStructPersistAfterSWIUp)/sizeof(ServerSettingStruct)); sl@0: SetupSettingsArrayL(changeAfter[2],settingStructChangeAfterSWIUp, sizeof(settingStructChangeAfterSWIUp)/sizeof(ServerSettingStruct)); sl@0: //deletedAfter[2] should be empty because SWIUpgrade Merge should not delete any setting. sl@0: sl@0: // ESWIDowngradeMerge sl@0: SetupSettingsArrayL(persistAfter[3],settingStructPersistAfterSWIDown, sizeof(settingStructPersistAfterSWIDown)/sizeof(ServerSettingStruct)); sl@0: SetupSettingsArrayL(changeAfter[3],settingStructChangeAfterSWIDown, sizeof(settingStructChangeAfterSWIDown)/sizeof(ServerSettingStruct)); sl@0: //deletedAfter[3] should be empty because settings deleted by SWIDowngrade Merge are recorded in aChanges. sl@0: sl@0: // ERomFlash sl@0: SetupSettingsArrayL(persistAfter[4],settingStructPersistAfterRomFlash, sizeof(settingStructPersistAfterRomFlash)/sizeof(ServerSettingStruct)); sl@0: SetupSettingsArrayL(changeAfter[4],settingStructChangeAfterRomFlash, sizeof(settingStructChangeAfterRomFlash)/sizeof(ServerSettingStruct)); sl@0: //deletedAfter[4] should be empty because settings deleted by RomFlash Merge are recorded in aChanges. sl@0: sl@0: TheTest.Printf(_L("- Verification test for MergeArray.\n")); sl@0: MergerArrayTestL(persistAfter, changeAfter, deletedAfter, EFalse); sl@0: sl@0: TheTest.Printf(_L("- OOM test for MergeArray.\n")); sl@0: MergerArrayTestL(persistAfter, changeAfter, deletedAfter, ETrue); sl@0: sl@0: // Resets the reference arrays. sl@0: for(TInt i = 0; i < sizeof(KMergerTypes) / sizeof(TMergeType); i++) sl@0: { sl@0: persistAfter[i].Reset(); sl@0: changeAfter[i].Reset(); sl@0: deletedAfter[i].Reset(); sl@0: } sl@0: } sl@0: /** sl@0: @SYMTestCaseID PDS-CENTRALREPOSITORY-UT-4046 sl@0: @SYMTestCaseDesc The centrep server panics when it reads a repository text file where sl@0: the value of a binary settings is missing. sl@0: @SYMTestPriority Medium sl@0: @SYMTestActions - Provide a repository text file for this test which have a binary sl@0: setting which value is missing. sl@0: - Open the repository text file, sl@0: this should return KErrCorrupt when parsing the repository text file. sl@0: @SYMTestExpectedResults The test must not fail. sl@0: @SYMDEF PDEF126904 sl@0: */ sl@0: LOCAL_C void PDEF126904L() sl@0: { sl@0: const TUid KUidBinaryValueRepositoryFile ={0x1020506B}; sl@0: const TInt KBinaryValueRepKey = 0xA; sl@0: TInt binaryValue = 0; sl@0: CRepository* repository = NULL; sl@0: sl@0: TRAPD(res, repository = CRepository::NewL(KUidBinaryValueRepositoryFile)); sl@0: if (res == KErrNone) sl@0: { sl@0: TInt err = KErrNone; sl@0: CleanupStack::PushL(repository); sl@0: err = repository->Get(KBinaryValueRepKey, binaryValue); sl@0: User::LeaveIfError(err); sl@0: CleanupStack::PopAndDestroy(repository); sl@0: } sl@0: else if (res == KErrCorrupt) sl@0: { sl@0: //This is just to confirm that the err should be KErrCorrupt. sl@0: TheTest.Printf(_L("The error is KErrCorrupt as expected.\n")); sl@0: } sl@0: else sl@0: { sl@0: User::Leave(res); sl@0: } sl@0: } sl@0: sl@0: /** sl@0: @SYMTestCaseID PDS-CENTRALREPOSITORY-UT-4084 sl@0: @SYMTestCaseDesc Ensure that the timestamp in a TXT file is always zero when not specified sl@0: instead of arbitrary value sl@0: @SYMTestPriority Medium sl@0: @SYMTestActions Create the CHeapRepository object from a TXT keyspace file where no timestamp(legacy) sl@0: section is specified. The timestamp should be set to zero sl@0: @SYMTestExpectedResults The test must not fail. sl@0: @SYMDEF DEF136161 sl@0: */ sl@0: LOCAL_C void DEF136161L() sl@0: { sl@0: RFs fs; sl@0: User::LeaveIfError(fs.Connect()); sl@0: sl@0: //this is a TXT based ROM keyspace sl@0: const TUid KTestUid={0x00000001}; sl@0: sl@0: CHeapRepository* repos=CHeapRepository::NewL(KTestUid); sl@0: CIniFileIn* iniFile; sl@0: TInt ret=CIniFileIn::NewLC(fs,iniFile,_L("z:\\private\\10202be9\\00000001.txt")); sl@0: User::LeaveIfError(ret); sl@0: repos->ReloadContentL(*iniFile); sl@0: sl@0: //check the timestamp is always set to zero sl@0: TEST(repos->TimeStamp()==TTime(0)); sl@0: sl@0: CleanupStack::PopAndDestroy(iniFile); sl@0: delete repos; sl@0: sl@0: fs.Close(); sl@0: } sl@0: sl@0: /** sl@0: @SYMTestCaseID PDS-CENTRALREPOSITORY-UT-4085 sl@0: @SYMTestCaseDesc Central Repository: Trying to configure Central Repository cache with centrep.in sl@0: @SYMTestPriority High sl@0: @SYMTestActions Testing that the SWIWatcher does nto leave when the cache configuration exists within sl@0: the private data cate sl@0: @SYMTestExpectedResults Test should pass and exhibit the expected behaviour sl@0: @SYMDEF PDEF139979 sl@0: */ sl@0: LOCAL_C void PDEF139979L() sl@0: { sl@0: __UHEAP_MARK; sl@0: CActiveScheduler* s=new(ELeave) CActiveScheduler; sl@0: CleanupStack::PushL(s); sl@0: CActiveScheduler::Install(s); sl@0: sl@0: RFs fs; sl@0: User::LeaveIfError(fs.Connect()); sl@0: CleanupClosePushL(fs); sl@0: sl@0: CFileMan* fm = CFileMan::NewL(fs); sl@0: CleanupStack::PushL(fm); sl@0: sl@0: TRAPD(err,TServerResources::InitialiseL()); sl@0: TEST2(err,KErrNone); sl@0: sl@0: delete TServerResources::iInstallDirectory; sl@0: _LIT(KInstallFolder,"c:\\private\\12345678\\"); sl@0: TServerResources::iInstallDirectory=(KInstallFolder()).AllocL(); sl@0: TInt erro=fm->Delete(_L("c:\\private\\12345678\\*.*")); sl@0: //copy centrep.ini file to the install folder sl@0: _LIT(KSource,"z:\\private\\10202be9\\centrepcache.ini0"); sl@0: _LIT(KDestination,"c:\\private\\12345678\\centrep.ini"); sl@0: TRAP(err,CopyTestFilesL(*fm,KSource(),KDestination())); sl@0: sl@0: CCentRepSWIWatcher* swi=CCentRepSWIWatcher::NewL(fs); sl@0: TRAP(err,swi->FindChangedEntriesL(EFalse)); sl@0: TEST2(err,KErrNone); sl@0: sl@0: delete swi; sl@0: TServerResources::Close(); sl@0: sl@0: //delete the c file before we exit sl@0: fm->Delete(KDestination()); sl@0: sl@0: CleanupStack::PopAndDestroy(3); sl@0: __UHEAP_MARKEND; sl@0: } sl@0: sl@0: /** sl@0: @SYMTestCaseID PDS-CENTRALREPOSITORY-UT-4086 sl@0: @SYMTestCaseDesc centralrepositorysrv.exe crashes and phone doesn't boot up sl@0: @SYMTestPriority High sl@0: @SYMTestActions Test merging two settings of different type, one type exist for sl@0: persist and one type for the new rom, when the type differes, we expect the sl@0: persist setting to be completely replaced by the rom. sl@0: @SYMTestExpectedResults The test must not panic or fail. sl@0: @SYMDEF PDEF141519 sl@0: */ sl@0: LOCAL_C void PDEF141519L() sl@0: { sl@0: __UHEAP_MARK; sl@0: sl@0: RSettingsArray persist; sl@0: RSettingsArray newRom; sl@0: RArray deletedSettings; sl@0: //persist setting sl@0: TServerSetting a(0x10); sl@0: a.SetType(TServerSetting::EInt); sl@0: a.SetIntValue(100); sl@0: persist.OrderedInsertL(a); sl@0: sl@0: //new rom setting sl@0: TServerSetting b(0x10); sl@0: b.SetType(TServerSetting::EString); sl@0: TBuf8<5> buffer(_L8("abc")); sl@0: HBufC8* hbuf=buffer.AllocL(); sl@0: b.SetStrValue(hbuf); sl@0: newRom.OrderedInsertL(b); sl@0: sl@0: User::LeaveIfError(persist.MergeArray(newRom,deletedSettings,ERomFlash)); sl@0: TServerSetting* persistEntry=persist.Find(0x10); sl@0: TEST2(persistEntry->Key(),0x10); sl@0: TEST2(persistEntry->Type(),TServerSetting::EString); sl@0: const HBufC8* val=persistEntry->GetStrValue(); sl@0: TEST2(val->Compare(buffer),0); sl@0: sl@0: persist.Close(); sl@0: newRom.Close(); sl@0: sl@0: __UHEAP_MARKEND; sl@0: } sl@0: sl@0: LOCAL_C void ConnectStartSuicideTransL(void) sl@0: { sl@0: const TUid KLargeReposUid1 ={0xcccccc00}; sl@0: CRepository* repository=CRepository::NewL(KLargeReposUid1); sl@0: repository->StartTransaction(CRepository::EConcurrentReadWriteTransaction); sl@0: } sl@0: sl@0: LOCAL_C TInt SuicidalTransThread(TAny*) sl@0: { sl@0: CTrapCleanup* cleanup = CTrapCleanup::New(); sl@0: if(!cleanup) sl@0: return KErrNoMemory; sl@0: sl@0: TRAP_IGNORE(ConnectStartSuicideTransL()); sl@0: //purposely waiting to be killed sl@0: User::WaitForAnyRequest(); sl@0: return 0; sl@0: } sl@0: sl@0: LOCAL_C void DEF143352L() sl@0: { sl@0: CleanupCDriveL(); sl@0: __UHEAP_MARK; sl@0: sl@0: const TUid KLargeReposUid1 ={0xcccccc00}; sl@0: //create on in this thread and start transaction too sl@0: CRepository* rep1=CRepository::NewL(KLargeReposUid1); sl@0: User::LeaveIfError(rep1->StartTransaction(CRepository::EConcurrentReadWriteTransaction)); sl@0: sl@0: //create thread to connect, start transaction on the same repository as previous sl@0: RThread testThread; sl@0: _LIT(KThreadName1, "Martin"); sl@0: testThread.Create(KThreadName1, SuicidalTransThread, KDefaultStackSize, KMinHeapSize, 0x100000, NULL); sl@0: sl@0: TRequestStatus requestStatus; sl@0: testThread.Logon(requestStatus); sl@0: testThread.Resume(); sl@0: sl@0: //wait for the first client to complete the start transaction sl@0: User::After(1000000); sl@0: sl@0: //opening another big keyspace to force the eviction(cache size is 100K) both repository is about 78K in the heap sl@0: //cccccc03 is exactly the same as cccccc00 sl@0: const TUid KLargeReposUid2 ={0xcccccc04}; sl@0: CRepository* rep2=CRepository::NewL(KLargeReposUid2); sl@0: sl@0: //now kill the thread we have created sl@0: testThread.Kill(KErrDied); sl@0: User::WaitForRequest(requestStatus); sl@0: TEST2(requestStatus.Int(), KErrDied); sl@0: sl@0: //Wait for the session to be cleaned up sl@0: User::After(1000000); sl@0: sl@0: //now current test thread will retry the same connection sl@0: //at this stage server will panic with kern-exec 3 sl@0: CRepository* rep4=CRepository::NewL(KLargeReposUid1); sl@0: sl@0: delete rep1; sl@0: delete rep2; sl@0: delete rep4; sl@0: sl@0: __UHEAP_MARKEND; sl@0: } sl@0: sl@0: LOCAL_C void FuncTestsL() sl@0: { sl@0: TheTest.Start(_L("DEF053500 - Central repository integer type key entries cannot handle hex values")); sl@0: sl@0: DEF053500L(); sl@0: sl@0: TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-CENTRALREPOSITORY-CT-4015 DEF111734 - Central repository crashes when accessing a closed repository with active transaction ")); sl@0: DEF111734L(); sl@0: sl@0: TheTest.Next(_L("DEF054368 - MetaData value in CentRep setting is not optional")); sl@0: DEF054368L(); sl@0: sl@0: TheTest.Next(_L("DEF055680 - Central repository find performance could be improved ")); sl@0: DEF055680L(); sl@0: sl@0: TheTest.Next(_L("INC054688 - Key based capabilities in ini-file crashes cenrep server ")); sl@0: INC054688L(); sl@0: sl@0: TheTest.Next(_L("DEF054632 - CenRep Initialisation default data does not work as expected")); sl@0: DEF054632L(); sl@0: sl@0: TheTest.Next(_L("DEF055661 - Central Repository does not allow AlwaysFail to be set for access control. ")); sl@0: DEF055661L(); sl@0: sl@0: TheTest.Next(_L("DEF055267 - Can not insert more than 71 records into WapAccessPoint Table ")); sl@0: DEF055267L(); sl@0: sl@0: TheTest.Next(_L("INC056194 - NTT - Central Repository checks DefaultWriteAccessPolicy when cancelling notif ")); sl@0: INC056194L(); sl@0: sl@0: TheTest.Next(_L("DEF057145 - CenRepSrv KERN-EXEC3 when running CommDB test harness ")); sl@0: DEF057145L(); sl@0: sl@0: TheTest.Next(_L("DEF057778 - Central repository ResetAll can cause user Panic 190 ")); sl@0: DEF057778L(); sl@0: sl@0: TheTest.Next(_L("DEF057522 - Centralrepository security policy incorrect behaviour ")); sl@0: DEF057522L(); sl@0: sl@0: TheTest.Next(_L("DEF057999 - Creating and deleting the same setting in a transaction doesn't work ")); sl@0: DEF057999L(); sl@0: sl@0: TheTest.Next(_L("DEF057470 - Central repository lacks a range delete method ")); sl@0: DEF057470L(); sl@0: sl@0: TheTest.Next(_L("INC058229 - CInstallFileWatcher::ReadInstallDirL contains insufficient error handling ")); sl@0: INC058229L(); sl@0: sl@0: TheTest.Next(_L("DEF058900 - CentralRepository Notification section document needs update ")); sl@0: DEF058900L(); sl@0: sl@0: TheTest.Next(_L("DEF061087 - Central repository cannot handle more than one range policy ")); sl@0: DEF061087L(); sl@0: sl@0: TheTest.Next(_L("DEF060843 - [PSAudit] Lack of centralrep. data type checking could cause instability & bugs ")); sl@0: DEF060843L(); sl@0: sl@0: TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-CENTRALREPOSITORY-CT-1433 INC069013 - Central repository panics the client when trying to read 8-bit descriptor with uneven length ")); sl@0: INC069013L(); sl@0: sl@0: TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-CENTRALREPOSITORY-CT-1434 DEF070731 - Central repository doesn't handle corrupt .cre files correctly. ")); sl@0: DEF070731L(); sl@0: sl@0: TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-CENTRALREPOSITORY-CT-1683 DEF084700 - UIF automated tests crash H4 board. ")); sl@0: DEF084700L(); sl@0: sl@0: TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-CENTRALREPOSITORY-CT-1862 DEF089945: [AQP] CommitTransaction returns incorrect error code if Find~L methods run OOM ")); sl@0: DEF089945L(); sl@0: sl@0: TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-CENTRALREPOSITORY-CT-3242 PDEF098500 - Backup to memory card causes phone freeze ")); sl@0: PDEF098500(); sl@0: sl@0: TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-CENTRALREPOSITORY-CT-1884 DEF093855: CenRep cancels transactions if they exceed 5 seconds... ")); sl@0: DEF093855L(); sl@0: sl@0: sl@0: // When adding a new defect test, if you decide to reuse a repository that has already been used sl@0: // in another defect test, make sure you modify the existing test which uses the repository and sl@0: // add the cache delay after that test closes the repository. e.g. DEF055680L sl@0: sl@0: TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-CENTRALREPOSITORY-CT-3477 PDEF106507 - Currupt installdir.bin file causes server to crash ")); sl@0: PDEF106507L(); sl@0: sl@0: TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-CENTRALREPOSITORY-CT-3517 INC108803 - R3.2 stability problems: CentralRepositorySrv crash ")); sl@0: INC108803L(); sl@0: sl@0: TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-CENTRALREPOSITORY-CT-3545 DEF109390: Centrep cache ini file corruption should not cause server crash. ")); sl@0: DEF109390L(); sl@0: sl@0: TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-CENTRALREPOSITORY-UT-4024 DEF116043: Cenrep doesn't protect against overflows in sorting ")); sl@0: DEF116043L(); sl@0: sl@0: TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-CENTRALREPOSITORY-CT-4035 DEF117987: CenrepNotify handler does not leave/return error ")); sl@0: DEF117987L(); sl@0: sl@0: TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-CENTRALREPOSITORY-CT-4034 DEF117848: Centrep notifier handler does not check return codes ")); sl@0: DEF117848L(); sl@0: sl@0: TheTest.Next(_L(" @SYMTestCaseID SYSLIB-CENTRALREPOSITORY-CT-4036 DEF118107: Central Repository Notification Handler flooded with notifications ")); sl@0: DEF118107L(); sl@0: sl@0: TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-CENTRALREPOSITORY-UT-4037 DEF116629: CentralRepository internal merge function need to be refactored and documented")); sl@0: DEF116629L(); sl@0: sl@0: TheTest.Next(_L(" @SYMTestCaseID:PDS-CENTRALREPOSITORY-UT-4046 PDEF126904 - Ini-file parsing of Symbian provided central repository server crashes")); sl@0: PDEF126904L(); sl@0: TheTest.Next(_L(" @SYMTestCaseID:PDS-CENTRALREPOSITORY-UT-4081 DEF132807 - CObservable::ObserverSortOrder ordering algorithm is wrong ")); sl@0: DEF132807L(); sl@0: sl@0: TheTest.Next(_L("@SYMTestCaseID:PDS-CENTRALREPOSITORY-UT-4084 DEF136161: CenRep file timestamp is never intialised ")); sl@0: DEF136161L(); sl@0: sl@0: TheTest.Next(_L("@SYMTestCaseID:PDS-CENTRALREPOSITORY-UT-4085 PDEF139979: Central Repository: Trying to configure Central Repository cache with centrep.in ")); sl@0: PDEF139979L(); sl@0: sl@0: TheTest.Next(_L("@SYMTestCaseID:PDS-CENTRALREPOSITORY-UT-4086 PDEF141518: centralrepositorysrv.exe crashes and phone doesn't boot up ")); sl@0: PDEF141519L(); sl@0: sl@0: TheTest.Next(_L("@SYMTestCaseID:PDS-CENTRALREPOSITORY-CT-XXXX DEF143352: CentralRepository server crash in CObservable::RefreshTransactorAccessPolicies ")); sl@0: DEF143352L(); sl@0: sl@0: TheTest.End(); sl@0: } sl@0: sl@0: LOCAL_C void MainL() sl@0: { sl@0: TheTest.Start(_L("Defect tests")); sl@0: CleanupCDriveL(); sl@0: sl@0: FuncTestsL(); sl@0: sl@0: TheTest.Next(_L("Clean out C: files")); sl@0: CleanupCDriveL(); sl@0: sl@0: TheTest.End(); sl@0: TheTest.Close(); sl@0: } sl@0: sl@0: TInt E32Main() sl@0: { sl@0: // sl@0: // For the tests to work we need SID policing enforced plus the specific sl@0: // capabilities listed below. sl@0: // sl@0: // These are dependent on the capabilities set in the platform security sl@0: // repository test initialisation file 87654321.txt. If the content sl@0: // of that file changes then the following clauses may need to be sl@0: // updated. sl@0: // sl@0: if(!PlatSec::ConfigSetting(PlatSec::EPlatSecEnforcement) || sl@0: !PlatSec::IsCapabilityEnforced(ECapabilityNetworkServices) || sl@0: !PlatSec::IsCapabilityEnforced(ECapabilityDRM) || sl@0: !PlatSec::IsCapabilityEnforced(ECapabilityLocalServices) || sl@0: !PlatSec::IsCapabilityEnforced(ECapabilityCommDD)) sl@0: { sl@0: TheTest.Start(_L("NOTE: Skipping tests due to incompatible PlatSec enforcement settings")); sl@0: TheTest.End(); sl@0: TheTest.Close(); sl@0: return 0; sl@0: } sl@0: sl@0: __UHEAP_MARK; sl@0: CTrapCleanup* cleanup = CTrapCleanup::New(); sl@0: if(!cleanup) sl@0: return KErrNoMemory; sl@0: sl@0: TRAPD(err, MainL()); sl@0: if (err != KErrNone) sl@0: User::Panic(_L("Testing failed: "), err); sl@0: sl@0: delete cleanup; sl@0: __UHEAP_MARKEND; sl@0: sl@0: return 0; sl@0: }