diff -r 000000000000 -r a41df078684a kerneltest/f32test/bench/t_notify_perf_util.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/kerneltest/f32test/bench/t_notify_perf_util.cpp	Mon Oct 19 15:55:17 2009 +0100
@@ -0,0 +1,293 @@
+// 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;
+    }