/*

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

#include <EPos_CPosLandmarkDatabase.h>

#include <bautils.h>

// CONSTANTS

_LIT(KTraceDir, "c:\\documents\\");

_LIT(KFileTrace, "c:\\documents\\TP42_File%d.xml");

_LIT(KFileTraceWild, "c:\\documents\\TP42_File*.xml");

_LIT( KDump, "%02d: '%S'" );

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

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

// CPosTp42::CloseTest

//

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

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

//

void CPosTp42::CloseTest()

    {

    iDataToRecognize.ResetAndDestroy();

    }

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

// CPosTp42::StartL

//

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

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

//

void CPosTp42::StartL()

    {

    BaflUtils::EnsurePathExistsL( iFileSession, KFileTrace );

    iErrorsFound = 0;

    // Test reading from buffer

    iLog->Log(_L("**************BUFFER***************"));

    TestWithBufferL();

    iLog->Log(_L("**************FILE***************"));

    //Test reading from file and filehandle

    TestWithFileL();

    iLog->Log(_L("**************EMPTY FILE***************"));

    //Test reading from empty file

    TestWithEmptyFileL();

    iLog->Log(_L("**************LARGE FILE***************"));

    //Test reading from large file

    TestWithLargeFilesL(_L("<?xml *?><lala:lmx xmlns:n=\"http://www.nokia.com/schemas/location/landmarks\""), CApaDataRecognizerType::ECertain);

    TestWithLargeFilesL(_L("<?xml k?> < *:lmx*>"), CApaDataRecognizerType::EProbable);

    iDataToRecognize.ResetAndDestroy();

    if (iErrorsFound != KErrNone)

        {

        TBuf<64> buf;

        buf.Format(_L("%d Errors were found in TP42"), iErrorsFound );

        iLog->Log(buf);

        User::Leave(-1);

        }

    }

// ---------++++++++++++++------------------------------------------------

// CPosTp42::TestWithBufferL

//

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

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

//

void CPosTp42::TestWithEmptyFileL()

    {

    // Create empty file

    RFile file;

    TBuf<100> buf;

    _LIT(KFileName, "c:\\documents\\DummyFile.txt");

    TInt err = file.Open(iFileSession, KFileName , EFileWrite);

    if (err != KErrNone && err != KErrAlreadyExists)

        {

        if (err == KErrNotFound)

            {

            User::LeaveIfError(file.Create(iFileSession, KFileName, EFileWrite));

            }

        else

           {   

            buf.Format(_L("Error %d when creating empty file"), err);

            iLog->Log(buf);

           }

        }

    file.Close();

    TBuf8<1> kalle;

    RApaLsSession lsSession;

    CleanupClosePushL(lsSession);

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

    TDataRecognitionResult recognizerResultFromFile;

    TDataRecognitionResult recognizerResultFromFileHandle;

    // Check file

    err = lsSession.RecognizeData(KFileName, kalle , recognizerResultFromFile);

    if (err != KErrNone) 

    {

    	iLog->Log(_L("Error from lsSession.RecognizeData"));

    	User::Leave(err);

    }

    iLog->Log(recognizerResultFromFile.iDataType.Des());

    TInt expCode = CApaDataRecognizerType::EProbable;

    if (recognizerResultFromFile.iDataType.Des() != _L("text/plain"))

        {

        iLog->Log(_L("datatype from recognizer"));

        }

    if (recognizerResultFromFile.iConfidence != expCode)

        {

      	iLog->Log(_L(" confidence from recognizer"));

        }

    // Check filehandle

	User::LeaveIfError(iFileSession.ShareProtected());

    RFile fileHandle;

    CleanupClosePushL(fileHandle);

    err = fileHandle.Open(iFileSession, KFileName, EFileRead | EFileShareAny);

    if (err != KErrNone)

    {

    	iLog->Log(_L("Error from file.Open"));

    	User::Leave(err);

    }

    err = lsSession.RecognizeData(fileHandle, recognizerResultFromFileHandle);

    if (err != KErrNone)

    {

    	iLog->Log(_L("Error from lsSession.RecognizeData"));

    	User::Leave(err);

    }

    CleanupStack::PopAndDestroy(&fileHandle);

    iLog->Log(recognizerResultFromFileHandle.iDataType.Des());

   if (recognizerResultFromFileHandle.iDataType.Des() != _L("text/plain"))

        {

         iLog->Log(_L(" datatype from recognizer"));

        }

    if (recognizerResultFromFileHandle.iConfidence != expCode)

        {

         iLog->Log(_L("confidence from recognizer"));

        }

    CleanupStack::PopAndDestroy(&lsSession);

    }

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

// CPosTp42::TestWithBufferL

//

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

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

//

void CPosTp42::TestWithBufferL()

    { 

    //start reading the file line by line and create objects.

    _LIT(KFileTestValues, "c:\\system\\test\\testdata\\LmRecognizerData.txt");

    RFile file;

    User::LeaveIfError(file.Open(iFileSession, KFileTestValues,  EFileRead));

    CleanupClosePushL(file);

    TBuf<500> line;    //declarera som en konstant tack

    while (ReadLn(file, line) != KErrEof)

        {

        TLex lex(line);

        if ( lex.Peek() != '#' )

            {

            CRecognizerData* recognizerData = CRecognizerData::NewL(line);

            CleanupStack::PushL(recognizerData);

            User::LeaveIfError(iDataToRecognize.Append(recognizerData));

            CleanupStack::Pop(recognizerData);

            }

        }

	CleanupStack::PopAndDestroy(&file);

    RApaLsSession lsSession;

    CleanupClosePushL(lsSession);

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

    TDataRecognitionResult recognizerResult;

    TBuf<10> dummy; //dummy

    TInt numberOfResults = iDataToRecognize.Count();

    for (TInt i = 0; i < numberOfResults; i++)

        {

        CRecognizerData* data = iDataToRecognize[i];

        TBuf8<200> kalle;

        kalle.Copy((data -> RecognizerData()));

        // Check buffer

        User::LeaveIfError(lsSession.RecognizeData(dummy, kalle , recognizerResult));

        const TDataRecognitionResult expected = data->ExpectedResult();

        TBuf<512> buf;

        TPtrC content( data->RecognizerData() );

        buf.Format( KDump, i+1, &content );

        iLog->Log( buf );

        CheckResultL(expected, recognizerResult);

        }

	CleanupStack::PopAndDestroy(&lsSession);  

    iDataToRecognize.ResetAndDestroy();

	}

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

// CPosTp42::TestWithFileL

//

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

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

//

void CPosTp42::TestWithFileL()

    { 

    //start reading the file line by line and create objects.

    _LIT(KFileTestValues, "c:\\system\\test\\testdata\\LmRecognizerDataFile.txt");

    RFile file;

    CFileMan* fileMan = CFileMan::NewL(iFileSession);

    CleanupStack::PushL(fileMan);

    // Delete all old files

    TInt err = fileMan->Delete(KFileTraceWild);

    if (err != KErrNone && err != KErrNotFound) iLog->Log(_L("Error from CFileMan::Delete"));

    CleanupStack::PopAndDestroy(fileMan);

    CleanupClosePushL(file);

    User::LeaveIfError(file.Open(iFileSession, KFileTestValues,  EFileRead));

    TBuf<500> line;

    while (ReadLn(file, line) != KErrEof)

        {

        TLex lex(line);

        if (lex.Peek() != '#')

            {

            CRecognizerData* recognizerData = CRecognizerData::NewL(line);

            CleanupStack::PushL(recognizerData);

            User::LeaveIfError(iDataToRecognize.Append(recognizerData));

            CleanupStack::Pop(recognizerData);

            }

        }

    CleanupStack::PopAndDestroy(&file);

    //start comparing

    RApaLsSession lsSession;

    CleanupClosePushL(lsSession);

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

    TDataRecognitionResult recognizerResultFromFile;

    TDataRecognitionResult recognizerResultFromFileHandle;

    TBuf<40> fileName; //dummy

    TInt numberOfResults = iDataToRecognize.Count();

    for (TInt i = 0; i < numberOfResults; i++)

        {

        CRecognizerData* data = iDataToRecognize[i];

        TBuf8<512> buf8;

        buf8.Copy( data->RecognizerData() );

        RFile file;

        TFileName fileName;

        TInt err = file.Temp( iFileSession, KTraceDir, fileName, EFileWrite );

        if ( err )

            {

            iLog->Log(_L("Failed to create temp file, %d"), err);

            User::Leave( err );

            }

        file.Write( buf8 );

        _LIT8( KCrLf, "\n" );

        file.Write( KCrLf );

        file.Close();

        const TDataRecognitionResult expected = data->ExpectedResult();

        TBuf<512> buf;

        TPtrC content( data->RecognizerData() );

        buf.Format( KDump, i+1, &content );

        iLog->Log( buf );

        // Check file

        recognizerResultFromFile.Reset();

        buf8.Zero();

        lsSession.RecognizeData( fileName, buf8, recognizerResultFromFile );

        CheckResultL(expected, recognizerResultFromFile);

        // Check FileHandle

        RFs fileSessionNew;

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

		CleanupClosePushL(fileSessionNew);

        //iLog->Log(_L("Check filehandle"));

		err = fileSessionNew.ShareProtected();

    	if (err != KErrNone) 

    	{

    		iLog->Log(_L("Error from file.ShareProtected"));

    		User::Leave(err);

    	}

        RFile fileHandle;

        CleanupClosePushL(fileHandle);

        err = fileHandle.Open(fileSessionNew, fileName, EFileRead | EFileShareAny);

        if (err != KErrNone) 

        {

        	iLog->Log(_L("Error from file.open"));

    		User::Leave(err);

        }

        err = lsSession.RecognizeData(fileHandle, recognizerResultFromFileHandle);

        if (err != KErrNone) 

        {

        	iLog->Log(_L("Error from lsSession.RecognizeData"));

    		User::Leave(err);

        }

        CleanupStack::PopAndDestroy(&fileHandle);

        CleanupStack::PopAndDestroy(&fileSessionNew);

        CheckResultL(expected, recognizerResultFromFileHandle);

        iFileSession.Delete( fileName );

        }

    CleanupStack::PopAndDestroy(&lsSession);

    iDataToRecognize.ResetAndDestroy();

	}

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

// CPosTp42::TestWithLargeFilesL

//

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

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

//

void CPosTp42::TestWithLargeFilesL(const TDesC& msg, TInt aExpCode)

    {

    RApaLsSession lsSession;

    CleanupClosePushL(lsSession);

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

    TDataRecognitionResult recognizerResultFromFile;

    TDataRecognitionResult recognizerResultFromFileHandle;

    const TInt KBufSize = 400;

    TBuf8<KBufSize> tmp1;

    TBuf8<KBufSize> tmp;

    TBuf8<1> kalle;

    _LIT(KEnd,"\n");

    RFile file;

    TFileName fileName;

    file.Temp( iFileSession, KTraceDir, fileName, EFileWrite );

    CleanupClosePushL(file);

    for (TInt i=0;i<10;i++)

        {

        tmp1.Append(_L("   \n\t   "));

        }

    tmp.Append(tmp1);

    tmp.Append(msg);

    tmp.Append(KEnd);

    tmp.Append(tmp1);

    tmp.Append(KEnd);

    file.Write(tmp);

    CleanupStack::PopAndDestroy(&file);

    lsSession.RecognizeData(fileName, kalle , recognizerResultFromFile);

    iLog->Log(recognizerResultFromFile.iDataType.Des());

    if (recognizerResultFromFile.iDataType.Des() != _L("application/vnd.nokia.landmarkcollection+xml"))

        {

        iLog->Log(_L("datatype from recognizer"));

        }

    if (recognizerResultFromFile.iConfidence != aExpCode)

        {

        iLog->Log(_L(" confidence from recognizer"));

        }

    // Check FileHandle

    iLog->Log(_L("Check filehandle"));

    RFs fs;

    CleanupClosePushL(fs);

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

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

    RFile fileHandle;

    CleanupClosePushL(fileHandle);

    TInt err = fileHandle.Open(fs, fileName, EFileRead | EFileShareAny);

    if (err != KErrNone)

    {

    iLog->Log(_L("Error from file.Open"));

   	User::Leave(err);	

    }

    err = lsSession.RecognizeData(fileHandle, recognizerResultFromFileHandle);

    if (err != KErrNone)

    {

    iLog->Log(_L("Error from lsSession.RecognizeData"));

   	User::Leave(err);	

    }

    CleanupStack::PopAndDestroy(&fileHandle);

    if (recognizerResultFromFileHandle.iDataType.Des() != _L("application/vnd.nokia.landmarkcollection+xml"))

        {

        iLog->Log(_L("datatype from recognizer"));

        }

    if (recognizerResultFromFileHandle.iConfidence != aExpCode)

        {

        iLog->Log(_L("confidence from recognizer"));

        }

    iFileSession.Delete( fileName );

    CleanupStack::PopAndDestroy(&fs);

    CleanupStack::PopAndDestroy(&lsSession);

    }

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

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

//

void CPosTp42::CheckResultL(TDataRecognitionResult aExpectedResult, TDataRecognitionResult aResult)

    {

    _LIT(KExpected, "Expect: '%S' (%d)");

    _LIT(KActual,   "Actual: '%S' (%d)");

    TBuf<256> exp, act;

    TPtrC expMime( aExpectedResult.iDataType.Des() );

    TPtrC actMime( aResult.iDataType.Des() );

    exp.Format(KExpected, &expMime, aExpectedResult.iConfidence );

    act.Format(KActual, &actMime, aResult.iConfidence );

    if ( aExpectedResult.iConfidence == NOLANDMARKNUMBER ) // Magic number for not any landmark

        {

        _LIT8(KLmxType, "application/vnd.nokia.landmarkcollection+xml");

        _LIT8(KGpxType, "application/gps+xml");

        if ( aResult.iDataType.Des8().Compare( KLmxType ) == 0 ||

             aResult.iDataType.Des8().Compare( KGpxType ) == 0 )

            {

            iLog->Log(_L( "ERR: landmark detected when it shouldn't be" ));

            iLog->Log(exp);

            iLog->Log(act);

            iErrorsFound++;

            }

        }

    else //if (aExpectedResult.iConfidence == CApaDataRecognizerType::ECertain) //a landmark buffer is expected

        {

        if ( aExpectedResult.iDataType != aResult.iDataType )

            {

            iLog->Log(_L( "ERR: datatype mismatch" ));

            iLog->Log(exp);

            iLog->Log(act);

            iErrorsFound++;

            }

        if ( aExpectedResult.iConfidence != aResult.iConfidence )

            {

            iLog->Log(_L("ERR: confidence mismatch"));

            iLog->Log(exp);

            iLog->Log(act);

            iErrorsFound++;

            }

        }

    }

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

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

//

//  Implementation of the supporter class

CRecognizerData* CRecognizerData::NewL(const TDesC& aDes)

    {

    CRecognizerData* self = new(ELeave) CRecognizerData;

    CleanupStack::PushL(self);

    self->ConstructL(aDes);

    CleanupStack::Pop();

    return self;

    }

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

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

CRecognizerData::CRecognizerData()

    {

    }

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

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

CRecognizerData::~CRecognizerData()

    {