/*
* 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()
{
delete iRecognizerData;
iRecognizerData = NULL;
}
// ---------------------------------------------------------
// ---------------------------------------------------------
//
TPtrC CRecognizerData::RecognizerData() const
{
return *iRecognizerData;
}
// ---------------------------------------------------------
// ---------------------------------------------------------
//
const TDataRecognitionResult& CRecognizerData::ExpectedResult() const
{
return iExpectedResult;
}
// ---------------------------------------------------------
// ---------------------------------------------------------
//
void CRecognizerData::ConstructL(const TDesC& aDes)
{
_LIT( KDelim, "#" );
TInt delim = aDes.Find( KDelim );
iRecognizerData = aDes.Left( delim ).AllocL();
iRecognizerData->Des().TrimRight();
TLex line( aDes.Mid( delim + 1 ) );
ParseResult( line.NextToken() );
ParseType( line.NextToken() );
}
// ---------------------------------------------------------
// ---------------------------------------------------------
//
void CRecognizerData::ParseResult(const TDesC& aDes)
{
_LIT(KECertain, "ECertain");
_LIT(KEProbable, "EProbable");
if (aDes.CompareF(KECertain) == 0)
{
iExpectedResult.iConfidence = CApaDataRecognizerType::ECertain;
}
else if (aDes.CompareF(KEProbable) == 0)
{
iExpectedResult.iConfidence = CApaDataRecognizerType::EProbable;
}
else
{
iExpectedResult.iConfidence = NOLANDMARKNUMBER;
}
}
// ---------------------------------------------------------
// ---------------------------------------------------------
//
void CRecognizerData::ParseType(const TDesC& aDes)
{
_LIT8(KLmxType, "application/vnd.nokia.landmarkcollection+xml");
_LIT8(KGpxType, "application/gps+xml");
_LIT(KGpx, "gpx");
_LIT(KLmx, "lmx");
TDataType dataLmx(KLmxType);
TDataType dataGpx(KGpxType);
if (aDes.CompareF(KGpx) == 0)
{
iExpectedResult.iDataType = dataGpx;
}
else if (aDes.CompareF(KLmx) == 0)
{
iExpectedResult.iDataType = dataLmx;
}
else
{
}
}
// End of File