/*
* 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_CPosTp55.h"
#include "FT_LandmarkConstants.h"
//#include <eposlmintservices.rsg>
#include <centralrepository.h>
#include <UiklafInternalCRKeys.h>
#include <utfw.h>
#include <f32file.h>
#include <coemain.h>
#include <EPos_CPosLandmarkEncoder.h>
#include <EPos_CPosLandmarkParser.h>
#include <barsread.h>
#include <bautils.h>

// CONSTANTS
_LIT(KFile1, "c:\\documents\\Tp55_1.txt");
_LIT(KFile2, "c:\\documents\\Tp55_2.txt");
_LIT(KFile3, "c:\\documents\\Tp55_3.txt");
const TInt KOneK = 1024;
const TInt KNrOfLandmarksToExport = 10;
//_LIT(KPosResourceFile, "\\resource\\eposlmintservices.rsc");
#ifdef __WINS__
_LIT(KXmlInputFile, "z:\\system\\test\\testdata\\TP55-DiskFullDuringExportImport.xml"); 
#else
_LIT(KXmlInputFile, "c:\\system\\test\\testdata\\TP55-DiskFullDuringExportImport.xml"); 
#endif
_LIT(KXmlOutputFile, "c:\\documents\\TP55-ExportedLandmarks.xml"); 
_LIT(KXmlBufferDumpFile, "c:\\documents\\BufferDump.xml");
_LIT(KInternalServicesResFileRom, "z:\\resource\\eposlmintservices.rsc");
_LIT(KInternalServicesResFileBackup, "c:\\resource\\copy_of_eposlmintservices.rsc");
_LIT(KInternalServicesResFileCdrive, "c:\\resource\\eposlmintservices.rsc");
//_LIT(KInternalServicesLargeResFile, "c:\\system\\test\\testdata\\eposlmintservices_453KB.rsc");
//_LIT(KInternalServicesSmallResFile, "c:\\system\\test\\testdata\\eposlmintservices_198KB.rsc");

// Approx 2141 bytes
_LIT8(KNonsense, "nonsensenonsensenonsensenonsensenonsensenonsensenonsensenonsensenonsense\
nonsensenonsensenonsensenonsensenonsensenonsensenonsensenonsense\
nonsensenonsensenonsensenonsensenonsensenonsensenonsensenonsense\
nonsensenonsensenonsensenonsensenonsensenonsensenonsensenonsense\
nonsensenonsensenonsensenonsensenonsensenonsensenonsensenonsense\
nonsensenonsensenonsensenonsensenonsensenonsensenonsensenonsense\
nonsensenonsensenonsensenonsensenonsensenonsensenonsensenonsense\
nonsensenonsensenonsensenonsensenonsensenonsensenonsensenonsense\
nonsensenonsensenonsensenonsensenonsensenonsensenonsensenonsense\
nonsensenonsensenonsensenonsensenonsensenonsensenonsensenonsense\
nonsensenonsensenonsensenonsensenonsensenonsensenonsensenonsense\
nonsensenonsensenonsensenonsensenonsensenonsensenonsensenonsense\
nonsensenonsensenonsensenonsensenonsensenonsensenonsensenonsense\
nonsensenonsensenonsensenonsensenonsensenonsensenonsensenonsense\
nonsensenonsensenonsensenonsensenonsensenonsensenonsensenonsense\
nonsensenonsensenonsensenonsensenonsensenonsensenonsensenonsense\
nonsensenonsensenonsensenonsensenonsensenonsensenonsensenonsense\
nonsensenonsensenonsensenonsensenonsensenonsensenonsensenonsense\
nonsensenonsensenonsensenonsensenonsensenonsensenonsensenonsense\
nonsensenonsensenonsensenonsensenonsensenonsensenonsensenonsense\
nonsensenonsensenonsensenonsensenonsensenonsensenonsensenonsense\
nonsensenonsensenonsensenonsensenonsensenonsensenonsensenonsense\
nonsensenonsensenonsensenonsensenonsensenonsensenonsensenonsense\
nonsensenonsensenonsensenonsensenonsensenonsensenonsensenonsense\
nonsensenonsensenonsensenonsensenonsensenonsensenonsensenonsense\
nonsensenonsensenonsensenonsensenonsensenonsensenonsensenonsense\
nonsensenonsensenonsensenonsensenonsensenonsensenonsensenonsense\
nonsensenonsensenonsensenonsensenonsensenonsensenonsensenonsense\
nonsensenonsensenonsensenonsensenonsensenonsensenonsensenonsense\
nonsensenonsensenonsensenonsensenonsensenonsensenonsensenonsense\
nonsensenonsensenonsensenonsensenonsensenonsensenonsensenonsense\
sensenonsensenonsensenonsensenonsensenonsensenonsense");

_LIT8(K64B, "nonsensenonsensenonsensenonsensenonsensenonsensenonsensenonsense");

// ================= MEMBER FUNCTIONS =======================

// ---------------------------------------------------------
// CPosTp55::GetName
//
// (other items were commented in a header).
// ---------------------------------------------------------
//
void CPosTp55::GetName(TDes& aName) const
    {
    _LIT(KTestName, "Tp55 - Disk Full Checking during Import/Export");
    aName = KTestName;
    }

// ---------------------------------------------------------
// CPosTp55::CloseTest
//
// (other items were commented in a header).
// ---------------------------------------------------------
//
void CPosTp55::CloseTest()
    {
    delete iDatabase;
    iDatabase = NULL;

    delete iOperationWrapper;
    delete iLandmarkEncoder;
    delete iLandmarkParser;
    delete iOutputBuffer;
    delete iInputBuffer;

    iFile1.Close();
    iFile2.Close();
    iFile3.Close();
    iFileServer.Delete(KFile1);
    iFileServer.Delete(KFile2);
    iFileServer.Delete(KFile3);

    //TryRestoreResourceFile();

    iXmlOutputFile.Close();
    iFileServer.Delete(KXmlOutputFile);
    iFileServer.Delete(KXmlBufferDumpFile);

    iFileServer.Close();
    }

// ---------------------------------------------------------
// CPosTp55::InitTestL
//
// (other items were commented in a header).
// ---------------------------------------------------------
//
void CPosTp55::InitTestL()
    {
    // File setup, create two files
    User::LeaveIfError(iFileServer.Connect());

    // Try to restore if previous execution of Tp55 panicked or was killed.
    //TryRestoreResourceFile();

    iOperationWrapper = new (ELeave) CActiveLmOperation(iLog);
    }

// ---------------------------------------------------------
// CPosTp55::StartL
//
// (other items were commented in a header).
// ---------------------------------------------------------
//
void CPosTp55::StartL()
    {
    // Retreive threshold from centralrepository
    CRepository* repository = CRepository::NewLC(KCRUidUiklaf);
    User::LeaveIfError(repository->Get(KUikOODDiskCriticalThreshold, iCriticalThreshold));
    CleanupStack::PopAndDestroy(repository);

    // Test import/export LMs when critical level is set to MLFW defined value.
    InitiateCriticalLevelL();
    TestCriticalLevelL();

/*
    // Test import/export LMs when critical level is set to a large value.
    iLog->Put(_L("\r\nRedefining critical level to 453 KB and running all tests again...."));
    CopyResourceFileL(KInternalServicesLargeResFile);
    InitiateCriticalLevelL();
    TestCriticalLevelL();

    // Test import/export LMs when critical level is set to a small value.
    iLog->Put(_L("\r\nRedefining critical level to 198 KB and running all tests again...."));
    CopyResourceFileL(KInternalServicesSmallResFile);
    InitiateCriticalLevelL();
    TestCriticalLevelL();
    */
    }

// ---------------------------------------------------------
// CPosTp55::NotifyProgress
//
// (other items were commented in a header).
// ---------------------------------------------------------
//
void CPosTp55::NotifyProgress(TReal aProgress)
    {
    iProgress = (TInt) (aProgress * 100);
//    iMsg.Format(_L("Progress = %d"), iProgress);
//    iLog->Put(iMsg);
//    LogVolumeInfoL();
    }

// ---------------------------------------------------------
// CPosTp55::TestCriticalLevelL
//
// (other items were commented in a header).
// ---------------------------------------------------------
//
void CPosTp55::TestCriticalLevelL()
    {
    // Restore disk space
    RecreateAndOpenFilesL();

    // ************ 1. Open database ************
    delete iDatabase;
    iDatabase = NULL;
    iDatabase = UseGeneratedDbFileL();
    if (iDatabase->IsInitializingNeeded())
       {
       ExecuteAndDeleteLD(iDatabase->InitializeL());
       }

    // ************ 2. Fill up disk space ************
    iLog->Put(_L("Consuming disk space..."));
    ConsumeDiskSpaceL(iFile1, iCriticalLevel + 3 * KOneK);
    LogVolumeInfoL();

//// Test importing landmarks
    iLog->Put(_L("Testing Importing..."));
    iLog->Put(_L("-- Testing import below critical level"));
    TBool testBeyondCriticalLevel = ETrue;
    ImportLandmarksTestL(!testBeyondCriticalLevel);
    
    // ************ 11. Repeat steps 3-10 ************
    iLog->Put(_L("\r\n-- Testing import beyond critical level"));
    ExecuteAndDeleteLD(iDatabase->CompactL());
    iLog->Put(_L("Consuming disk space..."));
    User::LeaveIfError(iFile2.Create(iFileServer, KFile2, EFileWrite));
    ConsumeDiskSpaceL(iFile2, iSizeLimit2);
    LogVolumeInfoL();
    ImportLandmarksTestL(testBeyondCriticalLevel);

    // Restore disk space
    RecreateAndOpenFilesL();

    // Use suitable database for exporting LMs
    delete iDatabase;
    iDatabase = NULL;
    iDatabase = UseGeneratedDbFileL();
    if (iDatabase->IsInitializingNeeded())
       {
       ExecuteAndDeleteLD(iDatabase->InitializeL());
       }

    // ************ 12. Fill up disk space ************
    iLog->Put(_L("Consuming disk space..."));
    ConsumeDiskSpaceL(iFile1, iSizeLimit1);
    LogVolumeInfoL();

//// Test importing landmarks
    iLog->Put(_L("Testing Exporting..."));
    ExportLandmarksTestL();
    }

// ---------------------------------------------------------
// CPosTp55::RecreateAndOpenFilesL
//
// (other items were commented in a header).
// ---------------------------------------------------------
//
void CPosTp55::RecreateAndOpenFilesL()
    {
    iLog->Put(_L("Removing large files..."));

    // Delete files
    iFile1.Close();
    iFileServer.Delete(KFile1);
    iFile2.Close();
    iFileServer.Delete(KFile2);
    iFile3.Close();
    iFileServer.Delete(KFile3);

    // Create and open files
    User::LeaveIfError(iFile1.Create(iFileServer, KFile1, EFileWrite));
    User::LeaveIfError(iFile2.Create(iFileServer, KFile2, EFileWrite));
    User::LeaveIfError(iFile3.Create(iFileServer, KFile3, EFileWrite));
    }

// ---------------------------------------------------------
// CPosTp55::ExportLandmarksTestL
//
// (other items were commented in a header).
// ---------------------------------------------------------
//
void CPosTp55::ExportLandmarksTestL()
    {
    TInt result(0);
    TBool doAddAllLandmarks = ETrue;
    TBool doExecuteIncrementally = ETrue;

//// Testing Disk full during addition of LMs to encoder
    iLog->Put(_L("\r\n--- Testing Disk full during addition of LMs to encoder"));

    // 13. ************ Export to file using encoder stand-alone ************
    iLog->Put(_L("------ Export to file incrementally using encoder stand-alone"));
    ReInitializeEncoderEtcL();
    iLandmarkEncoder->SetOutputFileL(KXmlOutputFile);
    AddCollectionDataToEncoderL();
    AddLandmarksToEncoderL(doAddAllLandmarks);

    // ************ Export to buffer incrementally using encoder stand-alone ************
//    iLog->Put(_L("------ Export to buffer incrementally using encoder stand-alone"));
// Not tested here since it does not result in KErrDiskFull but in KErrNoMemory. Time-consuming test
/*    ReInitializeEncoderEtcL();
    delete iOutputBuffer;
    iOutputBuffer = NULL;
    iOutputBuffer = iLandmarkEncoder->SetUseOutputBufferL();
    AddCollectionDataToEncoderL();
    while (result == KErrNone)
        {
        TRAP(result, AddLandmarksToEncoderL(!doAddAllLandmarks));
        iMsg.Format(_L("Size of output buffer: %d"), iOutputBuffer->Size());
        iLog->Put(iMsg);
        }
    iMsg.Format(_L("Export to buffer left with error code %d"), result);
    iLog->Put(iMsg);
    */

//// Testing Disk full during ExportLandmarksL()
    iLog->Put(_L("\r\n--- Testing Disk full during ExportLandmarksL()"));

    // Create array of all IDs in database
    RArray<TPosLmItemId> itemIds;
    CleanupClosePushL(itemIds);
    PopulateArrayL(itemIds, doAddAllLandmarks);

    // ************ 14. Export to file incrementally using ExportLandmarksL() ************
    iLog->Put(_L("------ Export to file incrementally using ExportLandmarksL()"));
    ReInitializeEncoderEtcL();
    iLandmarkEncoder->SetOutputFileL(KXmlOutputFile);
    AddCollectionDataToEncoderL();
    ExportWithExportLandmarksMethodL(itemIds, doExecuteIncrementally);

    // ************ 15. Export to file synchronously using ExportLandmarksL() ************
    iLog->Put(_L("------ Export to file synchronously using ExportLandmarksL()"));
    ReInitializeEncoderEtcL();
    iLandmarkEncoder->SetOutputFileL(KXmlOutputFile);
    AddCollectionDataToEncoderL();
    ExportWithExportLandmarksMethodL(itemIds, !doExecuteIncrementally);

    // ************ Export to buffer incrementally using ExportLandmarksL() ************
//    iLog->Put(_L("------ Export to buffer incrementally using ExportLandmarksL()"));
// Not tested here since it does not result in KErrDiskFull but in KErrNoMemory. Time-consuming test

    // ************ Export to buffer synchronously ExportLandmarksL() ************
//    iLog->Put(_L("------ Export to buffer synchronously ExportLandmarksL() ------"));
// Not tested here since it does not result in KErrDiskFull but in KErrNoMemory. Time-consuming test

    CleanupStack::PopAndDestroy(&itemIds);

//// Testing Disk full during finalizing of encoder
    iLog->Put(_L("\r\n--- Testing Disk full during finalizing of encoder"));

    // ************ 16. Export to file using encoder stand-alone and finalizing incrementally ************
    iLog->Put(_L("------ Export to file using encoder stand-alone and finalizing incrementally"));
    ReInitializeEncoderEtcL();
    iLandmarkEncoder->SetOutputFileL(KXmlOutputFile);
    AddCollectionDataToEncoderL();
    AddLandmarksToEncoderL(!doAddAllLandmarks);
    FillFile3L(); // Fill up disk space so much that next call to FinalizeL results in KErrDiskFull.
    FinalizeEncoderL(doExecuteIncrementally);

    // ************ 17. Export to file using encoder stand-alone and finalizing synchronously ************
    iLog->Put(_L("------ Export to file using encoder stand-alone and finalizing synchronously"));
    ReInitializeEncoderEtcL();
    iLandmarkEncoder->SetOutputFileL(KXmlOutputFile);
    AddCollectionDataToEncoderL();
    AddLandmarksToEncoderL(!doAddAllLandmarks);
    FillFile3L(); // Fill up disk space so much that next call to FinalizeL results in KErrDiskFull.
    FinalizeEncoderL(!doExecuteIncrementally);

    // Create array of some IDs in database
    CleanupClosePushL(itemIds);
    PopulateArrayL(itemIds, !doAddAllLandmarks);

    // ************ 18. Export to file using ExportLandmarksL() and finalizing incrementally ************
    iLog->Put(_L("------ Export to file using ExportLandmarksL() and finalizing incrementally"));
    ReInitializeEncoderEtcL();
    iLandmarkEncoder->SetOutputFileL(KXmlOutputFile);
    AddCollectionDataToEncoderL();
    ExportWithExportLandmarksMethodL(itemIds, doExecuteIncrementally);
    FillFile3L(); // Fill up disk space so much that next call to FinalizeL results in KErrDiskFull.
    FinalizeEncoderL(doExecuteIncrementally);

    // ************ 19. Export to file using ExportLandmarksL() and finalizing synchronously ************
    iLog->Put(_L("------ Export to file using ExportLandmarksL() and finalizing synchronously"));
    ReInitializeEncoderEtcL();
    iLandmarkEncoder->SetOutputFileL(KXmlOutputFile);
    AddCollectionDataToEncoderL();
    ExportWithExportLandmarksMethodL(itemIds, !doExecuteIncrementally);
    FillFile3L(); // Fill up disk space so much that next call to FinalizeL results in KErrDiskFull.
    FinalizeEncoderL(!doExecuteIncrementally);

    CleanupStack::PopAndDestroy(&itemIds);

//// Testing when disk is already full
    iLog->Put(_L("\r\n--- Testing when disk is already full"));
    TVolumeInfo volumeInfoBeforeTest, volumeInfoAfterTest;

    // ************ 20. CPosLandmarkEncoder::SetOutPutFileL() ************
    iLog->Put(_L("------ CPosLandmarkEncoder::SetOutPutFileL()"));
    iFile2.Close();
    DeleteFileL(KFile2);
    ReInitializeEncoderEtcL();
    User::LeaveIfError(iFile2.Create(iFileServer, KFile2, EFileWrite));
    ConsumeDiskSpaceL(iFile2, iSizeLimit2);
    User::LeaveIfError(iFileServer.Volume(volumeInfoBeforeTest, EDriveC));
    TRAP(result, iLandmarkEncoder->SetOutputFileL(KXmlOutputFile));
    User::LeaveIfError(iFileServer.Volume(volumeInfoAfterTest, EDriveC));

    // Verify
    _LIT(KSetFile1, "SetOutPutFileL() didn't result in KErrDiskFull but in %d");
    AssertTrueSecL(result == KErrDiskFull, KSetFile1, result);
    iLog->Put(_L("SetOutputFileL() left with KErrDiskFull"));
    _LIT(KSetFile2, "SetOutPutFileL() consumed disk space even if critical level has been passed. %d");
    AssertTrueSecL(volumeInfoBeforeTest.iFree == volumeInfoAfterTest.iFree, KSetFile2);

    // ************ 21. CPosLandmarkEncoder::AddLandmarkL() ************
    iLog->Put(_L("------ CPosLandmarkEncoder::AddLandmarkL()"));
    iFile2.Close();
    DeleteFileL(KFile2);
    ReInitializeEncoderEtcL();
    iLandmarkEncoder->SetOutputFileL(KXmlOutputFile);
    AddCollectionDataToEncoderL();
    CPosLmItemIterator* iterator = iDatabase->LandmarkIteratorL();
    CleanupStack::PushL(iterator);
    CPosLandmark* landmark = iDatabase->ReadLandmarkLC(iterator->NextL());
    User::LeaveIfError(iFile2.Create(iFileServer, KFile2, EFileWrite));
    ConsumeDiskSpaceL(iFile2, iSizeLimit2);
    User::LeaveIfError(iFileServer.Volume(volumeInfoBeforeTest, EDriveC));
    TRAP(result, iLandmarkEncoder->AddLandmarkL(*landmark));
    User::LeaveIfError(iFileServer.Volume(volumeInfoAfterTest, EDriveC));
    CleanupStack::PopAndDestroy(2, iterator);

    // Verify
    _LIT(KAddLmErr1, "Adding LM to encoder didn't result in KErrDiskFull but in %d when beyond critical level");
    AssertTrueSecL(result == KErrDiskFull, KAddLmErr1, result);
    iLog->Put(_L("AddLandmarkL() left with KErrDiskFull"));
    _LIT(KAddLmErr2, "AddLandmarkL() consumed disk space even if critical level has been passed. %d");
    AssertTrueSecL(volumeInfoBeforeTest.iFree == volumeInfoAfterTest.iFree, KAddLmErr2);

    // ************ 22. CPosLandmarkEncoder::FinalizeL() ************
    iLog->Put(_L("------ CPosLandmarkEncoder::FinalizeL()"));
    iFile2.Close();
    DeleteFileL(KFile2);
    ReInitializeEncoderEtcL();
    iLandmarkEncoder->SetOutputFileL(KXmlOutputFile);
    AddCollectionDataToEncoderL();
    AddLandmarksToEncoderL(!doAddAllLandmarks);
    User::LeaveIfError(iFile2.Create(iFileServer, KFile2, EFileWrite));
    ConsumeDiskSpaceL(iFile2, iSizeLimit2);
    delete iOperation;
    iOperation = NULL;
    User::LeaveIfError(iFileServer.Volume(volumeInfoBeforeTest, EDriveC));
    TRAP(result, iOperation = iLandmarkEncoder->FinalizeEncodingL());
    User::LeaveIfError(iFileServer.Volume(volumeInfoAfterTest, EDriveC));

    // Verify
    _LIT(KFinalizeErr1, "FinalizeL() didn't result in KErrDiskFull but in %d");
    AssertTrueSecL(result == KErrDiskFull, KFinalizeErr1, result);
    iLog->Put(_L("FinalizeEncodingL() left with KErrDiskFull"));
    _LIT(KFinalizeErr2, "FinalizeL() consumed disk space even if critical level has been passed. %d");
    AssertTrueSecL(volumeInfoBeforeTest.iFree == volumeInfoAfterTest.iFree, KFinalizeErr2);

    // ************ 23. CPosLandmarkEncoder::SetOutPutFileL() - Bonus test 1 ************
    iLog->Put(_L("------ CPosLandmarkEncoder::SetOutPutFileL() - Bonus test 1"));
    iFile2.Close();
    DeleteFileL(KFile2);
    ReInitializeEncoderEtcL();
    User::LeaveIfError(iFile2.Create(iFileServer, KFile2, EFileWrite));
    ConsumeDiskSpaceL(iFile2, iSizeLimit2);
    TRAP(result, iLandmarkEncoder->SetOutputFileL(KXmlOutputFile));

    // Verify
    AssertTrueSecL(result == KErrDiskFull, KSetFile1, result);
    iLog->Put(_L("SetOutputFileL() left with KErrDiskFull"));

    // Try it again
    TRAP(result, iLandmarkEncoder->SetOutputFileL(KXmlOutputFile));

    // Verify
    _LIT(KSetFile3, "SetOutPutFileL() didn't result in KErrAlreadyExists but in %d");
    AssertTrueSecL(result == KErrAlreadyExists, KSetFile3, result);
    iLog->Put(_L("SetOutputFileL() left with KErrAlreadyExists"));

    // ************ 24. CPosLandmarkEncoder::FinalizeL() - Bonus test 2 ************
    // This test tests if it is possible to finalize when adding LMs to encoder has 
    // been interrupted due to KErrDiskFull.
    iLog->Put(_L("------ CPosLandmarkEncoder::FinalizeL() - Bonus test 2"));
    iFile2.Close();
    DeleteFileL(KFile2);
    ReInitializeEncoderEtcL();
    iLandmarkEncoder->SetOutputFileL(KXmlOutputFile);
    AddCollectionDataToEncoderL();

    // Add landmarks will result in KErrDiskFull
    AddLandmarksToEncoderL(doAddAllLandmarks);

    // Restore some disk space
    iFile1.Close();
    DeleteFileL(KFile1);

    // Try to finalize
    delete iOperation;
    iOperation = NULL;
    TRAP(result, ExecuteAndDeleteLD(iLandmarkEncoder->FinalizeEncodingL()));
    AssertTrueSecL(result == KErrNone, _L("FinalizeL() left with %d"), result);
    iLog->Put(_L("FinalizeL() successful"));

    // ************ CPosLandmarkEncoder::SetOutPutFileL() - Bonus test 3 ************
//  Not tested here since this is a panic test. (Not tested anywhere else)
/*    iLog->Put(_L("------ CPosLandmarkEncoder::SetOutPutFileL() - Bonus test 3"));
    iFile2.Close();
    DeleteFileL(KFile2);
    ReInitializeEncoderEtcL();
    User::LeaveIfError(iFile2.Create(iFileServer, KFile2, EFileWrite));
    ConsumeDiskSpaceL(iFile2, iSizeLimit2);
    TRAP(result, iLandmarkEncoder->SetOutputFileL(KXmlOutputFile));

    // Verify
    AssertTrueSecL(result == KErrDiskFull, KSetFile1, result);
    iLog->Put(_L("SetOutputFileL() left with KErrDiskFull"));

    // Free some disc space and try to finish the export operation. (AddLandmarksL will panic with EPosLmProtocolBreak)
    iFile2.Close();
    DeleteFileL(KFile2);
    AddLandmarksToEncoderL(!doAddAllLandmarks);
    FinalizeEncoderL(doExecuteIncrementally);*/
    }

// ---------------------------------------------------------
// CPosTp55::ImportLandmarksTestL
//
// (other items were commented in a header).
// ---------------------------------------------------------
//
void CPosTp55::ImportLandmarksTestL(TBool aCriticalLevelPassed)
    {
    delete iInputBuffer;
    iInputBuffer = NULL;
    iInputBuffer = CreateInputBufferL();
    TBool doExecuteIncrementally = ETrue;

    // ************ 3. Import all LMs in XML file incrementally ************
    iLog->Put(_L("---- Import all LMs in XML file incrementally"));
    ImportLandmarksL(KXmlInputFile, NULL, doExecuteIncrementally, aCriticalLevelPassed);

    // ************ 4. Import all LMs in XML file synchronously ************
    iLog->Put(_L("---- Import all LMs in XML file synchronously"));
    ImportLandmarksL(KXmlInputFile, NULL, !doExecuteIncrementally, aCriticalLevelPassed);

    // ************ 5. Import all LMs in XML buffer incrementally ************
    iLog->Put(_L("---- Import all LMs in XML buffer incrementally"));
    ImportLandmarksL(KNullDesC, NULL, doExecuteIncrementally, aCriticalLevelPassed);

    // ************ 6. Import all LMs in XML buffer synchronously ************
    iLog->Put(_L("---- Import all LMs in XML buffer synchronously"));
    ImportLandmarksL(KNullDesC, NULL, !doExecuteIncrementally, aCriticalLevelPassed);

    // Create array of ids to Import (subset of all landmarks in the input file/buffer)
    RArray<TUint> itemIds;
    CleanupClosePushL(itemIds);
    for (TInt i = 10; i < 60; i++)
        {
        User::LeaveIfError(itemIds.Append(i));
        }

    // ************ 7. Import a subset of LMs in XML file incrementally ************
    iLog->Put(_L("---- Import a subset of LMs in XML file incrementally"));
    ImportLandmarksL(KXmlInputFile, &itemIds, doExecuteIncrementally, aCriticalLevelPassed);

    // ************ 8. Import a subset of LMs in XML file synchronously ************
    iLog->Put(_L("---- Import a subset of LMs in XML file synchronously"));
    ImportLandmarksL(KXmlInputFile, &itemIds, !doExecuteIncrementally, aCriticalLevelPassed);

    // ************ 9. Import a subset of LMs in XML buffer incrementally ************
    iLog->Put(_L("---- Import a subset of LMs in XML buffer incrementally"));
    ImportLandmarksL(KNullDesC, &itemIds, doExecuteIncrementally, aCriticalLevelPassed);

    // ************ 10. Import a subset of LMs in XML buffer synchronously ************
    iLog->Put(_L("---- Import a subset of LMs in XML buffer synchronously"));
    ImportLandmarksL(KNullDesC, &itemIds, !doExecuteIncrementally, aCriticalLevelPassed);

    CleanupStack::PopAndDestroy(&itemIds);

    iFile2.Close();
    DeleteFileL(KFile2);
    }

// ---------------------------------------------------------
// CPosTp55::ConsumeDiskSpaceL
//
// (other items were commented in a header).
// ---------------------------------------------------------
//
void CPosTp55::ConsumeDiskSpaceL(
    RFile& aFile, TInt aSizeLimit)
    {
    TInt err(KErrNone);

    TVolumeInfo volumeInfo;
    err=iFileServer.Volume(volumeInfo, EDriveC);

    // Fill file fast
    HBufC8* bigBuf = (&KNonsense)->AllocLC();
    while (volumeInfo.iFree > aSizeLimit)
        {
        err = aFile.Write(*bigBuf);
        if (err != KErrNone) iLog->Put(_L("Problem writing"));
        err = iFileServer.Volume(volumeInfo, EDriveC);
        if (err != KErrNone) iLog->Put(_L("Problem voluming"));
        }

    CleanupStack::PopAndDestroy(bigBuf);
    }

// ---------------------------------------------------------
// CPosTp55::ImportLandmarksL
//
// (other items were commented in a header).
// ---------------------------------------------------------
//	
void CPosTp55::ImportLandmarksL(
    const TDesC& aInputFile,
    RArray<TUint>* aArrayOfIds,
    TBool aExecuteIncrementally,
    TBool aTestBeyondCriticalLevel)
    {
    // Recreate parser
    delete iLandmarkParser;
    iLandmarkParser = NULL;
    
    // to minimize risk of KErrLocked
    User::After(500000);
    iLog->Put(_L("Compacting"));
    ExecuteAndDeleteLD(iDatabase->CompactL());
    User::After(500000);

    iLandmarkParser = CPosLandmarkParser::NewL(KMimeType);

    iProgress = 0;
    TBool useInputFile = aInputFile != KNullDesC;
    TBool importSubset = aArrayOfIds != NULL;
    TInt result(KErrNone);

    // Prepare and set output for exported LMs
    if (useInputFile)
        {
        iLog->Put(_L("SetInputFileL"));
        iLandmarkParser->SetInputFileL(aInputFile);
        }
    else // use buffer as output
        {
        iLog->Put(_L("SetInputBuffer"));
        iLandmarkParser->SetInputBuffer(*iInputBuffer);
        }

    // Sample the db size
    CPosLandmarkDatabase::TSize dbSizeBeforeImport;
    TInt err = KErrLocked;
    while (err == KErrLocked)
        {
        TRAP(err, dbSizeBeforeImport = iDatabase->SizeL());
        if (err == KErrLocked) 
            {
            iLog->Put(_L("KErrLocked from iDatabase->SizeL()"));
            User::After(100000);
            }
        }

    // Start importing LMs.
    delete iOperation;
    iOperation = NULL;
    if (importSubset)
        {
        iLog->Put(_L("ImportLandmarksL"));
        iOperation = iDatabase->ImportLandmarksL(
            *iLandmarkParser, *aArrayOfIds, CPosLandmarkDatabase::EDefaultOptions);
        }
    else
        {
        iLog->Put(_L("ImportLandmarksL"));
        iOperation = iDatabase->ImportLandmarksL(
            *iLandmarkParser, CPosLandmarkDatabase::EDefaultOptions);
        }

    // Execute importing LMs
    iLog->Put(_L("ExecuteLmOperationL"));
    result = ExecuteLmOperationL(aExecuteIncrementally);

    // Check result
    _LIT(KErrMsg, "ImportLandmarksL() didn't result in KErrDiskFull but in %d");
    AssertTrueSecL(result == KErrDiskFull, KErrMsg, result);

    if (aTestBeyondCriticalLevel)
        {
        // Sample the db size
        TInt err2 = KErrLocked;
        CPosLandmarkDatabase::TSize dbSizeAfterImport;
        while (err2 == KErrLocked)
            {
            TRAP(err2, dbSizeAfterImport = iDatabase->SizeL());
            if (err2 == KErrLocked)
                {
                iLog->Put(_L("KErrLocked from iDatabase->SizeL(2)"));
                User::After(100000);
                }
            }

        TBool dbSizeIsConstant = dbSizeAfterImport.iFileSize == dbSizeBeforeImport.iFileSize;
        _LIT(KErrMsg, "Database size has changed when importing landmarks beyond critical level");
        if (!dbSizeIsConstant)
            {
            LogErrorAndLeave(KErrMsg);
            }
        iLog->Put(_L("Size of database untouched when importing landmarks beyond critical level"));
        }
    else
        {
        if (aExecuteIncrementally)
            {
            _LIT(KFormat, "Got KErrDiskFull after importing %d%% of the landmarks.");
            iMsg.Format(KFormat, iProgress);
            }
        else
            {
            _LIT(KFormat, "Got KErrDiskFull when importing landmarks synchronously");
            iMsg.Copy(KFormat());
            }
        iLog->Put(iMsg);
        }
    }

// ---------------------------------------------------------
// CPosTp55::InitiateCriticalLevelL
// Initiates iCriticalLevel. (value of iCriticalLevel is extracted from an MLFW 
// resource file that can reside on any drive)
// (other items were commented in a header).
// ---------------------------------------------------------
//	
void CPosTp55::InitiateCriticalLevelL()
    { 
    iLog->Put(_L("InitiateCriticalLevelL"));
    /*
    // Find drive that the resource file resides on.
    TFindFile* filefinder = new (ELeave) TFindFile(iFileServer);
    CleanupStack::PushL(filefinder);
    TParse* fileparser = new (ELeave) TParse;
    CleanupStack::PushL(fileparser);
    fileparser->Set(KPosResourceFile, NULL, NULL);
    User::LeaveIfError(
        filefinder->FindByDir(fileparser->NameAndExt(), fileparser->DriveAndPath()));

    // Open resource file
    RResourceFile resFile;
    resFile.OpenL(iFileServer, filefinder->File());
    CleanupClosePushL(resFile);

    // Allocate the critical level as a buffer
    //TInt R_POS_LANDMARK_INTERNAL_CRITICAL_DISK_LEVEL = 250;
    HBufC8* resourceBuffer = resFile.AllocReadLC(iCriticalThreshold);

    // Convert the buffer to an int
    TResourceReader resReader;
    resReader.SetBuffer(resourceBuffer);
    iCriticalLevel = KOneK * resReader.ReadInt16();
    CleanupStack::PopAndDestroy(4, filefinder);
    */
    iCriticalLevel = iCriticalThreshold;
    iSizeLimit1 = iCriticalLevel + 18 * KOneK; // Do not mess with this value!
    iSizeLimit2 = iCriticalLevel - 20 * KOneK;

    iMsg.Format(_L("CriticalLevel = %d, limit1 = %d, limit2 = %d "), iCriticalLevel, iSizeLimit1, iSizeLimit2);
    iLog->Put(iMsg);
    }

// ---------------------------------------------------------
// CPosTp55::LogVolumeInfoL
// Initiates iCriticalLevel. (value of iCriticalLevel is extracted from an MLFW 
// resource file that can reside on any drive)
// (other items were commented in a header).
// ---------------------------------------------------------
//	
void CPosTp55::LogVolumeInfoL()
    {
    _LIT(KUID,"Unique ID: %08x\r\n");
    _LIT(KSize,"Size: %d bytes\r\n");
    _LIT(KFree,"Free space: %d bytes\r\n");

    TVolumeInfo volumeInfo;
    TInt err = iFileServer.Volume(volumeInfo, EDriveC);
    if (err != KErrNone) 
        LogErrorAndLeave(_L("Error from iFileServer"));

    iMsg.Zero();
    iMsg.AppendFormat(KUID, volumeInfo.iUniqueID);
	iMsg.AppendFormat(KSize, volumeInfo.iSize);
	iMsg.AppendFormat(KFree, volumeInfo.iFree);
    iLog->Put(_L("\r\nMemory info:"));
    iLog->Put(iMsg);
    }

// ---------------------------------------------------------
// CPosTp55::DeleteFileL
//
// (other items were commented in a header).
// ---------------------------------------------------------
//
void CPosTp55::DeleteFileL(const TDesC& aFile)
    {
    TInt err = iFileServer.Delete(aFile);

    if (err != KErrNone && err != KErrNotFound)
        {
        _LIT(KErrText, "DeleteFileL(): The file %S could not be deleted, errorcode %d");
        iMsg.Format(KErrText, &aFile, err);
        LogErrorAndLeave(iMsg, err);
        }
    }

// ---------------------------------------------------------
// CPosTp55::FillFile3L
//
// (other items were commented in a header).
// ---------------------------------------------------------
//
void CPosTp55::FillFile3L()
    {
    iFile3.Close();
    iFileServer.Delete(KFile3);
    User::LeaveIfError(iFile3.Create(iFileServer, KFile3, EFileWrite));

    TVolumeInfo volumeInfo;
    User::LeaveIfError(iFileServer.Volume(volumeInfo, EDriveC));
    while (volumeInfo.iFree > iCriticalLevel + 512)
        {
        User::LeaveIfError(iFile3.Write(K64B));
        User::LeaveIfError(iFileServer.Volume(volumeInfo, EDriveC));
        }
    }

// ---------------------------------------------------------
// CPosTp55::CreateInputBufferL
//
// (other items were commented in a header).
// ---------------------------------------------------------
//
HBufC8* CPosTp55::CreateInputBufferL()
    {
    RFile inputFile;
    User::LeaveIfError(inputFile.Open(iFileServer, KXmlInputFile, EFileRead));
    CleanupClosePushL(inputFile);

    TInt fileSize;
    User::LeaveIfError(inputFile.Size(fileSize));
    HBufC8* buffer = HBufC8::NewLC(fileSize);

    // Copy file contents to buffer
    TPtr8 writableBuffer = buffer->Des();
    User::LeaveIfError(inputFile.Read(writableBuffer, fileSize));

    CleanupStack::Pop(buffer);
    CleanupStack::PopAndDestroy(&inputFile);
    return buffer;
    }

// ---------------------------------------------------------
// CPosTp55::ReInitializeEncoderEtcL
//
// (other items were commented in a header).
// ---------------------------------------------------------
//
void CPosTp55::ReInitializeEncoderEtcL()
    {
    delete iLandmarkEncoder;
    iLandmarkEncoder = NULL;
    iLandmarkEncoder = CPosLandmarkEncoder::NewL(KMimeType);

    DeleteFileL(KXmlOutputFile);
    DeleteFileL(KXmlBufferDumpFile);
    iFile3.Close();
    DeleteFileL(KFile3);

    iProgress = 0;
    }

// ---------------------------------------------------------
// CPosTp55::ReInitializeEncoderEtcL
//
// (other items were commented in a header).
// ---------------------------------------------------------
//
TInt CPosTp55::ExecuteLmOperationL(
    TBool aExecuteIncrementally)
    {
    TInt result(0);

    if (aExecuteIncrementally)
        {
        // Execute the finalizing incrementally.
        iOperationWrapper->Start(iOperation, this);
        CActiveScheduler::Start();
        result = iOperationWrapper->iStatus.Int();
        }
    else
        {
        TRAP(result, iOperation->ExecuteL());
        }

    return result;
    }

// ---------------------------------------------------------
// CPosTp55::SetOutputBufferL
//
// (other items were commented in a header).
// ---------------------------------------------------------
//
void CPosTp55::SetOutputBufferL()
    {
    delete iOutputBuffer;
    iOutputBuffer = NULL;
    iOutputBuffer = iLandmarkEncoder->SetUseOutputBufferL(); 
    }

// ---------------------------------------------------------
// CPosTp55::AddCollectionDataToEncoderL
//
// (other items were commented in a header).
// ---------------------------------------------------------
//
void CPosTp55::AddCollectionDataToEncoderL()
    {
    // Add long collection name to encoder
    HBufC* collectionName = HBufC::NewLC(2 * KNonsense().Length());
    collectionName->Des().Copy(KNonsense);
    iLandmarkEncoder->AddCollectionDataL(EPosLmCollDataCollectionName, *collectionName);

    // Add long collection desc to encoder
    HBufC* collectionDesc = HBufC::NewLC(3 * collectionName->Length());
    collectionDesc->Des().Append(*collectionName);
    collectionDesc->Des().Append(*collectionName);
    collectionDesc->Des().Append(*collectionName);
    iLandmarkEncoder->AddCollectionDataL(EPosLmCollDataCollectionDescription, *collectionDesc);
    CleanupStack::PopAndDestroy(2, collectionName);
    }

// ---------------------------------------------------------
// CPosTp55::AddLandmarksToEncoderL
//
// (other items were commented in a header).
// ---------------------------------------------------------
//
void CPosTp55::AddLandmarksToEncoderL(TBool aAddAll)
    {
    // Add landmarks to export to encoder manually.
    TInt result(0);
    CPosLmItemIterator* iterator = iDatabase->LandmarkIteratorL();
    CleanupStack::PushL(iterator);
    TInt maxNrOfLMs = (aAddAll) ? iterator->NumOfItemsL() : KNrOfLandmarksToExport;
    for (TInt i = 0; i < maxNrOfLMs && result != KErrDiskFull; i++)
        {
        CPosLandmark* landmark = iDatabase->ReadLandmarkLC(iterator->NextL());
        TRAP(result, iLandmarkEncoder->AddLandmarkL(*landmark));
        if (result == KErrLocked)
            {
            iLog->Put(_L("KErrLocked when AddLandmarkL in AddLandmarksToEncoderL"));
            User::After(100000);
            }
        CleanupStack::PopAndDestroy(landmark);
        iProgress = (TInt) (100 * i / maxNrOfLMs);
        }
    CleanupStack::PopAndDestroy(iterator);

    if (aAddAll)
        {
        if (result == KErrDiskFull)
            {
            iMsg.Format(_L("Got KErrDiskFull after adding %d%% of the landmarks to the encoder."), iProgress);
            iLog->Put(iMsg);
            }
        else
            {
            _LIT(KAddLmErr, "Didn't get EKrrDiskFull but %d when adding LMs to encoder");
            LogVolumeInfoL();
            LogErrorAndLeave(KAddLmErr);
            }
        }
    else
        {
        _LIT(KAddLmErr, "Didn't get EKrrNone but %d when adding LMs to encoder");
        AssertTrueSecL(result == KErrNone, KAddLmErr, result);
        }
    }

// ---------------------------------------------------------
// CPosTp55::ExportWithExportLandmarksMethodL()
//
// (other items were commented in a header).
// ---------------------------------------------------------
//
void CPosTp55::ExportWithExportLandmarksMethodL(
    RArray<TPosLmItemId>& aArrayOfIds,
    TBool aExecuteIncrementally)
    {
    delete iOperation;
    iOperation = NULL;
    iOperation = iDatabase->ExportLandmarksL(
        *iLandmarkEncoder, aArrayOfIds, CPosLandmarkDatabase::EDefaultOptions);
    TInt result = ExecuteLmOperationL(aExecuteIncrementally);

    if (aArrayOfIds.Count() == KNrOfLandmarksToExport) // not all of the LMs have been added
        {
        // Check that KErrDiskFull is not returned
        _LIT(KErrMsg, "Expected KErrNone from ExportLandmarksL() but got %d.");
        AssertTrueSecL(result == KErrNone, KErrMsg, result);
        }
    else // We should have gotten KErrDiskFull when adding LMs to encoder.
        {
        _LIT(KErrMsg, "ExportLandmarksL() didn't result in KErrDiskFull but in %d");
        AssertTrueSecL(result == KErrDiskFull, KErrMsg, result);
        if (aExecuteIncrementally)
            {
            iMsg.Format(_L("Got KErrDiskFull after adding %d%% of the landmarks to the encoder."), iProgress);
            }
        else
            {
            iMsg = _L("Got KErrDiskFull when exporting landmarks synchronously");            
            }
        iLog->Put(iMsg);
        }
    }

// ---------------------------------------------------------
// CPosTp55::FinalizeEncoderL()
//
// (other items were commented in a header).
// ---------------------------------------------------------
//
void CPosTp55::FinalizeEncoderL(
    TBool aExecuteIncrementally)
    {
    delete iOperation;
    iOperation = NULL;
    TRAPD(result, iOperation = iLandmarkEncoder->FinalizeEncodingL());
    if (result == KErrNone)
        {
        result = ExecuteLmOperationL(aExecuteIncrementally);

        // Check that KErrDiskFull is returned
        _LIT(KErrMsg, "FinalizeL() didn't result in KErrDiskFull but in %d");
        AssertTrueSecL(result == KErrDiskFull, KErrMsg, result);
        iLog->Put(_L("Execution of FinalizeEncodingL() left with KErrDiskFull"));
        }
    else
        {
        AssertTrueSecL(result == KErrDiskFull, _L("FinalizeEncodingL() left with %d"), result);
        iLog->Put(_L("FinalizeEncodingL() left with KErrDiskFull"));
        }
    }

// ---------------------------------------------------------
// CPosTp55::FinalizeEncoderL()
//
// (other items were commented in a header).
// ---------------------------------------------------------
//
void CPosTp55::PopulateArrayL(
    RArray<TPosLmItemId>& aArray,
    TBool aDoAddAllLms)
    {
    CPosLmItemIterator* iterator = iDatabase->LandmarkIteratorL();
    CleanupStack::PushL(iterator);
    TInt nrOfLms = aDoAddAllLms ? iterator->NumOfItemsL() : KNrOfLandmarksToExport;
    for (TInt i = 0; i < nrOfLms; i++)
        {
        CPosLandmark* landmark = iDatabase->ReadLandmarkLC(iterator->NextL());
        User::LeaveIfError(aArray.Append(landmark->LandmarkId()));
        CleanupStack::PopAndDestroy(landmark);
        }
    CleanupStack::PopAndDestroy(iterator);
    }

// ---------------------------------------------------------
// CPosTp55::CopyResourceFileL
// 
// (other items were commented in a header).
// ---------------------------------------------------------
//
void CPosTp55::CopyResourceFileL(const TDesC& aResourceFile)
    {
    // Release all landmark references to make DLLs be unloaded.
    delete iDatabase;
    iDatabase = NULL;
    delete iLandmarkEncoder;
    iLandmarkEncoder = NULL;
    delete iLandmarkParser;
    iLandmarkParser = NULL;
    delete iOperation;
    iOperation = NULL;

    CFileMan* fileMan = CFileMan::NewL(iFileServer);
    CleanupStack::PushL(fileMan);
    
    // Check if landmark is flashed
     if (!BaflUtils::FileExists(iFileServer, KInternalServicesResFileRom))
        {
         iLog->Put(_L("Landmark is NOT flashed, backing up eposlmintservices.rsc by renaming it bofore copying rsc-file."));
        // Landmark FW is not flashed. Rename the file before copying an own defiend file.
        // Since landmark FW is not flashed the file should exist hence leaving if it is not found!
         User::LeaveIfError(fileMan->Rename(KInternalServicesResFileCdrive, KInternalServicesResFileBackup, CFileMan::EOverWrite));
        }
     else
        {
        iLog->Put(_L("Landmark framework is flashed, copying global categories to c:"));
        }

    User::LeaveIfError(fileMan->Copy(aResourceFile, KInternalServicesResFileCdrive, CFileMan::EOverWrite));
 
    CleanupStack::PopAndDestroy(fileMan);
    }

// ---------------------------------------------------------
// CPosTp55::TryRestoreResourceFile
// 
// (other items were commented in a header).
// ---------------------------------------------------------
//
void CPosTp55::TryRestoreResourceFile()
    {
    CFileMan* fileMan = NULL;
    TRAPD(err, fileMan = CFileMan::NewL(iFileServer));
    if (fileMan)
        {
        // Try to restore the backup up rsc-file (only possible when LM FW is not flashed.
        TInt result = fileMan->Copy(KInternalServicesResFileBackup, KInternalServicesResFileCdrive, CFileMan::EOverWrite);
        if (result == KErrNotFound)
            {
            if (BaflUtils::FileExists(iFileServer, KInternalServicesResFileRom))
                {
                // LM FW is flashed. We need to remove the rsc-file on c:
                fileMan->Delete(KInternalServicesResFileCdrive);
                }
            }
        delete fileMan;
        }
    }

// End of file