/*

* 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_CPosTp46.h"

#include <EPos_CPosLandmarkDatabase.h> 

#include <EPos_CPosLandmarkDatabase.h>

#include <EPos_CPosLandmarkEncoder.h>

#include <EPos_CPosLandmarkParser.h>

#include <LbsPosition.h> 

#include <e32std.h>

#include <ss_std.h>

const TInt KNoMultipleClients = 10;

_LIT(KExportFileIndex,    "c:\\TP46-ExportedFileFromThread%d.xml");

#ifdef __WINS__

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

#else                   

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

#endif

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

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

// CPosTp46::GetName

//

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

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

//

void CPosTp46::GetName(TDes& aName) const

    {

    _LIT(KTestName, "TP46 - Multiple export operations");

    aName = KTestName;

    }

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

// CPosTp46::CloseTest

//

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

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

//

void CPosTp46::CloseTest()

    {

    for (TInt i=0; i<iThreads.Count(); i++)

        {

        iThreads[i].Close();

        }

    iThreads.Close();

    delete iDatabase;

    iDatabase=NULL;

    iUseLogFromThreadIsDisabled = EFalse;

    }

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

// CPosTp46::StartL

//

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

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

//

void CPosTp46::StartL()

    {

    // Make sure no logging from thread (causes crash)

    iUseLogFromThreadIsDisabled = ETrue;

    MakeSurePanicDebugFileExistsL();

    iDatabase = UseGeneratedDbFileL();

    if (iDatabase->IsInitializingNeeded())

       {

       ExecuteAndDeleteLD(iDatabase->InitializeL()); 

       }

    RemoveFilesL();

    iLog->Put(_L("Export landmarks syncronously simultaneously"));

    iTestStep=0;

    StartMultipleClientsL(KNoMultipleClients);

    iLog->Put(_L("Export landmarks incrementally simultaneously"));

    ++iTestStep;

    RemoveFilesL();

    StartMultipleClientsL(KNoMultipleClients);

    iLog->Put(_L("Export landmarks after import operation has taken write lock"));

    ++iTestStep;

    RemoveFilesL();

    CPosLandmarkParser* parser = CPosLandmarkParser::NewL(KMimeType);

    CleanupStack::PushL(parser);

    parser->SetInputFileL(KImportFile);

    // Take write lock

    CPosLmOperation* op = iDatabase->ImportLandmarksL(*parser, CPosLandmarkDatabase::EDefaultOptions); 

    CleanupStack::PushL(op);

    // Try to export

    StartMultipleClientsL(KNoMultipleClients);

    CleanupStack::PopAndDestroy(2, parser);

    // ESLI-64LLU3 - read/write lock only affects the same database instance.

    parser = CPosLandmarkParser::NewL(KMimeType);

    CleanupStack::PushL(parser);

    parser->SetInputFileL(KImportFile);

    CPosLandmarkDatabase* lmd = CPosLandmarkDatabase::OpenL();

    CleanupStack::PushL(lmd);

    if (lmd->IsInitializingNeeded())

       {

       ExecuteAndDeleteLD(lmd->InitializeL()); 

       }

    op = iDatabase->ImportLandmarksL(*parser, CPosLandmarkDatabase::EDefaultOptions); 

    CleanupStack::PushL(op);

    TRAPD(err, CleanupStack::PopAndDestroy(lmd->ReadLandmarkLC(1)));

    AssertTrueSecL(err == KErrLocked, _L("Didn't get KErrLocked but %d"), err);

    TRAP(err, CleanupStack::PopAndDestroy(iDatabase->ReadLandmarkLC(1))); 

    AssertTrueSecL(err == KErrLocked, _L("Didn't get KErrLocked but %d"), err);

    // Lock should prevent export threads to complete successfully

    StartMultipleClientsL(KNoMultipleClients);

    // Release lock - export threads should complete successfully

    CleanupStack::PopAndDestroy(op);

    iTestStep = ESync;

    StartMultipleClientsL(KNoMultipleClients);

    CleanupStack::PopAndDestroy(lmd);

    CleanupStack::PopAndDestroy(parser);

    }

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

// CPosTp46::RemoveFiles

//

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

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

//

void CPosTp46::RemoveFilesL()

    {

    RFs fs;

    User::LeaveIfError(fs.Connect());

    for (TInt i=1; i <= KNoMultipleClients; i++)

        {

        TBuf<100> fileName;

        fileName.Format(KExportFileIndex, i);

        fs.Delete(fileName);

        }

    fs.Close();

    }

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

// CPosTp46::StartMultipleClientsL

//

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

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

//

void CPosTp46::StartMultipleClientsL(const TUint aNoClients)

    {

    _LIT(KMultipleErr, "Error %d from thread %d");

    _LIT(KPanicErr, "Thread %d has panicked or is alive");

    _LIT(KSuccess, "Threads %d is successful");

    CreateThreadsL(aNoClients);

    RArray<TRequestStatus> statuses;

    CleanupClosePushL(statuses);

    for (TUint j=0; j<aNoClients; j++)

        {

        TRequestStatus status;

        statuses.Append(status);

        }

    TUint i=0; 

    for (i=0; i<aNoClients; i++)

        { 

        iThreads[i].Logon(statuses[i]);

        iThreads[i].Resume();

        }

    for (i=0; i<aNoClients; i++)

        {

        User::WaitForRequest(statuses[i]);

        }

    TUint errors=0; 

    for (i=0; i<aNoClients; i++)

        {

        TInt exitReason = iThreads[i].ExitReason();

        TBuf<100> info;

        if (exitReason != KErrNone)

            {

            errors++;

            info.Format(KMultipleErr, exitReason, i+1);

            }  

         else

            {

            info.Format(KSuccess, i+1);

            }

        iLog->Put(info);

        AssertTrueSecL(iThreads[i].ExitType() == EExitKill, KPanicErr, i+1);

        AssertTrueSecL(exitReason == KErrNone || exitReason == KErrLocked, info);

        }

    if (iTestStep != EImportStarted)

        {

        AssertTrueSecL(errors == 0, _L("No thread should leave with error, all should be able to read from the db"));

        }

    else

        {

        AssertTrueSecL(errors == aNoClients, _L("All threads should leave with error, none should be able to read from the db"));

        }

    for (i=0; i<aNoClients; i++)

        {

        iThreads[i].Close();

        }

    iThreadIndex=0;

    iThreads.Close();

    CleanupStack::PopAndDestroy(&statuses);

    }

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

// CPosTp46::RunTestL

//

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

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

//

void CPosTp46::RunTestL(TAny* aData)

    {

    CPosTp46* self = reinterpret_cast<CPosTp46*>(aData);

    TInt index = ++self->iThreadIndex;

    CPosLandmarkDatabase* lmd = CPosLandmarkDatabase::OpenL();

    CleanupStack::PushL(lmd);

    if (lmd->IsInitializingNeeded())

       {

       ExecuteAndDeleteLD(lmd->InitializeL()); 

       }

   /*

    _LIT(KInfo, "Thread %d");

    TBuf<100> info;

    info.Format(KInfo, index);

    RDebug::Print(info);

    */ 

    CPosLandmarkEncoder* encoder = CPosLandmarkEncoder::NewL(KMimeType);

    CleanupStack::PushL(encoder);

    CPosLmItemIterator* iter = lmd->LandmarkIteratorL();

    CleanupStack::PushL(iter);

    RArray<TPosLmItemId> arrayOfIds;

    CleanupClosePushL(arrayOfIds);

    TInt numberOfElements = iter->NumOfItemsL();    

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

    TBuf<100> fileName;

    fileName.Format(KExportFileIndex, index);

    encoder->SetOutputFileL(fileName);

    switch (self->iTestStep)

        {

        //case self->ESync:

        	case 0:

        //case self->EImportStarted:

        	case 2:

            {

            CPosLmOperation* op = lmd->ExportLandmarksL(*encoder, arrayOfIds, CPosLandmarkDatabase::EIncludeCategories); 

            CleanupStack::PushL(op);

            op->ExecuteL();

            CleanupStack::PopAndDestroy(op);

            op = encoder->FinalizeEncodingL(); 

            CleanupStack::PushL(op);

            op->ExecuteL();

            CleanupStack::PopAndDestroy(op);

            break;

            }

        //case self->EInc:

        	case 1:

            {

            CPosLmOperation* op2 = lmd->ExportLandmarksL(*encoder, arrayOfIds, CPosLandmarkDatabase::EIncludeCategories);  

            self->RunAsyncOperationLD(op2);

            op2 = encoder->FinalizeEncodingL(); 

            self->RunAsyncOperationLD(op2);

            break;

            }  

        }

    /*

    _LIT(KInfo3, "Thread %d after execute");

    info.Format(KInfo3, index);

    RDebug::Print(info);

    */

    CleanupStack::PopAndDestroy(4, lmd);

    }

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

// ThreadFunction

//

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

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

//

LOCAL_C TInt ThreadFunction(TAny* aData)

    {

    CTrapCleanup* cleanup=CTrapCleanup::New(); 

    CActiveScheduler* actSch = new (ELeave) CActiveScheduler;

    CActiveScheduler::Install(actSch);

    TRAPD(err, CPosTp46::RunTestL(aData));

    delete actSch;

    delete cleanup;

    return err;

    }

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

// CPosTp46::CreateThreadsL

//

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

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

//

void CPosTp46::CreateThreadsL(const TUint aNoThreads)

    {

    _LIT(KThreadName, "TP46 test thread%d");

    _LIT(KCreateThreadErr, "Create thread failed with %d");

    for (TUint i=0; i<aNoThreads; i++)

        {

        RThread thread;

        TBuf<32> name;

	    name.Format(KThreadName, 1+iThreads.Count());

        TInt err;

        err = thread.Create(name, ThreadFunction, KDefaultStackSize, KMinHeapSize, KMaxHeapSize, reinterpret_cast<TAny*>(this));

        AssertTrueSecL(err == KErrNone, KCreateThreadErr, err);                                                                  

        iThreads.Append(thread);

        }

    }

//  End of File