/*

* Copyright (c) 2005 Nokia Corporation and/or its subsidiary(-ies). 

* All rights reserved.

* This component and the accompanying materials are made available

* which accompanies this distribution, and is available

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description: 

*   ?description_line

*

*/

//  INCLUDES

#include "FT_CPosTp45.h"

#include <EPos_CPosLandmarkDatabase.h>

#include <EPos_CPosLandmarkEncoder.h>

#include <EPos_CPosLandmarkParser.h>

#include <bautils.h>

// CONSTANTS

const TInt KNoCategoriesTp45  = 100;

// Filename with 260 characters

_LIT(KLongFileName, "c:\\File123456File123456File123456File123456File123456File123456File123456File123456File123456File123456File123456File123456File123456File123456File123456File123456File123456File123456File123456File123456File123456File123456File123456File123456File123456File12");

// Filename with 264 characters

_LIT(KLongFileName2, "c:\\File123456File123456File123456File123456File123456File123456File123456File123456File123456File123456File123456File123456File123456File123456File123456File123456File123456File123456File123456File123456File123456File123456File123456File123456File123456File12.txt");

_LIT(KDefaultOptions,   "c:\\system\\test\\testdata\\TP45-DefOptions.xml"); 

_LIT(KInclCategories,   "c:\\system\\test\\testdata\\TP45-IncCategories.xml"); 

_LIT(KExclCategories,   "c:\\system\\test\\testdata\\TP45-ExcCategories.xml");

_LIT(KOneLandmark,      "c:\\system\\test\\testdata\\TP45-OneLandmark.xml");

_LIT(KTwoLandmarks,     "c:\\system\\test\\testdata\\TP45-TwoLandmarks.xml");

_LIT(KTwoLandmarksWithColData, "c:\\system\\test\\testdata\\TP45-TwoLandmarksWithCollData.xml");

_LIT(KFileSync,         "c:\\documents\\TP45-DefOptions.xml"); 

_LIT(KFileInc,          "c:\\documents\\TP45-DefOptionsInc.xml");     

_LIT(KFileWait4Req,     "c:\\documents\\TP45-DefOptionsWait4Req.xml");     

_LIT(KBufferSync,       "c:\\documents\\TP45-DefOptionsBuffer.xml");                      

_LIT(KBufferInc,        "c:\\documents\\TP45-DefOptionsBufferInc.xml"); 

_LIT(KBufferWait4Req,   "c:\\documents\\TP45-DefOptionsBufferWait4Req.xml"); 

_LIT(KFileSync2,        "c:\\documents\\TP45-IncCategories.xml");

_LIT(KFileInc2,         "c:\\documents\\TP45-IncCategoriesInc.xml");

_LIT(KFileWait4Req2,    "c:\\documents\\TP45-IncCategoriesWait4Req.xml");

_LIT(KBufferSync2,      "c:\\documents\\TP45-IncCategoriesBuffer.xml");

_LIT(KBufferInc2,       "c:\\documents\\TP45-IncCategoriesBufferInc.xml");

_LIT(KBufferWait4Req2,  "c:\\documents\\TP45-IncCategoriesBufferWait4Req.xml");

_LIT(KFileSync3,        "c:\\documents\\TP45-ExcCategories.xml");

_LIT(KFileInc3,         "c:\\documents\\TP45-ExcCategoriesInc.xml");

_LIT(KFileWait4Req3,    "c:\\documents\\TP45-ExcCategoriesWait4Req.xml");

_LIT(KBufferSync3,      "c:\\documents\\TP45-ExcCategoriesBuffer.xml");

_LIT(KBufferInc3,       "c:\\documents\\TP45-ExcCategoriesBufferInc.xml");

_LIT(KBufferWait4Req3,  "c:\\documents\\TP45-ExcCategoriesBufferWait4Req.xml");

_LIT(KFileSync4,        "c:\\documents\\TP45-OneLandmark.xml");

_LIT(KFileInc4,         "c:\\documents\\TP45-OneLandmarkInc.xml");

_LIT(KFileWait4Req4,    "c:\\documents\\TP45-OneLandmarkWait4Req.xml");

_LIT(KFileSync5,        "c:\\documents\\TP45-TwoLandmarks.xml");

_LIT(KFileInc5,         "c:\\documents\\TP45-TwoLandmarksInc.xml");

_LIT(KFileWait4Req5,    "c:\\documents\\TP45-TwoLandmarksWait4Req.xml");

_LIT(KFileSync6,        "c:\\documents\\TP45-TwoLandmarksWithCollData.xml");

_LIT(KFileCancelled,    "c:\\documents\\TP45-Cancelled.xml");

_LIT(KFileCancelledInCallback, "c:\\documents\\TP45-CancelledInCallback.xml");

_LIT(KTmpFile, "c:\\documents\\TMP.xml");

//const TPosLmItemId KGlobalCategoryId = 2;

//const TPosLmItemId KGlobalCategoryId2 = 4;

const TPosLmItemId KGlobalCategoryId = 5;

const TPosLmItemId KGlobalCategoryId2 = 9;

const TPosLmItemId KLandmarkId = 3;

const TPosLmItemId KLandmarkId2 = 1;

const TInt KMaxCancelled = 10;

const TInt KMaxCancelledInCallback = 50;

_LIT(KCollectionName, "TP45-CollectionName");

_LIT(KCollectionDes, "TP45-Description");

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

// ---------------------------------------------------------

// CPosTp45::CloseTest

//

// (other items were commented in a header).

// ---------------------------------------------------------

//

void CPosTp45::CloseTest()

    {

    iLog->Log(_L("CloseTest"));   

    delete iDatabase;

    delete iLandmarkEncoder;    

    delete iBuffer;   

    // Added for BC testing         

    delete iCategoryManager;

    iGlobalCategoryIds.Close();

    iGlobalCategoryNames.Close();    

    iGlobalCategoryTestNames.Close(); 

    iCategories.ResetAndDestroy();

    iCategories.Close();  

    RemoveGlobalCategoriesL();

    }

// ---------------------------------------------------------

// CPosTp45::StartL

//

// (other items were commented in a header).

// ---------------------------------------------------------

//

void CPosTp45::StartL()

    { 

    BaflUtils::EnsurePathExistsL( iFileSession, KTmpFile );

    RemoveDefaultDbL();

    RemoveGlobalCategoriesL();

    iDatabase = CPosLandmarkDatabase::OpenL();        

    if (iDatabase->IsInitializingNeeded())

       {

       ExecuteAndDeleteLD(iDatabase->InitializeL());

       }

    iCategoryManager = CPosLmCategoryManager::NewL(*iDatabase);

    ExecuteAndDeleteLD(iDatabase->CompactL());          

    // Setup global category info

    SetupGlobalCategoriesL(); 

    AddLandmarksL();

    AddCategoriesL();

    iLandmarkEncoder = CPosLandmarkEncoder::NewL(KLmxMimeType);

    TestErrorCodesL();

    RArray<TPosLmItemId> arrayOfIds;

    CleanupClosePushL(arrayOfIds);

    CPosLmItemIterator* iter = iDatabase->LandmarkIteratorL();

    CleanupStack::PushL(iter);

    TInt numberOfElements = iter->NumOfItemsL();    

    iter->GetItemIdsL(arrayOfIds, 0, (numberOfElements));   

    iLogToFile = ETrue;

    TBool useWaitForRequest = ETrue;

// Exporting all landmarks to file

    iLog->Log(_L("Exporting all landmarks syncronously to file")); 

    ExportLandmarksL(KFileSync, arrayOfIds, CPosLandmarkDatabase::EDefaultOptions);

   	iLog->Log(_L("Exporting all landmarks incrementally to file")); 

    ExportLandmarksIncL(KFileInc, arrayOfIds, CPosLandmarkDatabase::EDefaultOptions, !useWaitForRequest);

   	iLog->Log(_L("Exporting all landmarks incrementally using User::WaitForRequest() to file")); 

    ExportLandmarksIncL(KFileWait4Req, arrayOfIds, CPosLandmarkDatabase::EDefaultOptions, useWaitForRequest);

    RenameGlobalCategoryL();

// Exporting with global cateogries to file

    iLog->Log(_L("Exporting all landmarks with global categories names syncronously to file")); 

    ExportLandmarksL(KFileSync2, arrayOfIds, CPosLandmarkDatabase::EIncludeCategories | 

                                     CPosLandmarkDatabase::EIncludeGlobalCategoryNames);      

    iLog->Log(_L("Exporting all landmarks with global categories names incrementally to file")); 

    ExportLandmarksIncL(KFileInc2, arrayOfIds, CPosLandmarkDatabase::EIncludeCategories | 

                                     CPosLandmarkDatabase::EIncludeGlobalCategoryNames,

                                     !useWaitForRequest);

    iLog->Log(_L("Exporting all landmarks with global categories names incrementally using User::WaitForRequest() to file")); 

    ExportLandmarksIncL(KFileWait4Req2, arrayOfIds, CPosLandmarkDatabase::EIncludeCategories | 

                                     CPosLandmarkDatabase::EIncludeGlobalCategoryNames,

                                     useWaitForRequest);

// Exporting without global cateogries to file

    iLog->Log(_L("Exporting all landmarks with categories exc. global categories syncronously to file")); 

    ExportLandmarksL(KFileSync3, arrayOfIds, CPosLandmarkDatabase::EIncludeCategories);

    iLog->Log(_L("Exporting all landmarks with categories exc. global categories incrementally to file")); 

    ExportLandmarksIncL(KFileInc3, arrayOfIds, CPosLandmarkDatabase::EIncludeCategories, !useWaitForRequest);

    iLog->Log(_L("Exporting all landmarks with categories exc. global categories incrementally using User::WaitForRequest() to file")); 

    ExportLandmarksIncL(KFileWait4Req3, arrayOfIds, CPosLandmarkDatabase::EIncludeCategories, useWaitForRequest);

    iLogToFile = EFalse;

// Exporting all landmarks to buffer

    iLog->Log(_L("Exporting all landmarks syncronously to buffer")); 

    ExportLandmarksL(KBufferSync, arrayOfIds, CPosLandmarkDatabase::EDefaultOptions);

   	iLog->Log(_L("Exporting all landmarks incrementally to buffer")); 

    ExportLandmarksIncL(KBufferInc, arrayOfIds, CPosLandmarkDatabase::EDefaultOptions, !useWaitForRequest);

   	iLog->Log(_L("Exporting all landmarks incrementally using User::WaitForRequest() to buffer")); 

    ExportLandmarksIncL(KBufferWait4Req, arrayOfIds, CPosLandmarkDatabase::EDefaultOptions, useWaitForRequest);

// Exporting all landmarks with global categories to buffer

    iLog->Log(_L("Exporting all landmarks with global categories names syncronously to buffer")); 

    ExportLandmarksL(KBufferSync2, arrayOfIds, CPosLandmarkDatabase::EIncludeCategories | 

                                     CPosLandmarkDatabase::EIncludeGlobalCategoryNames);      

    iLog->Log(_L("Exporting all landmarks with global categories names incrementally to buffer")); 

    ExportLandmarksIncL(KBufferInc2, arrayOfIds, CPosLandmarkDatabase::EIncludeCategories | 

                                     CPosLandmarkDatabase::EIncludeGlobalCategoryNames,

                                     !useWaitForRequest);

    iLog->Log(_L("Exporting all landmarks with global categories names incrementally using User::WaitForRequest() to buffer")); 

    ExportLandmarksIncL(KBufferWait4Req2, arrayOfIds, CPosLandmarkDatabase::EIncludeCategories | 

                                     CPosLandmarkDatabase::EIncludeGlobalCategoryNames,

                                     useWaitForRequest);

// Exporting all landmarks with global categories to buffer

    iLog->Log(_L("Exporting all landmarks with categories exc. global categories syncronously to buffer")); 

    ExportLandmarksL(KBufferSync3, arrayOfIds, CPosLandmarkDatabase::EIncludeCategories);

    iLog->Log(_L("Exporting all landmarks with categories exc. global categories incrementally to buffer")); 

    ExportLandmarksIncL(KBufferInc3, arrayOfIds, CPosLandmarkDatabase::EIncludeCategories, !useWaitForRequest);

    iLog->Log(_L("Exporting all landmarks with categories exc. global categories incrementally using User::WaitForRequest() to buffer")); 

    ExportLandmarksIncL(KBufferWait4Req3, arrayOfIds, CPosLandmarkDatabase::EIncludeCategories, useWaitForRequest);

    iLogToFile = ETrue;

    CleanupStack::PopAndDestroy(iter);  

    arrayOfIds.Reset();

// Exporting one landmark to file    

    arrayOfIds.Append(KLandmarkId);

    iLog->Log(_L("Exporting one landmark syncronously to file")); 

    ExportLandmarksL(KFileSync4, arrayOfIds, CPosLandmarkDatabase::EDefaultOptions);

    iLog->Log(_L("Exporting one landmark syncronously to file incrementally")); 

    ExportLandmarksIncL(KFileInc4, arrayOfIds, CPosLandmarkDatabase::EDefaultOptions, !useWaitForRequest);

    iLog->Log(_L("Exporting one landmark syncronously to file incrementally using User::WaitForRequest()")); 

    ExportLandmarksIncL(KFileWait4Req4, arrayOfIds, CPosLandmarkDatabase::EDefaultOptions, useWaitForRequest);

// Exporting two landmarks to file    

    arrayOfIds.Append(KLandmarkId2);

    iLog->Log(_L("Exporting two landmark syncronously to file")); 

    ExportLandmarksL(KFileSync5, arrayOfIds, CPosLandmarkDatabase::EDefaultOptions);

    iLog->Log(_L("Exporting two landmark syncronously to file incrementally")); 

    ExportLandmarksIncL(KFileInc5, arrayOfIds, CPosLandmarkDatabase::EDefaultOptions, !useWaitForRequest);

    iLog->Log(_L("Exporting two landmark syncronously to file incrementally using User::WaitForRequest()")); 

    ExportLandmarksIncL(KFileWait4Req5, arrayOfIds, CPosLandmarkDatabase::EDefaultOptions, useWaitForRequest);

// Exporting landmarks with collection data    

    iLog->Log(_L("Exporting landmarks with collection data added to the encoder")); 

    ExportWithCollectionDataL(arrayOfIds, CPosLandmarkDatabase::EDefaultOptions);

    iLog->Log(_L("Compares the created XML files with saved correct ones")); 

    TInt errors = 0;

    errors += CompareL(KDefaultOptions, KFileSync);

    errors += CompareL(KDefaultOptions, KFileInc);

    errors += CompareL(KDefaultOptions, KFileWait4Req);

    errors += CompareL(KDefaultOptions, KBufferSync);

    errors += CompareL(KDefaultOptions, KBufferInc);

    errors += CompareL(KDefaultOptions, KBufferWait4Req);

    TFileName filename;

    CreateCorrectXmlFileL( KInclCategories, filename );

    errors += CompareL(filename, KFileSync2);

    errors += CompareL(filename, KFileInc2);

    errors += CompareL(filename, KFileWait4Req2);

    errors += CompareL(filename, KFileInc2);

    errors += CompareL(filename, KBufferSync2);

    errors += CompareL(filename, KBufferInc2);

    errors += CompareL(filename, KBufferWait4Req2);

    CreateCorrectXmlFileL( KExclCategories, filename );

    errors += CompareL(filename, KFileSync3);

    errors += CompareL(filename, KFileInc3);

    errors += CompareL(filename, KFileWait4Req3);

    errors += CompareL(filename, KBufferSync3);

    errors += CompareL(filename, KBufferInc3);

    errors += CompareL(filename, KBufferWait4Req3);

    errors += CompareL(KOneLandmark, KFileSync4);

    errors += CompareL(KOneLandmark, KFileInc4);

    errors += CompareL(KOneLandmark, KFileWait4Req4);

    errors += CompareL(KTwoLandmarks, KFileSync5);

    errors += CompareL(KTwoLandmarks, KFileInc5);

    errors += CompareL(KTwoLandmarks, KFileWait4Req5);

    errors += CompareL(KTwoLandmarksWithColData, KFileSync6);

    if (errors > 0)

        {

        errors = errors / KErrGeneral;

        }

		AssertTrueSecL(errors == 0, _L("%d file(s) are not equal"), errors);

		delete iDatabase;

    iDatabase = NULL;

    iDatabase = UseGeneratedDbFileL();

    if (iDatabase->IsInitializingNeeded())

       {

       ExecuteAndDeleteLD(iDatabase->InitializeL());

       }

    iLog->Log(_L("Exports landmarks and cancels the operation")); 

    ExportAndCancelL(KFileCancelled, EFalse, CPosLandmarkDatabase::EDefaultOptions);

    iLog->Log(_L("Exports landmarks and cancels the operation in a callback")); 

    ExportAndCancelL(KFileCancelledInCallback, ETrue, CPosLandmarkDatabase::EDefaultOptions);

		VerifyCancelL(KFileCancelled, KMaxCancelled);

		VerifyCancelL(KFileCancelledInCallback, KMaxCancelledInCallback);

    CleanupStack::PopAndDestroy(&arrayOfIds);  

  	}

// ---------------------------------------------------------

// CPosTp45::ExportLandmarksL

//

// (other items were commented in a header).

// ---------------------------------------------------------

//	

void CPosTp45::ExportLandmarksL(const TDesC& aFileName, 

                                RArray<TPosLmItemId>& aArrayOfIds, 

                                CPosLandmarkDatabase::TTransferOptions aTransferOptions)

    {

    iLog->Log(_L("ExportLandmarksL"));

    TBuf<100> file;

    file.Append(aFileName);

    if (iLogToFile)

        {        

        DeleteFile(file);

        iLandmarkEncoder->SetOutputFileL(file);

        }

    else

        {

        iBuffer = iLandmarkEncoder->SetUseOutputBufferL(); 

        }

    CPosLmOperation* op = iDatabase->ExportLandmarksL(*iLandmarkEncoder, aArrayOfIds, aTransferOptions); 

    CleanupStack::PushL(op);

    op->ExecuteL();

    CleanupStack::PopAndDestroy(op);

    op = iLandmarkEncoder->FinalizeEncodingL(); 

    CleanupStack::PushL(op);

    op->ExecuteL();

    CleanupStack::PopAndDestroy(op);

    if (!iLogToFile)

        {

        WriteBufferToFileL(iBuffer, file); 

        delete iBuffer;

        iBuffer = NULL;

        }

    }

// ---------------------------------------------------------

// CPosTp45::ExportLandmarksIncL

//

// (other items were commented in a header).

// ---------------------------------------------------------

//	

void CPosTp45::ExportLandmarksIncL(const TDesC& aFileName,

                                   RArray<TPosLmItemId>& aArrayOfIds, 

                                   CPosLandmarkDatabase::TTransferOptions aTransferOptions,

                                   TBool aUseWaitForRequest)

    {

    iLog->Log(_L("ExportLandmarksIncL"));

    TBuf<100> file;

    file.Append(aFileName);

    if (iLogToFile)

        {        

        DeleteFile(file);

        iLandmarkEncoder->SetOutputFileL(file); 

        }

    else

        {

        iBuffer = iLandmarkEncoder->SetUseOutputBufferL(); 

        }

    CPosLmOperation* op = iDatabase->ExportLandmarksL(*iLandmarkEncoder, aArrayOfIds, aTransferOptions); 

    if (aUseWaitForRequest)

        {

        CleanupStack::PushL(op);

        RunAsyncOperationByWaitForReqL(op);

        CleanupStack::PopAndDestroy(op);

        }

    else

        {

        RunAsyncOperationLD(op);

        }

    op = iLandmarkEncoder->FinalizeEncodingL(); 

    if (aUseWaitForRequest)

        {

        CleanupStack::PushL(op);

        RunAsyncOperationByWaitForReqL(op);

        CleanupStack::PopAndDestroy(op);

        }

    else

        {

        RunAsyncOperationLD(op);

        }

    if (!iLogToFile)

        {

        WriteBufferToFileL(iBuffer, file);

        delete iBuffer;

        iBuffer = NULL; 

        }

	}

// ---------------------------------------------------------

// CPosTp45::ExportWithCollectionDataL

//

// (other items were commented in a header).

// ---------------------------------------------------------

//	

void CPosTp45::ExportWithCollectionDataL(RArray<TPosLmItemId>& aArrayOfIds, 

                                         CPosLandmarkDatabase::TTransferOptions aTransferOptions)

    {

    iLog->Log(_L("ExportWithCollectionDataL"));

    TBuf<100> file;

    //file.Append(KTargetPath);

    file.Append(KFileSync6);

    DeleteFile(file);

    iLandmarkEncoder->SetOutputFileL(file); 

    iLandmarkEncoder->AddCollectionDataL(EPosLmCollDataCollectionName, KCollectionName);

    iLandmarkEncoder->AddCollectionDataL(EPosLmCollDataCollectionDescription, KCollectionDes);

    CPosLmOperation* op = iDatabase->ExportLandmarksL(*iLandmarkEncoder, aArrayOfIds, aTransferOptions); 

    CleanupStack::PushL(op);

    op->ExecuteL();

    CleanupStack::PopAndDestroy(op);

    op = iLandmarkEncoder->FinalizeEncodingL(); 

    CleanupStack::PushL(op);

    op->ExecuteL();

    CleanupStack::PopAndDestroy(op);

    iLog->Log(_L("ExportWithCollectionDataL Done"));

    }

// ---------------------------------------------------------

// CPosTp45::ExportAndCancelL

//

// (other items were commented in a header).

// ---------------------------------------------------------

//	

void CPosTp45::ExportAndCancelL(const TDesC& aFileName, 

                                const TBool& aInCallback, 

                                CPosLandmarkDatabase::TTransferOptions aTransferOptions)

    {

    iLog->Log(_L("ExportAndCancelL"));

    TBuf<100> file;

    //file.Append(KTargetPath);

    file.Append(aFileName);

    DeleteFile(file);

    iLandmarkEncoder->SetOutputFileL(file); 

    CPosLmItemIterator* iter = iDatabase->LandmarkIteratorL();

    CleanupStack::PushL(iter);

    RArray<TPosLmItemId> arrayOfIds;

    CleanupClosePushL(arrayOfIds);

    TInt numberOfElements = iter->NumOfItemsL();    

    iter->GetItemIdsL(arrayOfIds, 0, (numberOfElements));

    if (aInCallback)

        {

        RunAsyncOperationAndCancelInCallbackLD(iDatabase->ExportLandmarksL(*iLandmarkEncoder, arrayOfIds, aTransferOptions));

        }

    else

        {

        RunAsyncOperationAndCancelLD(iDatabase->ExportLandmarksL(*iLandmarkEncoder, arrayOfIds, aTransferOptions));

        } 

    CPosLmOperation* op = iLandmarkEncoder->FinalizeEncodingL(); 

    CleanupStack::PushL(op);

    op->ExecuteL();

    CleanupStack::PopAndDestroy(3, iter);

    iLog->Log(_L("ExportAndCancelL Done"));

    }

// ---------------------------------------------------------

// CPosTp45::VerifyCancelL

//

// (other items were commented in a header).

// ---------------------------------------------------------

//	    

void CPosTp45::VerifyCancelL(const TDesC& aFileName, const TInt aMaxExported)

    {

    iLog->Log(_L("VerifyCancelL"));

    TBuf<100> file;

    file.Append(aFileName);