/*
* Copyright (c) 2005 Nokia Corporation and/or its subsidiary(-ies). 
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of "Eclipse Public License v1.0"
* which accompanies this distribution, and is available
* at the URL "http://www.eclipse.org/legal/epl-v10.html".
*
* Initial Contributors:
* Nokia Corporation - initial contribution.
*
* Contributors:
*
* Description: 
*   ?description_line
*
*/


//  INCLUDES
#include "FT_CPosTp134.h"
#include <EPos_CPosLandmarkDatabase.h>
#include <EPos_CPosLmMultiDbSearch.h> 
#include <EPos_CPosLmTextCriteria.h>
#include <EPos_CPosLmCatNameCriteria.h>
#include <EPos_CPosLMItemIterator.h>    
#include <EPos_TPosLMSortPref.h>
#include "FT_CSearchResult.h"
#include <EPos_CPosLmDatabaseManager.h>
#include <EPos_CPosLmDisplayData.h>
#include <EPos_CPosLmDisplayItem.h>
#include "FT_LandmarkConstants.h"
#include <centralrepository.h>
     
// CONSTANTS
_LIT(KUriDb01, "C:TP104DB01.LDB");
_LIT(KUriDb01Full, "file://C:TP104DB01.LDB");
_LIT(KUriDb02Full, "file://C:TP104DB02.LDB");
_LIT(KUriDb02, "C:TP104DB02.LDB");
_LIT(KUriDbNonExisting, "file://C:TP104DBBLABLA.LDB");
_LIT(KUriDbCorrupt, ":jf785hjtr748.abc");
_LIT(KUriNotSupported, "bike://test/tp104.wheel");
_LIT(KProtocolFile, "file");

#ifdef __WINS__
    _LIT(KUriRemovableMediaDb, "file://D:REMOVABLEDB.LDB");
    _LIT(KUriRemovableMediaDbNonExisting, "file://D:REMOVABLEDBBLABLA.LDB");
    #else
    _LIT(KUriRemovableMediaDb, "file://F:REMOVABLEDB.LDB");
    _LIT(KUriRemovableMediaDbNonExisting, "file://F:REMOVABLEDBBLABLA.LDB");
    #endif
    
_LIT(KNewDbName, "TP134 Disp Name");

_LIT(KErrorWrongDrive, "Wrong drive returned from db info");

_LIT(KErrorWrongDefault, "Wrong default db returned from db info");
_LIT(KErrorWrongDbUri, "Wrong db uri returned from db info");
_LIT(KErrorWrongProtocol, "Wrong protocol returned from db info");
_LIT(KErrorWrongDbName, "Wrong db name returned from db info");
_LIT(KErrorWrongAttributeInfo, "Wrong attribute info from db info");
_LIT(KErrorWrongNrOfDbs, "Wrong nr of db:s for ListDatasesL");
_LIT(KErrorWrongCodeForNonExistingDb, "Wrong error code for non-existing db");
_LIT(KErrorWrongCodeForNonExistingDbRem, "Wrong error code for non-existing db on removable media");
_LIT(KErrorWrongCodeForCorruptUri, "Wrong error code for corrupt uri");
_LIT(KErrorWrongCodeForNotSupportedUri, "Wrong error code for not supported uri");

// ================= MEMBER FUNCTIONS =======================
// Cleanup for RPointerArray<HPosLmDatabaseInfo> objects
void TP134CleanupTestPointerArray(TAny* aArray)

    {
    (static_cast<RPointerArray<HPosLmDatabaseInfo>*>(aArray))->ResetAndDestroy();
    }

// ---------------------------------------------------------
// CPosTp134::CloseTest
//
// (other items were commented in a header).
// ---------------------------------------------------------
//
void CPosTp134::CloseTest()
    {
    iLog->Log(_L("CloseTest"));
    }

// ---------------------------------------------------------
// CPosTp134::StartL
//
// (other items were commented in a header).
// ---------------------------------------------------------
//
void CPosTp134::StartL()
    {
    iLog->Log(_L("Warning: this test case requires E: drive"));
    
    iErrorsFound = KErrNone;
    RemoveAllLmDatabasesL();
    SetupExpectedResultsL();
    // Create the test DB:s
    iDbMan = CPosLmDatabaseManager::NewL();
    HPosLmDatabaseInfo* dbInfo01 = HPosLmDatabaseInfo::NewLC(KUriDb01);
    iDbMan->CreateDatabaseL(*dbInfo01);
    CleanupStack::PopAndDestroy(dbInfo01);
    HPosLmDatabaseInfo* dbInfo02 = HPosLmDatabaseInfo::NewLC(KUriDb02);
    iDbMan->CreateDatabaseL(*dbInfo02);
    CleanupStack::PopAndDestroy(dbInfo02);
    HPosLmDatabaseInfo* dbInfoRemovableMedia = HPosLmDatabaseInfo::NewLC(KUriRemovableMediaDb);
    iDbMan->CreateDatabaseL(*dbInfoRemovableMedia);
    CleanupStack::PopAndDestroy(dbInfoRemovableMedia);
    dbInfo02 = NULL;
    dbInfo01 = NULL;
    dbInfoRemovableMedia = NULL;
    
    // 1 Get info about the default DB
    dbInfo01 = HPosLmDatabaseInfo::NewLC(KUriDb01Full);
    iDbMan->SetDefaultDatabaseUriL(KUriDb01Full);
    iDbMan->GetDatabaseInfoL(*dbInfo01);
    CheckInfoL(dbInfo01, 1);
    CleanupStack::PopAndDestroy(dbInfo01);
    dbInfo01 = NULL;
    
    // 2 Get info about a non-default DB
    dbInfo02 = HPosLmDatabaseInfo::NewLC(KUriDb02Full);
    iDbMan->GetDatabaseInfoL(*dbInfo02);
    CheckInfoL(dbInfo02, 2);
    CleanupStack::PopAndDestroy(dbInfo02);
    dbInfo02 = NULL;
    
    // 3a Change the default db
    // Check error report "ESLI-6CXJP3 Default database not marked as default"
    iDbMan->SetDefaultDatabaseUriL(KUriDb02);
    dbInfo02 = HPosLmDatabaseInfo::NewLC(KUriDb02Full);
    iDbMan->GetDatabaseInfoL(*dbInfo02);
    CheckInfoL(dbInfo02, 3);
    CleanupStack::PopAndDestroy(dbInfo02);
    dbInfo02 = NULL;
    
    iDbMan->SetDefaultDatabaseUriL(KUriDb01Full);
    
    // 3b Change the default db
    // Check error report "ESLI-6CXJP3 Default database not marked as default"
    iDbMan->SetDefaultDatabaseUriL(KUriDb02Full);
    iDbUri[3] = KUriDb02;
    iProtocol[3]  = KNullDesC;
    dbInfo02 = HPosLmDatabaseInfo::NewLC(KUriDb02);
    iDbMan->GetDatabaseInfoL(*dbInfo02);
    CheckInfoL(dbInfo02, 3);
    CleanupStack::PopAndDestroy(dbInfo02);
    dbInfo02 = NULL;
    
    iDbMan->SetDefaultDatabaseUriL(KUriDb01Full);
    // 3c Change the default db
    // Check error report "ESLI-6CXJP3 Default database not marked as default"
    iDbMan->SetDefaultDatabaseUriL(KUriDb02Full);
    iDbUri[3] = KUriDb02Full;
    iProtocol[3]  = KProtocolFile;
    dbInfo02 = HPosLmDatabaseInfo::NewLC(KUriDb02Full);
    iDbMan->GetDatabaseInfoL(*dbInfo02);
    CheckInfoL(dbInfo02, 3);
    CleanupStack::PopAndDestroy(dbInfo02);
    dbInfo02 = NULL;
    
    
    // 4 DB on removable media
    dbInfoRemovableMedia = HPosLmDatabaseInfo::NewLC(KUriRemovableMediaDb);
    iDbMan->GetDatabaseInfoL(*dbInfoRemovableMedia);
    CheckInfoL(dbInfoRemovableMedia, 4);
    CleanupStack::PopAndDestroy(dbInfoRemovableMedia);
    dbInfoRemovableMedia = NULL;
    
    // 5 Get info for all databases using ListDatabasesL
    iDbMan->ListDatabasesL(iDbArray);
    AssertTrueSecL(iDbArray.Count() == 3, KErrorWrongNrOfDbs);
    
    HPosLmDatabaseInfo* dbInfo = NULL;
    for(TInt count = 0; count < 3; count++)
        {
        dbInfo = iDbArray[count];
        TBuf<50> testbuf = dbInfo->DatabaseUri();
        if (dbInfo->DatabaseUri() == KUriDb01Full)
            {
            CheckInfoL(dbInfo, 5);
            }
        else if (dbInfo->DatabaseUri() == KUriDb02Full)
            {
            CheckInfoL(dbInfo, 6);
            }
        else if (dbInfo->DatabaseUri() == KUriRemovableMediaDb)
            {
            CheckInfoL(dbInfo, 7);
            }
        }
        
    // According to header for ListDatabasesL in EPos_CPosLmDatabaseManager.h
    // "Any objects which are in the array when it is passed to this function are not removed."
    // Therefore add object and make sure that it is not removed
    HPosLmDatabaseInfo* testDbInfo = HPosLmDatabaseInfo::NewLC(_L("VeryMuchDummyURI.ldb"));
    iDbArray.ResetAndDestroy();
    iDbArray.Append(testDbInfo);
    iDbMan->ListDatabasesL(iDbArray);
    AssertTrueSecL(iDbArray.Count() == 4, _L("iDbArray count should be 4"));

    CleanupStack::Pop(testDbInfo);
    iDbArray.ResetAndDestroy();
         
    // 6 Get info from a non-existing db:
    TPosLmDatabaseSettings dummySettings;
    HPosLmDatabaseInfo* dbInfoNonExisting = HPosLmDatabaseInfo::NewLC(KUriDbNonExisting);
    TInt err = KErrNone;
    TRAP(err, iDbMan->GetDatabaseInfoL(*dbInfoNonExisting));
    AssertTrueSecL(err == KErrNotFound, KErrorWrongCodeForNonExistingDb);
    
    CleanupStack::PopAndDestroy(dbInfoNonExisting);
    dbInfoNonExisting = NULL;
    
    // 7 Get info from a non-existing db on the removable media:
    HPosLmDatabaseInfo* dbInfoNonExistingRem = HPosLmDatabaseInfo::NewLC(KUriRemovableMediaDbNonExisting);
    TRAP(err, iDbMan->GetDatabaseInfoL(*dbInfoNonExistingRem));
    AssertTrueSecL(err == KErrNotFound, KErrorWrongCodeForNonExistingDbRem);
    CleanupStack::PopAndDestroy(dbInfoNonExistingRem);
    dbInfoNonExistingRem = NULL;
    
    // 8 Get info from a corrupt uri:
    HPosLmDatabaseInfo* dbInfoCorrupt = HPosLmDatabaseInfo::NewLC(KUriDbCorrupt);
    TRAP(err, iDbMan->GetDatabaseInfoL(*dbInfoCorrupt));
    AssertTrueSecL(err == KErrArgument, KErrorWrongCodeForCorruptUri);
    TRAP(err, iDbMan->ModifyDatabaseSettingsL(KUriDbCorrupt, dummySettings));
    AssertTrueSecL(err == KErrArgument, KErrorWrongCodeForCorruptUri);
    CleanupStack::PopAndDestroy(dbInfoCorrupt);
    dbInfoCorrupt = NULL;
    
    // 9 Get info from a non-supported protocol in uri
    HPosLmDatabaseInfo* dbInfoNotSupported = HPosLmDatabaseInfo::NewLC(KUriNotSupported);
    TRAP(err, iDbMan->GetDatabaseInfoL(*dbInfoNotSupported));
    AssertTrueSecL(err == KErrNotSupported, KErrorWrongCodeForNotSupportedUri);
    TRAP(err, iDbMan->ModifyDatabaseSettingsL(KUriNotSupported, dummySettings));
    AssertTrueSecL(err == KErrNotSupported, KErrorWrongCodeForNotSupportedUri);
    CleanupStack::PopAndDestroy(dbInfoNotSupported);
    dbInfoNotSupported = NULL;
    
    // 10 Get info from the non-default db
    dbInfo01 = HPosLmDatabaseInfo::NewLC(KUriDb01);
    iDbMan->GetDatabaseInfoL(*dbInfo01);
    CheckInfoL(dbInfo01, 8);
    
    // 11 Change the display name for the non-default DB
    TPosLmDatabaseSettings settings = dbInfo01->Settings();
    TPosLmDatabaseName bufName(KNewDbName);
    settings.SetDatabaseName(bufName);
    iDbMan->ModifyDatabaseSettingsL(KUriDb01, settings);
    CleanupStack::PopAndDestroy(dbInfo01);
    dbInfo01 = NULL;
    
    // 12 Get info after name change
    dbInfo01 = HPosLmDatabaseInfo::NewLC(KUriDb01);
    iDbMan->GetDatabaseInfoL(*dbInfo01);
    CheckInfoL(dbInfo01, 9);
    CleanupStack::PopAndDestroy(dbInfo01);
    dbInfo01 = NULL;
    
    // 10b Get info from the removable media db
    dbInfoRemovableMedia = HPosLmDatabaseInfo::NewLC(KUriRemovableMediaDb);
    iDbMan->GetDatabaseInfoL(*dbInfoRemovableMedia);
    CheckInfoL(dbInfoRemovableMedia, 11);
    
    // 11b Change the display name for the non-default DB
    settings = dbInfoRemovableMedia->Settings();
    bufName = KNewDbName;
    settings.SetDatabaseName(bufName);
    iDbMan->ModifyDatabaseSettingsL(KUriRemovableMediaDb, settings);
    CleanupStack::PopAndDestroy(dbInfoRemovableMedia);
    dbInfoRemovableMedia = NULL;
    
    // 12b Get info after name change
    dbInfoRemovableMedia = HPosLmDatabaseInfo::NewLC(KUriRemovableMediaDb);
    iDbMan->GetDatabaseInfoL(*dbInfoRemovableMedia);
    CheckInfoL(dbInfoRemovableMedia, 12);
    CleanupStack::PopAndDestroy(dbInfoRemovableMedia);
    dbInfoRemovableMedia = NULL;
    
    // 13 Get info after name change
    dbInfo01 = HPosLmDatabaseInfo::NewLC(KUriDb01);
    iDbMan->GetDatabaseInfoL(*dbInfo01);
    CheckInfoL(dbInfo01, 9);
    
    // 14 Change display name, but use the unset attribute mechanism
    settings = dbInfo01->Settings();
    settings.UnsetAttribute(TPosLmDatabaseSettings::EName);
    iDbMan->ModifyDatabaseSettingsL(KUriDb01, settings);
    CleanupStack::PopAndDestroy(dbInfo01);
    dbInfo01 = NULL;
    
    // 15 Get info after "non-name-change"
    dbInfo01 = HPosLmDatabaseInfo::NewLC(KUriDb01);
    iDbMan->GetDatabaseInfoL(*dbInfo01);
    CheckInfoL(dbInfo01, 10);
    CleanupStack::PopAndDestroy(dbInfo01);
    dbInfo01 = NULL;
    
    // 16 Check max length and KNullDesC
    //_LIT(KErrorWrongCode, "Didn't receive correct error code");
	_LIT(KMaxLengthString64,    "1aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa.ldb");
    _LIT(KMaxLengthString64Bad, "x1aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa.ldb");
    _LIT(KMaxLengthString66,    "c:2aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa.ldb");
    _LIT(KMaxLengthString66Bad, "c:x2aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa.ldb");
    _LIT(KMaxLengthString71,    "file://3aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa.ldb");
    _LIT(KMaxLengthString71Bad, "file://x3aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa.ldb");
    _LIT(KMaxLengthString73,    "file://c:4aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa.ldb");
    _LIT(KMaxLengthString73Bad, "file://c:x4aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa.ldb");
    
    CheckUriLengthL(KMaxLengthString64, KErrNotFound);
    CheckUriLengthL(KMaxLengthString64Bad, KErrNotFound); // tbd shall it be like this? (Should be KErrArgument)
    CheckUriLengthL(KMaxLengthString66, KErrNotFound);
    CheckUriLengthL(KMaxLengthString66Bad, KErrNotFound); // tbd shall it be like this?
    CheckUriLengthL(KMaxLengthString71, KErrNotFound);
    CheckUriLengthL(KMaxLengthString71Bad, KErrNotFound); // tbd shall it be like this?
    CheckUriLengthL(KMaxLengthString73, KErrNotFound);
    CheckUriLengthL(KMaxLengthString73Bad, KErrNotFound); // tbd shall it be like this?
    CheckUriLengthL(KNullDesC, KErrArgument); //tbd This crashes, should it be so?
    
    if (iErrorsFound != KErrNone) //LogErrorAndLeave(_L("Errors found in TP134"));
    	{
    	iLog->Log(_L("Errors found in TP134"));
    	User::Leave(-1);	
    	}
    else iLog->Log(_L("CPosTp134 Passed"));
    
    }
    
void CPosTp134::CheckInfoL(HPosLmDatabaseInfo* aDbInfo, TInt aTestNr)
    {
    _LIT(KTestInfo, "Step nr %d");
    TBuf<20> testInfo;
    testInfo.Format(KTestInfo, aTestNr);
    iLog->Log(testInfo);
    
    AssertTrueSecL(iDbDrive[aTestNr] == (aDbInfo->DatabaseDrive()).GetUpperCase(), KErrorWrongDrive);

   
    iLog->Log(aDbInfo->DatabaseUri());
    iLog->Log(iDbUri[aTestNr]);
    AssertTrueSecL(iDefaultDb[aTestNr] == aDbInfo->IsDefault(), KErrorWrongDefault);
    AssertTrueSecL(iDbUri[aTestNr] == aDbInfo->DatabaseUri(), KErrorWrongDbUri);
    
    AssertTrueSecL(iProtocol[aTestNr] == aDbInfo->Protocol(), KErrorWrongProtocol);
    
    TPosLmDatabaseSettings settings = aDbInfo->Settings();
    if ( iDbName[aTestNr] != settings.DatabaseName() )
        {
        iLog->Log(_L("CheckInfo: dbNames do not match: exp '%S', act '%S'"),
            &iDbName[aTestNr], &settings.DatabaseName() );
        User::Leave( KErrGeneral );
        }

    AssertTrueSecL(iAttrSet[aTestNr] == settings.IsAttributeSet(TPosLmDatabaseSettings::EName),
                                                                KErrorWrongAttributeInfo);
    }
    
void CPosTp134::SetupExpectedResultsL()
    {
    TChar cDrive = 'C';
    #ifdef __WINS__
    TChar removableDrive = 'D';
    TMediaType mediaTypeRemovable = EMediaHardDisk;
    // DatabaseMedia() seems to return EMediaRam for WINS and EMediaFlash for target
    TMediaType mediaType = EMediaRam;
    #else
    TMediaType mediaTypeRemovable = EMediaFlash;
    TChar removableDrive = 'F';
    // DatabaseMedia() seems to return EMediaRam for WINS and EMediaFlash for target
    TMediaType mediaType = EMediaNANDFlash;
    #endif
    
    HBufC* dbName = ReadDefaultDatabaseNameFromResourceLC();
    iLog->Log(_L("Default database name: '%S'"), dbName );
    
    iDbDrive[1]   = cDrive;
    iMediaType[1] = mediaType;
    iDefaultDb[1] = ETrue;
    iDbUri[1]     = KUriDb01Full;
    iProtocol[1]  = KProtocolFile;
    iDbName[1]    = *dbName;
    iAttrSet[1]   = ETrue; // TBD Shall it actually be so?
    
    iDbDrive[2]   = cDrive;
    iMediaType[2] = mediaType;
    iDefaultDb[2] = EFalse;
    iDbUri[2]     = KUriDb02Full;
    iProtocol[2]  = KProtocolFile;
    iDbName[2]    = KNullDesC;
    iAttrSet[2]   = EFalse;
    
    iDbDrive[3]   = cDrive;
    iMediaType[3] = mediaType;
    iDefaultDb[3] = ETrue;
    iDbUri[3]     = KUriDb02Full;
    iProtocol[3]  = KProtocolFile;
    iDbName[3]    = *dbName;
    iAttrSet[3]   = ETrue;
    
    iDbDrive[4]   = removableDrive;
    iMediaType[4] = mediaTypeRemovable;
    iDefaultDb[4] = EFalse;
    iDbUri[4]     = KUriRemovableMediaDb;
    iProtocol[4]  = KProtocolFile;
    iDbName[4]    = KNullDesC;
    iAttrSet[4]   = EFalse;
    
    iDbDrive[5]   = cDrive;
    iMediaType[5] = mediaType;
    iDefaultDb[5] = EFalse;
    iDbUri[5]     = KUriDb01Full;
    iProtocol[5]  = KProtocolFile;
    iDbName[5]    = KNullDesC;
    iAttrSet[5]   = EFalse;
    
    iDbDrive[6]   = cDrive;
    iMediaType[6] = mediaType;
    iDefaultDb[6] = ETrue;
    iDbUri[6]     = KUriDb02Full;
    iProtocol[6]  = KProtocolFile;
    iDbName[6]    = *dbName;
    iAttrSet[6]   = ETrue;
    
    iDbDrive[7]   = removableDrive;
    iMediaType[7] = mediaTypeRemovable;
    iDefaultDb[7] = EFalse;
    iDbUri[7]     = KUriRemovableMediaDb;
    iProtocol[7]  = KProtocolFile;
    iDbName[7]    = KNullDesC;
    iAttrSet[7]   = EFalse;
    
    iDbDrive[8]   = cDrive;
    iMediaType[8] = mediaType;
    iDefaultDb[8] = EFalse;
    iDbUri[8]     = KUriDb01;
    iProtocol[8]  = KNullDesC;
    iDbName[8]    = KNullDesC;
    iAttrSet[8]   = EFalse;

    iDbDrive[9]   = cDrive;
    iMediaType[9] = mediaType;
    iDefaultDb[9] = EFalse;
    iDbUri[9]     = KUriDb01;
    iProtocol[9]  = KNullDesC;
    iDbName[9]    = KNewDbName;
    iAttrSet[9]   = ETrue;
    
    iDbDrive[10]   = cDrive;
    iMediaType[10] = mediaType;
    iDefaultDb[10] = EFalse;
    iDbUri[10]     = KUriDb01;
    iProtocol[10]  = KNullDesC;
    iDbName[10]    = KNullDesC;
    iAttrSet[10]   = EFalse;
    
    iDbDrive[11]   = removableDrive;
    iMediaType[11] = mediaTypeRemovable;
    iDefaultDb[11] = EFalse;
    iDbUri[11]     = KUriRemovableMediaDb;
    iProtocol[11]  = KProtocolFile;
    iDbName[11]    = KNullDesC;
    iAttrSet[11]   = EFalse;
    
    iDbDrive[12]   = removableDrive;
    iMediaType[12] = mediaTypeRemovable;
    iDefaultDb[12] = EFalse;
    iDbUri[12]     = KUriRemovableMediaDb;
    iProtocol[12]  = KProtocolFile;
    iDbName[12]    = KNewDbName;
    iAttrSet[12]   = ETrue;
    
    CleanupStack::PopAndDestroy( dbName );
    }
    
void CPosTp134::CheckUriLengthL(const TDesC& aUri,
                                TInt aExpectedErrorCode)
    {
    _LIT(KErrorWrongCode, "Wrong code when testing uri lengths");
    TPosLmDatabaseSettings dummySettings;
    HPosLmDatabaseInfo* dbInfo = HPosLmDatabaseInfo::NewLC(aUri);
    TInt err = KErrNone;
    TRAP(err, iDbMan->GetDatabaseInfoL(*dbInfo));
    AssertTrueSecL(err == aExpectedErrorCode, KErrorWrongCode);
    TRAP(err, iDbMan->ModifyDatabaseSettingsL(aUri, dummySettings));
    AssertTrueSecL(err == aExpectedErrorCode, KErrorWrongCode);
    CleanupStack::PopAndDestroy(dbInfo);    
    }

//  End of File