Symaptic: os/persistentdata/loggingservices/eventlogger/test/src/t

     1 // Copyright (c) 2005-2010 Nokia Corporation and/or its subsidiary(-ies).

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

     4 // under the terms of "Eclipse Public License v1.0"

     5 // which accompanies this distribution, and is available

     6 // at the URL "http://www.eclipse.org/legal/epl-v10.html".

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 // Platform security prohibits the existing logeng tests from doing

    15 // direct operations on data-caged files.  Giving the tests a higher

    16 // capability might mask other errors.  Therefore any file manipulation

    17 // may be sub-contracted to this process as needed.

    18 //

    19 //

    20 #include <s32file.h>

    21 #include <babackup.h>

    22 #include "t_logutil2.h"

    23 #include "t_logutil3.h"

    25 const TUid KTestEventUid = {0x10005393};

    26 _LIT(KTestEventDesc1, "Event Type Description");

    27 _LIT(KTestDirection1, "Direction");

    28 _LIT(KTestStatus1, "Status");

    29 _LIT(KTestStatus2, "Changed Status");

    30 _LIT(KTestNumber1, "Number");

    31 const TLogContactItemId KTestContact1 = 0x1234;

    32 const TLogContactItemId KTestContact2 = 0x1234567;

    33 _LIT(KTestRemote1, "Remote Test 1");

    34 _LIT(KTestRemote2, "Remote Test 2");

    35 _LIT(KTestRemote3, "Remote Test 3");

    36 _LIT(KTestStatusT3, "Status Test 3");

    37 _LIT(KTestEventDesc, "Test Event");

    39 _LIT(KLogEngPrivatePath, "c:\\private\\101f401d\\");

    41 _LIT(KLogHiCapHelperPanic, "TLHCHlpr");

    43 RTest TheTest(_L("t_loghicaphelper")); //used in t_logutil.cpp only

    45 RFs theFs;

    46 CActiveScheduler *TheTestScheduler = NULL;

    48 //===========================================================================================

    50 //Supported remote operaions

    51 enum THelperOp

    52 	{

    53 	EOpNotDefined,

    54     EDeleteDatabase1,

    55     EDeleteDatabase2,

    56 	EIsDatabaseOpen,

    57 	EDatabaseSize,

    58 	ECopyCorruptDbFile,

    59 	ECopyCorruptDamagedDbFile,

    60 	ECopyOldDbFile,

    61 	EAddEvent,

    62 	EAddTestEvents,

    63 	EAddEventType,

    64 	EInvalidSchema,

    65 	EIsMatchingEnabled

    66 	} ;

    68 _LIT(KOldCorruptDatabase,"z:\\test\\corruptLogdbu.dat");

    69 _LIT(KOldCorruptDamagedDatabase,"z:\\test\\corruptDamagedLogdbu.dat");

    70 _LIT(KOldFormatDatabase,"z:\\test\\oldLogdbu.dat");

    73 CTestActive::CTestActive(TInt aPriority)

    74 :	CActive(aPriority)

    75 	{

    76 	CActiveScheduler::Add(this);

    77 	iDelayTime=0;

    78 	}

    80 CTestActive::~CTestActive()

    81 	{

    82 	Cancel();

    83 	}

    85 void CTestActive::DoCancel()

    86 	{

    87 	TRequestStatus* s=&iStatus;

    88 	User::RequestComplete(s, KErrNone);

    89 	}

    91 void CTestActive::StartL()

    92 	{

    93 	iDelayCompletion=EFalse;

    94 	iDelayTime=0;

    95 	iStatus = KRequestPending;

    96 	SetActive();

    97 	}

    99 void CTestActive::StartL(TInt aDelay)

   100 	{

   101 	iDelayCompletion=ETrue;

   102 	iDelayTime=aDelay;

   103 	iStatus = KRequestPending;

   104 	SetActive();

   105 	}

   107 void CTestActive::RunL()

   108 	{

   109 	if(iDelayCompletion && iDelayTime)

   110 		{

   111 		// Wait for events in other threads to have a go....

   112 		User::After(iDelayTime);

   113 		iDelayTime=0;

   114 		iStoredStatus=iStatus;

   115 		SetActive();

   116 		TRequestStatus* s=&iStatus;

   117 		User::RequestComplete(s, KErrNone);

   118 		}

   119 	else

   120 		{

   121 		if(iDelayCompletion)

   122 			iStatus=iStoredStatus;

   124 		LOGTEXT("CTestActive::RunL() - Stopping the scheduler");

   125 		CActiveScheduler::Stop();

   126 		}

   127 	}

   129 //.................................................................................................

   131 //See TestUtils::TestInvalidSchemaL(). Re-creates the LogEng database and checkes whether a new

   132 //LogEng connection can be established (by creating a CLogClient object).

   133 static void TestInvalidSchemaL()

   134 	{

   135 	TheTestScheduler = new (ELeave) CActiveScheduler;

   136 	CleanupStack::PushL( TheTestScheduler );

   137 	CActiveScheduler::Install( TheTestScheduler );

   139    	//Reseting of log engine databse is done via its backup server.  This seems a

   140    	//bit odd.  Perhaps write a CLogClient API that does it?

   141    	//Create backup session wrapper

   142    	CBaBackupSessionWrapper* backup = CBaBackupSessionWrapper::NewL();

   143    	CleanupStack::PushL(backup);

   145    	//This eventually calls CLogBackup::ChangeFileLockL(..) which closes the database

   146    	//file and notifies all handles to that file that it has closed.

   147    	backup->CloseFileL(KLogDatabaseName, MBackupObserver::EReleaseLockNoAccess);

   148  	User::After(1000000);

   150    	//Since the log engine database file is closed we can replace it.

   151    	//Once this file is deleted, the backup server notices this and attempts to reopen

   152    	//the database.  Since the file is deleted a default database is created instead.

   153     RDbNamedDatabase database;

   154 	TInt err = database.Replace(theFs, KLogDatabaseName);

   155 	database.Close();

   156 	LEAVE_IF_ERROR(err);

   158 	// The following will leave if there is a problem

   159 	CLogClient* client = CLogClient::NewL(theFs);

   160 	delete client;

   162 	CleanupStack::PopAndDestroy(2); // scheduler + backup

   163 	TheTestScheduler = NULL;

   164 	}

   166 //.................................................................................................

   168 //See TestUtils::AddEventTypeL(). Adds an event type to the LogEng database.

   169 static void AddEventTypeL()

   170 	{

   171 	TheTestScheduler = new (ELeave) CActiveScheduler;

   172 	CleanupStack::PushL(TheTestScheduler);

   173 	CActiveScheduler::Install(TheTestScheduler);

   175 	CLogClient* client = CLogClient::NewL(theFs);

   176 	CleanupStack::PushL(client);

   178 	CTestActive* active = new(ELeave)CTestActive();

   179 	CleanupStack::PushL(active);

   181 	CLogEventType* type = CLogEventType::NewL();

   182 	CleanupStack::PushL(type);

   184 	type->SetUid(KTestEventUid);

   185 	type->SetDescription(KTestEventDesc1);

   186 	type->SetLoggingEnabled(ETrue);

   188 	client->AddEventType(*type, active->iStatus);

   190 	active->StartL();

   191 	CActiveScheduler::Start();

   192 	LEAVE_IF_ERROR(active->iStatus.Int());

   194 	CleanupStack::PopAndDestroy(4); // scheduler, client, active, type

   195 	TheTestScheduler = NULL;

   196 	}

   198 //.................................................................................................

   200 //See TestUtils::AddViewTestEventsL(). Adds events to the LogEng database.

   201 static void AddTestEventsL()

   202 	{

   203 	TheTestScheduler = new (ELeave) CActiveScheduler;

   204 	CleanupStack::PushL(TheTestScheduler);

   205 	CActiveScheduler::Install(TheTestScheduler);

   207 	CTestActive* active = new(ELeave)CTestActive;

   208 	CleanupStack::PushL(active);

   210  	CLogClient* client = CLogClient::NewL(theFs);

   211 	CleanupStack::PushL(client);

   213 	TLogString direction;

   214 	client->GetString(direction, R_LOG_DIR_IN);

   216 	// Create a test event type

   217 	CLogEventType* type = CLogEventType::NewL();

   218 	CleanupStack::PushL(type);

   219 	type->SetUid(KTestEventUid);

   220 	type->SetDescription(KTestEventDesc);

   221 	type->SetLoggingEnabled(ETrue);

   223 	// Register the event type

   224 	active->StartL();

   225 	client->AddEventType(*type, active->iStatus);

   226 	CActiveScheduler::Start();

   227 	LEAVE_IF_ERROR(active->iStatus.Int());

   229 	// Now add some events...

   230 	//

   231 	CLogEvent* event = CLogEvent::NewL();

   232 	CleanupStack::PushL(event);

   233 	//

   234 	event->SetEventType(KLogCallEventTypeUid);

   235 	event->SetContact(KTestContact1);

   236 	event->SetDirection(direction);

   237 	event->SetDurationType(KLogDurationValid);

   238 	event->SetNumber(KTestNumber1);

   239 	event->SetRemoteParty(KTestRemote1);

   240 	event->SetStatus(KTestStatus1);

   242 	// Add event

   243 	active->StartL();

   244 	client->AddEvent(*event, active->iStatus);

   245 	CActiveScheduler::Start();

   246 	LEAVE_IF_ERROR(active->iStatus.Int());

   247 	//

   249 	event->SetEventType(KTestEventUid);	// low cap visible

   250 	event->SetContact(KTestContact1);

   251 	event->SetDirection(direction);

   252 	event->SetDurationType(KLogDurationNone);

   253 	event->SetNumber(KTestNumber1);

   254 	event->SetRemoteParty(KTestRemote1);

   255 	event->SetStatus(KTestStatus1);

   257 	// Add event

   258 	active->StartL();

   259 	client->AddEvent(*event, active->iStatus);

   260 	CActiveScheduler::Start();

   261 	LEAVE_IF_ERROR(active->iStatus.Int());

   262 	//

   264 	event->SetEventType(KLogCallEventTypeUid);

   265 	event->SetContact(KTestContact2);

   266 	event->SetDirection(direction);

   267 	event->SetDurationType(KLogDurationValid);

   268 	event->SetNumber(KTestNumber1);

   269 	event->SetRemoteParty(KTestRemote2);

   270 	event->SetStatus(KTestStatus2);

   272 	// Add event and 4 duplicates

   273 	for(TInt i=0; i<5; i++)

   274 		{

   275 		active->StartL();

   276 		client->AddEvent(*event, active->iStatus);

   277 		CActiveScheduler::Start();

   278 		LEAVE_IF_ERROR(active->iStatus.Int());

   279 		}

   281 	event->SetEventType(KTestEventUid);	// low cap visible

   282 	event->SetContact(KTestContact2);

   283 	event->SetDirection(KTestDirection1);

   284 	event->SetDurationType(KLogDurationData);

   285 	event->SetNumber(KTestNumber1);

   286 	event->SetRemoteParty(KTestRemote3);

   287 	event->SetStatus(KTestStatusT3);

   289 	// Add event

   290 	active->StartL();

   291 	client->AddEvent(*event, active->iStatus);

   292 	CActiveScheduler::Start();

   293 	LEAVE_IF_ERROR(active->iStatus.Int());

   295 	CleanupStack::PopAndDestroy(5);	// event, client, type, active, scheduler

   296 	TheTestScheduler = NULL;

   297 	}

   299 //.................................................................................................

   301 //See TestUtils::AddEventL(). Adds an event to the LogEng database.

   302 //The event type is set to be: KLogCallEventTypeUid.

   303 //Return: the Id of the added event

   304 static TInt AddEventL()

   305 	{

   306 	TheTestScheduler = new (ELeave) CActiveScheduler;

   307 	CleanupStack::PushL(TheTestScheduler);

   308 	CActiveScheduler::Install(TheTestScheduler);

   310 	CLogClient* client = CLogClient::NewL(theFs);

   311 	CleanupStack::PushL(client);

   313 	CTestActive* active = new(ELeave)CTestActive();

   314 	CleanupStack::PushL(active);

   316 	CLogEvent* event = CLogEvent::NewL();

   317 	CleanupStack::PushL(event);

   319 	event->SetEventType(KLogCallEventTypeUid);

   321 	active->StartL();

   322 	client->AddEvent(*event, active->iStatus);

   323 	CActiveScheduler::Start();

   324 	LEAVE_IF_ERROR(active->iStatus.Int());

   325     TLogId eventId = event->Id();

   327 	CleanupStack::PopAndDestroy(4); // scheduler, client, active, event

   328 	TheTestScheduler = NULL;

   329 	return eventId;

   330 	}

   332 //.................................................................................................

   334 #ifdef _DEBUG

   335 static void StopLogServerL()

   336 	{

   337 	static RLogTestSession logServSession;

   338 	//this function doesn't have any effect on UREL builds as LogEng server doesn't

   339 	//support the transient mode in UREL builds

   340 	//Used for LogEng server side heap failure testing.

   341 	TInt error = KErrNone;

   343 	if(!logServSession.Handle())

   344 		{

   345 		error = logServSession.Connect();

   346 		}

   348 	// Is the server running?

   349 	if(error == KErrNotFound)

   350 		{

   351 		return;

   352 		}

   353 	LEAVE_IF_ERROR(error);

   355 	// Make the server transient

   356 	TInt p0 = 1;

   357 	TIpcArgs  ipcArgs(p0);

   358 	LEAVE_IF_ERROR(logServSession.Send(ELogMakeTransient, ipcArgs));

   360 	logServSession.Close();

   362 	User::After(6 * 1000000); // Enough time for the server to exit

   363 	}

   364 #else//_DEBUG

   365 static void StopLogServerL()

   366 	{

   367 	RDebug::Print(_L("StopLogServerL(): the LogEng server cannot be stopped in release mode. ELogMakeTransient is a debug message.\n"));

   368 	}

   369 #endif//_DEBUG

   371 //.................................................................................................

   373 static void DoDeleteDatabaseL(const TDesC& aDbPath, TBool aCloseBeforeDelete)

   374     {

   375     CBaBackupSessionWrapper* backup = NULL;

   376     if(aCloseBeforeDelete)

   377         {

   378         //Reseting of log engine databse is done via its backup server.

   379         //Create backup session wrapper

   380         backup = CBaBackupSessionWrapper::NewL();

   381         CleanupStack::PushL(backup);

   383         //This eventually calls CLogBackup::ChangeFileLockL(..) which closes the database

   384         //file and notifies all handles to that file that it has closed.

   385         backup->CloseFileL(aDbPath, MBackupObserver::EReleaseLockNoAccess);

   386         User::After(1000000);

   387         }

   389     //Since the log engine database file is closed we can delete it.

   390     //Once this file is deleted, the backup server notices this and attempts to reopen

   391     //the database.  Since the file is deleted a default database is created instead.

   393     TInt error = theFs.Delete(aDbPath);

   395     if(!(error == KErrNone || error == KErrNotFound || error == KErrPathNotFound) )

   396         {

   397         RDebug::Print(_L("DoDeleteDatabaseL(), Error %d deleting database \"%S\"\n"),error, &aDbPath);

   398         }

   399     else

   400         {

   401         RDebug::Print(_L("DoDeleteDatabaseL(), Database \"%S\" deleted ok\n"), &aDbPath);

   402         }

   404     if(aCloseBeforeDelete)

   405         {

   406         //The next line restarts the logeng server and re-creates logdbu.dat file.

   407         CleanupStack::PopAndDestroy(backup);

   409         TInt count = 10;

   410         while(count--)

   411             {

   412             User::After(100000);

   413             TEntry entry;

   414             if(theFs.Entry(aDbPath, entry) == KErrNone)

   415                 {

   416                 break;

   417                 }

   418             }

   419         }

   420     }

   422 //See TestUtils::DeleteDatabaseL().

   423 //If "aCloseBeforeDelete" is true then re-create the LogEng database.

   424 static void DeleteDatabaseL(TBool aCloseBeforeDelete)

   425     {

   426     RDebug::Print(_L("DeleteDatabaseL(), Deleting database \"%S\"\r\n"), &KLogDatabaseName);

   428     TRAPD(err, DoDeleteDatabaseL(KLogDatabaseName, aCloseBeforeDelete));

   429     if(err == KErrNotFound || err == KErrPathNotFound)

   430         {

   431         err = KErrNone;

   432         }

   433     LEAVE_IF_ERROR(err);

   434     }

   436 //.................................................................................................

   438 //See TestUtils::CopyCorruptDbL().

   439 //See TestUtils::CopyOldDbL().

   440 //See TestUtils::CopyCorruptDamagedDbL()

   441 //

   442 //The LogEng database will be replaced with a the database which name is passed as a parameter (for testing purposes).

   443 //The LogEng server will be stopped.

   444 //This call works only in debug mode.

   445 static void CopyDatabaseL(const TDesC& aNewDatabase)

   446 	{

   447 	StopLogServerL();

   449 	CFileMan* fileMan=CFileMan::NewL(theFs);

   450 	CleanupStack::PushL(fileMan);

   452 	DeleteDatabaseL(ETrue); // it won't be replaced as the server has stopped

   454   	TInt err = fileMan->Copy(aNewDatabase, KLogDatabaseName);

   455 	if(err != KErrNone)

   456 		{

   457 		// Note this only works on textshell ROMs, techview ROMs fail here with KErrInUse (-14)

   458 		RDebug::Print(_L("CopyDatabaseL(), File copy \"%S\" to \"%S\", err=%d\n"), &aNewDatabase, &KLogDatabaseName, err);

   459 		LEAVE(err);

   460 		}

   461 	// files copied are sometimes read-only, so make read-write

   462 	err = theFs.SetAtt(KLogDatabaseName, 0, KEntryAttReadOnly);

   463 	if(err != KErrNone)

   464 		{

   465 		RDebug::Print(_L("CopyDatabaseL(), Set \"%S\" file attributes err=%d\n"), &KLogDatabaseName, err);

   466 		LEAVE(err);

   467 		}

   469 	CleanupStack::PopAndDestroy(); // fileMan

   470 	}

   472 //.................................................................................................

   474 //See TestUtils::DatabaseSizeL().

   475 //Returns the LogEng database size.

   476 static TInt DatabaseSizeL()

   477 	{

   478 	TEntry file;

   479 	LEAVE_IF_ERROR(theFs.Entry(KLogDatabaseName, file));

   480 	return file.iSize;

   481 	}

   483 //.................................................................................................

   485 static void Initialize(const TDesC& aName)

   486 	{

   487     User::RenameThread(aName);

   488 	}

   490 //.................................................................................................

   492 //See TestUtils::IsDatabaseOpenL().

   493 //Returns whether the LogEng database is open or not.

   494 static TBool DatabaseIsOpenL()

   495 	{

   496 	TBool answer;

   497 	LEAVE_IF_ERROR(theFs.IsFileOpen(KLogDatabaseName, answer));

   498 	return answer;

   499 	}

   501 //.................................................................................................

   503 //See TestUtils::MatchingEnabledL().

   504 //The function opens the LogEng repository (KUidLogengRepository) and gets the value of

   505 //KContactMatchCountRepKey resource.

   506 //If the value is 0 - "contacts matching" part of the test will be skipped.

   507 static TBool MatchingEnabledL()

   508 	{

   509 	TInt contactMatchCount = 0;

   510 	TLogContactNameFormat contactNameFormat = ELogWesternFormat;

   511 	LogGetContactmatchCountAndNameFormatL(contactMatchCount, contactNameFormat);

   512     RDebug::Print(_L("** contact match count = %d, contact name format = %d\r\n"), contactMatchCount, (TInt)contactNameFormat);

   513 	return contactMatchCount > 0;

   514 	}

   516 //.................................................................................................

   518 static TInt DoTaskL(THelperOp aOperation)

   519     {

   520     TInt rc = KErrNone;

   521 	switch(aOperation)

   522 	    {

   523         case EDeleteDatabase1:

   524             DeleteDatabaseL(ETrue);

   525             break;

   526         case EDeleteDatabase2:

   527             DeleteDatabaseL(EFalse);

   528             break;

   529         case EIsDatabaseOpen:

   530             rc = DatabaseIsOpenL();

   531             break;

   532         case EDatabaseSize:

   533             rc = DatabaseSizeL();

   534             break;

   535         case ECopyCorruptDbFile:

   536             CopyDatabaseL(KOldCorruptDatabase);

   537             break;

   538         case ECopyCorruptDamagedDbFile:

   539             CopyDatabaseL(KOldCorruptDamagedDatabase);

   540             break;

   541         case ECopyOldDbFile:

   542             CopyDatabaseL(KOldFormatDatabase);

   543             break;

   544         case EAddEvent:

   545             rc = AddEventL();

   546             break;

   547         case EAddTestEvents:

   548             AddTestEventsL();

   549             break;

   550         case EAddEventType:

   551             AddEventTypeL();

   552             break;

   553         case EInvalidSchema:

   554             TestInvalidSchemaL();

   555             break;

   556         case EIsMatchingEnabled:

   557             rc = MatchingEnabledL();

   558             break;

   559         default:

   560             rc = KErrNone;	// go away quietly

   561             break;

   562 	    }

   563 	LEAVE_IF_ERROR(rc);

   564 	return rc;

   565     }

   567 //.................................................................................................

   569 static THelperOp TaskType(const TDesC& aCmdLine)

   570     {

   571     THelperOp task = EOpNotDefined;

   573     if(aCmdLine.CompareF(_L("-delete_db1")) == 0)

   574         {

   575         task = EDeleteDatabase1;

   576         }

   577     else if(aCmdLine.CompareF(_L("-delete_db2")) == 0)

   578         {

   579         task = EDeleteDatabase2;

   580         }

   581     else if(aCmdLine.CompareF(_L("-db_is_open")) == 0)

   582         {

   583         task = EIsDatabaseOpen;

   584         }

   585     else if(aCmdLine.CompareF(_L("-db_size")) == 0)

   586         {

   587         task = EDatabaseSize;

   588         }

   589     else if(aCmdLine.CompareF(_L("-copy_corrupt")) == 0)

   590         {

   591         task = ECopyCorruptDbFile;

   592         }

   593     else if(aCmdLine.CompareF(_L("-copy_corrupt_damaged")) == 0)

   594         {

   595         task = ECopyCorruptDamagedDbFile;

   596         }

   597     else if(aCmdLine.CompareF(_L("-copy_old")) == 0)

   598         {

   599         task = ECopyOldDbFile;

   600         }

   601     else if(aCmdLine.CompareF(_L("-add_event")) == 0)

   602         {

   603         task = EAddEvent;

   604         }

   605     else if(aCmdLine.CompareF(_L("-add_view_test_events")) == 0)

   606         {

   607         task = EAddTestEvents;

   608         }

   609     else if(aCmdLine.CompareF(_L("-add_event_type")) == 0)

   610         {

   611         task = EAddEventType;

   612         }

   613     else if(aCmdLine.CompareF(_L("-invalid_schema")) == 0)

   614         {

   615         task = EInvalidSchema;

   616         }

   617     else if(aCmdLine.CompareF(_L("-is_matching_enabled")) == 0)

   618         {

   619         task = EIsMatchingEnabled;

   620         }

   621     else

   622         {

   623         RDebug::Print(_L("** t_logHiCapHelper, ** Bad command line argument: %S\r\n"), &aCmdLine);

   624         User::Panic(KLogHiCapHelperPanic, KErrArgument);

   625         }

   626     return task;

   627     }

   629 static TInt EnvCreate()

   630     {

   631     TInt err = theFs.Connect();

   632     if(err == KErrNone)

   633         {

   634         err = theFs.MkDirAll(KLogEngPrivatePath);

   635         if(err == KErrAlreadyExists)

   636             {

   637             err = KErrNone;

   638             }

   639         }

   640     if(err != KErrNone)

   641         {

   642         RDebug::Print(_L("** t_logHiCapHelper, error %d creating test environment\r\n"), err);

   643         }

   644     return err;

   645     }

   647 TInt E32Main()

   648 	{

   649 	__UHEAP_MARK;

   651 	Initialize(_L("t_loghicaphelper"));

   653 	CTrapCleanup* tc = CTrapCleanup::New();

   654 	if(!tc)

   655 	   {

   656         User::Panic(KLogHiCapHelperPanic, KErrNoMemory);

   657 	   }

   659 	TBuf<64> cmdLine;

   660 	User::CommandLine(cmdLine);

   661 	THelperOp task = TaskType(cmdLine);

   663     TInt rc = 0;

   664 	TInt err = EnvCreate();

   665 	if(err == KErrNone)

   666 	    {

   667 	    TRAP(err, rc = DoTaskL(task));

   668 	    if(err < 0)

   669 	        {

   670 	        rc = err;

   671 	        RDebug::Print(_L("** t_logHiCapHelper, DoTaskL(), Task %d, Error %d\n"), task, rc);

   672 	        }

   673 	    }

   675     theFs.Close();

   676 	delete tc;

   678 	__UHEAP_MARKEND;

   680 	return rc;

   681 	}

author	sl
	Tue, 10 Jun 2014 14:32:02 +0200
changeset 1	260cb5ec6c19
permissions	-rw-r--r--