// Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).

 // All rights reserved.

 // This component and the accompanying materials are made available

 // under the terms of the License "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:

 // f32test\bench\t_notify_perf_util.cpp

 // 

 //

 #include "t_notify_perf.h"

 #include "t_server.h"

 void DoKillThreadsL()

     {

     TInt count = 0;

     while (count < gNotiThreads.Count())

         {

         gNotiThreads[count].Kill(KErrGeneral);

         count++;

         }

     gFileThread.Kill(KErrGeneral);

     }

 // Safe way of checking in sub threads, it leaves when check fails, Main thread will catch the error and exit.

 // if use test() directly in sub-threads, the threads may hang if check fails

 void SafeTestL(TBool aResult, TInt aId, TInt aLine, TText* aFile)

     {

     if (!aResult)

         {

         if (aId >= 0)

             {

             RDebug::Print(_L("NotificationThread%02d: Failed check in %s at line %d"), aId, aFile, aLine);

             }

         else if (aId == KNoThreadId)

             {

             RDebug::Print(_L("Failed check in %s at line %d"), aFile, aLine);

             }

         CTestExecutor::KillAllTestThreads();

         }

     }

 void SafeTestL(TInt aResult, TInt aExpected, TInt aId, TInt aLine, TText* aFile)

     {

     if (aResult != aExpected)

         {

         if (aId >= 0)

             {

             RDebug::Print(_L("NotificationThread%02d: Failed check in %s at line %d, expected %d, got %d"), aId, aFile, aLine, aExpected, aResult);

             }

         else if (aId == KNoThreadId)

             {

             RDebug::Print(_L("Failed check in %s at line %d, expected %d, got %d"), aFile, aLine, aExpected, aResult);

             }

         CTestExecutor::KillAllTestThreads();

         }

     }

 void SetTestPaths()

     {

     gTestPath.FillZ();

     gLogFilePath.FillZ();

     gTestPath.Append(gDriveToTest);

     gTestPath.Append(_L(":\\F32-TST\\T_Notify_Perf\\"));

 #ifndef __WINSCW__

     gLogFilePath.Append(gDriveToTest);

 #else

     gLogFilePath.Append((TChar)'C');  //If emulator lets stick it on C: (\epoc32\wisncw\c\)

 #endif

     if (gPerfMeasure)

         gLogFilePath.Append(_L(":\\F32-TST\\NPTestLog\\"));

     else

         gLogFilePath.Append(_L(":\\F32-TST\\Temp\\"));

     }

 // Mapping from file operations to notification types

 TUint OpNotifyMapping(TUint16& aOption, TInt aOperation)

     {

     if (aOption & EEnhanced)

         {

         switch(aOperation)

             {       

             case EOpCreate:

             case EOpCreateDir:

                 return TFsNotification::ECreate;

             case EOpReplace:

             case EOpRename:

             case EOpRenameDir:

                 return TFsNotification::ERename;

             case EOpChgAttr:

                 return TFsNotification::EAttribute;

             case EOpWrite:

             case EOpResize:

             case EOpManyChanges:

             case EOpManyFiles:

                 return TFsNotification::EFileChange;

             case EOpDelete:

             case EOpDeleteDir:

                 return TFsNotification::EDelete;

             case EOpMixed:

                 return (TUint) (TFsNotification::EAllOps & (~TFsNotification::EOverflow));

             default:

                 return (TUint) TFsNotification::EAllOps;

             }

         }

     else if (aOption & EOriginal)

         {

         switch(aOperation)

             {   

             case EOpCreate:

             case EOpReplace:

             case EOpRename:

                 return ENotifyFile;

             case EOpChgAttr:

             case EOpResize:

                 return ENotifyAttributes;

             case EOpWrite:

             case EOpManyChanges:

             case EOpManyFiles:

                 return ENotifyWrite;

             case EOpDelete:

                 return ENotifyEntry;

             case EOpCreateDir:

             case EOpRenameDir:

             case EOpDeleteDir:

                 return ENotifyDir;

             case EOpMixed:

             default:

                 return ENotifyAll;

             }

         }

     else if (aOption & EPlugin)

         {

         switch(aOperation)

             {

             case EOpCreate:

                 return EMdsFileCreated;

             case EOpReplace:

                 return EMdsFileReplaced;

             case EOpRename:

                 return EMdsFileRenamed;

             case EOpDelete:

                 return EMdsFileDeleted;

             case EOpRenameDir:

                 return EMdsDirRenamed;

             default:

                 // All other operations are not testable

                 return EMdsFileUnknown;

             }

         }

     return 0;

     }

 // generate file names for testing

 void FileNameGen(TFileName& aName, TInt aNum, TBool aIsFile = ETrue)

     {

     aName.FillZ();

     aName.Copy(gTestPath);

     if (aIsFile)

         aName.AppendFormat(_L("%04d.tst"), aNum);

     else

         aName.AppendFormat(_L("DIR%04d\\"), aNum);

     }

 void ClearTestPathL()

     {

     RDebug::Print(_L("Clearing test path..."));

     RFs fs;

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

     CFileMan* fm = CFileMan::NewL(fs);

     TInt r = fm->RmDir(gTestPath);

     test(r==KErrNone || r==KErrPathNotFound || r==KErrNotFound);

     r = fs.MkDirAll(gTestPath);

     test(r==KErrNone || r==KErrAlreadyExists);

     delete fm;

     fs.Close();

     }

 void DeleteLogFilesL()

     {

     RDebug::Print(_L("Clearing test logs if exist..."));

     RFs fs;

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

     CFileMan* fm = CFileMan::NewL(fs);

     TFileName logFiles;

     logFiles.Copy(gLogFilePath);

     logFiles.Append('*');

     logFiles.Append(gLogPostFix);

     TInt r = fm->Delete(logFiles);

     test(r==KErrNone || r==KErrPathNotFound || r==KErrNotFound);

     if (r != KErrNone)

         {

         r = fs.MkDirAll(gLogFilePath);

         test(r==KErrNone || r==KErrAlreadyExists);

         }

     delete fm;

     fs.Close();

     }

 // Copy log files from test drive to MMC

 void CopyLogFilesL()

     {

     RFs fs;

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

     CFileMan* fm = CFileMan::NewL(fs);

     TFileName path;

     path.Append(_L("D:\\NPTLogs\\"));

     TInt r = fs.MkDirAll(path);

     test(r == KErrNone || r == KErrAlreadyExists);

     fm->Copy(gLogFilePath, path);

     delete fm;

     fs.Close();

     }

 // compare the name of two entries

 TBool CompareEntryName(const TEntry& aEntry1, const TEntry& aEntry2)

     {

     return (aEntry1.iName.Compare(aEntry2.iName) == 0);

     }

 // start file operations

 void DoFileOperationL(TThreadParam* aParam)

     {

     CFileOperator fileOperator(aParam->iSetting, *(aParam->iLoggerArray), aParam->iSmphFT, aParam->iSmphNT);

     fileOperator.DoChangesL();

     }

 // start monitoring notification

 void DoNotificationOperationL(TThreadParam* aParam)

     {

     CActiveScheduler* sch = new(ELeave) CActiveScheduler(); 

     CleanupStack::PushL(sch);

     CActiveScheduler::Install(sch);

     CNotifyOperator notifyOperator(aParam->iSetting, aParam->iSmphFT, aParam->iSmphNT, aParam->iLogger);

     aParam->iSmphFT->Signal();

     notifyOperator.StartOperationL();

     CleanupStack::PopAndDestroy();

     }

 // entry function of file operaton thread

 TInt FileOperationThread(TAny* aParam)

     {

     CTrapCleanup* cleanup;

     cleanup = CTrapCleanup::New();

     TRAPD(r, DoFileOperationL(static_cast<TThreadParam*>(aParam)));

     delete cleanup;

     return r;

     }

 // entry function of notification thread

 TInt NotificationOperationThread(TAny* aParam)

     {

     CTrapCleanup* cleanup;

     cleanup = CTrapCleanup::New();

     TRAPD(r, DoNotificationOperationL(static_cast<TThreadParam*>(aParam)));

     delete cleanup;

     return r;

     }

 TInt KillerThread(TAny*)

     {

     CTrapCleanup* cleanup;

     cleanup = CTrapCleanup::New();

     TRAPD(r, DoKillThreadsL());

     delete cleanup;

     return r;

     }