/*
* 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_CPosTp8.h"
#include <EPos_CPosLandmarkDatabase.h>
#include <EPos_CPosLandmark.h>
#include <LbsPosition.h>
#include <EPos_CPosLMOperation.h>
#include "FT_LandmarkConstants.h"
// CONSTANTS
const TInt KNoLandmarks = 100;
// ================= MEMBER FUNCTIONS =======================
// ---------------------------------------------------------
// CPosTp8::CloseTest
//
// (other items were commented in a header).
// ---------------------------------------------------------
//
void CPosTp8::CloseTest()
{
iLog->Log(_L("CloseTest"));
iLandmarks.ResetAndDestroy();
iLandmarks.Close();
delete iDatabase;
iDatabase=NULL;
}
// ---------------------------------------------------------
// CPosTp8::StartL
//
// (other items were commented in a header).
// ---------------------------------------------------------
//
void CPosTp8::StartL()
{
_LIT(KLogFileName, "c:\\documents\\TP8TimeMeasurements.txt");
TTime start, stop, totalStart, totalStop;
totalStart.UniversalTime();
start.UniversalTime();
RemoveDefaultDbL();
RemoveAllLmDatabasesL();
_LIT(KTestPath, "c:\\system\\test\\testdata\\");
// copy the test db to the private path
CFileMan* fileMan = CFileMan::NewL(iFileSession);
CleanupStack::PushL(fileMan);
TBuf<150> srcPath;
srcPath.Append(KTestPath);
srcPath.Append(KTp8TestDb);
TInt err = fileMan->Copy(srcPath, KLmTp8DefaultDbPath,
CFileMan::EOverWrite);
if (err != KErrNone)
iLog->Log(_L("Error when copying file"));
CleanupStack::PopAndDestroy(fileMan);
CPosLmDatabaseManager* manager = CPosLmDatabaseManager::NewL();
CleanupStack::PushL(manager);
// This db must exist
manager->SetDefaultDatabaseUriL(KTp8TestDb);
CleanupStack::PopAndDestroy(manager);
start.UniversalTime();
iDatabase= CPosLandmarkDatabase::OpenL(KTp8TestDb);
stop.UniversalTime();
TInt64 msec = (stop.Int64() - start.Int64())/1000;
TBuf8<KMsgBufSize> msg;
_LIT8(KTrace, "Opening (creating) an empty database = %d msec");
msg.Format(KTrace, msec);
LogToFileL(KLogFileName, msg);
if (iDatabase->IsInitializingNeeded())
{
start.UniversalTime();
ExecuteAndDeleteLD(iDatabase->InitializeL());
stop.UniversalTime();
msec = (stop.Int64() - start.Int64())/1000;
_LIT8(KTrace2, "Initializing an empty database = %d msec");
msg.Format(KTrace2, msec);
LogToFileL(KLogFileName, msg);
}
// Add landmarks
start.UniversalTime();
AddLandmarksL(iDatabase);
stop.UniversalTime();
msec = (stop.Int64() - start.Int64())/1000;
_LIT8(KTrace3, "AddLandmarksL = %d msec");
msg.Format(KTrace3, msec);
LogToFileL(KLogFileName, msg);
delete iDatabase;
iDatabase=NULL;
iDatabase = BackupTp8DbFileL();
if (iDatabase->IsInitializingNeeded())
{
ExecuteAndDeleteLD(iDatabase->InitializeL());
}
// Read landmarks
start.UniversalTime();
ReadLandmarksL(iDatabase);
stop.UniversalTime();
msec = (stop.Int64() - start.Int64())/1000;
_LIT8(KTrace4, "ReadLandmarksL = %d msec");
msg.Format(KTrace4, msec);
LogToFileL(KLogFileName, msg);
// Update landmarks
start.UniversalTime();
UpdateLandmarksL(iDatabase);
stop.UniversalTime();
msec = (stop.Int64() - start.Int64())/1000;
_LIT8(KTrace5, "UpdateLandmarksL = %d msec");
msg.Format(KTrace5, msec);
LogToFileL(KLogFileName, msg);
ReadLandmarksL(iDatabase);
// Remove landmarks one by one
start.UniversalTime();
RemoveLandmarksL(iDatabase);
stop.UniversalTime();
msec = (stop.Int64() - start.Int64())/1000;
_LIT8(KTrace6, "RemoveLandmarksL = %d msec");
msg.Format(KTrace6, msec);
LogToFileL(KLogFileName, msg);
// Restore database
delete iDatabase;
iDatabase=NULL;
iDatabase=RestoreTp8DbFileL();
if (iDatabase->IsInitializingNeeded())
{
ExecuteAndDeleteLD(iDatabase->InitializeL());
}
// Remove set of landmarks synchronously
start.UniversalTime();
RemoveSetOfLandmarksL(iDatabase);
stop.UniversalTime();
msec = (stop.Int64() - start.Int64())/1000;
_LIT8(KTrace7, "RemoveSetOfLandmarksL = %d msec");
msg.Format(KTrace7, msec);
LogToFileL(KLogFileName, msg);
// Restore database
delete iDatabase;
iDatabase=NULL;
iDatabase=RestoreTp8DbFileL();
if (iDatabase->IsInitializingNeeded())
{
ExecuteAndDeleteLD(iDatabase->InitializeL());
}
// Remove set of landmarks and remove all landmarks asynchronously
start.UniversalTime();
RemoveLandmarksAsyncL(iDatabase);
stop.UniversalTime();
msec = (stop.Int64() - start.Int64())/1000;
_LIT8(KTrace8, "RemoveLandmarksAsyncL = %d msec");
msg.Format(KTrace8, msec);
LogToFileL(KLogFileName, msg);
// Restore database
delete iDatabase;
iDatabase=NULL;
iDatabase=RestoreTp8DbFileL();
if (iDatabase->IsInitializingNeeded())
{
ExecuteAndDeleteLD(iDatabase->InitializeL());
}
// Remove set of landmarks and remove all landmarks with User::WaitForRequest()
start.UniversalTime();
RemoveLandmarksAsyncWithWaitForReqL(iDatabase);
stop.UniversalTime();
msec = (stop.Int64() - start.Int64())/1000;
_LIT8(KTrace9, "RemoveLandmarksAsyncWithWaitForReqL = %d msec");
msg.Format(KTrace9, msec);
LogToFileL(KLogFileName, msg);
// Restore database
delete iDatabase;
iDatabase=NULL;
iDatabase=RestoreTp8DbFileL();
if (iDatabase->IsInitializingNeeded())
{
ExecuteAndDeleteLD(iDatabase->InitializeL());
}
// Remove set of landmarks asynchronously and cancel
iLog->Log(_L("TESTS BELOW ARE TESTING CANCEL"));
RemoveLandmarksAsyncAndCancelL();
// Check maximum length of Landmarkname
CheckLandmarkNameMaxLengthL();
totalStop.UniversalTime();
msec = (totalStop.Int64() - totalStart.Int64())/1000;
_LIT8(KTrace10, "Complete test case = %d msec");
msg.Format(KTrace10, msec);
LogToFileL(KLogFileName, msg);
}
// ---------------------------------------------------------
// CPosTp8::AddLandmarksL
//
// (other items were commented in a header).
// ---------------------------------------------------------
//
void CPosTp8::AddLandmarksL(CPosLandmarkDatabase* aDatabase)
{
iLog->Log(_L("Adding and copying landmarks"));
_LIT(KCategoryAddedErr, "A category that doesn't exist in the database should not be added to the landmark");
_LIT(KLmName, "LmTP8 - %d");
_LIT(KLmDescription, "LmTP8Description - %d");
iLandmarks.ResetAndDestroy();
for (TInt i=0; i<(KNoLandmarks/4); i++)
{
TBuf<100> lmName;
TBuf<100> lmDesc;
lmName.Format(KLmName,i);
CPosLandmark* landmark = CPosLandmark::NewLC();
landmark->SetLandmarkNameL(lmName);
lmDesc.Format(KLmDescription,i);
landmark->SetLandmarkDescriptionL(lmDesc);
CPosLandmark* copy = CPosLandmark::NewLC(*landmark);
CPosLandmark* landmark2 = CPosLandmark::NewL();
CleanupStack::PushL(landmark2);
landmark2->SetLandmarkNameL(lmName);
landmark2->SetLandmarkDescriptionL(lmDesc);
CPosLandmark* copy2 = CPosLandmark::NewL(*landmark2);
CleanupStack::PushL(copy2);
TInt err = KErrLocked;
ExecuteAndDeleteLD(aDatabase->CompactL());
while (err == KErrLocked)
{
TRAP(err, aDatabase->AddLandmarkL(*landmark));
}
err = KErrLocked;
while (err == KErrLocked)
{
TRAP(err, aDatabase->AddLandmarkL(*copy));
}
err = KErrLocked;
while (err == KErrLocked)
{
TRAP(err, aDatabase->AddLandmarkL(*landmark2));
}
err = KErrLocked;
while (err == KErrLocked)
{
TRAP(err, aDatabase->AddLandmarkL(*copy2));
}
TPosLmItemId id2 = 5123321;
CPosLandmark* landmark3 = CPosLandmark::NewLC();
landmark3->AddCategoryL(id2);
landmark3->AddCategoryL(id2);
err = KErrLocked;
while (err == KErrLocked)
{
TRAP(err, aDatabase->AddLandmarkL(*landmark3)); // CR115 this should not fail any more
}
CPosLandmark* readLm3 = aDatabase->ReadLandmarkLC(landmark3->LandmarkId());
RArray<TPosLmItemId> catIds;
CleanupClosePushL(catIds);
readLm3->GetCategoriesL(catIds);
AssertTrueSecL(catIds.Count() == 0, KCategoryAddedErr);
CleanupStack::PopAndDestroy(3, landmark3);
iLandmarks.Append(landmark);
iLandmarks.Append(copy);
iLandmarks.Append(landmark2);
iLandmarks.Append(copy2);
CleanupStack::Pop(4, landmark);
}
}
// ---------------------------------------------------------
// CPosTp8::ReadLandmarksL
//
// (other items were commented in a header).
// ---------------------------------------------------------
//
void CPosTp8::ReadLandmarksL(CPosLandmarkDatabase* aDatabase)
{
iLog->Log(_L("Reading landmarks"));
_LIT(KReadNotFoundErr, "The landmark id doesn't exist so ReadLandmark should return not found");
TBuf<100> buf;
buf.Format(_L("Reading %d nr of landmarks from id %d to id %d"), iLandmarks.Count(),
iLandmarks[0]->LandmarkId(), iLandmarks[iLandmarks.Count()-1]->LandmarkId());
iLog->Log(buf);
for (TInt i = 0; i<iLandmarks.Count(); i++)
{
CPosLandmark* lm = aDatabase->ReadLandmarkLC(iLandmarks[i]->LandmarkId());
CompareLandmarksL(*iLandmarks[i], *lm);
CleanupStack::PopAndDestroy(); // lm
}
TPosLmItemId id = 5123321;
CPosLandmark* lm=NULL;
TRAPD(err, lm=aDatabase->ReadLandmarkLC(id));
delete lm;
lm = NULL;
AssertTrueSecL(err == KErrNotFound, KReadNotFoundErr);
id = 13434;
lm=NULL;
TRAP(err, lm=aDatabase->ReadLandmarkLC(id));
delete lm;
AssertTrueSecL(err == KErrNotFound, KReadNotFoundErr);
id = 0;
lm=NULL;
TRAP(err, lm=aDatabase->ReadLandmarkLC(id));
delete lm;
AssertTrueSecL(err == KErrNotFound, KReadNotFoundErr);
}
// ---------------------------------------------------------
// CPosTp8::UpdateLandmarksL
//
// (other items were commented in a header).
// ---------------------------------------------------------
//
void CPosTp8::UpdateLandmarksL(CPosLandmarkDatabase* aDatabase)
{
iLog->Log(_L("Updating landmarks"));
_LIT(KCategoryName, "UpdatedCategory %d");
_LIT(KCategoryName2, "UpdatedCategory2:%d:%d");
_LIT(KCategoryAddedErr, "A category that doesn't exist in the database should not be added to the landmark");
for (TInt i = 0; i<iLandmarks.Count(); i++)
{
TCoordinate coord(KLatitude2, KLongitude2, KAltitude2);
TLocality loc(coord, KHorizontalAcc2, KVerticalAcc2);
TInt j = 0;
switch(i)
{
case 0:
iLandmarks[i]->SetLandmarkNameL(KName2);
break;
case 1:
iLandmarks[i]->SetPositionL(loc);
break;
case 2:
iLandmarks[i]->SetIconL(KMbmFileName2, KIconIndex2, KPosLmIconMaskNotUsed);
break;
case 3:
iLandmarks[i]->SetLandmarkDescriptionL(KDescription2);
break;
case 4:
iLandmarks[i]->SetCoverageRadius(KCoverageRadius);
break;
case 5:
AddFields2L(iLandmarks[i]);
break;
case 6:
for(j=0; j<KNoCategories; j++)
{
TBuf<100> name;
name.Format(KCategoryName, j);
iLandmarks[i]->AddCategoryL(CreateCategoryL(name));
}
break;
case 8:
AddFields3L(iLandmarks[i]);
break;
case 9:
break;
default:
iLandmarks[i]->SetLandmarkNameL(KName2);
iLandmarks[i]->SetPositionL(loc);
iLandmarks[i]->SetIconL(KMbmFileName2, KIconIndex2, KPosLmIconMaskNotUsed);
iLandmarks[i]->SetLandmarkDescriptionL(KDescription2);
iLandmarks[i]->SetCoverageRadius(KCoverageRadius);
AddFields2L(iLandmarks[i]);
for(j=0; j<KNoCategories; j++)
{
TBuf<100> name;
name.Format(KCategoryName2, j, i);
iLandmarks[i]->AddCategoryL(CreateCategoryL(name));
}
break;
}
}
TInt err = KErrLocked;
for (TInt k = 0; k<iLandmarks.Count(); k++)
{
err = KErrLocked;
while (err == KErrLocked)
{
TRAP(err, aDatabase->UpdateLandmarkL(*iLandmarks[k]));
}
}
ExecuteAndDeleteLD(aDatabase->CompactL());
_LIT(KTemp, "temp");
TPosLmItemId id2 = 8787876;
CPosLandmark* landmark = CreateLandmarkLC(KTemp);
err = KErrLocked;
while (err == KErrLocked)
{
TRAP(err, aDatabase->AddLandmarkL(*landmark));
}
landmark->AddCategoryL(id2);
// 0 is equal to KPosLmNullItemId, should leave
id2 = 0;
TRAP(err, landmark->AddCategoryL(id2));
AssertTrueSecL(err == KErrArgument, _L("AddCategory(0) should leave with KErrArgument"));
err = KErrLocked;
while (err == KErrLocked)
{
TRAP(err, aDatabase->UpdateLandmarkL(*landmark)); // CR115 this should not fail any more
}
// Make sure category not added to lm (TR ESLI-5X7FTZ)
CPosLandmark* readLm = aDatabase->ReadLandmarkLC(landmark->LandmarkId());
RArray<TPosLmItemId> catIds;
CleanupClosePushL(catIds);
readLm->GetCategoriesL(catIds);
AssertTrueSecL(catIds.Count() == 3, KCategoryAddedErr);
aDatabase->RemoveLandmarkL(landmark->LandmarkId());
CleanupStack::PopAndDestroy(3, landmark);
}
// ---------------------------------------------------------
// CPosTp8::RemoveLandmarksL
//
// (other items were commented in a header).
// ---------------------------------------------------------
//
void CPosTp8::RemoveLandmarksL(CPosLandmarkDatabase* aDatabase)
{
iLog->Log(_L("Removing landmarks"));
ExecuteAndDeleteLD(aDatabase->CompactL());
const TInt start=9;
const TInt end=55;
// First check invalid landmark ids, nothing should happen
CheckRemovedL(iLandmarks.Count(), iLandmarks.Count());
TPosLmItemId id = 5123321;
TInt err = KErrLocked;
while (err == KErrLocked)
{
TRAP(err, aDatabase->RemoveLandmarkL(id));
}
id = 11233;
err = KErrLocked;
while (err == KErrLocked)
{
TRAP(err, aDatabase->RemoveLandmarkL(id));
}
id = 0;
err = KErrLocked;
while (err == KErrLocked)
{
TRAP(err, aDatabase->RemoveLandmarkL(id));
}
CheckRemovedL(iLandmarks.Count(), iLandmarks.Count());
for (TInt i = start; i<=end; i++)
{
err = KErrLocked;
while (err == KErrLocked)
{
TRAP(err, aDatabase->RemoveLandmarkL(iLandmarks[i]->LandmarkId()));
}
}
CheckRemovedL(start, end);
for (TInt j = start; j<=end; j++)
{
err = KErrLocked;
while (err == KErrLocked)
{
TRAP(err, aDatabase->RemoveLandmarkL(iLandmarks[j]->LandmarkId())); // nothing should happen
}
}
CheckRemovedL(start, end);
iLog->Log(_L("Removing all landmarks"));
ExecuteAndDeleteLD(aDatabase->CompactL());
ExecuteAndDeleteLD(aDatabase->RemoveAllLandmarksL());
CheckRemovedL(0, iLandmarks.Count()-1);
ExecuteAndDeleteLD(aDatabase->RemoveAllLandmarksL());
CheckRemovedL(0, iLandmarks.Count()-1);
}
// ---------------------------------------------------------
// CPosTp8::RemoveLandmarksAsyncL
//
// (other items were commented in a header).
// ---------------------------------------------------------
//
void CPosTp8::RemoveLandmarksAsyncL(CPosLandmarkDatabase* aDatabase)
{
iLog->Log(_L("Removing landmarks asynchronously"));
// Remove a set of landmarks async
const TInt start=3;
const TInt end=47;
RArray<TPosLmItemId> ids;
CleanupClosePushL(ids);
for(TInt i=start; i<=end; i++)
{
ids.Append(iLandmarks[i]->LandmarkId());
}
RunAsyncOperationLD(aDatabase->RemoveLandmarksL(ids));
CleanupStack::PopAndDestroy(&ids);
CheckRemovedL(start, end);
// Remove all async
delete iDatabase;
iDatabase=NULL;
iDatabase=RestoreTp8DbFileL();
if (iDatabase->IsInitializingNeeded())
{
ExecuteAndDeleteLD(iDatabase->InitializeL());
}
iLog->Log(_L("Removing all landmarks asynchronously"));
RunAsyncOperationLD(iDatabase->RemoveAllLandmarksL());
CheckRemovedL(0, iLandmarks.Count()-1);
}
// ---------------------------------------------------------
// CPosTp8::RemoveLandmarksAsyncWithWaitForReqL
//
// (other items were commented in a header).
// ---------------------------------------------------------
//
void CPosTp8::RemoveLandmarksAsyncWithWaitForReqL(CPosLandmarkDatabase* aDatabase)
{
iLog->Log(_L("Removing landmarks asynchronously with User::WaitForRequest"));
// Remove a set of landmarks async with WaitForReq
const TInt start=3;
const TInt end=47;
RArray<TPosLmItemId> ids;
CleanupClosePushL(ids);
for(TInt i=start; i<=end; i++)
{
ids.Append(iLandmarks[i]->LandmarkId());
}
CPosLmOperation* op = aDatabase->RemoveLandmarksL(ids);
CleanupStack::PushL(op);
RunAsyncOperationByWaitForReqL(op);
CleanupStack::PopAndDestroy(op);
CheckRemovedL(start, end);
// Remove all async with WaitForReq
delete iDatabase;
iDatabase=NULL;
iDatabase=RestoreTp8DbFileL();
if (iDatabase->IsInitializingNeeded())
{
ExecuteAndDeleteLD(iDatabase->InitializeL());
}
iLog->Log(_L("Removing all landmarks asynchronously with User::WaitForRequest"));
TRAPD(error,op = iDatabase->RemoveAllLandmarksL());
iLog->Log(_L("error while RemoveAllLandmarksL = %d"),error);
CleanupStack::PushL(op);
RunAsyncOperationByWaitForReqL(op);
CleanupStack::PopAndDestroy(2, &ids);
CheckRemovedL(0, iLandmarks.Count()-1);
}
// ---------------------------------------------------------
// CPosTp8::RemoveLandmarksAsyncAndCancelL
//
// (other items were commented in a header).
// ---------------------------------------------------------
//
void CPosTp8::RemoveLandmarksAsyncAndCancelL()
{
iLog->Log(_L("Removing landmarks asynchronously and cancel"));
// Remove a set of landmarks async
const TInt start=3;
const TInt end=47;
RArray<TPosLmItemId> ids;
CleanupClosePushL(ids);
for(TInt i=start; i<=end; i++)
{
ids.Append(iLandmarks[i]->LandmarkId());
}
TReal32 progress(0);
while (progress < 1.0)
{
RunAsyncOperationAndCancelInCallbackLD(iDatabase->RemoveLandmarksL(ids), progress);
delete iDatabase;
iDatabase=NULL;
iDatabase=RestoreTp8DbFileL();
if (iDatabase->IsInitializingNeeded())
{
ExecuteAndDeleteLD(iDatabase->InitializeL());
}
progress = progress + 0.09;
}
CleanupStack::PopAndDestroy(&ids);
iLog->Log(_L("Removing all landmarks asynchronously and cancel"));
progress = 0;
while (progress < 1.0)
{
RunAsyncOperationAndCancelInCallbackLD(iDatabase->RemoveAllLandmarksL(), progress);
delete iDatabase;
iDatabase=NULL;
iDatabase=RestoreTp8DbFileL();
if (iDatabase->IsInitializingNeeded())
{
ExecuteAndDeleteLD(iDatabase->InitializeL());
}
progress = progress + 0.09;
}
}
// ---------------------------------------------------------
// CPosTp8::RemoveSetOfLandmarksL
//
// (other items were commented in a header).
// ---------------------------------------------------------
//
void CPosTp8::RemoveSetOfLandmarksL(CPosLandmarkDatabase* aDatabase)
{
iLog->Log(_L("Removing set of landmarks"));
const TInt start=3;
const TInt end=57;
RArray<TPosLmItemId> ids;
CleanupClosePushL(ids);
// Test with empty list, should leave with KErrArgument
TRAPD(err, iOperation = aDatabase->RemoveLandmarksL(ids));
if (err != KErrArgument)
{
iLog->Log(_L("Removing empty iterator should leave with KErrArgument"));
User::Leave(err);
}
#if 0
// Added for testing -- Start
iOperation->ExecuteL();
// Added for testing -- End
delete iOperation;
iOperation = NULL;
#endif
// Test with invalid sets of lm id arrays
ids.Append(11234);
ids.Append(556);
ids.Append(908);
ExecuteAndDeleteLD(aDatabase->RemoveLandmarksL(ids));
// Check that no landmark has been removed
CheckRemovedL(iLandmarks.Count(), iLandmarks.Count());
for(TInt i=start; i<=end; i++)
{
ids.Append(iLandmarks[i]->LandmarkId());
// Also add invalid ids
ids.Append(i+5000);
}
ExecuteAndDeleteLD(aDatabase->RemoveLandmarksL(ids));
CheckRemovedL(start, end);
ExecuteAndDeleteLD(aDatabase->RemoveLandmarksL(ids));
CleanupStack::PopAndDestroy(&ids);
CheckRemovedL(start, end);
}
// ---------------------------------------------------------
// CPosTp8::CheckRemoved
//
// (other items were commented in a header).
// ---------------------------------------------------------
//
void CPosTp8::CheckRemovedL(const TInt startIndex, const TInt stopIndex)
{
_LIT(KRemoveNotFoundErr, "Landmark has not been removed");
_LIT(KRemoveFoundErr, "Landmark should not been removed");
for (TInt i = 0; i<iLandmarks.Count(); i++)
{
TRAPD(err, ReadLandmarkL(iLandmarks[i]->LandmarkId()));
if (i >= startIndex && i <= stopIndex)
{
AssertTrueSecL(err == KErrNotFound, KRemoveNotFoundErr);
}
else
{
AssertTrueSecL(err == KErrNone, KRemoveFoundErr);
}
}
}
// ---------------------------------------------------------
// CPosTp8::ReadLandmarkL
//
// (other items were commented in a header).
// ---------------------------------------------------------
//
void CPosTp8::ReadLandmarkL(TPosLmItemId aCategoryId)
{
CPosLandmark* lm = iDatabase->ReadLandmarkLC(aCategoryId);
CleanupStack::PopAndDestroy(lm);
}
//---------------------------------------------------------
// CPosTp8::CheckLandmarkNameMaxLengthL
//
// (other items were commented in a header).
// ---------------------------------------------------------
//
void CPosTp8::CheckLandmarkNameMaxLengthL()
{
_LIT(K255Error, "Landmark name is not limited to 255 characters");
iLog->Log(_L("CheckLandmarkNameMaxLengthL"));
const TInt KPosLmMaxTextFieldLength = 255;
HBufC* hbuf = HBufC::NewLC(KPosLmMaxTextFieldLength+1);
CPosLandmark* lm = CPosLandmark::NewLC();
// Test empty name, is OK
lm->SetLandmarkNameL(*hbuf);
while(hbuf->Des().Length() < KPosLmMaxTextFieldLength)
{
hbuf->Des().Append(_L("X"));
}
lm->SetLandmarkNameL(*hbuf);
hbuf->Des().Append(_L("X"));
TRAPD(err, lm->SetLandmarkNameL(*hbuf));
AssertTrueSecL(err == KErrArgument, K255Error);
CleanupStack::PopAndDestroy(2, hbuf);
}
// ---------------------------------------------------------
// CPosTp8::BackupTp8DbFileL()
//
// (other items were commented in a header).
// ---------------------------------------------------------
//
CPosLandmarkDatabase* CPosTp8::BackupTp8DbFileL()
{
CPosLmDatabaseManager* manager = CPosLmDatabaseManager::NewL();
CleanupStack::PushL(manager);
manager->SetDefaultDatabaseUriL(KTp8TestDb);
HBufC* defaultDbUri = manager->DefaultDatabaseUriLC();
TBuf<255> buf;
// Extract URI except characters ".ldb"
buf.Append(defaultDbUri->Left(defaultDbUri->Length()-4));
buf.Append(_L("COPY.LDB"));
// Delete in case it already exist
TRAPD(err, manager->DeleteDatabaseL(buf));
if (err != KErrNone && err != KErrNotFound) iLog->Log(_L("Could not delete file"));
manager->CopyDatabaseL(*defaultDbUri, buf);
CleanupStack::PopAndDestroy(defaultDbUri);
CleanupStack::PopAndDestroy(manager);
return CPosLandmarkDatabase::OpenL();
}
// ---------------------------------------------------------
// CPosTp8::RestoreTp8DbFileL()
//
// (other items were commented in a header).
// ---------------------------------------------------------
//
CPosLandmarkDatabase* CPosTp8::RestoreTp8DbFileL()
{
CPosLmDatabaseManager* manager = CPosLmDatabaseManager::NewL();
CleanupStack::PushL(manager);
manager->SetDefaultDatabaseUriL(KTp8TestDb);
HBufC* defaultDbUri = manager->DefaultDatabaseUriLC();
TBuf<255> buf;
// Extract URI except characters ".ldb"
buf.Append(defaultDbUri->Left(defaultDbUri->Length()-4));
buf.Append(_L("COPY.LDB"));
// Delete in case it already exist
TRAPD(err, manager->DeleteDatabaseL(*defaultDbUri));
if (err != KErrNone && err != KErrNotFound) iLog->Log(_L("Could not delete file"));
manager->CopyDatabaseL(buf, *defaultDbUri);
CleanupStack::PopAndDestroy(defaultDbUri);
CleanupStack::PopAndDestroy(manager);
return CPosLandmarkDatabase::OpenL();
}
// End of File