/*

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

#include <EPos_CPosLandmarkDatabase.h>

#include <EPos_CPosLMCategoryManager.h>

#include <EPos_CPosLandmarkEncoder.h>

#include <EPos_CPosLandmarkParser.h>

#include <e32std.h>

//#include <ss_std.h>

// CONSTANTS

_LIT8(KNonExistingMimeType1, "APPLICATION/VND.NOKIA.LANDMARKCOLLECTION+XML");

_LIT8(KNonExistingMimeType2, "application/vnd.nokia.kokoibollen");

//_LIT8(KNonExistingMimeType3, "application/vnd.nokia.kokoibollenapplication/vnd.nokia.kokoibollenapplication/vnd.nokia.kokoibollenapplication/vnd.nokia.kokoibollenapplication/vnd.nokia.kokoibollenapplication/vnd.nokia.kokoibollenapplication/vnd.nokia.kokoibollenapplication/vnd.nokia.kokoibollenapplication/vnd.nokia.kokoibollenapplication/vnd.nokia.kokoibollenapplication/vnd.nokia.kokoibollen");

_LIT8(KEmptyMimeType, "");

_LIT(KPosLandmarksServerName, "*eposlmserver*");

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

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

// CPosTp51::StartL

//

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

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

//

void CPosTp51::StartL()

    {

    iErrorsFound = 0;

    MakeSurePanicDebugFileExistsL();

    RemoveDefaultDbL();

    iDatabase = UseGeneratedDbFileL();

    if (iDatabase->IsInitializingNeeded())

       {

       ExecuteAndDeleteLD(iDatabase->InitializeL());

       }

    // <<<<<<<<<<<<<<Panic testing below>>>>>>>>>>>>>>>>>>>

    iLog->Log(_L(">>>>>>>Start Panic test<<<<<<<<<"));

    //	1 The client asks the API to parse XML content both synchronously 

    // and incrementally without specifying the input method. 

    iExpectedExitType = ExitPanic;

    iLog->Log(_L("Panic test 1"));

    iTestCase = 1;

    iExpectedErrorCode = EPosLmProtocolBreak;

    iMimeType.Set( KLmxMimeType );

    ResumeThreadAndVerifyExitL();

    iMimeType.Set( KGpxMimeType );

    ResumeThreadAndVerifyExitL();

    iExpectedExitType = ExitPanic;

    iLog->Log(_L("Panic test 2"));

    iTestCase = 2;

    iExpectedErrorCode = EPosLmProtocolBreak;

    iMimeType.Set( KLmxMimeType );

    ResumeThreadAndVerifyExitL();

    iMimeType.Set( KGpxMimeType );

    ResumeThreadAndVerifyExitL();

    // Import landmarks with an invalid transfer option

    iExpectedExitType = ExitPanic;

    iLog->Log(_L("Panic test 3"));

    iTestCase = 3;

    iExpectedErrorCode = EPosLmInvalidArgument;

    iMimeType.Set( KLmxMimeType );

    ResumeThreadAndVerifyExitL();

    iMimeType.Set( KGpxMimeType );

    ResumeThreadAndVerifyExitL();

     // Import landmarks with an invalid transfer option

    iExpectedExitType = ExitPanic;

    iLog->Log(_L("Panic test 9"));

    iTestCase = 9;

    iExpectedErrorCode = EPosLmInvalidArgument;

    iMimeType.Set( KLmxMimeType );

    ResumeThreadAndVerifyExitL();

    iMimeType.Set( KGpxMimeType );

    ResumeThreadAndVerifyExitL();

    // Import landmarks with an invalid transfer option

    iExpectedExitType = ExitPanic;

    iLog->Log(_L("Panic test 10"));

    iTestCase = 10;

    iExpectedErrorCode = EPosLmInvalidArgument;

    iMimeType.Set( KLmxMimeType );

    ResumeThreadAndVerifyExitL();

    iMimeType.Set( KGpxMimeType );

    ResumeThreadAndVerifyExitL();

    // Create a parser with incorrect MIME type, should leave

    iExpectedExitType = ExitLeave;

    iLog->Log(_L("Leave test 4"));

    iTestCase = 4;

    iExpectedErrorCode = KErrNotSupported;

    ResumeThreadAndVerifyExitL();

    // Create a parser with incorrect MIME (correct MIME type but with capital letters) type, should leave

    iExpectedExitType = ExitLeave;

    iLog->Log(_L("Leave test 5"));

    iTestCase = 5;

    iExpectedErrorCode = KErrNotSupported;

    ResumeThreadAndVerifyExitL();

    // Create a parser with incorrect MIME type, should leave

    iExpectedExitType = ExitLeave;

    iLog->Log(_L("Leave test 18"));

    iTestCase = 18;

    iExpectedErrorCode = KErrNotSupported;

    ResumeThreadAndVerifyExitL();

#if 0

    // Create a parser with incorrect MIME type, should leave

    // TE: the REComSession::CreateImplementationL( leaves with KErrArgument which I think is acceptable

    // Nokia: This is not part of API definition, case removed

    iExpectedExitType = ExitLeave;

    iLog->Log(_L("Leave test 19"));

    iTestCase = 19;

    iExpectedErrorCode = KErrArgument;

    ResumeThreadAndVerifyExitL();

#endif    

    // Create a parser, parse inc. but change input method after one step

    iExpectedExitType = ExitPanic;

    iLog->Log(_L("Leave test 6"));

    iTestCase = 6;

    iExpectedErrorCode = EPosLmProtocolBreak;

    iMimeType.Set( KLmxMimeType );

    ResumeThreadAndVerifyExitL();

    iMimeType.Set( KGpxMimeType );

    ResumeThreadAndVerifyExitL();

#ifndef __WINS__

    // Fetch Import Iterator with NULL argument

    iExpectedExitType = ExitPanic;

    iLog->Log(_L("Panic test 7"));

    iTestCase = 7;

    iExpectedErrorCode = 3; // Kern-Exec 3

    ResumeThreadAndVerifyExitL();

    ListAllServers();

    if (!ServerAlive(KPosLandmarksServerName))

        {

        iLog->Log(_L("Server not alive as expected(1)!"));

        User::Leave(-1);

        }

    // Use a CPosLmOperation object from a compact operation as input to an

    // ImportedLandmarksIteratorL function call

    iExpectedExitType = ExitPanic;

    iLog->Log(_L("Panic test 8"));

    iTestCase = 8;

    iExpectedErrorCode = 3; // Kern-Exec 3

    ResumeThreadAndVerifyExitL();

    ListAllServers();

    if (!ServerAlive(KPosLandmarksServerName))

        {

        iLog->Log(_L("Server not alive as expected(2)!"));

        User::Leave(-1);

        }

#endif

    // Import subset of landmarks with non existing ids

    iLog->Log(_L("Panic test 11"));

    iTestCase = 11;

    iExpectedExitType = ExitPanic;

    iExpectedErrorCode = EPosInvalidIndex;

    iMimeType.Set( KLmxMimeType );

    ResumeThreadAndVerifyExitL();

    iMimeType.Set( KGpxMimeType );

    ResumeThreadAndVerifyExitL();

    // Import subset of landmarks with empty subset of ids

    // should leave with KErrArgument

    iLog->Log(_L("Panic test 12"));

    iTestCase = 12;

    iExpectedExitType = ExitLeave;

    iExpectedErrorCode = KErrArgument;

    iMimeType.Set( KLmxMimeType );

    ResumeThreadAndVerifyExitL();

    iMimeType.Set( KGpxMimeType );

    ResumeThreadAndVerifyExitL();

    // Try to receive parsed landmark with invalid index

    iLog->Log(_L("Panic test 13"));

    iTestCase = 13;

    iExpectedExitType = ExitPanic;

    iExpectedErrorCode = EPosInvalidIndex;

    iMimeType.Set( KLmxMimeType );

    ResumeThreadAndVerifyExitL();

    iMimeType.Set( KGpxMimeType );

    ResumeThreadAndVerifyExitL();

    // Try to ParseContentL from empty buffer

    iLog->Log(_L("Panic test 14"));

    iTestCase = 14;

    iExpectedExitType = ExitLeave;

    iExpectedErrorCode = KErrPosLmUnknownFormat;

    iMimeType.Set( KLmxMimeType );

    ResumeThreadAndVerifyExitL();

    iMimeType.Set( KGpxMimeType );

    ResumeThreadAndVerifyExitL();

    // Try toParseContentL from NULL input buffer

    iLog->Log(_L("Panic test 15"));

    iTestCase = 15;

    iExpectedExitType = ExitPanic;

    iExpectedErrorCode = 3; // Kern-Exec 3

    iMimeType.Set( KLmxMimeType );

    ResumeThreadAndVerifyExitL();

    iMimeType.Set( KGpxMimeType );

    ResumeThreadAndVerifyExitL();

    // Try to ImportLandmarks from empty buffer

    iLog->Log(_L("Panic test 16"));

    iTestCase = 16;

    iExpectedExitType = ExitLeave;

    iExpectedErrorCode = KErrPosLmUnknownFormat;

    iMimeType.Set( KLmxMimeType );

    ResumeThreadAndVerifyExitL();

    iMimeType.Set( KGpxMimeType );

    ResumeThreadAndVerifyExitL();

    // Try to ImportLandmarks from NULL buffer

    iLog->Log(_L("Panic test 17"));

    iTestCase = 17;

    iExpectedExitType = ExitPanic;

    iExpectedErrorCode = 3; // Kern-Exec 3

    iMimeType.Set( KLmxMimeType );

    ResumeThreadAndVerifyExitL();

    iMimeType.Set( KGpxMimeType );

    ResumeThreadAndVerifyExitL();

    iLog->Log(_L(">>>>>>>Panic test Done<<<<<<<<<"));

    if (iErrorsFound != KErrNone)

        {

        iLog->Log(_L("Errors found in TP51"));

        User::Leave(-2);

        }

    }

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

// CPosTp51::ResumeThreadAndVerifyExitL

//

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

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

//

void CPosTp51::ResumeThreadAndVerifyExitL()

    {

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

    _LIT(KPanicErr, "ERROR: Method didn't panic, exit type %d"); 

    _LIT(KPanicCodeErr, "ERROR: Unexpected panic code, actual %d, expected %d");

    _LIT(KLeaveErr, "ERROR: Method didn't leave, exit type %d"); 

    _LIT(KLeaveCodeErr, "ERROR: Unexpected leave error, actual %d, expected %d");

    CreateThreadL();

    TRequestStatus status;

    iThread.Logon(status);

    iThread.Resume();

    User::WaitForRequest(status);

    if (iExpectedExitType == ExitPanic)

        {

        if (iThread.ExitType() != EExitPanic )

            {

            iLog->Log( KPanicErr, iThread.ExitType() );

            iErrorsFound++;

            }

        if ( iThread.ExitReason() != iExpectedErrorCode )

            {

            iLog->Log( KPanicCodeErr, iThread.ExitReason(), iExpectedErrorCode );

            iErrorsFound++;

            }

        }

    else if (iExpectedExitType == ExitLeave)

        {

        if (iThread.ExitType() != EExitKill )

            {

            iLog->Log( KLeaveErr, iThread.ExitType() );

            iErrorsFound++;

            }

        if ( iThread.ExitReason() != iExpectedErrorCode )

            {

            iLog->Log( KLeaveCodeErr, iThread.ExitReason(), iExpectedErrorCode );

            iErrorsFound++;

            }

        }

    iThread.Close();

    }

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

// CPosTp51::CloseTest

//

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

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

//

void CPosTp51::CloseTest()

    {

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

    iThread.Close();

    delete iDatabase;

    iDatabase = NULL;

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

	}

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

// CPosTp51::RunPanicTestL

//

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

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

void CPosTp51::RunPanicTestL(TAny* aData)

    {

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

	_LIT(KXML1, "c:\\system\\test\\TestData\\TP47_UTF-16-bigEndian.xml");

	_LIT(KXML2, "c:\\system\\test\\TestData\\TP47_UTF-16-littleEndian.xml");

	_LIT(KXML3, "c:\\system\\test\\TestData\\TP47_UTF-16-bigEndian.gpx");

	_LIT(KXML4, "c:\\system\\test\\TestData\\TP47_UTF-16-littleEndian.gpx");

     if (self->iTestCase == 1)

        {

         // Create parser 

        CPosLandmarkParser* landmarkParser = CPosLandmarkParser::NewL(self->iMimeType);

        //Should Panic when no input is set, parse sync

        ExecuteAndDeleteLD(landmarkParser->ParseContentL());

        }

     else if (self->iTestCase == 2)

        {

         // Create parser, 

         CPosLandmarkParser* landmarkParser = CPosLandmarkParser::NewL(self->iMimeType);

         // Parse content, should panic when no input set, parse incrementally

         CPosLmOperation* operation = landmarkParser->ParseContentL();

         self->RunAsyncOperationLD(operation);

        }

     else if (self->iTestCase == 3)

        {

         CPosLandmarkDatabase* database = self->OpenDatabaseLC();

         // Create parser

         CPosLandmarkParser* landmarkParser = CPosLandmarkParser::NewL(self->iMimeType);

         // Importlandmarks with invalid transfer option, should panic

         ExecuteAndDeleteLD(database->ImportLandmarksL(*landmarkParser, 666));

         CleanupStack::PopAndDestroy(landmarkParser);

         CleanupStack::PopAndDestroy(database);

        }

     else if (self->iTestCase == 4)

        {

         // Create parser with incorrect MIME type, should leave with KErrNotSupported

         CPosLandmarkParser* landmarkParser = CPosLandmarkParser::NewL(KNonExistingMimeType2);

         CleanupStack::PushL(landmarkParser);

         CleanupStack::PopAndDestroy(landmarkParser);

        }

     else if (self->iTestCase == 5)

        {

         // Create parser with incorrect MIME (including capital letters) type, should leave with KErrNotSupported

         CPosLandmarkParser* landmarkParser = CPosLandmarkParser::NewL(KNonExistingMimeType1);

         CleanupStack::PushL(landmarkParser);

         CleanupStack::PopAndDestroy(landmarkParser);

        }

     else if (self->iTestCase == 18)

        {

         // Create parser with incorrect MIME type (long string), should leave with KErrNotSupported

         CPosLandmarkParser* landmarkParser = CPosLandmarkParser::NewL(KNonExistingMimeType2);

         CleanupStack::PushL(landmarkParser);

         CleanupStack::PopAndDestroy(landmarkParser);

        }

    else if (self->iTestCase == 19)

        {

         // Create parser with incorrect MIME (empty string) type, should leave with KErrNotSupported (or KErrArgument)

         // however the REComSession::CreateImplementationL( leaves with KErrArgument which I think is acceptable

         CPosLandmarkParser* landmarkParser = CPosLandmarkParser::NewL(KEmptyMimeType);

         CleanupStack::PushL(landmarkParser);

         CleanupStack::PopAndDestroy(landmarkParser);

        }

     else if (self->iTestCase == 6)

        {

         CPosLandmarkDatabase* database = self->OpenDatabaseLC();

         // Create parser

         CPosLandmarkParser* landmarkParser = CPosLandmarkParser::NewL(self->iMimeType);

         landmarkParser->SetInputFileL(KXML1);

         // Call ParseContentL

         CPosLmOperation* operation = landmarkParser->ParseContentL();

         TRequestStatus status = KPosLmOperationNotComplete;

         TReal32 progress;

         // Set new input method before first operation has completed

         landmarkParser->SetInputFileL(KXML2);

         // Use first operation object->should panic

         operation->NextStep(status, progress);

         User::WaitForRequest(status);

         CleanupStack::PopAndDestroy(landmarkParser);

         CleanupStack::PopAndDestroy(database);

        }

     else if (self->iTestCase == 7)

        {

        // <<<<<<<<<<<<<< Fetch iterator with CPosLmOperation == NULL >>>>>>>>>>>>>>>>>>>

        CPosLandmarkDatabase* databasen = self->OpenDatabaseLC();

        CPosLmItemIterator* iterator = databasen->ImportedLandmarksIteratorL(NULL);

        delete iterator;

        CleanupStack::PopAndDestroy(databasen);

        }

     else if (self->iTestCase == 8)

        {

        // <<<<<<<<<<<<<< Fetch iterator with CPosLmOperation != ImportLandmarksL() >>>>>>>>>>>>>>>>>>>

        CPosLandmarkDatabase* databasen = self->OpenDatabaseLC();

        CPosLmOperation* operation = databasen->CompactL();

        CleanupStack::PushL(operation);

        CPosLmItemIterator* iterator = databasen->ImportedLandmarksIteratorL(operation);

        delete iterator;

        CleanupStack::PopAndDestroy(2, databasen);

        }

    else if (self->iTestCase == 9)

        {

         CPosLandmarkDatabase* database = self->OpenDatabaseLC();

         // Create parser

         CPosLandmarkParser* landmarkParser = CPosLandmarkParser::NewL(self->iMimeType);

         // Importlandmarks with invalid transfer option, should panic

         ExecuteAndDeleteLD(database->ImportLandmarksL(*landmarkParser, 0x17));

         CleanupStack::PopAndDestroy(landmarkParser);

         CleanupStack::PopAndDestroy(database);

        }

    else if (self->iTestCase == 10)

        {

         CPosLandmarkDatabase* database = self->OpenDatabaseLC();

         // Create parser

         CPosLandmarkParser* landmarkParser = CPosLandmarkParser::NewL(self->iMimeType);

         CleanupStack::PushL(landmarkParser);

         RArray<TUint> subset;

         CleanupClosePushL(subset);

         subset.Append(12);subset.Append(13);

         // Importlandmarks with invalid transfer option, should panic

         ExecuteAndDeleteLD(database->ImportLandmarksL(*landmarkParser, subset, 0x17));

         CleanupStack::PopAndDestroy(landmarkParser);

         CleanupStack::PopAndDestroy(database);

        }

    else if (self->iTestCase == 11)

        {

        // Importlandmarks with non existing subset of ids, should panic

         CPosLandmarkDatabase* database = self->OpenDatabaseLC();

         // Create parser

         CPosLandmarkParser* landmarkParser = CPosLandmarkParser::NewL(self->iMimeType);

         CleanupStack::PushL(landmarkParser);

         if ( self->iMimeType != KGpxMimeType )

             {

             landmarkParser->SetInputFileL(KXML1);

             }

         else

             {

             landmarkParser->SetInputFileL(KXML3);

             }

         RArray<TUint> subset;

         CleanupClosePushL(subset);

         subset.Append(1);subset.Append(2);subset.Append(1200);subset.Append(1300);

         // Importlandmarks with non existing subset of ids, should panic

         // Should it Panic with EPosInvalidIndex

         ExecuteAndDeleteLD(database->ImportLandmarksL(*landmarkParser, subset, CPosLandmarkDatabase::EIncludeCategories));

         CleanupStack::PopAndDestroy(&subset);

         CleanupStack::PopAndDestroy(landmarkParser);

         CleanupStack::PopAndDestroy(database);

        }

    else if (self->iTestCase == 12)

        {

        // Importlandmarks with empty subset of id, leaves with KErrArgument

         CPosLandmarkDatabase* database = self->OpenDatabaseLC();

         // Create parser

         CPosLandmarkParser* landmarkParser = CPosLandmarkParser::NewL(self->iMimeType);

         CleanupStack::PushL(landmarkParser);

         landmarkParser->SetInputFileL(KXML1);

         RArray<TUint> subset;

         CleanupClosePushL(subset);

         // Importlandmarks with empty subset of ids, should leave with KErrArgument

         ExecuteAndDeleteLD(database->ImportLandmarksL(*landmarkParser, subset, CPosLandmarkDatabase::EIncludeCategories));

         CleanupStack::PopAndDestroy(&subset);

         CleanupStack::PopAndDestroy(landmarkParser);

         CleanupStack::PopAndDestroy(database);

        }        

    else if (self->iTestCase == 13)

        {

        // Retreive parsed landmark with index outside interval of parsed landmarks

         CPosLandmarkDatabase* database = self->OpenDatabaseLC();

         // Create parser

         CPosLandmarkParser* landmarkParser = CPosLandmarkParser::NewL(self->iMimeType);

         CleanupStack::PushL(landmarkParser);

         if ( self->iMimeType != KGpxMimeType )

             {

             landmarkParser->SetInputFileL(KXML1);

             }

         else

             {

             landmarkParser->SetInputFileL(KXML3);

             }

         ExecuteAndDeleteLD(landmarkParser->ParseContentL());

         // Should panic with EPosInvalidIndex

         landmarkParser->LandmarkLC(2000);

         CleanupStack::PopAndDestroy(landmarkParser);

         CleanupStack::PopAndDestroy(database);

        }

    else if (self->iTestCase == 14)