--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/kerneltest/f32test/server/t_notifier.cpp Mon Oct 19 15:55:17 2009 +0100
@@ -0,0 +1,4523 @@
+// Copyright (c) 2008-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\server\t_notifier.cpp
+//
+//
+
+#include <f32file.h>
+#include <e32test.h>
+#include <e32svr.h>
+#include <hal.h>
+#include "t_server.h"
+#include "t_chlffs.h"
+#include "t_notify_plugin.h"
+
+const TInt KNotificationHeaderSize = (sizeof(TUint16)*2)+(sizeof(TUint));
+const TInt KMinNotificationBufferSize = 2*KNotificationHeaderSize + 2*KMaxFileName;
+
+
+RTest test(_L("T_NOTIFIER"));
+const TInt KMaxHeapSize = 0x800000;
+TInt globalDriveNum;
+
+void DismountPlugin()
+ {
+ TheFs.DismountPlugin(KNotifyPluginName);
+ TheFs.RemovePlugin(KNotifyPluginFileName);
+ }
+
+inline void safe_test(RTest& aTest, TInt aError, TInt aLine, TText* aName)
+ {
+ if(aError!=KErrNone)
+ {
+ test.Printf(_L(": ERROR : %d received on line %d\n"),aError,aLine);
+ DismountPlugin();
+ aTest.operator()(aError==KErrNone,aLine,(TText*)aName);
+ }
+ }
+
+// Used by TestMultipleNotificationsL() to show which line the function is called from
+inline void safe_test(RTest& aTest, TInt aError, TInt aLine, TInt aLineCall)
+ {
+ if(aError != KErrNone)
+ {
+ aTest.Printf(_L(": ERROR : %d received on line %d\n"), aError, aLine);
+ aTest.Printf(_L(": ERROR : Function called from line number: %d\n"), aLineCall);
+ aTest.operator()(aError == KErrNone, aLine);
+ }
+ }
+
+// Prints out the filename
+#define ExpandMe(X) L ## X
+#define Expand(X) ExpandMe(X)
+
+namespace t_notification
+ {
+ enum EOperation
+ {
+ //TFsNotification::ECreate
+ EFileReplace,
+ EFileCreate,
+ EFileCreate_subs, //Create files in subdir, watch subdirs
+ EFileCreate_subs_nowatch, //Create files in subdir, do not monitor subdirs
+ EFileCreate_txt_nowatch, //Create .txt files in subdir, do not monitor subdirs
+ EFileCreate_txt, //Create .txt files
+ EFsMkDir, //Create directory
+ //TFsNotification::EAttribute
+ EFileSetAtt,
+ EFileSetAtt_subs, //Set attributes in subdir
+ EFileSet,
+ EFsSetEntry,
+ //TFsNotification::ERename
+ EFsReplace, //Replace file
+ EFsRename, //Rename file
+ EFsRename_dir, //Rename directory
+ EFileRename,
+ EFileRename_wild, //Rename file using wildcard name
+ //TFsNotification::EDelete
+ EFsDelete, //Delete file
+ EFsRmDir, //Remove directory
+ EFsRmDir_nonEmpty, //Remove non-empty directory, which will return KErrInUse
+ EFsRmDir_wild, //Remove subdirectory using wildcard name
+ //TFsNotification::EFileChange
+ EFileWrite,
+ EFileWrite_samesize, //Write to file without changing its size
+ EFileWrite_async, //Asynchronous write
+ EFileSetSize,
+ //TFsNotification::EVolumeName
+ ESetVolumeLabel,
+ //TFsNotification::EDriveName
+ ESetDriveName,
+ //TFsNotification::EMediaChange
+ EMount,
+ EDismount,
+ EMountScan,
+ EMountDismount,
+ EFormat,
+ EMediaCardRemoval,
+ EMediaCardInsertion,
+ ERawDiskWrite,
+ //Multiple Filters
+ EAllOps1, //Create/Replace and Delete
+ EAllOps2, //Create/Replace, FileChange(Write) and Delete
+ EAllOps3, //Create/Replace, FileChange(SetSize) and Delete
+ EAllOps4, //Create/Replace, Attribute(SetAtt) and Delete
+ EAllOps5, //Create/Replace and Rename
+ EAllOps6, //VolumeName and DriveName
+ ECFileManMove //Create filex in monitored directory, write 4, move to unmonitored, setsize 8, move back, delete
+ };
+ }
+
+// Package filename and semaphore for thread
+struct SThreadPackage
+ {
+ TFileName iFileName;
+ RSemaphore iBarrier;
+ };
+
+struct SThreadPackageDualSemaphore
+ {
+ TFileName iFileName;
+ RSemaphore iBarrier;
+ RSemaphore iBarrier2;
+ };
+
+struct SThreadPackage2
+ {
+ TInt iTestCase;
+ RSemaphore iBarrier;
+ };
+
+// Used by TestMultipleNotificationsL
+struct SThreadPackageMultiple
+ {
+ TFileName iString; //Commonly stores the filename
+ TFileName iFileName; //Commonly stores the path (not inc filename)
+ RSemaphore iBarrier;
+ t_notification::EOperation iOperation;
+ TFsNotification::TFsNotificationType iNotifyType;
+ TInt iIterations; //# of times to 'do' something
+ TInt iMaxNotifications; //# of notifications expected
+ TInt iBufferSize;
+ TInt iLineCall; //Line where the function is called from
+ };
+
+void PrintLine()
+ {
+ test.Printf(_L("======================================================================\n"));
+ }
+
+
+// We should receive an EMediaChange notification even though we did not register for it
+void TestMediaCardNotificationWhenNotRegisteredForIt()
+ {
+ RFs fs;
+ TInt r = fs.Connect();
+ test(r==KErrNone);
+
+ CFsNotify* notify = NULL;
+ TRAP(r,notify= CFsNotify::NewL(fs,KMinNotificationBufferSize));
+
+ TBuf<40> path;
+ path.Append((TChar)gDriveToTest);
+ path.Append(_L(":\\F32-TST\\T_NOTIFIER\\"));
+
+ TBuf<20> filename;
+ filename.Append(_L("media.change1"));
+
+ r = notify->AddNotification((TUint)TFsNotification::ECreate,path,filename);
+ test(r==KErrNone);
+
+ TRequestStatus status;
+ r = notify->RequestNotifications(status);
+ test(r==KErrNone);
+
+ test.Printf(_L("*****************************************************************\n"));
+ test.Printf(_L("Waiting 10 seconds.\n"));
+ test.Printf(_L("This is a MANUAL test, it requires the removal of the media card.\n"));
+ test.Printf(_L("PLEASE REMOVE THE MEDIA CARD. (DriveNumber %d)\n"),globalDriveNum);
+ test.Printf(_L("Or press Ctrl + F5 on the emulator.\n"));
+ test.Printf(_L("*****************************************************************\n"));
+ RTimer timer1;
+ r = timer1.CreateLocal();
+ test(r == KErrNone);
+ TRequestStatus timeout;
+ TTimeIntervalMicroSeconds32 time = 10000000;
+ timer1.After(timeout,time);
+ User::WaitForRequest(timeout,status);
+ test(status.Int() != KRequestPending);
+ timer1.Cancel();
+ timer1.Close();
+
+ const TFsNotification* notification = notify->NextNotification();
+ test(notification != NULL);
+ TFsNotification::TFsNotificationType type = notification->NotificationType();
+ test(type == TFsNotification::EMediaChange);
+ TBuf<2> drive;
+ drive.Append((TChar)gDriveToTest);
+ drive.Append(_L(":"));
+ TPtrC drivePtr;
+ r = notification->Path(drivePtr);
+ test(r==KErrNone);
+ r = drivePtr.Compare(drive);
+ test(r==0);
+
+ test.Printf(_L("*****************************************************************\n"));
+ test.Printf(_L("Waiting 10 seconds.\n"));
+ test.Printf(_L("This is a MANUAL test, it requires the insertion of the media card.\n"));
+ test.Printf(_L("PLEASE INSERT THE MEDIA CARD. (DriveNumber %d)\n"),globalDriveNum);
+ test.Printf(_L("Or press Ctrl + F5 on the emulator.\n"));
+ test.Printf(_L("*****************************************************************\n"));
+
+ notification = notify->NextNotification();
+ if(notification == NULL)
+ {
+ notify->RequestNotifications(status);
+ RTimer timer2;
+ r = timer2.CreateLocal();
+ test(r == KErrNone);
+ TRequestStatus timeout2;
+ timer2.After(timeout2,time);
+ User::WaitForRequest(timeout2,status);
+ test(status.Int() != KRequestPending);
+ notification = notify->NextNotification();
+ timer2.Cancel();
+ timer2.Close();
+ }
+ test(notification != NULL);
+ type = notification->NotificationType();
+ test(type == TFsNotification::EMediaChange);
+
+ delete notify;
+ fs.Close();
+ }
+
+// Creates two sessions, removes the first one
+// and then checks if the second one still works
+TInt TestClientRemovalL()
+ {
+ RFs fs;
+ TInt r = fs.Connect();
+ test(r==KErrNone);
+
+ CFsNotify* notify1 = NULL;
+ CFsNotify* notify2 = NULL;
+ TRAP(r,notify1= CFsNotify::NewL(fs,KMinNotificationBufferSize);
+ notify2= CFsNotify::NewL(fs,KMinNotificationBufferSize);
+ );
+ if(r!=KErrNone)
+ {
+ delete notify1;
+ delete notify2;
+ test(r==KErrNone);
+ }
+
+ TBuf<40> path;
+ path.Append((TChar)gDriveToTest);
+ path.Append(_L(":\\F32-TST\\T_NOTIFIER\\"));
+
+ TBuf<15> filename;
+ filename.Append(_L("create.file"));
+
+ TBuf<40> fullname;
+ fullname.Append(path);
+ fullname.Append(filename);
+
+ r = notify1->AddNotification((TUint)TFsNotification::ECreate,path,filename);
+ test(r==KErrNone);
+ r = notify2->AddNotification((TUint)TFsNotification::ECreate,path,filename);
+ test(r==KErrNone);
+
+ delete notify1; //Delete notify1 and ensure we still get notification on notify2
+
+ TRequestStatus status;
+ r = notify2->RequestNotifications(status);
+ test(r==KErrNone);
+
+ RFile file;
+ file.Replace(fs,fullname,EFileWrite); //Replace produces Create notification
+ file.Close();
+
+ RTimer tim;
+ r = tim.CreateLocal();
+ test(r==KErrNone);
+
+ TRequestStatus timStatus;
+ TTimeIntervalMicroSeconds32 time = 10000000; //10 seconds
+ tim.After(timStatus,time);
+
+ User::WaitForRequest(status,timStatus);
+ test(status!=KRequestPending);
+
+ r = fs.Delete(fullname);
+ test(r==KErrNone);
+
+ delete notify2;
+ tim.Close();
+ fs.Close();
+ return KErrNone;
+ }
+
+/*
+ * This tests that u can set and receive notifications in the root
+ * of a drive.
+ *
+ * (something which was apparently not possible on RFs::NotifyChange)
+ */
+TInt TestRootDriveNotifications()
+ {
+ test.Next(_L("TestRootDriveNotifications"));
+ RFs fs;
+ fs.Connect();
+
+ CFsNotify* notify = NULL;
+
+ TRAPD(r,notify = CFsNotify::NewL(fs,KMinNotificationBufferSize););
+ test(r==KErrNone);
+ test(notify!=NULL);
+
+ TBuf<40> path;
+ path.Append((TChar)gDriveToTest);
+ path.Append(_L(":\\"));
+
+ TBuf<15> filename;
+ filename.Append(_L("*"));
+
+ r = notify->AddNotification((TUint)TFsNotification::ECreate,path,filename);
+ test(r==KErrNone);
+
+ TRequestStatus status;
+ r = notify->RequestNotifications(status);
+ test(r==KErrNone);
+
+ RFile file;
+ TBuf<40> filePath;
+ filePath.Append((TChar)gDriveToTest);
+ filePath.Append(_L(":\\file.root"));
+ r = file.Replace(fs,filePath,EFileRead);
+ test(r==KErrNone);
+ file.Close();
+
+ TRequestStatus s2;
+ RTimer tim;
+ test(tim.CreateLocal()==KErrNone);
+ TTimeIntervalMicroSeconds32 time = 10000000; //10 seconds
+ tim.After(s2,time);
+ User::WaitForRequest(status,s2);
+ test(status!=KRequestPending);
+
+ delete notify;
+ notify = NULL;
+ tim.Close();
+ fs.Close();
+ return KErrNone;
+ }
+
+/*
+ * Creates and deletes loads of CFsNotify objects and makes sure they're all
+ * cleaned up afterwards.
+ */
+TInt TestNewDeleteCFsNotify(TInt aIterations)
+ {
+ RPointerArray<CFsNotify> array;
+ TInt inArray = 0;
+ TInt r = KErrNone;
+ for(TInt i = 0; i < aIterations; i++)
+ {
+ CFsNotify* notify = NULL;
+ TRAP(r,notify = CFsNotify::NewL(TheFs,500));
+ if(r==KErrNone)
+ {
+ test(notify!=NULL);
+ r = array.Append(notify);
+ if(r==KErrNone)
+ {
+ inArray++;
+ }
+ else
+ {
+ delete notify;
+ break;
+ }
+ }
+ else
+ {
+ break;
+ }
+ }
+
+ for(TInt j = inArray-1; j >= 0; j--)
+ {
+ CFsNotify* notify = (CFsNotify*)array[j];
+ array.Remove(j);
+ delete notify;
+ }
+
+ array.Reset();
+ array.Close();
+ return KErrNone;
+ }
+
+
+/*
+ * Creates a file
+ * Used in SimpleTest1L(), TestTwoDoersL() TestTwoWatchersL(), TestCancelNotificationL()
+ */
+TInt SimpleSingleNotificationTFDoer(TAny* aAny)
+ {
+ SThreadPackageDualSemaphore pkgDoer = *(SThreadPackageDualSemaphore*)aAny;
+ RTest simpleTestDoer(_L("SimpleSingleNotificationTFDoer"));
+ simpleTestDoer.Start(_L("SimpleSingleNotificationTFDoer"));
+ TBuf<40> path;
+ path.Append(gDriveToTest);
+ path.Append(_L(":\\F32-TST\\T_NOTIFIER\\"));
+ path.Append(pkgDoer.iFileName);
+
+ //Delete file so we definitely get a create notification
+ RFs fs;
+ TInt r = fs.Connect();
+ safe_test(simpleTestDoer,r,__LINE__,(TText*)Expand("t_notifier.cpp"));
+ r = fs.Delete(path);
+ if(r==KErrNone || r==KErrPathNotFound || r==KErrNotFound)
+ r = KErrNone;
+ safe_test(simpleTestDoer,r,__LINE__,(TText*)Expand("t_notifier.cpp"));
+ r = fs.MkDirAll(path);
+ if(r==KErrNone || r==KErrAlreadyExists)
+ r = KErrNone;
+ safe_test(simpleTestDoer,r,__LINE__,(TText*)Expand("t_notifier.cpp"));
+
+ simpleTestDoer.Printf(_L("SimpleSingleNotificationTFDoer - Create File %S\n"),&path);
+ //Create file
+ RFile file;
+ r = file.Create(fs,path,EFileWrite);
+ safe_test(simpleTestDoer,r,__LINE__,(TText*)Expand("t_notifier.cpp"));
+ file.Close();
+
+ fs.Close();
+ simpleTestDoer.End();
+ simpleTestDoer.Close();
+ return KErrNone;
+ }
+
+/*
+ * Watches 1 file creation
+ * Used in SimpleTest1L()
+ */
+TInt SimpleSingleNotificationTFWatcher(TAny* aAny)
+ {
+ CTrapCleanup* cleanup;
+ cleanup = CTrapCleanup::New();
+ RThread thread;
+ TUint64 threadId = thread.Id().Id();
+
+ SThreadPackage pkgDoer = *(SThreadPackage*)aAny;
+ RSemaphore& simpleBarrierTest = pkgDoer.iBarrier;
+
+ RTest simpleTestWatcher(_L("SimpleSingleNotificationTFWatcher"));
+ simpleTestWatcher.Start(_L("SimpleSingleNotificationTFWatcher"));
+
+ RFs fs;
+ fs.Connect();
+
+ simpleTestWatcher.Printf(_L("SimpleSingleNotificationTFWatcher(%d) - Create CFsNotify\n"),threadId);
+ CFsNotify* notify = NULL;
+ TRAPD(r,notify = CFsNotify::NewL(fs,100); );
+ safe_test(simpleTestWatcher,r,__LINE__,(TText*)Expand("t_notifier.cpp"));
+ TBuf<40> path;
+ path.Append(gDriveToTest);
+ path.Append(_L(":\\F32-TST\\T_NOTIFIER\\")); //len=22
+
+ TBuf<20> filename;
+ filename.Append(pkgDoer.iFileName);
+
+ TBuf<40> fullname;
+ fullname.Append(path);
+ fullname.Append(filename);
+
+ simpleTestWatcher.Printf(_L("SimpleSingleNotificationTFWatcher - Add Notification for %S\n"),&path);
+ r = notify->AddNotification((TUint)TFsNotification::ECreate,path,filename);
+ safe_test(simpleTestWatcher,r,__LINE__,(TText*)Expand("t_notifier.cpp"));
+ TRequestStatus status;
+ simpleTestWatcher.Printf(_L("SimpleSingleNotificationTFWatcher(%d) - Request Notifications\n"),threadId);
+ r = notify->RequestNotifications(status);
+ safe_test(simpleTestWatcher,r,__LINE__,(TText*)Expand("t_notifier.cpp"));
+
+ simpleBarrierTest.Signal();
+
+ simpleTestWatcher.Printf(_L("SimpleSingleNotificationTFWatcher(%d) - Wait for status to return\n"),threadId);
+ User::WaitForRequest(status);
+
+ simpleTestWatcher.Printf(_L("(%d) NextNotification\n"),threadId);
+ const TFsNotification* notification = notify->NextNotification();
+ //Test notification is not null.
+ //We should be getting 1 notification.
+ if(notification == NULL)
+ safe_test(simpleTestWatcher,KErrNotFound,__LINE__,(TText*)Expand("t_notifier.cpp"));
+
+ simpleTestWatcher.Printf(_L("(%d) - Notification Type\n"),threadId);
+ TFsNotification::TFsNotificationType notificationType = ((TFsNotification*)notification)->NotificationType();
+ if(notificationType != TFsNotification::ECreate)
+ safe_test(simpleTestWatcher,KErrGeneral,__LINE__,(TText*)Expand("t_notifier.cpp"));
+ simpleTestWatcher.Printf(_L("(%d) - Notification Path\n"),threadId);
+ TPtrC _pathC;
+ ((TFsNotification*)notification)->Path(_pathC);
+ simpleTestWatcher.Printf(_L("Notification Path = %S\n"),&_pathC);
+ TBuf<40> _path;
+ _path.Copy(_pathC);
+ if(_path.Match(fullname)!=KErrNone)
+ safe_test(simpleTestWatcher,KErrBadName,__LINE__,(TText*)Expand("t_notifier.cpp"));
+
+ /*
+ TInt driveNumber = 0;
+ TInt gDriveNum = -1;
+ notification->DriveNumber(driveNumber);
+ RFs::CharToDrive(_pathC[0],gDriveNum);
+ if(driveNumber != gDriveNum)
+ safe_test(simpleTestWatcher,KErrBadHandle,__LINE__,(TText*)Expand("t_notifier.cpp"));
+
+ TUid uid;
+ TUint32 realUID = 0x76543210;
+ r = notification->UID(uid);
+ safe_test(simpleTestWatcher,r,__LINE__,(TText*)Expand("t_notifier.cpp"));
+ safe_test(simpleTestWatcher,(realUID == uid.iUid)==1,__LINE__,(TText*)Expand("t_notifier.cpp"));
+ */
+ delete notify;
+ fs.Close();
+ simpleTestWatcher.End();
+ simpleTestWatcher.Close();
+ delete cleanup;
+ return KErrNone;
+ }
+
+/*
+ * SimpleTest1L - Runs a simple Create test, gets 1 notification, calls type, path etc and exits
+ * Two threads: 1 watcher, 1 doer
+ */
+TInt SimpleCreateTestL()
+ {
+ test.Next(_L("SimpleTest"));
+ RFs fs;
+ fs.Connect();
+ _LIT(KFileName,"simple.create");
+ SThreadPackage pkgDoer;
+ pkgDoer.iFileName = KFileName;
+
+ SThreadPackage watcherPkg;
+ watcherPkg.iFileName = KFileName;
+ User::LeaveIfError(pkgDoer.iBarrier.CreateLocal(0));
+ User::LeaveIfError(watcherPkg.iBarrier.CreateLocal(0));
+ RThread watcher;
+ RThread doer;
+ watcher.Create(_L("Simple1WatcherThread"),SimpleSingleNotificationTFWatcher,KDefaultStackSize,KMinHeapSize,KMaxHeapSize,&watcherPkg);
+ doer.Create(_L("Simple1DoerThread"),SimpleSingleNotificationTFDoer,KDefaultStackSize,KMinHeapSize,KMaxHeapSize,&pkgDoer);
+ watcher.Resume();
+ watcherPkg.iBarrier.Wait(); //Wait till Watcher has requested notification
+ doer.Resume();
+
+ TRequestStatus status;
+ doer.Logon(status);
+ User::WaitForRequest(status);
+ test.Printf(_L("SimpleCreateTest - Doer Exit Reason = %d\n"),doer.ExitReason());
+ safe_test(test,doer.ExitReason(),__LINE__,(TText*)Expand("t_notifier.cpp"));
+
+ RDebug::Print(_L("Line %d"),__LINE__);
+
+
+ watcher.Logon(status);
+ RTimer timer1;
+ TInt r = timer1.CreateLocal();
+ safe_test(test,r,__LINE__,(TText*)Expand("t_notifier.cpp"));
+ TRequestStatus timeout;
+ TTimeIntervalMicroSeconds32 time = 10000000; //10 seconds
+ timer1.After(timeout,time);
+ User::WaitForRequest(timeout,status);
+ test(status.Int() != KRequestPending);
+ timer1.Cancel();
+ timer1.Close();
+
+
+// User::WaitForRequest(status);
+ test.Printf(_L("SimpleCreateTest - Watcher Exit Reason = %d\n"),watcher.ExitReason());
+ safe_test(test,watcher.ExitReason(),__LINE__,(TText*)Expand("t_notifier.cpp"));
+
+ CLOSE_AND_WAIT(doer);
+ CLOSE_AND_WAIT(watcher);
+
+ pkgDoer.iBarrier.Close();
+ watcherPkg.iBarrier.Close();
+ fs.Close();
+ return KErrNone;
+ }
+
+// Doer thread for TestMultipleNotificationsL
+TInt MultipleNotificationTFDoer(TAny* aAny)
+ {
+ RDebug::Print(_L("MultipleNotificationTFDoer - Start, Line %d"), __LINE__);
+ SThreadPackageMultiple pkgDoer = *(SThreadPackageMultiple*)aAny;
+ RTest multipleTestDoer(_L("MultipleNotificationTFDoer"));
+ multipleTestDoer.Start(_L("Multi-Doer"));
+ multipleTestDoer.Printf(_L("MultipleNotificationTFDoer - Line %d"),__LINE__);
+ TBuf<40> basepath;
+ basepath.Append(gDriveToTest);
+ basepath.Append(_L(":\\F32-TST\\T_NOTIFIER\\"));
+
+ RThread thread;
+ RDebug::Print(_L("MultipleNotificationTFDoer - Line %d"), __LINE__);
+ TUint64 threadID = thread.Id().Id();
+ RDebug::Print(_L("MultipleNotificationTFDoer - Line %d"), __LINE__);
+
+ //Delete file so we definitely get a create notification
+ RFs fs;
+ TInt r = fs.Connect();
+ safe_test(multipleTestDoer,r,__LINE__,pkgDoer.iLineCall);
+
+ TEntry entry;
+ TBool wildcard = EFalse;
+ TBuf<40> _path;
+ _path.Append(basepath);
+ _path.Append(pkgDoer.iFileName);
+ _path.Append(pkgDoer.iString);
+ r = fs.Entry(_path, entry);
+ if (pkgDoer.iNotifyType != TFsNotification::EMediaChange &&
+ pkgDoer.iNotifyType != TFsNotification::EDriveName &&
+ pkgDoer.iNotifyType != TFsNotification::EVolumeName &&
+ pkgDoer.iOperation != t_notification::EAllOps6)
+ {
+ if (r == KErrBadName)
+ {
+ wildcard = ETrue;
+ }
+ if(r != KErrNone && r != KErrPathNotFound && r != KErrNotFound && r != KErrBadName)
+ safe_test(multipleTestDoer,r,__LINE__,pkgDoer.iLineCall);
+ if (r == KErrNone && !entry.IsDir() && pkgDoer.iOperation != t_notification::EFsDelete && !wildcard &&
+ pkgDoer.iOperation != t_notification::EFsRmDir && pkgDoer.iOperation != t_notification::EFsRmDir_nonEmpty)
+ {
+ r = fs.Delete(_path);
+ if(r != KErrNone && r != KErrPathNotFound && r != KErrNotFound)
+ safe_test(multipleTestDoer,r,__LINE__,pkgDoer.iLineCall);
+ }
+ r = fs.MkDirAll(basepath);
+ if(r != KErrNone && r != KErrAlreadyExists)
+ safe_test(multipleTestDoer,r,__LINE__,pkgDoer.iLineCall);
+ }
+
+ multipleTestDoer.Printf(_L("MultipleNotificationTFDoer (%d) - Line %d"),threadID,__LINE__);
+
+ switch(pkgDoer.iOperation)
+ {
+ case t_notification::EFileReplace:
+ {
+ RFile file;
+ //Generate Notification
+ multipleTestDoer.Printf(_L("File Replace - (%d)\n"),threadID);
+ r = file.Replace(fs,_path,EFileWrite); //RFile::Replace -> TFsNotification::ECreate
+ safe_test(multipleTestDoer,r,__LINE__,pkgDoer.iLineCall);
+ file.Close();
+
+ r = fs.Delete(_path);
+ safe_test(multipleTestDoer,r,__LINE__,pkgDoer.iLineCall);
+ break;
+ }
+ case t_notification::EFileCreate:
+ case t_notification::EFileCreate_txt_nowatch:
+ case t_notification::EFileCreate_txt:
+ case t_notification::EAllOps1:
+ {
+ multipleTestDoer.Printf(_L("MultipleNotificationTFDoer (%d) - Line %d"),threadID,__LINE__);
+ if(wildcard)
+ {
+ for (TInt i = 0; i < pkgDoer.iIterations; i++)
+ {
+ multipleTestDoer.Printf(_L("MultipleNotificationTFDoer (%d) - Line %d"),threadID,__LINE__);
+ RFile file;
+ TBuf<40> path;
+ path.Append(basepath);
+ path.AppendNum(i);
+ if(pkgDoer.iOperation == t_notification::EFileCreate_txt)
+ {
+ //Create file with different extension (no notification)
+ path.Append(_L(".wrg"));
+ fs.Delete(path);
+ multipleTestDoer.Printf(_L("File Create (wrong extension) - %S (%d)\n"),&path,threadID);
+ r = file.Create(fs, path, EFileWrite);
+ safe_test(multipleTestDoer,r,__LINE__,pkgDoer.iLineCall);
+ //Change path to contain file with correct extension (notification occurs)
+ path.Replace(path.Length()-3,3,_L("txt"));
+ }
+ else if(pkgDoer.iOperation == t_notification::EFileCreate_txt_nowatch)
+ {
+ path.Append(_L(".txt"));
+ }
+ fs.Delete(path);
+
+ multipleTestDoer.Printf(_L("File Create - %S (%d)\n"),&path,threadID);
+ r = file.Create(fs, path, EFileWrite);
+ safe_test(multipleTestDoer,r,__LINE__,pkgDoer.iLineCall);
+ file.Close();
+ r = fs.Delete(path);
+ safe_test(multipleTestDoer,r,__LINE__,pkgDoer.iLineCall);
+ }
+ }
+ else
+ {
+ multipleTestDoer.Printf(_L("MultipleNotificationTFDoer (%d) - Line %d"),threadID,__LINE__);
+ for(TInt i = 0; i < pkgDoer.iIterations; i++)
+ {
+ multipleTestDoer.Printf(_L("MultipleNotificationTFDoer (%d) - Line %d"),threadID,__LINE__);
+ RFile file;
+ multipleTestDoer.Printf(_L("File Create - %S (%d)\n"),&_path,threadID);
+ r = file.Create(fs,_path,EFileWrite);
+ safe_test(multipleTestDoer,r,__LINE__,pkgDoer.iLineCall);
+ file.Close();
+ r = fs.Delete(_path);
+ safe_test(multipleTestDoer,r,__LINE__,pkgDoer.iLineCall);
+ }
+ }
+ break;
+ }
+ case t_notification::EFileCreate_subs:
+ case t_notification::EFileCreate_subs_nowatch:
+ {
+ if (wildcard)
+ {
+ for (TInt i = 0; i < pkgDoer.iIterations; i++)
+ {
+ RFile file;
+ TBuf<40> path;
+ path.Append(basepath);
+ path.Append(_L("SubDir\\"));
+ r = fs.MkDirAll(path);
+ if(r != KErrNone && r != KErrAlreadyExists)
+ safe_test(multipleTestDoer,r,__LINE__,pkgDoer.iLineCall);
+ path.AppendNum(i);
+ fs.Delete(path);
+ multipleTestDoer.Printf(_L("File Create - %S (%d)\n"),&path,threadID);
+ r = file.Create(fs, path, EFileWrite);
+ safe_test(multipleTestDoer,r,__LINE__,pkgDoer.iLineCall);
+ file.Close();
+ r = fs.Delete(path);
+ safe_test(multipleTestDoer,r,__LINE__,pkgDoer.iLineCall);
+ }
+ }
+ break;
+ }
+ case t_notification::EFileWrite:
+ case t_notification::EAllOps2:
+ {
+ //Works on single file
+ RFile file;
+ TBuf<40> path;
+ path.Append(basepath);
+ path.Append(pkgDoer.iFileName);
+ path.Append(pkgDoer.iString);
+ r = file.Replace(fs,path,EFileWrite);
+ safe_test(multipleTestDoer,r,__LINE__,pkgDoer.iLineCall);
+ for(TInt i = 0; i < pkgDoer.iIterations; i++)
+ {
+ multipleTestDoer.Printf(_L("File Write - %S (%d)\n"),&path,threadID);
+ r = file.Write(4*i,_L8("abcd"));
+ safe_test(multipleTestDoer,r,__LINE__,pkgDoer.iLineCall);
+ //If cache is enabled, a notification is received only when the cache is flushed
+ //We flush the file to make this a general test
+ multipleTestDoer.Printf(_L("File Flush - (%d)\n"),threadID);
+ r = file.Flush();
+ safe_test(multipleTestDoer,r,__LINE__,pkgDoer.iLineCall);
+ }
+ file.Close();
+ r = fs.Delete(path);
+ safe_test(multipleTestDoer,r,__LINE__,pkgDoer.iLineCall);
+ break;
+ }
+ case t_notification::EFileWrite_samesize:
+ {
+ RFile file;
+ TBuf<40> path;
+ path.Append(basepath);
+ path.Append(pkgDoer.iFileName);
+ path.Append(pkgDoer.iString);
+ r = file.Replace(fs,path,EFileWrite);
+ safe_test(multipleTestDoer,r,__LINE__,pkgDoer.iLineCall);
+ multipleTestDoer.Printf(_L("File Write - %S (%d)\n"),&path,threadID);
+ r = file.Write(0,_L8("abcd"));
+ safe_test(multipleTestDoer,r,__LINE__,pkgDoer.iLineCall);
+
+ //If cache is enabled, a notification is received only when the cache is flushed
+ //We flush the file to make this a general test
+ multipleTestDoer.Printf(_L("File Flush - (%d)\n"),threadID);
+ r = file.Flush();
+ safe_test(multipleTestDoer,r,__LINE__,pkgDoer.iLineCall);
+
+ for(TInt i = 0; i < pkgDoer.iIterations; i++)
+ {
+ TBuf<2> toWrite;
+ toWrite.AppendNum(i);
+ multipleTestDoer.Printf(_L("File Write - %S (%d)\n"),&path,threadID);
+ r = file.Write(0,(TDesC8&)toWrite);
+ safe_test(multipleTestDoer,r,__LINE__,pkgDoer.iLineCall);
+ multipleTestDoer.Printf(_L("File Flush - (%d)\n"),threadID);
+ r = file.Flush();
+ safe_test(multipleTestDoer,r,__LINE__,pkgDoer.iLineCall);
+ }
+ file.Close();
+ r = fs.Delete(path);
+ safe_test(multipleTestDoer,r,__LINE__,pkgDoer.iLineCall);
+ break;
+ }
+ case t_notification::EFileWrite_async:
+ {
+ RFile file;
+ TBuf<40> path;
+ path.Append(basepath);
+ path.Append(pkgDoer.iFileName);
+ path.Append(pkgDoer.iString);
+ r = file.Replace(fs,path,EFileWrite);
+ safe_test(multipleTestDoer,r,__LINE__,pkgDoer.iLineCall);
+ for(TInt i = 0; i < pkgDoer.iIterations; i++)
+ {
+ TRequestStatus status;
+ file.Write(52*i, _L8("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"), status);
+ User::WaitForRequest(status);
+ multipleTestDoer.Printf(_L("File Write Async - %S (%d)\n"),&path,threadID);
+ TInt fileSize;
+ file.Size(fileSize);
+ multipleTestDoer.Printf(_L("File Write Async - FileSize: %d\n"),fileSize);
+ multipleTestDoer.Printf(_L("File Flush - (%d)\n"),threadID);
+ r = file.Flush();
+ safe_test(multipleTestDoer,r,__LINE__,pkgDoer.iLineCall);
+ }
+ file.Close();
+ r = fs.Delete(path);
+ safe_test(multipleTestDoer,r,__LINE__,pkgDoer.iLineCall);
+ break;
+ }
+ case t_notification::EFileSetSize:
+ case t_notification::EAllOps3:
+ {
+ //Works on single file
+ RFile file;
+ TBuf<40> path;
+ path.Append(basepath);
+ path.Append(pkgDoer.iFileName);
+ path.Append(pkgDoer.iString);
+ r = file.Replace(fs,path,EFileWrite);
+ safe_test(multipleTestDoer,r,__LINE__,pkgDoer.iLineCall);
+
+ //Increase file size
+ for(TInt i = 0; i < pkgDoer.iIterations; i++)
+ {
+ r = file.SetSize(4*(i+1));
+ safe_test(multipleTestDoer,r,__LINE__,pkgDoer.iLineCall);
+ multipleTestDoer.Printf(_L("File Set Size - %d (%d)\n"),4*(i+1),threadID);
+ }
+
+ //Decrease file size
+ for(TInt j = pkgDoer.iIterations - 2; j >= 0; j--)
+ {
+ r = file.SetSize(4*(j+1));
+ safe_test(multipleTestDoer,r,__LINE__,pkgDoer.iLineCall);
+ multipleTestDoer.Printf(_L("File Set Size - %d (%d)\n"),4*(j+1),threadID);
+ }
+
+ file.Close();
+ r = fs.Delete(path);
+ safe_test(multipleTestDoer,r,__LINE__,pkgDoer.iLineCall);
+ break;
+ }
+ case t_notification::EFsReplace:
+ {
+ TBuf<45> path;
+ path.Append(basepath);
+ path.Append(pkgDoer.iFileName);
+ path.Append(pkgDoer.iString);
+ path.AppendNum(0);
+
+ RFile tempFile;
+ multipleTestDoer.Printf(_L("RFs Replace (Create temp file) - (%d)\n"),threadID);
+ r = tempFile.Replace(fs,_path,EFileWrite);
+ safe_test(multipleTestDoer,r,__LINE__,pkgDoer.iLineCall);
+ tempFile.Close();
+
+ multipleTestDoer.Printf(_L("RFs Replace - (%d)\n"),threadID);
+ r = fs.Replace(_path,path); //RFs::Replace -> TFsNotification::ERename
+ safe_test(multipleTestDoer,r,__LINE__,pkgDoer.iLineCall);
+
+ r = fs.Delete(path);
+ safe_test(multipleTestDoer,r,__LINE__,pkgDoer.iLineCall);
+ break;
+ }
+ case t_notification::EFsRename:
+ {
+ TBuf<45> path;
+ path.Append(basepath);
+ path.Append(pkgDoer.iFileName);
+ path.Append(pkgDoer.iString);
+ path.AppendNum(0);
+
+ RFile file;
+ r = file.Replace(fs,_path,EFileWrite);
+ safe_test(multipleTestDoer,r,__LINE__,pkgDoer.iLineCall);
+ file.Close();
+
+ multipleTestDoer.Printf(_L("RFs Rename - (%d)\n"),threadID);
+ r = fs.Rename(_path,path);
+ safe_test(multipleTestDoer,r,__LINE__,pkgDoer.iLineCall);
+
+ r = fs.Delete(path);
+ safe_test(multipleTestDoer,r,__LINE__,pkgDoer.iLineCall);
+ break;
+ }
+ case t_notification::EFileRename:
+ case t_notification::EFileRename_wild:
+ case t_notification::EAllOps5:
+ {
+ TBuf<45> path;
+ path.Append(basepath);
+ if (!wildcard)
+ {
+ path.Append(pkgDoer.iFileName);
+ path.Append(pkgDoer.iString);
+ }
+ path.AppendNum(0);
+
+ //Delete new path to ensure it does not exist
+ r = fs.Delete(path);
+ if(r != KErrNone && r != KErrNotFound && r != KErrPathNotFound)
+ safe_test(multipleTestDoer,r,__LINE__,pkgDoer.iLineCall);
+
+ if (wildcard)
+ {
+ _path.Delete(_path.Length()-1,1);
+ _path.AppendNum(9);
+ }
+
+ RFile file;
+ r = file.Replace(fs, _path, EFileWrite);
+ safe_test(multipleTestDoer,r,__LINE__,pkgDoer.iLineCall);
+
+ if (wildcard)
+ {
+ for(TInt i = 1; i <= pkgDoer.iIterations; i++)
+ {
+ path.Delete(path.Length()-1,1);
+ path.AppendNum(i);
+ multipleTestDoer.Printf(_L("File Rename - %S (%d)\n"),&path,threadID);
+ r = file.Rename(path);
+ safe_test(multipleTestDoer,r,__LINE__,pkgDoer.iLineCall);
+ }
+ }
+ else
+ {
+ multipleTestDoer.Printf(_L("File Rename - (%d)\n"),threadID);
+ r = file.Rename(path);
+ safe_test(multipleTestDoer,r,__LINE__,pkgDoer.iLineCall);
+ }
+
+ file.Close();
+ r = fs.Delete(path);
+ safe_test(multipleTestDoer,r,__LINE__,pkgDoer.iLineCall);
+ break;
+ }
+ case t_notification::EFsRename_dir:
+ {
+ r = fs.MkDirAll(_path);
+ if(r != KErrNone && r != KErrAlreadyExists)
+ safe_test(multipleTestDoer,r,__LINE__,pkgDoer.iLineCall);
+
+ TBuf<45> newPath;
+ newPath.Copy(_path);
+ newPath.Delete(newPath.Length()-1,1);
+ newPath.AppendNum(0);
+ newPath.Append(KPathDelimiter);
+
+ //Delete new path to ensure it does not exist
+ r = fs.RmDir(newPath);
+ if(r != KErrNone && r != KErrNotFound && r != KErrPathNotFound)
+ safe_test(multipleTestDoer,r,__LINE__,pkgDoer.iLineCall);
+
+ multipleTestDoer.Printf(_L("RFs Rename Dir - (%d)\n"),threadID);
+ r = fs.Rename(_path,newPath);
+ safe_test(multipleTestDoer,r,__LINE__,pkgDoer.iLineCall);
+ break;
+ }
+ case t_notification::EFsDelete:
+ {
+ if (wildcard)
+ {
+ for(TInt i = 0; i < pkgDoer.iIterations; i++)
+ {
+ //Create/replace file
+ RFile file;
+ TBuf<40> path;
+ path.Append(basepath);
+ r = fs.MkDirAll(path);
+ if(r != KErrNone && r != KErrAlreadyExists)
+ safe_test(multipleTestDoer,r,__LINE__,pkgDoer.iLineCall);
+ path.AppendNum(i);
+ path.Append(_L(".txt"));
+ r = file.Replace(fs,path,EFileWrite);
+ safe_test(multipleTestDoer,r,__LINE__,pkgDoer.iLineCall);
+ file.Close();
+
+ //Delete file
+ multipleTestDoer.Printf(_L("RFs Delete - %S (%d)\n"),&path,threadID);
+ r = fs.Delete(path);
+ safe_test(multipleTestDoer,r,__LINE__,pkgDoer.iLineCall);
+
+ //Create file with a different extension which should not produce notifications
+ path.AppendNum(i);
+ r = file.Replace(fs,path,EFileWrite);
+ safe_test(multipleTestDoer,r,__LINE__,pkgDoer.iLineCall);
+ file.Close();
+
+ //Delete that file
+ multipleTestDoer.Printf(_L("RFs Delete - %S (%d)\n"),&path,threadID);
+ r = fs.Delete(path);
+ safe_test(multipleTestDoer,r,__LINE__,pkgDoer.iLineCall);
+ }
+ }
+ else
+ {
+ RFile file;
+ r = file.Replace(fs,_path,EFileWrite); //Make sure file exists
+ safe_test(multipleTestDoer,r,__LINE__,pkgDoer.iLineCall);
+ file.Close();
+
+ multipleTestDoer.Printf(_L("RFs Delete - (%d)\n"),threadID);
+ r = fs.Delete(_path);
+ safe_test(multipleTestDoer,r,__LINE__,pkgDoer.iLineCall);
+ }
+ break;
+ }
+ case t_notification::EFileSet:
+ {
+ RFile file;
+ r = file.Replace(fs,_path,EFileWrite);
+ safe_test(multipleTestDoer,r,__LINE__,pkgDoer.iLineCall);
+
+ multipleTestDoer.Printf(_L("File Set - (%d)\n"),threadID);
+ r = file.Set(TTime(0),KEntryAttHidden,KEntryAttReadOnly);
+ safe_test(multipleTestDoer,r,__LINE__,pkgDoer.iLineCall);
+
+ file.Close();
+ break;
+ }
+ case t_notification::EFileSetAtt:
+ case t_notification::EAllOps4:
+ {
+ RFile file;
+ r = file.Replace(fs,_path,EFileWrite);
+ safe_test(multipleTestDoer,r,__LINE__,pkgDoer.iLineCall);
+
+ multipleTestDoer.Printf(_L("File SetAtt - (%d)\n"),threadID);
+ r = file.SetAtt(KEntryAttHidden,KEntryAttReadOnly);
+ safe_test(multipleTestDoer,r,__LINE__,pkgDoer.iLineCall);
+
+ file.Close();
+ r = fs.Delete(_path);
+ safe_test(multipleTestDoer,r,__LINE__,pkgDoer.iLineCall);
+ break;
+ }
+ case t_notification::EFileSetAtt_subs:
+ {
+ if (wildcard)
+ {
+ TBuf<40> path;
+ path.Append(basepath);
+ path.Append(_L("SubDir\\"));
+ r = fs.MkDirAll(path);
+ if(r != KErrNone && r != KErrAlreadyExists)
+ safe_test(multipleTestDoer,r,__LINE__,pkgDoer.iLineCall);
+
+ //Create/replace files and set their attributes
+ for(TInt i = 0; i < pkgDoer.iIterations; i++)
+ {
+ RFile file;
+ TBuf<40> dirPath;
+ dirPath.Append(path);
+ dirPath.AppendNum(i);
+ dirPath.Append(_L(".ext"));
+ r = file.Replace(fs, dirPath, EFileWrite);
+ safe_test(multipleTestDoer,r,__LINE__,pkgDoer.iLineCall);
+
+ multipleTestDoer.Printf(_L("File SetAtt Subs - %d.ext - (%d)\n"),i,threadID);
+ r = file.SetAtt(KEntryAttHidden,KEntryAttReadOnly);
+ safe_test(multipleTestDoer,r,__LINE__,pkgDoer.iLineCall);
+
+ file.Close();
+ r = fs.Delete(dirPath);
+ safe_test(multipleTestDoer,r,__LINE__,pkgDoer.iLineCall);
+ }
+ }
+ break;
+ }
+ case t_notification::EFsSetEntry:
+ {
+ RFile file;
+ r = file.Replace(fs,_path,EFileWrite);
+ safe_test(multipleTestDoer,r,__LINE__,pkgDoer.iLineCall);
+ file.Close();
+
+ multipleTestDoer.Printf(_L("RFs SetEntry - (%d)\n"),threadID);
+ r = fs.SetEntry(_path,TTime(0),KEntryAttHidden,KEntryAttReadOnly);
+ safe_test(multipleTestDoer,r,__LINE__,pkgDoer.iLineCall);
+ break;
+ }
+ case t_notification::EDismount:
+ {
+ multipleTestDoer.Printf(_L("DismountFileSystem - (%d)\n"),threadID);
+ r = fs.DismountFileSystem(pkgDoer.iFileName,globalDriveNum);
+ safe_test(multipleTestDoer,r,__LINE__,pkgDoer.iLineCall);
+ break;
+ }
+ case t_notification::EMount:
+ {
+ multipleTestDoer.Printf(_L("MountFileSystem - (%d)\n"),threadID);
+ r = fs.MountFileSystem(pkgDoer.iFileName,globalDriveNum);
+ safe_test(multipleTestDoer,r,__LINE__,pkgDoer.iLineCall);
+ break;
+ }
+ case t_notification::EMountScan:
+ {
+ multipleTestDoer.Printf(_L("DismountFileSystem - (%d)\n"),threadID);
+ r = fs.DismountFileSystem(pkgDoer.iFileName,globalDriveNum);
+ safe_test(multipleTestDoer,r,__LINE__,pkgDoer.iLineCall);
+ TBool isMount;
+ multipleTestDoer.Printf(_L("MountFileSystemAndScan - (%d)\n"),threadID);
+ r = fs.MountFileSystemAndScan(pkgDoer.iFileName,globalDriveNum,isMount);
+ if(!isMount)
+ safe_test(multipleTestDoer,KErrGeneral,__LINE__,pkgDoer.iLineCall);
+ safe_test(multipleTestDoer,r,__LINE__,pkgDoer.iLineCall);
+ break;
+ }
+ case t_notification::EMountDismount:
+ {
+ for(TInt i = 0; i < pkgDoer.iIterations; i++)
+ {
+ multipleTestDoer.Printf(_L("DismountFileSystem - (%d)\n"),threadID);
+ r = fs.DismountFileSystem(pkgDoer.iFileName,globalDriveNum);
+ safe_test(multipleTestDoer,r,__LINE__,pkgDoer.iLineCall);
+
+ multipleTestDoer.Printf(_L("MountFileSystem - (%d)\n"),threadID);
+ r = fs.MountFileSystem(pkgDoer.iFileName,globalDriveNum);
+ safe_test(multipleTestDoer,r,__LINE__,pkgDoer.iLineCall);
+ }
+ break;
+ }
+ case t_notification::EFormat:
+ {
+ RFormat format;
+ TInt count = -1;
+ TBuf<2> driveDes;
+ driveDes.Append(pkgDoer.iFileName);
+ driveDes.Append((TChar)':');
+ format.Open(fs,driveDes,EQuickFormat,count);
+ multipleTestDoer.Printf(_L("Format - (%d)\n"),threadID);
+ while(count != 0)
+ {
+ format.Next(count);
+ }
+ format.Close();
+
+ break;
+ }
+ case t_notification::EMediaCardRemoval:
+ case t_notification::EMediaCardInsertion:
+ {
+ //These are MANUAL tests, they require the removal/insertion of the media card
+ //Instructions are given out in the watcher thread
+ break;
+ }
+ case t_notification::ESetDriveName:
+ {
+ for(TInt i = 0; i < pkgDoer.iIterations; i++)
+ {
+ multipleTestDoer.Printf(_L("SetDriveName - MyDrive\n"));
+ _LIT(KDriveName,"MyDrive");
+ r = fs.SetDriveName(globalDriveNum,KDriveName);
+ safe_test(multipleTestDoer,r,__LINE__,pkgDoer.iLineCall);
+
+ multipleTestDoer.Printf(_L("SetDriveName - MyDrive2\n"));
+ _LIT(KDriveName2,"MyDrive2");
+ r = fs.SetDriveName(globalDriveNum,KDriveName2);
+ safe_test(multipleTestDoer,r,__LINE__,pkgDoer.iLineCall);
+ }
+ break;
+ }
+ case t_notification::ERawDiskWrite:
+ {
+ RRawDisk rawdisk;
+ TInt drive = 0;
+ TBuf<1> driveDes;
+ driveDes.Append(pkgDoer.iFileName);
+ RFs::CharToDrive(pkgDoer.iFileName[0],drive);
+ r = rawdisk.Open(fs,drive);
+ safe_test(multipleTestDoer,r,__LINE__,pkgDoer.iLineCall);
+
+ //Read some data
+ TBuf8<10> readData;
+ r = rawdisk.Read(0,readData);
+ safe_test(multipleTestDoer,r,__LINE__,pkgDoer.iLineCall);
+
+ //Write it back
+ TPtrC8 dataPtr(readData);
+ r = rawdisk.Write((TInt64)0,dataPtr);
+ safe_test(multipleTestDoer,r,__LINE__,pkgDoer.iLineCall);
+ rawdisk.Close();
+ break;
+ }
+ case t_notification::ESetVolumeLabel:
+ {
+ for(TInt i = 0; i < pkgDoer.iIterations; i++)
+ {
+ multipleTestDoer.Printf(_L("SetVolumeLabel - MyVolume\n"));
+ _LIT(KVolumeLabel,"MyVolume");
+ r = fs.SetVolumeLabel(KVolumeLabel,globalDriveNum);
+ safe_test(multipleTestDoer,r,__LINE__,pkgDoer.iLineCall);
+
+ multipleTestDoer.Printf(_L("SetVolumeLabel - MyVolume2\n"));
+ _LIT(KVolumeLabel2,"MyVolume2");
+ r = fs.SetVolumeLabel(KVolumeLabel2,globalDriveNum);
+ safe_test(multipleTestDoer,r,__LINE__,pkgDoer.iLineCall);
+ }
+ break;
+ }
+ case t_notification::EFsRmDir:
+ {
+ r = fs.MkDirAll(_path); //Make sure directory exists
+ if(r != KErrNone && r != KErrAlreadyExists)
+ safe_test(multipleTestDoer,r,__LINE__,pkgDoer.iLineCall);
+ multipleTestDoer.Printf(_L("RFs RmDir - Remove directory\n"));
+ r = fs.RmDir(_path);
+ safe_test(multipleTestDoer,r,__LINE__,pkgDoer.iLineCall);
+ break;
+ }
+ case t_notification::EFsRmDir_wild:
+ {
+ if (wildcard)
+ {
+ TBuf<40> path;
+ path.Append(basepath);
+ path.Append(_L("SubDir\\"));
+ r = fs.MkDirAll(path);
+ if(r != KErrNone && r != KErrAlreadyExists)
+ safe_test(multipleTestDoer,r,__LINE__,pkgDoer.iLineCall);
+
+ multipleTestDoer.Printf(_L("RFs RmDir - Remove directory\n"));
+ r = fs.RmDir(path);
+ safe_test(multipleTestDoer,r,__LINE__,pkgDoer.iLineCall);
+ break;
+ }
+ }
+ case t_notification::EFsRmDir_nonEmpty:
+ case t_notification::EFsMkDir:
+ {
+ TBuf<50> path;
+ path.Append(_path);
+ path.Append(pkgDoer.iFileName); //Append another sub-directory
+ multipleTestDoer.Printf(_L("RFs RmDir \n"));
+ r=fs.RmDir(path);
+ if(r != KErrNone && r != KErrPathNotFound && r != KErrNotFound)
+ safe_test(multipleTestDoer,r,__LINE__,pkgDoer.iLineCall);
+ r=fs.RmDir(_path);
+ if(r != KErrNone && r != KErrPathNotFound && r != KErrNotFound)
+ safe_test(multipleTestDoer,r,__LINE__,pkgDoer.iLineCall);
+
+ multipleTestDoer.Printf(_L("RFs MkDir \n"));
+ r=fs.MkDir(path);
+ multipleTestDoer (r==KErrPathNotFound);
+ r=fs.MkDir(_path);
+ safe_test(multipleTestDoer,r,__LINE__,pkgDoer.iLineCall);
+ r=fs.MkDir(path);
+ safe_test(multipleTestDoer,r,__LINE__,pkgDoer.iLineCall);
+
+ multipleTestDoer.Printf(_L("RFs RmDir nonEmpty - Full path: %S"),&_path);
+ r = fs.RmDir(_path);
+ if(r != KErrInUse)
+ safe_test(multipleTestDoer,KErrGeneral,__LINE__,pkgDoer.iLineCall);
+
+ r = fs.RmDir(path);
+ safe_test(multipleTestDoer,r,__LINE__,pkgDoer.iLineCall);
+
+ multipleTestDoer.Printf(_L("RFs EFsRmDir_nonEmpty - Full path: %S"),&_path);
+ r = fs.RmDir(_path);
+ safe_test(multipleTestDoer,r,__LINE__,pkgDoer.iLineCall);
+
+ break;
+ }
+ case t_notification::EAllOps6:
+ {
+ //Set drive name to TestDrive
+ multipleTestDoer.Printf(_L("SetDriveName - TestDrive\n"));
+ _LIT(KDriveName,"TestDrive");
+ r = fs.SetDriveName(globalDriveNum,KDriveName);
+ safe_test(multipleTestDoer,r,__LINE__,pkgDoer.iLineCall);
+ //Set volume label to TestVolume
+ multipleTestDoer.Printf(_L("SetVolumeLabel - TestVolume\n"));
+ _LIT(KVolumeLabel,"TestVolume");
+ r = fs.SetVolumeLabel(KVolumeLabel,globalDriveNum);
+ safe_test(multipleTestDoer,r,__LINE__,pkgDoer.iLineCall);
+ break;
+ }
+ case t_notification::ECFileManMove:
+ {
+ CTrapCleanup* cleanup;
+ cleanup = CTrapCleanup::New();
+
+ multipleTestDoer.Printf(_L("Doer - ECFileManMove_part1\n"));
+
+ //Stage 1 - Create File & write some data
+ RFile file;
+ r = file.Replace(fs,_path,EFileWrite);
+ safe_test(multipleTestDoer,r,__LINE__,pkgDoer.iLineCall);
+ r = file.SetSize(4);
+ safe_test(multipleTestDoer,r,__LINE__,pkgDoer.iLineCall);
+ file.Close();
+
+ CFileMan* cfman = NULL;
+ TRAP(r, cfman = CFileMan::NewL(fs);)
+ test(r == KErrNone);
+ test(cfman != NULL);
+ TBuf<40> unmonitored_path;
+ unmonitored_path.Append(gDriveToTest);
+ unmonitored_path.Append(_L(":\\F32-TST\\"));
+ unmonitored_path.Append(pkgDoer.iString);
+
+ //Stage 2 - Move to unmonitored Dir
+ //Rename 1
+ r = cfman->Move(_path,unmonitored_path);
+ safe_test(multipleTestDoer,r,__LINE__,pkgDoer.iLineCall);
+
+ //SetSize (size := 8)
+ RFile file2;
+ r = file2.Open(fs,unmonitored_path,EFileWrite);
+ safe_test(multipleTestDoer,r,__LINE__,pkgDoer.iLineCall);
+ r = file2.SetSize(8);
+ safe_test(multipleTestDoer,r,__LINE__,pkgDoer.iLineCall);
+ file2.Flush();
+ file2.Close();
+
+ //Stage 3 - Move back to monitored Dir
+ //Rename 2
+ r = cfman->Move(unmonitored_path,_path);
+ safe_test(multipleTestDoer,r,__LINE__,pkgDoer.iLineCall);
+
+ //Stage 4 - Delete
+ //Delete
+ r = cfman->Delete(_path);
+ safe_test(multipleTestDoer,r,__LINE__,pkgDoer.iLineCall);
+
+ delete cleanup;
+ delete cfman;
+ break;
+ }
+ default:
+ {
+ break;
+ }
+ }
+
+ fs.Close();
+ multipleTestDoer.End();
+ multipleTestDoer.Close();
+ return KErrNone;
+ }
+
+/*
+ * Test process Capabilites tries to set up filters on the
+ * the private folder for uid 01234567.
+ * This function returns the results to trying to add filters on the specified path.
+ *
+ * There are three MMP files:
+ * t_notifier_nocaps.mmp, t_notifier_allfiles.mmp, t_notifier_belongs.mmp
+ *
+ * t_notifier_nocaps.mmp -
+ * This process does not have any capabilites, so should not be allowed to set the filter.
+ * t_notifier_allfiles.mmp -
+ * This process has ALLFILES capability, so should
+ * t_notifier_belongs.mmp -
+ * This process is process with UID 01234567 so this should work too.
+ *
+ * See: f32test\server\t_notifier_caps.cpp
+ */
+TInt TestProcessCapabilities(const TDesC& aProcessName)
+ {
+ RProcess process;
+ TUidType uid;
+ TPtrC command((TText*)&gDriveToTest,1);
+ TInt r = process.Create(aProcessName,command,uid);
+ test(r==KErrNone);
+ process.Resume();
+ TRequestStatus s1;
+ TRequestStatus s2;
+ RTimer tim;
+ r = tim.CreateLocal();
+ test(r==KErrNone);
+ TTimeIntervalMicroSeconds32 delay = 5000000; //5 seconds
+ tim.After(s1,delay);
+ process.Logon(s2);
+ User::WaitForRequest(s1,s2);
+ test(s2.Int()!=KRequestPending);
+ r = process.ExitReason();
+ process.Close();
+ return r;
+ }
+
+/*
+ * Creates a file and writes to it twice.
+ * Used in TestTwoNotificationsL().
+ */
+TInt TwoNotificationsTFDoer(TAny* aAny)
+ {
+ RTest testDoer(_L("TestTwoNotificationsThreadFunctionDoer"));
+ testDoer.Start(_L("TestTwoNotificationsThreadFunctionDoer"));
+
+ SThreadPackageMultiple package = *(SThreadPackageMultiple*)aAny;
+ TBuf<40> path;
+ path.Append(gDriveToTest);
+ path.Append(_L(":\\F32-TST\\T_NOTIFIER\\")); //len=22
+ path.Append(package.iFileName);
+
+ //Delete file so we definitely get a create notification
+ RFs fs;
+ TInt r = fs.Connect();
+ testDoer(r==KErrNone);
+ r = fs.Delete(path);
+ testDoer(r==KErrNone || r==KErrPathNotFound || r==KErrNotFound);
+ r = fs.MkDirAll(path);
+ testDoer(r==KErrNone || r==KErrAlreadyExists);
+
+ testDoer.Printf(_L("TestTwoNotificationsThreadFunctionDoer - Create File %S\n"),&path);
+ //Create file
+ RFile file;
+ r = file.Create(fs,path,EFileWrite);
+ testDoer(r == KErrNone);
+
+ testDoer.Printf(_L("TestTwoNotificationsThreadFunctionDoer - Size File 1 %S\n"),&path);
+ TInt fileSize = 0;
+ r = file.Size(fileSize);
+ testDoer(r == KErrNone);
+ testDoer(fileSize==0);
+
+ testDoer.Printf(_L("TestTwoNotificationsThreadFunctionDoer - Write File 1 %S\n"),&path);
+ r = file.Write(_L8("1234"));
+ testDoer(r == KErrNone);
+ testDoer.Printf(_L("TestTwoNotificationsThreadFunctionDoer - Size File 2 %S\n"),&path);
+ r = file.Size(fileSize);
+ testDoer(r == KErrNone);
+ test(fileSize==4);
+
+ testDoer.Printf(_L("TestTwoNotificationsThreadFunctionDoer - Write File 2 %S\n"),&path);
+ r = file.Write(_L8("5678"));
+ testDoer(r == KErrNone);
+ testDoer.Printf(_L("TestTwoNotificationsThreadFunctionDoer - Size File 3 %S\n"),&path);
+ r = file.Size(fileSize);
+ testDoer(r == KErrNone);
+ test(fileSize==8);
+
+ file.Close();
+
+ fs.Close();
+ testDoer.End();
+ testDoer.Close();
+ return KErrNone;
+ }
+
+ /*
+ * The following enum are for the CFileMan test
+ */
+ enum TCFsManEnum
+ {
+ ECFManCreate1 = 0x01,
+ ECFManWrite1 = 0x02,
+ ECFManDelete1 = 0x04,
+ ECFManCreate2 = 0x08,
+ ECFManSetSize1 = 0x10,
+ ECFManWrite2 = 0x20,
+ ECFManAtt1 = 0x40,
+ ECFManDelete2 = 0x80,
+ //Either a create, copy, delete (above - not supported in test)
+ //or rename operation (below)
+ ECFManRename1 = 0x100,
+ ECFManRename2 = 0x200
+ };
+
+/*
+ * Used by MultipleNotificationsTFWatcher() to test the notifications.
+ */
+void HandleMultipleNotifications(RTest& aTest, SThreadPackageMultiple& aPackage, CFsNotify* notify, TDesC& aFullname)
+ {
+ RThread thread;
+ TUint64 threadID = thread.Id().Id();
+ TInt numNotifications = 0;
+ TInt64 fileSize = 0;
+ TBool overflow = EFalse;
+
+ TInt scratch = 0;
+
+ for(TInt i = 0; i < aPackage.iMaxNotifications; ) //Outer-loop to control when we should exit
+ {
+ aTest.Printf(_L("(%d) - NextNotification\n"),threadID);
+ const TFsNotification* notification = notify->NextNotification();
+ while(notification != NULL)
+ {
+ numNotifications++;
+ aTest.Printf(_L("NumNotifications = %d\n"),numNotifications);
+ //Test notification is not null.
+ //We should be getting 1 notification.
+ aTest(notification != NULL);
+
+ aTest.Printf(_L("(%d) - Notification Type\n"),threadID);
+ TFsNotification::TFsNotificationType notificationType = notification->NotificationType();
+ aTest(notificationType & aPackage.iNotifyType ||
+ notificationType & TFsNotification::EOverflow);
+
+ aTest.Printf(_L("Notification Type = %u - (%d)\n"),notificationType,threadID);
+
+ if(notificationType != TFsNotification::EOverflow)
+ {
+ aTest.Printf(_L("(%d) - Notification Path\n"),threadID);
+ TPtrC _pathC;
+ ((TFsNotification*) notification)->Path(_pathC);
+ aTest.Printf(_L("%S - (%d)\n"),&_pathC,threadID);
+
+ if(aPackage.iOperation == t_notification::ECFileManMove
+ && (scratch == (ECFManWrite1 | ECFManCreate1)))
+ {
+ TChar drive = gDriveToTest;
+ TBuf<40> unmodified_path;
+ unmodified_path.Append(drive);
+ unmodified_path.Append(_L(":\\F32-TST\\"));
+ unmodified_path.Append(_L("cf1le.man"));
+ ((TFsNotification*) notification)->NewName(_pathC);
+ TInt matches = _pathC.Match(unmodified_path);
+ safe_test(aTest,matches,__LINE__,aPackage.iLineCall);
+ }
+ else if((scratch == (ECFManWrite1 | ECFManCreate1 | ECFManRename1)))
+ {
+ ((TFsNotification*) notification)->NewName(_pathC);
+ safe_test(aTest,_pathC.Match(aFullname),__LINE__,aPackage.iLineCall);
+ }
+ else
+ {
+ safe_test(aTest,_pathC.Match(aFullname),__LINE__,aPackage.iLineCall);
+ }
+
+ }
+ else
+ {
+ aTest.Printf(_L("(%d) - OVERFLOW\n"),threadID);
+ //Overflow
+ overflow = ETrue;
+ return;
+ }
+
+ //notificationType will only be of 1 type
+ if(notificationType == TFsNotification::EFileChange)
+ {
+ if(!(((aPackage.iNotifyType & TFsNotification::EFileChange) == TFsNotification::EFileChange) &&
+ (aPackage.iOperation == t_notification::EFileWrite ||
+ aPackage.iOperation == t_notification::EFileWrite_async ||
+ aPackage.iOperation == t_notification::EFileWrite_samesize ||
+ aPackage.iOperation == t_notification::EFileSetSize ||
+ aPackage.iOperation == t_notification::ECFileManMove ||
+ aPackage.iOperation == t_notification::EAllOps2 ||
+ aPackage.iOperation == t_notification::EAllOps3)))
+ safe_test(aTest,KErrGeneral,__LINE__,aPackage.iLineCall);
+
+ if (aPackage.iOperation == t_notification::ECFileManMove)
+ {
+ ((TFsNotification*) notification)->FileSize(fileSize);
+ //File just been created and written to.
+ if(fileSize == 4)
+ {
+ scratch |= ECFManWrite1;
+ }
+ else if(fileSize == 8)
+ {
+ scratch |= ECFManWrite2;
+ }
+ }
+ else if (aPackage.iNotifyType == TFsNotification::EFileChange)
+ {
+ ((TFsNotification*) notification)->FileSize(fileSize);
+ aTest.Printf(_L("Filesize - %d (%d)\n"),fileSize,threadID);
+ //A notification is received every time the size is changed
+ //due to the flushing
+ if (aPackage.iOperation == t_notification::EFileWrite_async)
+ {
+ //We write 52 letters
+ if(fileSize != 52*(i+1))
+ safe_test(aTest,KErrGeneral,__LINE__,aPackage.iLineCall);
+ }
+ else if (aPackage.iOperation == t_notification::EFileWrite_samesize)
+ {
+ //Only 4 letters in file
+ if(fileSize != 4)
+ safe_test(aTest,KErrGeneral,__LINE__,aPackage.iLineCall);
+ }
+ else if (i < aPackage.iIterations)
+ {
+ //We write/increase size by 4 letters/bytes
+ if(fileSize != 4*(i+1))
+ safe_test(aTest,KErrGeneral,__LINE__,aPackage.iLineCall);
+ }
+ else
+ {
+ //We decrease size by 4 bytes
+ if(fileSize != 4*(aPackage.iMaxNotifications-i))
+ safe_test(aTest,KErrGeneral,__LINE__,aPackage.iLineCall);
+ }
+ }
+ }
+ else if(notificationType == TFsNotification::ECreate)
+ {
+ if(!(((aPackage.iNotifyType & TFsNotification::ECreate) == TFsNotification::ECreate) &&
+ (aPackage.iOperation == t_notification::EFileCreate ||
+ aPackage.iOperation == t_notification::EFileReplace ||
+ aPackage.iOperation == t_notification::EFileCreate_subs ||
+ aPackage.iOperation == t_notification::EFileCreate_subs_nowatch ||
+ aPackage.iOperation == t_notification::EFileCreate_txt_nowatch ||
+ aPackage.iOperation == t_notification::EFileCreate_txt ||
+ aPackage.iOperation == t_notification::EFsMkDir ||
+ aPackage.iOperation == t_notification::ECFileManMove ||
+ aPackage.iOperation == t_notification::EAllOps1 ||
+ aPackage.iOperation == t_notification::EAllOps2 ||
+ aPackage.iOperation == t_notification::EAllOps3 ||
+ aPackage.iOperation == t_notification::EAllOps4 ||
+ aPackage.iOperation == t_notification::EAllOps5)))
+ safe_test(aTest,KErrGeneral,__LINE__,aPackage.iLineCall);
+ if (aPackage.iOperation == t_notification::EFileCreate_txt)
+ {
+ //Check filename is of correct extension
+ TPtrC _path;
+ ((TFsNotification*) notification)->Path(_path);
+ TBuf<5> _ext;
+ _ext.Append(_L(".txt"));
+ TBuf<5> ext;
+ ext.Append(_path.Right(4));
+ safe_test(aTest,ext.Match(_ext),__LINE__,aPackage.iLineCall);
+ }
+ else if (aPackage.iOperation == t_notification::ECFileManMove)
+ {
+ if(scratch & ECFManCreate1)
+ {
+ scratch |= ECFManCreate2; //File created second time
+ }
+ else
+ {
+ scratch |= ECFManCreate1; //File created first time
+ }
+ }
+ }
+ else if(notificationType == TFsNotification::EDelete)
+ {
+ if(!(((aPackage.iNotifyType & TFsNotification::EDelete) == TFsNotification::EDelete) &&
+ (aPackage.iOperation == t_notification::EFsDelete ||
+ aPackage.iOperation == t_notification::EFsRmDir ||
+ aPackage.iOperation == t_notification::EFsRmDir_nonEmpty ||
+ aPackage.iOperation == t_notification::EFsRmDir_wild ||
+ aPackage.iOperation == t_notification::ECFileManMove ||
+ aPackage.iOperation == t_notification::EAllOps1 ||
+ aPackage.iOperation == t_notification::EAllOps2 ||
+ aPackage.iOperation == t_notification::EAllOps3 ||
+ aPackage.iOperation == t_notification::EAllOps4)))
+ safe_test(aTest,KErrGeneral,__LINE__,aPackage.iLineCall);
+
+ if(aPackage.iOperation == t_notification::ECFileManMove)
+ {
+ if(scratch & ECFManDelete1)
+ {
+ scratch |= ECFManDelete2;
+ }
+ else
+ {
+ scratch |= ECFManDelete1;
+ }
+ }
+ }
+ else if(notificationType == TFsNotification::ERename)
+ {
+ if(!(((aPackage.iNotifyType & TFsNotification::ERename) == TFsNotification::ERename) &&
+ (aPackage.iOperation == t_notification::EFileRename ||
+ aPackage.iOperation == t_notification::EFileRename_wild ||
+ aPackage.iOperation == t_notification::EFsReplace ||
+ aPackage.iOperation == t_notification::ECFileManMove ||
+ aPackage.iOperation == t_notification::EFsRename ||
+ aPackage.iOperation == t_notification::EFsRename_dir ||
+ aPackage.iOperation == t_notification::EAllOps5)))
+ safe_test(aTest,KErrGeneral,__LINE__,aPackage.iLineCall);
+ TPtrC newnameC;
+ ((TFsNotification*)notification)->NewName(newnameC);
+ aTest.Printf(_L("%S - (%d)\n"),&newnameC,threadID);
+
+ TPtrC _pathC;
+ ((TFsNotification*) notification)->Path(_pathC);
+
+ TBuf<40> _path;
+ _path.Copy(_pathC);
+
+ if (aPackage.iOperation == t_notification::EFsRename_dir)
+ {
+ _path.Delete(_path.Length()-1,1);
+ _path.AppendNum(0);
+ _path.Append(KPathDelimiter);
+ }
+ else if (aPackage.iOperation == t_notification::EFileRename_wild)
+ {
+ _path.Delete(_path.Length()-1,1);
+ _path.AppendNum(numNotifications);
+ }
+ else
+ {
+ _path.AppendNum(0);
+ }
+
+ if(aPackage.iOperation != t_notification::ECFileManMove)
+ {
+ safe_test(aTest,newnameC.Match(_path),__LINE__,aPackage.iLineCall);
+ }
+ else if(scratch & ECFManRename1)
+ {
+ scratch |= ECFManRename2;
+ }
+ else
+ {
+ scratch |= ECFManRename1;
+ }
+
+ }
+ else if(notificationType == TFsNotification::EAttribute)
+ {
+ if(!(((aPackage.iNotifyType & TFsNotification::EAttribute) == TFsNotification::EAttribute) &&
+ (aPackage.iOperation == t_notification::EFsSetEntry ||
+ aPackage.iOperation == t_notification::EFileSet ||
+ aPackage.iOperation == t_notification::EFileSetAtt ||
+ aPackage.iOperation == t_notification::EFileSetAtt_subs ||
+ aPackage.iOperation == t_notification::ECFileManMove ||
+ aPackage.iOperation == t_notification::EAllOps4)))
+ safe_test(aTest,KErrGeneral,__LINE__,aPackage.iLineCall);
+ TUint setAtt = 0;
+ TUint clearAtt = 0;
+ ((TFsNotification*) notification)->Attributes(setAtt, clearAtt);
+
+ if(aPackage.iOperation == t_notification::ECFileManMove)
+ {
+ scratch |= ECFManAtt1;
+ }
+ else
+ {
+ if(setAtt != KEntryAttHidden)
+ safe_test(aTest,KErrGeneral,__LINE__,aPackage.iLineCall);
+ if(clearAtt != KEntryAttReadOnly)
+ safe_test(aTest,KErrGeneral,__LINE__,aPackage.iLineCall);
+ }
+ }
+ else if(notificationType == TFsNotification::EMediaChange)
+ {
+ if(!(((aPackage.iNotifyType & TFsNotification::EMediaChange) == TFsNotification::EMediaChange) &&
+ (aPackage.iOperation == t_notification::EMount ||
+ aPackage.iOperation == t_notification::EMountScan ||
+ aPackage.iOperation == t_notification::EDismount ||
+ aPackage.iOperation == t_notification::EMountDismount ||
+ aPackage.iOperation == t_notification::EMediaCardInsertion ||
+ aPackage.iOperation == t_notification::EMediaCardRemoval ||
+ aPackage.iOperation == t_notification::EFormat ||
+ aPackage.iOperation == t_notification::ECFileManMove ||
+ aPackage.iOperation == t_notification::ERawDiskWrite)))
+ safe_test(aTest,KErrGeneral,__LINE__,aPackage.iLineCall);
+ }
+ else if(notificationType == TFsNotification::EDriveName)
+ {
+ if(!(((aPackage.iNotifyType & TFsNotification::EDriveName) == TFsNotification::EDriveName) &&
+ (aPackage.iOperation == t_notification::ESetDriveName ||
+ aPackage.iOperation == t_notification::EAllOps6)))
+ safe_test(aTest,KErrGeneral,__LINE__,aPackage.iLineCall);
+ }
+ else if(notificationType == TFsNotification::EVolumeName)
+ {
+ if(!(((aPackage.iNotifyType & TFsNotification::EVolumeName) == TFsNotification::EVolumeName) &&
+ (aPackage.iOperation == t_notification::ESetVolumeLabel ||
+ aPackage.iOperation == t_notification::EAllOps6)))
+ safe_test(aTest,KErrGeneral,__LINE__,aPackage.iLineCall);
+
+ TPtrC newnameC;
+ ((TFsNotification*)notification)->NewName(newnameC);
+ aTest.Printf(_L("New volume name: %S - (%d)\n"),&newnameC,threadID);
+ }
+
+ i++;
+ notification = notify->NextNotification();
+ if (notification == NULL)
+ aTest.Printf(_L("Notification is NULL - (%d)\n"),threadID);
+ }
+
+ if(i==1) //First iteration will only ever get 1 notification
+ {
+ if(numNotifications != 1)
+ safe_test(aTest,KErrGeneral,__LINE__,aPackage.iLineCall);
+ }
+
+ if(numNotifications < aPackage.iMaxNotifications && !overflow) //Ensure we get all of the notifications we expected
+ {
+ TRequestStatus status;
+ notify->RequestNotifications(status);
+ User::WaitForRequest(status);
+ }
+ }
+
+ //0x307 = create1 | write1 | delete1 | rename1 | rename2
+ if(aPackage.iOperation == t_notification::ECFileManMove && (scratch != 0x307))
+ {
+ aTest.Printf(_L("CFileManMove test failure - scratch = 0x%x"),scratch);
+ safe_test(aTest,KErrGeneral,__LINE__,aPackage.iLineCall);
+ }
+
+ }
+
+/*
+ * Watches for changes in files/directories.
+ * Used in TestMultipleNotificationsL().
+ */
+TInt MultipleNotificationsTFWatcher(TAny* aAny)
+ {
+ CTrapCleanup* cleanup;
+ cleanup = CTrapCleanup::New();
+
+ RThread thread;
+ TUint64 threadID = thread.Id().Id();
+
+ SThreadPackageMultiple package = *(SThreadPackageMultiple*) aAny;
+ RTest multipleWatcherTest(_L("MultipleNotificationsTFWatcher"));
+ multipleWatcherTest.Start(_L("MultipleNotificationsTFWatcher"));
+
+ RFs fs;
+ fs.Connect();
+
+ multipleWatcherTest.Printf(_L("MultipleNotificationsTFWatcher (%d) - Create CFsNotify\n"),threadID);
+ CFsNotify* notify = NULL;
+ TRAPD(r,notify = CFsNotify::NewL(fs,package.iBufferSize));
+ safe_test(multipleWatcherTest,r,__LINE__,package.iLineCall);
+ TBuf<40> path;
+ TBuf<20> filename;
+ if(package.iNotifyType != TFsNotification::EMediaChange &&
+ package.iNotifyType != TFsNotification::EDriveName &&
+ package.iNotifyType != TFsNotification::EVolumeName &&
+ package.iOperation != t_notification::EAllOps6)
+ {
+ path.Append(gDriveToTest);
+ path.Append(_L(":\\F32-TST\\T_NOTIFIER\\")); //len=22
+ path.Append(package.iFileName);
+ filename.Append(package.iString);
+ }
+ else
+ {
+ path.Append((TChar)globalDriveNum+(TChar)'A');
+ path.Append(_L(":"));
+ }
+ TBuf<40> fullname;
+ fullname.Append(path);
+ fullname.Append(filename);
+
+ if (package.iNotifyType == TFsNotification::EVolumeName ||
+ package.iOperation == t_notification::EAllOps6)
+ {
+ //Ensure volume has no label
+ multipleWatcherTest.Printf(_L("Set volume label to nothing\n"));
+ r = fs.SetVolumeLabel(_L(""),globalDriveNum);
+ safe_test(multipleWatcherTest,r,__LINE__,package.iLineCall);
+ }
+
+ if (package.iNotifyType == TFsNotification::EDriveName ||
+ package.iOperation == t_notification::EAllOps6)
+ {
+ //Ensure drive has no name
+ multipleWatcherTest.Printf(_L("Set drive name to nothing\n"));
+ r = fs.SetDriveName(globalDriveNum,_L(""));
+ safe_test(multipleWatcherTest,r,__LINE__,package.iLineCall);
+ }
+
+ multipleWatcherTest.Printf(_L("MultipleNotificationsTFWatcher - Add Notification for path %S\n"),&path);
+ multipleWatcherTest.Printf(_L("Add Notification for type %u - (%d)\n"),(TUint)package.iNotifyType,threadID);
+ r = notify->AddNotification((TUint)package.iNotifyType,path,filename);
+ safe_test(multipleWatcherTest,r,__LINE__,package.iLineCall);
+
+ TRequestStatus status;
+ multipleWatcherTest.Printf(_L("(%d) - Request Notifications\n"),threadID);
+ r = notify->RequestNotifications(status);
+ safe_test(multipleWatcherTest,r,__LINE__,package.iLineCall);
+
+ if (package.iOperation == t_notification::EMediaCardRemoval)
+ {
+ multipleWatcherTest.Printf(_L("*****************************************************************\n"));
+ multipleWatcherTest.Printf(_L("Waiting 10 seconds.\n"));
+ multipleWatcherTest.Printf(_L("This is a MANUAL test, it requires the removal of the media card.\n"));
+ multipleWatcherTest.Printf(_L("PLEASE REMOVE THE MEDIA CARD. (DriveNumber %d)\n"),globalDriveNum);
+ multipleWatcherTest.Printf(_L("Or press Ctrl + F5 on the emulator.\n"));
+ multipleWatcherTest.Printf(_L("*****************************************************************\n"));
+ }
+ if (package.iOperation == t_notification::EMediaCardInsertion)
+ {
+ multipleWatcherTest.Printf(_L("*******************************************************************\n"));
+ multipleWatcherTest.Printf(_L("Waiting 10 seconds.\n"));
+ multipleWatcherTest.Printf(_L("This is a MANUAL test, it requires the insertion of the media card.\n"));
+ multipleWatcherTest.Printf(_L("PLEASE INSERT THE MEDIA CARD. (DriveNumber %d)\n"),globalDriveNum);
+ multipleWatcherTest.Printf(_L("*******************************************************************\n"));
+ }
+
+ multipleWatcherTest.Printf(_L("(%d) - Signal Test thread to start Doer thread\n"),threadID);
+ package.iBarrier.Signal();
+ User::WaitForRequest(status);
+
+ multipleWatcherTest.Printf(_L("(%d) - MultipleNotificationsTFWatcher Line %d\n"),threadID,__LINE__);
+
+ //Handles the notifications
+ HandleMultipleNotifications(multipleWatcherTest, package, notify, (TDesC&)fullname);
+
+ multipleWatcherTest.Printf(_L("(%d) - MultipleNotificationsTFWatcher Line %d\n"),threadID,__LINE__);
+
+ delete notify;
+ fs.Close();
+ multipleWatcherTest.End();
+ multipleWatcherTest.Close();
+ delete cleanup;
+ return KErrNone;
+ }
+
+/*
+ * TestTwoNotificationsL - Tests File Write, 1 Doer writes to a file twice.
+ * 1 Watcher watches for file write changes. Just so happens that the second one overflows.
+ */
+TInt TestTwoNotificationsL()
+ {
+ test.Next(_L("TestTwoNotifications"));
+
+ RFs fs;
+ fs.Connect();
+ RSemaphore twoNotificationsDoerBar;
+ SThreadPackageMultiple package;
+ _LIT(KFileName,"file0.write");
+ package.iIterations = 10;
+ package.iOperation = t_notification::EFileWrite;
+ package.iNotifyType = TFsNotification::EFileChange;
+ package.iFileName = KFileName;
+ package.iBufferSize = 100; //Should get changed to KMin... in CFsNotify::NewL
+
+ User::LeaveIfError(twoNotificationsDoerBar.CreateLocal(0));
+ User::LeaveIfError(package.iBarrier.CreateLocal(0));
+ RThread watcher;
+ RThread doer;
+
+ TInt r = watcher.Create(_L("TestTwoNotificationsWatcherThread"),MultipleNotificationsTFWatcher,KDefaultStackSize,KMinHeapSize,KMaxHeapSize,&package);
+ test(r==KErrNone);
+ r = doer.Create(_L("TestTwoNotificationsDoerThread"),TwoNotificationsTFDoer,KDefaultStackSize,KMinHeapSize,KMaxHeapSize,&package);
+ test(r==KErrNone);
+ test.Next(_L("TestTwoNotifications - Resume Watcher"));
+ watcher.Resume();
+ test.Next(_L("TestTwoNotifications - Wait for Watcher to be ready"));
+ package.iBarrier.Wait(); //Wait till Watcher has requested notification
+ test.Next(_L("TestTwoNotifications - Resume Doer"));
+ doer.Resume();
+
+ test.Next(_L("TestTwoNotifications - Wait for doer thread death"));
+ TRequestStatus status;
+ doer.Logon(status);
+ User::WaitForRequest(status);
+ test(doer.ExitReason()==KErrNone);
+
+ test.Next(_L("TestTwoNotifications - Wait for watcher thread death"));
+ watcher.Logon(status);
+ User::WaitForRequest(status);
+ test(watcher.ExitReason()==KErrNone);
+
+ CLOSE_AND_WAIT(doer);
+ CLOSE_AND_WAIT(watcher);
+
+ twoNotificationsDoerBar.Close();
+ package.iBarrier.Close();
+ fs.Close();
+
+ return KErrNone;
+ }
+
+
+/*
+ * Watch two threads to receive two notifications.
+ * Used in TestTwoDoersL().
+ */
+TInt TestTwoDoersWatcher(TAny* aAny)
+ {
+ CTrapCleanup* cleanup;
+ cleanup = CTrapCleanup::New();
+
+ RSemaphore& twoThreadsBarrier = *(RSemaphore*)aAny;
+ RTest twoThreadsWatcherTest(_L("TwoThreadsWatcher"));
+ twoThreadsWatcherTest.Start(_L("TwoThreadsWatcher"));
+
+ RFs fs;
+ fs.Connect();
+
+ twoThreadsWatcherTest.Next(_L("Create CFsNotify"));
+ CFsNotify* notify = NULL;
+ TRAPD(r,notify = CFsNotify::NewL(fs,200));
+ twoThreadsWatcherTest(r == KErrNone);
+
+ TBuf<40> path1;
+ TBuf<20> filename1;
+ TBuf<40> path2;
+ TBuf<20> filename2;
+ path1.Append(gDriveToTest);
+ path2.Append(gDriveToTest);
+ path1.Append(_L(":\\F32-TST\\T_NOTIFIER\\"));
+ filename1.Append(_L("file1.create"));
+ path2.Append(_L(":\\F32-TST\\T_NOTIFIER\\"));
+ filename2.Append(_L("file2.create"));
+ TBuf<40> fullname1;
+ fullname1.Append(path1);
+ fullname1.Append(filename1);
+ TBuf<40> fullname2;
+ fullname2.Append(path2);
+ fullname2.Append(filename2);
+
+ twoThreadsWatcherTest.Printf(_L("TwoThreadsWatcher - Add Notification for %S\n"),&path1);
+ r = notify->AddNotification((TUint)TFsNotification::ECreate,path1,filename1);
+ twoThreadsWatcherTest(r == KErrNone);
+
+ twoThreadsWatcherTest.Printf(_L("TwoThreadsWatcher - Add Notification for %S\n"),&path2);
+ r = notify->AddNotification((TUint)TFsNotification::ECreate,path2,filename2);
+ twoThreadsWatcherTest(r == KErrNone);
+
+ TRequestStatus status;
+ twoThreadsWatcherTest.Next(_L("TwoThreadsWatcher - Request Notifications"));
+ r = notify->RequestNotifications(status);
+ twoThreadsWatcherTest(r == KErrNone);
+
+ twoThreadsBarrier.Signal(); //Signal Doer threads to start
+ User::WaitForRequest(status);
+
+ // We should be getting 2 notifications
+ // Test notifications are not null and check notification types and paths
+ // 1st notification:
+ twoThreadsWatcherTest.Next(_L("TwoThreadsWatcher - First Notification"));
+ const TFsNotification* notification = notify->NextNotification();
+ twoThreadsWatcherTest(notification != NULL);
+ twoThreadsWatcherTest.Next(_L("TwoThreadsWatcher - First Notification Type"));
+ TFsNotification::TFsNotificationType notificationType = ((TFsNotification*)notification)->NotificationType();
+ twoThreadsWatcherTest(notificationType == TFsNotification::ECreate);
+ twoThreadsWatcherTest.Next(_L("TwoThreadsWatcher - First Notification Path"));
+ TPtrC _pathC;
+ ((TFsNotification*)notification)->Path(_pathC);
+ twoThreadsWatcherTest.Printf(_L("TwoThreadsWatcher - First Notification Path returned %S\n"),&_pathC);
+ TBuf<40> _path;
+ _path.Copy(_pathC);
+ //We can't guarantee which thread ran first so check that it was either path1 or path2
+ twoThreadsWatcherTest(_path.Match(fullname1) == KErrNone || _path.Match(fullname2) == KErrNone);
+
+ // 2nd notification:
+ twoThreadsWatcherTest.Next(_L("TwoThreadsWatcher - Second Notification"));
+ notification = notify->NextNotification();
+ // Check if next notification exists
+ if (!notification)
+ {
+ notify->RequestNotifications(status);
+ User::WaitForRequest(status);
+ notification = notify->NextNotification();
+ }
+ twoThreadsWatcherTest(notification != NULL);
+ twoThreadsWatcherTest.Next(_L("TwoThreadsWatcher - Second Notification Type"));
+ notificationType = ((TFsNotification*)notification)->NotificationType();
+ twoThreadsWatcherTest(notificationType == TFsNotification::ECreate);
+ twoThreadsWatcherTest.Next(_L("TwoThreadsWatcher - Second Notification Path"));
+ ((TFsNotification*)notification)->Path(_pathC);
+ twoThreadsWatcherTest.Printf(_L("TwoThreadsWatcher - Second Notification Path returned %S\n"),&_pathC);
+ _path.Copy(_pathC);
+ twoThreadsWatcherTest(_path.Match(fullname1) == KErrNone || _path.Match(fullname2) == KErrNone);
+
+ delete notify;
+ fs.Close();
+ twoThreadsWatcherTest.End();
+ twoThreadsWatcherTest.Close();
+ delete cleanup;
+ return KErrNone;
+ }
+
+/*
+ * TestTwoDoersL - Two Doer threads create a file each and there's one Watcher
+ * which expects two notifications (one from each Doer).
+ */
+TInt TestTwoDoersL()
+ {
+ test.Next(_L("TestTwoDoers"));
+
+ RFs fs;
+ fs.Connect();
+
+ _LIT(KFileName1,"file1.create");
+ _LIT(KFileName2,"file2.create");
+ RSemaphore simpleBarrierTest;
+ SThreadPackage pkgDoer1;
+ SThreadPackage pkgDoer2;
+ pkgDoer1.iFileName = KFileName1;
+ pkgDoer2.iFileName = KFileName2;
+
+ User::LeaveIfError(pkgDoer1.iBarrier.CreateLocal(0));
+ User::LeaveIfError(pkgDoer2.iBarrier.CreateLocal(0));
+ User::LeaveIfError(simpleBarrierTest.CreateLocal(0));
+ RThread watcher;
+ RThread doer1;
+ RThread doer2;
+
+ watcher.Create(_L("TestTwoDoers-WatcherThread"),TestTwoDoersWatcher,KDefaultStackSize,KMinHeapSize,KMaxHeapSize,&simpleBarrierTest);
+ doer1.Create(_L("TestTwoDoers-DoerThread1"),SimpleSingleNotificationTFDoer,KDefaultStackSize,KMinHeapSize,KMaxHeapSize,&pkgDoer1);
+ doer2.Create(_L("TestTwoDoers-DoerThread2"),SimpleSingleNotificationTFDoer,KDefaultStackSize,KMinHeapSize,KMaxHeapSize,&pkgDoer2);
+ watcher.Resume();
+ simpleBarrierTest.Wait(); //Wait until Watcher has created CFsNotify
+
+ doer1.Resume();
+ doer2.Resume();
+
+ test.Next(_L("TestTwoDoers - Wait for doer1 thread death"));
+ TRequestStatus status;
+ doer1.Logon(status);
+ User::WaitForRequest(status);
+ test(doer1.ExitReason()==KErrNone);
+
+ test.Next(_L("TestTwoDoers - Wait for doer2 thread death"));
+ doer2.Logon(status);
+ User::WaitForRequest(status);
+ test(doer2.ExitReason()==KErrNone);
+
+ test.Next(_L("TestTwoDoers - Wait for watcher thread death"));
+ watcher.Logon(status);
+ RTimer timer1;
+ TInt r = timer1.CreateLocal();
+ safe_test(test,r,__LINE__,(TText*)Expand("t_notifier.cpp"));
+ TRequestStatus timeout;
+ TTimeIntervalMicroSeconds32 time = 10000000; //10 seconds
+ timer1.After(timeout,time);
+ User::WaitForRequest(timeout,status);
+ test(status.Int() != KRequestPending);
+ timer1.Cancel();
+ timer1.Close();
+ //User::WaitForRequest(status);
+ test(watcher.ExitReason()==KErrNone);
+
+ CLOSE_AND_WAIT(doer1);
+ CLOSE_AND_WAIT(doer2);
+ CLOSE_AND_WAIT(watcher);
+
+ pkgDoer1.iBarrier.Close();
+ pkgDoer2.iBarrier.Close();
+ simpleBarrierTest.Close();
+ fs.Close();
+ return KErrNone;
+ }
+
+/*
+ * TestTwoWatchersL - Uses two watcher threads and one doer thread to test that running
+ * two distinct sub sessions at the same time (both watch the same file).
+ */
+TInt TestTwoWatchersL()
+ {
+ test.Next(_L("TestTwoWatchers"));
+ RFs fs;
+ fs.Connect();
+ _LIT(KFileName,"file.creat3");
+ SThreadPackage pkgDoer;
+ pkgDoer.iFileName = KFileName;
+
+ SThreadPackage watcherPkg;
+ watcherPkg.iFileName = KFileName;
+
+ User::LeaveIfError(pkgDoer.iBarrier.CreateLocal(0));
+ User::LeaveIfError(watcherPkg.iBarrier.CreateLocal(0));
+ RThread watcher;
+ RThread watcher2;
+ RThread doer;
+ watcher.Create(_L("TestTwoWatchersWatcherThread"),SimpleSingleNotificationTFWatcher,KDefaultStackSize,KMinHeapSize,KMaxHeapSize,&watcherPkg);
+ watcher2.Create(_L("TestTwoWatchersWatcher2Thread"),SimpleSingleNotificationTFWatcher,KDefaultStackSize,KMinHeapSize,KMaxHeapSize,&watcherPkg);
+ doer.Create(_L("TestTwoWatchersDoerThread"),SimpleSingleNotificationTFDoer,KDefaultStackSize,KMinHeapSize,KMaxHeapSize,&pkgDoer);
+ watcher.Resume();
+ watcher2.Resume();
+ watcherPkg.iBarrier.Wait(); //Wait till both watchers have requested notification
+ watcherPkg.iBarrier.Wait();
+ doer.Resume();
+
+ test.Printf(_L("Wait for DOER to terminate , Line %d"),__LINE__);
+ TRequestStatus status;
+ doer.Logon(status);
+ User::WaitForRequest(status);
+ test(doer.ExitReason()==KErrNone);
+
+ test.Printf(_L("Wait for WATCHER to terminate , Line %d"),__LINE__);
+ watcher.Logon(status);
+ RTimer timer1;
+ TInt r = timer1.CreateLocal();
+ safe_test(test,r,__LINE__,(TText*)Expand("t_notifier.cpp"));
+ TRequestStatus timeout;
+ TTimeIntervalMicroSeconds32 time = 10000000; //10 seconds
+ timer1.After(timeout,time);
+ User::WaitForRequest(timeout,status);
+ test(status.Int() != KRequestPending);
+ timer1.Cancel();
+ timer1.Close();
+// User::WaitForRequest(status);
+ test(watcher.ExitReason()==KErrNone);
+
+ test.Printf(_L("Wait for WATCHER2 to terminate , Line %d"),__LINE__);
+ watcher2.Logon(status);
+ RTimer timer2;
+ r = timer2.CreateLocal();
+ safe_test(test,r,__LINE__,(TText*)Expand("t_notifier.cpp"));
+ TRequestStatus timeout2;
+ timer2.After(timeout2,time);
+ User::WaitForRequest(timeout2,status);
+ test(status.Int() != KRequestPending);
+ timer2.Cancel();
+ timer2.Close();
+ //User::WaitForRequest(status);
+ test(watcher2.ExitReason()==KErrNone);
+
+ CLOSE_AND_WAIT(doer);
+ CLOSE_AND_WAIT(watcher);
+ CLOSE_AND_WAIT(watcher2);
+
+ pkgDoer.iBarrier.Close();
+ watcherPkg.iBarrier.Close();
+ fs.Close();
+ return KErrNone;
+ }
+
+
+/*
+ * TestTwoWatchersTwoDoersL - Two watcher threads watches two different doer threads.
+ */
+TInt TestTwoWatchersTwoDoersL()
+ {
+ test.Next(_L("TestTwoWatchersTwoDoers"));
+ RFs fs;
+ fs.Connect();
+ _LIT(KFileName1,"f1le.create");
+ _LIT(KFileName2,"f2le.create");
+ SThreadPackage package1;
+ package1.iFileName = KFileName1;
+
+ SThreadPackage package2;
+ package2.iFileName = KFileName2;
+
+ User::LeaveIfError(package1.iBarrier.CreateLocal(0));
+ User::LeaveIfError(package2.iBarrier.CreateLocal(0));
+ RThread watcher;
+ RThread watcher2;
+ RThread doer;
+ RThread doer2;
+ watcher.Create(_L("TestTwoWatchersTwoDoersWatcherThread"),SimpleSingleNotificationTFWatcher,KDefaultStackSize,KMinHeapSize,KMaxHeapSize,&package1);
+ doer.Create(_L("TestTwoWatchersTwoDoersDoerThread"),SimpleSingleNotificationTFDoer,KDefaultStackSize,KMinHeapSize,KMaxHeapSize,&package1);
+
+ watcher2.Create(_L("TestTwoWatchersTwoDoersWatcher2Thread"),SimpleSingleNotificationTFWatcher,KDefaultStackSize,KMinHeapSize,KMaxHeapSize,&package2);
+ doer2.Create(_L("TestTwoWatchersTwoDoersDoer2Thread"),SimpleSingleNotificationTFDoer,KDefaultStackSize,KMinHeapSize,KMaxHeapSize,&package2);
+ watcher.Resume();
+ watcher2.Resume();
+ package1.iBarrier.Wait(); //Wait till both watchers have requested notification
+ package2.iBarrier.Wait();
+ doer.Resume();
+ doer2.Resume();
+
+ test.Printf(_L("Wait for DOER to terminate , Line %d"),__LINE__);
+ TRequestStatus status;
+ doer.Logon(status);
+ User::WaitForRequest(status);
+ test(doer.ExitReason()==KErrNone);
+
+ test.Printf(_L("Wait for DOER2 to terminate , Line %d"),__LINE__);
+ doer2.Logon(status);
+ User::WaitForRequest(status);
+ test(doer2.ExitReason()==KErrNone);
+
+ test.Printf(_L("Wait for WATCHER to terminate , Line %d"),__LINE__);
+ watcher.Logon(status);
+ RTimer timer1;
+ TInt r = timer1.CreateLocal();
+ safe_test(test,r,__LINE__,(TText*)Expand("t_notifier.cpp"));
+ TRequestStatus timeout;
+ TTimeIntervalMicroSeconds32 time = 10000000; //10 seconds
+ timer1.After(timeout,time);
+ User::WaitForRequest(timeout,status);
+ test(status.Int() != KRequestPending);
+ timer1.Cancel();
+ timer1.Close();
+ test(watcher.ExitReason()==KErrNone);
+
+ test.Printf(_L("Wait for WATCHER2 to terminate , Line %d"),__LINE__);
+ watcher2.Logon(status);
+ RTimer timer2;
+ r = timer2.CreateLocal();
+ safe_test(test,r,__LINE__,(TText*)Expand("t_notifier.cpp"));
+ TRequestStatus timeout2;
+ timer2.After(timeout2,time);
+ User::WaitForRequest(timeout2,status);
+ test(status.Int() != KRequestPending);
+ timer2.Cancel();
+ timer2.Close();
+ test(watcher2.ExitReason()==KErrNone);
+
+ CLOSE_AND_WAIT(doer);
+ CLOSE_AND_WAIT(doer2);
+ CLOSE_AND_WAIT(watcher);
+ CLOSE_AND_WAIT(watcher2);
+
+ package1.iBarrier.Close();
+ package2.iBarrier.Close();
+ fs.Close();
+ return KErrNone;
+ }
+
+
+/*
+ * Multi-purpose test
+ *
+ * If aFailureExpected is ETrue, it is expected that the watcher thread is not terminated normally,
+ * due to the notification(s) not being sent.
+ * Since this function is called many times, aLineCall is used to show the line where it is called from.
+ * See SThreadPackageMultiple.
+ */
+TInt TestMultipleNotificationsL(const TDesC& aFilename, const TDesC& aString, TInt aIterations,
+ TInt aMaxNotifications, t_notification::EOperation aOperation,
+ TUint aNotifyType, TInt aBufferSize, TBool aFailureExpected, TInt aLineCall)
+ {
+ test.Next(_L("TestMultipleNotifications"));
+
+ RFs fs;
+ fs.Connect();
+ SThreadPackageMultiple package;
+ package.iIterations = aIterations;
+ package.iMaxNotifications = aMaxNotifications;
+ package.iOperation = aOperation;
+ package.iNotifyType = (TFsNotification::TFsNotificationType)aNotifyType;
+ package.iString = aString;
+ package.iFileName = aFilename;
+ package.iBufferSize = aBufferSize;
+ package.iLineCall = aLineCall;
+
+ User::LeaveIfError(package.iBarrier.CreateLocal(0));
+ RThread watcher;
+ RThread doer;
+ RTimer tim;
+ User::LeaveIfError(tim.CreateLocal());
+
+ TInt r = watcher.Create(_L("TestMultipleNotificationsWatcherThread"),MultipleNotificationsTFWatcher,KDefaultStackSize,KMinHeapSize,KMaxHeapSize,&package);
+ safe_test(test,r,__LINE__,package.iLineCall);
+ r = doer.Create(_L("TestMultipleNotificationsDoerThread"),MultipleNotificationTFDoer,KDefaultStackSize*2,KMinHeapSize,KMaxHeapSize,&package);
+ safe_test(test,r,__LINE__,package.iLineCall);
+ test.Next(_L("TestMultipleNotifications - Resume Watcher"));
+ watcher.Resume();
+ test.Next(_L("TestMultipleNotifications - Wait for Watcher to be ready"));
+ package.iBarrier.Wait(); //Wait till Watcher has requested notification
+ test.Next(_L("TestMultipleNotifications - Resume Doer"));
+ doer.Resume();
+
+ test.Next(_L("TestMultipleNotifications - Wait for doer thread death"));
+ TRequestStatus status;
+ doer.Logon(status);
+ User::WaitForRequest(status);
+ test.Printf(_L("TestMultipleNotifications - Doer Exit Reason %d\n"),doer.ExitReason());
+ safe_test(test,doer.ExitReason(),__LINE__,package.iLineCall);
+
+ TRequestStatus timStatus;
+ TTimeIntervalMicroSeconds32 timeout;
+ if (aFailureExpected && !(package.iOperation == t_notification::EMediaCardInsertion ||
+ package.iOperation == t_notification::EMediaCardRemoval))
+ {
+ timeout = 1500000; //1.5 seconds, we don't want to wait too long if we expect it to fail
+ }
+ else
+ {
+ timeout = 10000000; //10 seconds
+ }
+ tim.After(timStatus,timeout);
+
+ test.Next(_L("TestMultipleNotifications - Wait for watcher thread death or timeout"));
+ watcher.Logon(status);
+ User::WaitForRequest(status,timStatus);
+ if(!(status != KRequestPending || aFailureExpected))
+ safe_test(test,KErrGeneral,__LINE__,package.iLineCall);
+
+ test.Printf(_L("TestMultipleNotifications - Watcher Exit Reason %d\n"),watcher.ExitReason());
+ safe_test(test,watcher.ExitReason(),__LINE__,package.iLineCall);
+
+ CLOSE_AND_WAIT(doer);
+
+ if(status == KRequestPending)
+ {
+ watcher.Kill(KErrTimedOut);
+ test.Printf(_L("TestMultipleNotifications - Watcher timed out\n"));
+ }
+ CLOSE_AND_WAIT(watcher);
+
+ package.iBarrier.Close();
+ fs.Close();
+ tim.Close();
+ test.Printf(_L("----------------------------------------------------------------------\n"));
+ return KErrNone;
+ }
+
+TInt TestMultipleNotificationsL(const TDesC& aFilename, const TDesC& aString, TInt aIterations,
+ TInt aMaxNotifications, t_notification::EOperation aOperation,
+ TFsNotification::TFsNotificationType aNotifyType, TInt aBufferSize,
+ TBool aFailureExpected, TInt aLineCall)
+ {
+ return TestMultipleNotificationsL(aFilename, aString, aIterations, aMaxNotifications, aOperation,
+ (TUint)aNotifyType, aBufferSize, aFailureExpected, aLineCall);
+ }
+
+TInt TestMultipleNotificationsL(const TDesC& aFilename, TInt aIterations, TInt aMaxNotifications,
+ t_notification::EOperation aOperation, TUint aNotifyType, TInt aBufferSize,
+ TBool aFailureExpected, TInt aLineCall)
+ {
+ return TestMultipleNotificationsL(aFilename,_L(""), aIterations, aMaxNotifications, aOperation, aNotifyType,
+ aBufferSize, aFailureExpected, aLineCall);
+ }
+
+
+// Watcher for TestAddRemoveNotificationL()
+TInt TestAddRemoveNotificationWatcher(TAny* aAny)
+ {
+ CTrapCleanup* cleanup;
+ cleanup = CTrapCleanup::New();
+ RThread thread;
+ TUint64 threadId = thread.Id().Id();
+
+ SThreadPackage pkgDoer = *(SThreadPackage*)aAny;
+ RSemaphore& addRemoveBarrier = pkgDoer.iBarrier;
+
+ RTest addRemoveWatcherTest(_L("TestAddRemoveNotificationWatcher"));
+ addRemoveWatcherTest.Start(_L("TestAddRemoveNotificationWatcher"));
+
+ RFs fs;
+ fs.Connect();
+
+ addRemoveWatcherTest.Printf(_L("TestAddRemoveNotificationWatcher(%d) - Create CFsNotify\n"),threadId);
+ CFsNotify* notify = NULL;
+ TRAPD(r,notify = CFsNotify::NewL(fs,100); );
+ addRemoveWatcherTest( r == KErrNone);
+ TBuf<40> path;
+ TBuf<20> filename;
+ path.Append(gDriveToTest);
+ path.Append(_L(":\\F32-TST\\T_NOTIFIER\\")); //len=22
+ filename.Append(pkgDoer.iFileName);
+
+ addRemoveWatcherTest.Printf(_L("TestAddRemoveNotificationWatcher - Add Notification for %S\n"),&path);
+ r = notify->AddNotification((TUint)TFsNotification::ECreate,path,filename);
+ addRemoveWatcherTest(r==KErrNone);
+ addRemoveWatcherTest.Printf(_L("TestAddRemoveNotificationWatcher(%d) - Remove Notifications\n"),threadId);
+ r = notify->RemoveNotifications();
+ addRemoveWatcherTest(r==KErrNone);
+ addRemoveWatcherTest.Printf(_L("TestAddRemoveNotificationWatcher(%d) - Request Notifications\n"),threadId);
+ TRequestStatus status;
+ r = notify->RequestNotifications(status);
+ addRemoveWatcherTest(r==KErrNone);
+ addRemoveWatcherTest.Printf(_L("TestAddRemoveNotificationWatcher status = %d"),status.Int());
+ addRemoveBarrier.Signal();
+
+ addRemoveWatcherTest.Printf(_L("TestAddRemoveNotificationWatcher(%d) - NextNotification\n"),threadId);
+ //We should not be getting any notifications as the notification request has been removed
+ const TFsNotification* notification = notify->NextNotification();
+ addRemoveWatcherTest(notification == NULL);
+
+ delete notify;
+ fs.Close();
+ addRemoveWatcherTest.End();
+ addRemoveWatcherTest.Close();
+ delete cleanup;
+ return KErrNone;
+ }
+
+
+/*
+ * TestAddRemoveNotificationL - Watcher adds and removes notification request.
+ * Any changes by doer thread should not be detected.
+ */
+TInt TestAddRemoveNotificationL()
+ {
+ test.Next(_L("TestAddRemoveNotification"));
+ RFs fs;
+ fs.Connect();
+
+ SThreadPackage package;
+ _LIT(KFileName,"noFile.create");
+ package.iFileName = KFileName;
+
+ User::LeaveIfError(package.iBarrier.CreateLocal(0));
+ RThread watcher;
+ RThread doer;
+
+ watcher.Create(_L("TestAddRemoveNotification-WatcherThread"),TestAddRemoveNotificationWatcher,KDefaultStackSize,KMinHeapSize,KMaxHeapSize,&package);
+ doer.Create(_L("TestAddRemoveNotification-DoerThread"),SimpleSingleNotificationTFDoer,KDefaultStackSize,KMinHeapSize,KMaxHeapSize,&package);
+ watcher.Resume();
+
+ test.Printf(_L("TestAddRemoveNotification - Wait until Watcher has created CFsNotify\n"));
+ package.iBarrier.Wait(); //Wait until Watcher has created CFsNotify
+ doer.Resume();
+
+ test.Next(_L("TestAddRemoveNotification - Wait for doer thread death"));
+ TRequestStatus status;
+ doer.Logon(status);
+ User::WaitForRequest(status);
+ test(doer.ExitReason()==KErrNone);
+
+ test.Next(_L("TestAddRemoveNotification - Wait for watcher thread death"));
+ watcher.Logon(status);
+ RTimer timer1;
+ TInt r = timer1.CreateLocal();
+ safe_test(test,r,__LINE__,(TText*)Expand("t_notifier.cpp"));
+ TRequestStatus timeout;
+ TTimeIntervalMicroSeconds32 time = 10000000; //10 seconds
+ timer1.After(timeout,time);
+ User::WaitForRequest(timeout,status);
+ test(status.Int() != KRequestPending);
+ timer1.Cancel();
+ timer1.Close();
+ test.Printf(_L("Test - Watcher Exit Reason %d\n"),watcher.ExitReason());
+ test(watcher.ExitReason()==KErrNone);
+
+ CLOSE_AND_WAIT(doer);
+ CLOSE_AND_WAIT(watcher);
+
+ package.iBarrier.Close();
+ fs.Close();
+ return KErrNone;
+ }
+
+
+/*
+ * Adds and cancels notification request.
+ * Used in TestCancelNotificationL().
+ */
+TInt TestCancelNotificationWatcher(TAny* aAny)
+ {
+ CTrapCleanup* cleanup;
+ cleanup = CTrapCleanup::New();
+
+ RTest cancelNotificationsWatcherTest(_L("TestCancelNotificationWatcher"));
+ cancelNotificationsWatcherTest.Start(_L("TestCancelNotificationWatcher"));
+
+ RThread thread;
+ TUint64 threadId = thread.Id().Id();
+
+ SThreadPackageDualSemaphore pkgDoer = *(SThreadPackageDualSemaphore*)aAny;
+ RSemaphore& addRemoveBarrier = pkgDoer.iBarrier;
+ RSemaphore& addRemoveBarrier2 = pkgDoer.iBarrier2;
+
+ RFs fs;
+ fs.Connect();
+
+ cancelNotificationsWatcherTest.Printf(_L("TestCancelNotificationWatcher(%d) - Create CFsNotify\n"),threadId);
+ CFsNotify* notify = NULL;
+ TRAPD(r,notify = CFsNotify::NewL(fs,100); );
+ cancelNotificationsWatcherTest(r == KErrNone);
+ TBuf<40> path;
+ TBuf<20> filename;
+ path.Append(gDriveToTest);
+ path.Append(_L(":\\F32-TST\\T_NOTIFIER\\")); //len=22
+ filename.Append(pkgDoer.iFileName);
+
+ cancelNotificationsWatcherTest.Printf(_L("TestCancelNotificationWatcher - Add Notification for %S\n"),&path);
+ r = notify->AddNotification((TUint)TFsNotification::ECreate,path,filename);
+ cancelNotificationsWatcherTest(r==KErrNone);
+ cancelNotificationsWatcherTest.Printf(_L("TestCancelNotificationWatcher(%d) - Request Notifications\n"),threadId);
+ TRequestStatus status;
+ r = notify->RequestNotifications(status);
+ cancelNotificationsWatcherTest(r==KErrNone);
+
+ cancelNotificationsWatcherTest.Printf(_L("TestCancelNotificationWatcher(%d) - Cancel Notifications\n"),threadId);
+ r = notify->CancelNotifications(status);
+ cancelNotificationsWatcherTest(r==KErrNone);
+
+ cancelNotificationsWatcherTest.Printf(_L("TestCancelNotificationWatcher(%d) - Signal W1 - Start doer\n"),threadId);
+ addRemoveBarrier.Signal(); //W1 - Start doer
+
+ cancelNotificationsWatcherTest.Printf(_L("TestCancelNotificationWatcher(%d) - Wait S1 - doer complete\n"),threadId);
+ addRemoveBarrier2.Wait(); //S1 - Wait for doer to have created file
+
+ cancelNotificationsWatcherTest.Printf(_L("TestCancelNotificationWatcher(%d) - NextNotification\n"),threadId);
+ //We should not be getting any notifications as the notification request has been removed
+ const TFsNotification* notification = notify->NextNotification();
+ cancelNotificationsWatcherTest(notification == NULL);
+
+ delete notify;
+ fs.Close();
+ cancelNotificationsWatcherTest.Printf(_L("TestCancelNotificationWatcher(%d) - Complete\n"),threadId);
+ cancelNotificationsWatcherTest.End();
+ cancelNotificationsWatcherTest.Close();
+ delete cleanup;
+ return KErrNone;
+ }
+
+
+/*
+ * TestCancelNotificationL - Watcher adds and cancels notification request.
+ */
+TInt TestCancelNotificationL()
+ {
+ test.Next(_L("TestCancelNotification"));
+ RFs fs;
+ fs.Connect();
+
+ SThreadPackageDualSemaphore package;
+ _LIT(KFileName,"cancel.create");
+ package.iFileName = KFileName;
+
+ User::LeaveIfError(package.iBarrier.CreateLocal(0));
+ User::LeaveIfError(package.iBarrier2.CreateLocal(0));
+ RThread watcher;
+ RThread doer;
+
+ TInt r = watcher.Create(_L("TestCancelNotification-WatcherThread"),TestCancelNotificationWatcher,KDefaultStackSize*2,KMinHeapSize,KMaxHeapSize,&package);
+ test(r == KErrNone);
+ r = doer.Create(_L("TestCancelNotification-DoerThread"),SimpleSingleNotificationTFDoer,KDefaultStackSize*2,KMinHeapSize,KMaxHeapSize,&package);
+ test(r == KErrNone);
+ test.Printf(_L("TestCancelNotificationL - Watcher.Resume()"));
+ watcher.Resume();
+ test.Printf(_L("TestCancelNotificationL - Waiting on package.iBarrier.Wait()"));
+ package.iBarrier.Wait(); //W1 - Wait until Watcher has created CFsNotify
+ test.Printf(_L("TestCancelNotificationL -Doer Resume"));
+ TRequestStatus status;
+ doer.Logon(status);
+ doer.Resume();
+
+ test.Next(_L("TestCancelNotification - Wait for doer thread death"));
+ User::WaitForRequest(status);
+ test(doer.ExitReason()==KErrNone);
+
+ package.iBarrier2.Signal(); //S1
+
+ test.Next(_L("TestCancelNotification - Wait for watcher thread death"));
+ watcher.Logon(status);
+
+ RTimer tim;
+ r = tim.CreateLocal();
+ test(r==KErrNone);
+
+ TRequestStatus timStatus;
+ TTimeIntervalMicroSeconds32 time = 10000000; //10 seconds
+ tim.After(timStatus,time);
+
+ User::WaitForRequest(status,timStatus);
+ test(status!=KRequestPending);
+ test(watcher.ExitReason()==KErrNone);
+
+ CLOSE_AND_WAIT(doer);
+ CLOSE_AND_WAIT(watcher);
+
+ package.iBarrier.Close();
+ package.iBarrier2.Close();
+ fs.Close();
+ tim.Close();
+ return KErrNone;
+ }
+
+/*
+ * Test that if we close the session
+ * before closing the subsession (deleting CFsNotify)
+ * that everything is A-Ok.
+ */
+TInt TestSessionCloseTF(TAny* aTestCase)
+ {
+ CTrapCleanup* cleanup;
+ cleanup = CTrapCleanup::New();
+
+ TRAPD(r,
+ RFs fs;
+ fs.Connect();
+ RDebug::Printf("TestSessionClose\n");
+
+ SThreadPackage2 package = *(SThreadPackage2*)aTestCase;
+ package.iBarrier.Signal();
+
+ switch(package.iTestCase)
+ {
+ case 1:
+ {
+ RDebug::Printf("TestSessionCloseTF - Case 1 - NewL\n");
+ CFsNotify* notify = CFsNotify::NewL(fs,KMinNotificationBufferSize);
+ User::LeaveIfNull(notify);
+
+ RDebug::Printf("TestSessionCloseTF - Case 1 - Fs.Close\n");
+ fs.Close();
+
+ TBuf<45> path;
+ path.Append((TChar)gDriveToTest);
+ path.Append(_L(":\\F32-TST\\T_NOTIFIER\\"));
+
+ TBuf<20> filename;
+ filename.Append(_L("session.close"));
+
+ CleanupStack::PushL(notify);
+
+ RDebug::Printf("TestSessionCloseTF - Case 1 - Add Notification - Panic Expected\n");
+ r = notify->AddNotification((TUint)TFsNotification::ECreate,path,filename);
+ User::LeaveIfError(r);
+
+ RDebug::Printf("TestSessionCloseTF - Case 1 - After Session Close\n");
+ fs.Close();
+ CleanupStack::Pop(notify);
+
+ RDebug::Printf("TestSessionCloseTF - Case 1 - After Delete Notify\n");
+ delete notify;
+ break;
+ }
+ case 2:
+ {
+ RDebug::Printf("TestSessionCloseTF - Case 2 - NewL\n");
+ CFsNotify* notify = CFsNotify::NewL(fs,KMinNotificationBufferSize);
+ User::LeaveIfNull(notify);
+
+ TBuf<45> path;
+ path.Append((TChar)gDriveToTest);
+ path.Append(_L(":\\F32-TST\\T_NOTIFIER\\"));
+ TBuf<20> filename;
+ filename.Append(_L("session.close"));
+
+ RDebug::Printf("TestSessionCloseTF - Case 2 - Add Notification\n");
+ r = notify->AddNotification((TUint)TFsNotification::ECreate,path,filename);
+ test(r==KErrNone);
+
+ RDebug::Printf("TestSessionCloseTF - Case 2 - Fs.Close\n");
+ fs.Close();
+
+ CleanupStack::PushL(notify);
+ TRequestStatus status;
+ RDebug::Printf("TestSessionCloseTF - Case 2 - Request Notification - Panic Expected\n");
+ r = notify->RequestNotifications(status);
+ CleanupStack::Pop(notify);
+
+ RDebug::Printf("TestSessionCloseTF - Case 2 - After Delete Notify\n");
+ delete notify;
+ break;
+ }
+ default:
+ {
+ break;
+ }
+ }
+ );
+ delete cleanup;
+ return r;
+ }
+
+/*
+ * Test that if we close the session
+ * before closing the subsession (deleting CFsNotify)
+ * that everything is A-Ok.
+ */
+void TestSessionClose(TInt aTestCase)
+ {
+ RSemaphore sem;
+ User::LeaveIfError(sem.CreateLocal(0));
+
+ SThreadPackage2 package;
+ package.iTestCase = aTestCase;
+ package.iBarrier = sem;
+
+ RThread thread;
+ thread.Create(_L("TestSessionClose"),TestSessionCloseTF,KDefaultStackSize,KMinHeapSize,KMaxHeapSize,&package);
+
+ thread.Resume();
+ sem.Wait();
+
+ TRequestStatus status;
+ thread.Logon(status);
+ User::WaitForRequest(status);
+ test.Printf(_L("Kern-Exec 0 is EXPECTED\n"));
+ TInt err = thread.ExitReason();
+ test(err == KErrNone);
+ TExitType et = thread.ExitType();
+ test(et == EExitPanic);
+ CLOSE_AND_WAIT(thread);
+ sem.Close();
+ }
+
+const TInt KNotificationOverflowIterationLimit = 7;
+
+/*
+ * Does stuff for TestOverflowL
+ * Synchronises such that watchers have seen 1 change.
+ * Then fills their buffers up to KNotificationOverflowIterationLimit.
+ *
+ */
+TInt TestOverflowDoerTF(TAny* aAny)
+ {
+ RFs fs;
+ fs.Connect();
+
+ SThreadPackage& package = *(SThreadPackage*) aAny;
+
+ TBuf<45> path;
+ path.Append((TChar)gDriveToTest);
+ path.Append(_L(":\\F32-TST\\T_NOTIFIER\\"));
+ path.Append(package.iFileName);
+
+ fs.MkDirAll(path);
+
+ RFile file;
+ TInt r = file.Replace(fs,path,EFileWrite);
+ User::LeaveIfError(r);
+
+ //Perform first set size.
+ r = file.SetSize(1);
+ User::LeaveIfError(r);
+
+ //Wait until both watchers have received this change.
+ package.iBarrier.Wait();
+
+ for(TInt i = 0; i< KNotificationOverflowIterationLimit; i++)
+ {
+ file.SetSize(i);
+ }
+
+ file.Close();
+ fs.Close();
+ return KErrNone;
+ }
+
+/*
+ * Thread function used as part of TestOverflowL
+ * Counts the number of notifications and ensures it the correct number before overflow is received#
+ */
+TInt TestOverflowWatcher1TF(TAny* aAny)
+ {
+ CTrapCleanup* cleanup;
+ cleanup = CTrapCleanup::New();
+
+ RTest overflowTest(_L("TestOverflowWatcher1TF"));
+ overflowTest.Start(_L("TestOverflowWatcher1TF"));
+
+ SThreadPackage& package = *(SThreadPackage*) aAny;
+ RFs fs;
+ fs.Connect();
+ TBuf<45> path;
+ TBuf<20> filename;
+ path.Append((TChar)gDriveToTest);
+ path.Append(_L(":\\F32-TST\\T_NOTIFIER\\"));
+ filename.Append(package.iFileName);
+
+ TRequestStatus status;
+ CFsNotify* notify = NULL;
+
+ //This notification's size is 80.
+ //80*7 = 560.
+ // -4 means we should get 6 notifications
+ //Except the first one will still be in the buffer
+ // (as we've not called RequestNotification yet) so we'll only actually get 5.
+ TRAPD(r, notify = CFsNotify::NewL(fs,(80*7)-4));
+ test(r == KErrNone);
+ User::LeaveIfNull(notify);
+ notify->AddNotification(TFsNotification::EFileChange,path,filename);
+ notify->RequestNotifications(status);
+
+ //Signal that we are ready for doer to start (W1)
+ package.iBarrier.Signal();
+
+ //We wait for the 1 notification (doer only does 1 at first)
+ User::WaitForRequest(status);
+
+ overflowTest.Next(_L("Overflow- Get First Notification (Start framework)"));
+ const TFsNotification *notification = notify->NextNotification();
+
+ TFsNotification::TFsNotificationType type = notification->NotificationType();
+ overflowTest.Printf(_L("Overflow - First Notification Type = %d\n"),type);
+
+ //Signal the test thread (W2)
+ package.iBarrier.Signal();
+ //Wait for Signal to continue (W3);
+ package.iBarrier.Wait();
+
+ notify->RequestNotifications(status);
+ User::WaitForRequest(status);
+
+ TInt count = 0;
+ overflowTest.Next(_L("Overflow- Get the rest of the notifications"));
+ notification = notify->NextNotification();
+ while(notification != NULL)
+ {
+
+ type = notification->NotificationType();
+ overflowTest.Printf(_L("Overflow - NotificationType = %d\n"),type);
+ if(type & TFsNotification::EOverflow)
+ {
+ delete notify;
+ fs.Close();
+ overflowTest.Printf(_L("Overflow +- Count = %d\n"),count);
+ overflowTest.End();
+ overflowTest.Close();
+ return count;
+ }
+
+ notification = notify->NextNotification();
+ count++;
+ }
+ overflowTest.Printf(_L("Overflow -- Count = %d\n"),count);
+
+ overflowTest.End();
+ overflowTest.Close();
+ delete notify;
+ delete cleanup;
+ fs.Close();
+ return -1;
+ }
+
+
+/*
+ * Overflow test
+ * As some of the tests above assume sucess if they receive an overflow
+ * we need to ensure that overflow works properly!
+ */
+TInt TestOverflowL()
+ {
+ /*
+ * The scheme used is as follows:
+ * 1 Doer thread which is setting the size of a file, over and over.
+ * 1 watcher thread.
+ *
+ * The doer thread does 1 operation then waits on a signal.
+ * The watcher thread requests notification and receives 1 notification.
+ * It then signals the Doer thread.
+ *
+ * The doer thread continues doing setsize until the number of notifications
+ * should have overflowed.
+ *
+ * The watcher Waits for a signal from doer (that all of the notifications have been sent).
+ * The watcher's last notification should be an overflow
+ */
+ test.Next(_L("TestOverflow"));
+ RFs fs;
+ TInt r = fs.Connect();
+ test(r == KErrNone);
+ _LIT(KFileName,"over.flow");
+ SThreadPackage doerPkg;
+ doerPkg.iFileName = KFileName;
+
+ SThreadPackage watcher1Pkg;
+ watcher1Pkg.iFileName = KFileName;
+
+ User::LeaveIfError(doerPkg.iBarrier.CreateLocal(0));
+ User::LeaveIfError(watcher1Pkg.iBarrier.CreateLocal(0));
+ RThread watcher1;
+ RThread doer;
+ watcher1.Create(_L("TestOverflowWatcher1Thread"),TestOverflowWatcher1TF,KDefaultStackSize,KMinHeapSize,KMaxHeapSize,&watcher1Pkg);
+ doer.Create(_L("TestOverflowDoerThread"),TestOverflowDoerTF,KDefaultStackSize,KMinHeapSize,KMaxHeapSize,&doerPkg);
+ watcher1.Resume();
+
+ //Wait until Request has been requested. (W1)
+ watcher1Pkg.iBarrier.Wait();
+
+ doer.Resume();
+
+ //Wait till watcher has received first notification (W2)
+ watcher1Pkg.iBarrier.Wait();
+
+ //Signal the doer that it is free to continue
+ //doing the rest of the operations
+ doerPkg.iBarrier.Signal();
+
+ test.Next(_L("TestOverflow - Wait for doer thread death"));
+ TRequestStatus status;
+ doer.Logon(status);
+ User::WaitForRequest(status);
+ test(doer.ExitReason()==KErrNone);
+ CLOSE_AND_WAIT(doer);
+
+ //Wait until doer has finished doing notifications
+ //thus the watcher should receive an overflow
+ // (W3)
+ watcher1Pkg.iBarrier.Signal();
+
+ RTimer tim;
+ r = tim.CreateLocal();
+ test(r==KErrNone);
+ TRequestStatus timStatus;
+
+ test.Next(_L("TestOverflow - Wait for watcher1 thread death"));
+ TTimeIntervalMicroSeconds32 interval = 10000000; //10 seconds
+ tim.After(timStatus,interval);
+ watcher1.Logon(status);
+ User::WaitForRequest(status,timStatus);
+ test(status != KRequestPending);
+ /*
+ * The number of notifications returned here should be 5.
+ * This is because :
+ *
+ * The first notification means that the buffer has lost 80 (the size of this
+ * particular notification). Even though the client has read it becase they've not called
+ * RequestNotification the server doesn't know that yet so that's why it's 5 not 6.
+ *
+ * That leaves 556 - 80. Which means only 5 notifications will fit.
+ */
+ TInt count = watcher1.ExitReason();
+ test(count==5);
+
+ CLOSE_AND_WAIT(watcher1);
+ watcher1Pkg.iBarrier.Close();
+ doerPkg.iBarrier.Close();
+ fs.Close();
+ tim.Close();
+ return KErrNone;
+ }
+
+/*
+ * Does stuff for TestPostOverflowL
+ * Synchronises such that watchers have seen 1 change.
+ * Then fills their buffers up to KNotificationOverflowIterationLimit.
+ * Then continues to request changes and akes sure that it gets 3 non-overflow notifications
+ * For DEF140387.
+ */
+TInt TestPostOverflowDoerTF(TAny* aAny)
+ {
+ RFs fs;
+ fs.Connect();
+
+ SThreadPackage& package = *(SThreadPackage*) aAny;
+
+ TBuf<45> path;
+ path.Append((TChar)gDriveToTest);
+ path.Append(_L(":\\F32-TST\\T_NOTIFIER\\"));
+ path.Append(package.iFileName);
+
+ fs.MkDirAll(path);
+
+ RFile file;
+ TInt r = file.Replace(fs,path,EFileWrite);
+ User::LeaveIfError(r);
+
+ //Perform first set size.
+ r = file.SetSize(1);
+ User::LeaveIfError(r);
+
+ //Wait until both watchers have received this change.
+ //D-W-1
+ package.iBarrier.Wait();
+
+ for(TInt i = 0; i< KNotificationOverflowIterationLimit; i++)
+ {
+ file.SetSize(i);
+ }
+
+ file.Close();
+ fs.Close();
+ return KErrNone;
+ }
+
+TInt HandlePostOverflow(SThreadPackage& aPackage, CFsNotify* aNotify)
+ {
+ TRequestStatus status;
+ TInt r = aNotify->RequestNotifications(status);
+ test(r == KErrNone);
+ //Signal that overflow has been found (W4)
+ aPackage.iBarrier.Signal();
+
+ User::WaitForRequest(status);
+
+ const TFsNotification* notification = NULL;
+ TInt count = 1;
+
+ notification = aNotify->NextNotification();
+ test(notification != NULL);
+
+ //3 set sizes will be done (Sx)
+ aPackage.iBarrier.Wait();
+
+ while(count < 3)
+ {
+ TUint type = notification->NotificationType();
+ if(type & TFsNotification::EOverflow)
+ {
+ return KErrOverflow;
+ }
+ notification = aNotify->NextNotification();
+ if(notification == NULL)
+ {
+ r = aNotify->RequestNotifications(status);
+ test(r == KErrNone);
+ User::WaitForRequest(status);
+ notification = aNotify->NextNotification();
+ }
+ test(notification != NULL);
+ count++;
+ }
+ return count;
+ }
+
+
+/*
+ * Thread function used as part of TestOverflowL
+ * Counts the number of notifications and ensures it the correct number before overflow is received#
+ */
+TInt TestPostOverflowWatcher1TF(TAny* aAny)
+ {
+ CTrapCleanup* cleanup;
+ cleanup = CTrapCleanup::New();
+
+ RTest overflowTest(_L("TestOverflowWatcher1TF"));
+ overflowTest.Start(_L("TestOverflowWatcher1TF"));
+
+ SThreadPackage& package = *(SThreadPackage*) aAny;
+ RFs fs;
+ fs.Connect();
+ TBuf<45> path;
+ TBuf<20> filename;
+ path.Append((TChar)gDriveToTest);
+ path.Append(_L(":\\F32-TST\\T_NOTIFIER\\"));
+ filename.Append(package.iFileName);
+
+ TRequestStatus status;
+ CFsNotify* notify = NULL;
+
+ //This notification's size is 80.
+ //80*7 = 560.
+ // -4 means we should get 6 notifications
+ //Except the first one will still be in the buffer
+ // (as we've not called RequestNotification yet) so we'll only actually get 5.
+ TRAPD(r, notify = CFsNotify::NewL(fs,(80*7)-4));
+ test(r == KErrNone);
+ User::LeaveIfNull(notify);
+ notify->AddNotification(TFsNotification::EFileChange,path,filename);
+ notify->RequestNotifications(status);
+
+ //Signal that we are ready for doer to start (W1)
+ package.iBarrier.Signal();
+
+ //We wait for the 1 notification (doer only does 1 at first)
+ User::WaitForRequest(status);
+
+ overflowTest.Next(_L("Overflow- Get First Notification (Start framework)"));
+ const TFsNotification *notification = notify->NextNotification();
+
+ TFsNotification::TFsNotificationType type = notification->NotificationType();
+ overflowTest.Printf(_L("Overflow - First Notification Type = %d\n"),type);
+
+ //Signal the test thread (W2)
+ package.iBarrier.Signal();
+ //Wait for Signal to continue (W3);
+ package.iBarrier.Wait();
+
+ notify->RequestNotifications(status);
+ User::WaitForRequest(status);
+
+ TInt handlePostOverflow = 0;
+ TInt count = 0;
+ overflowTest.Next(_L("Overflow- Get the rest of the notifications"));
+ notification = notify->NextNotification();
+ while(notification != NULL)
+ {
+
+ type = notification->NotificationType();
+ overflowTest.Printf(_L("Overflow - NotificationType = %d\n"),type);
+ if(type & TFsNotification::EOverflow)
+ {
+ overflowTest.Printf(_L("Overflow +- Count = %d\n"),count);
+ if(handlePostOverflow)
+ {
+ count = HandlePostOverflow(package,notify);
+ }
+ delete notify;
+ fs.Close();
+ overflowTest.End();
+ overflowTest.Close();
+ return count;
+ }
+ notification = notify->NextNotification();
+ count++;
+
+ if(count==5)
+ handlePostOverflow = 1;
+ }
+ overflowTest.Printf(_L("Overflow -- Count = %d\n"),count);
+
+ overflowTest.End();
+ overflowTest.Close();
+ delete notify;
+ delete cleanup;
+ fs.Close();
+ return -1;
+ }
+
+
+TInt TestPostOverflowNotifications()
+ {
+ test.Next(_L("TestPostOverflowNotifications"));
+ RFs fs;
+ TInt r = fs.Connect();
+ test(r == KErrNone);
+ _LIT(KFileName,"post.over");
+ SThreadPackage doerPkg;
+ doerPkg.iFileName = KFileName;
+
+ SThreadPackage watcher1Pkg;
+ watcher1Pkg.iFileName = KFileName;
+
+ User::LeaveIfError(doerPkg.iBarrier.CreateLocal(0));
+ User::LeaveIfError(watcher1Pkg.iBarrier.CreateLocal(0));
+ RThread watcher1;
+ RThread doer;
+ watcher1.Create(_L("TestPostOverflowWatcher1Thread"),TestPostOverflowWatcher1TF,KDefaultStackSize,KMinHeapSize,KMaxHeapSize,&watcher1Pkg);
+ doer.Create(_L("TestPostOverflowDoerThread"),TestPostOverflowDoerTF,KDefaultStackSize,KMinHeapSize,KMaxHeapSize,&doerPkg);
+ watcher1.Resume();
+
+ //Wait until Request has been requested. (W1)
+ watcher1Pkg.iBarrier.Wait();
+
+ doer.Resume();
+
+ //Wait till watcher has received first notification (W2)
+ watcher1Pkg.iBarrier.Wait();
+
+ //Signal the doer that it is free to continue
+ //doing the rest of the operations (D-W-1)
+ doerPkg.iBarrier.Signal();
+
+ test.Next(_L("TestOverflow - Wait for doer thread death"));
+ TRequestStatus status;
+ doer.Logon(status);
+ User::WaitForRequest(status);
+ test(doer.ExitReason()==KErrNone);
+ CLOSE_AND_WAIT(doer);
+
+ //Wait until doer has finished doing notifications
+ //thus the watcher should receive an overflow
+ // (W3)
+ watcher1Pkg.iBarrier.Signal();
+
+
+ //wait for the watcher to have processed the first overflow
+ //and to have requested notification.
+ //Then we will perform some actions here
+ // The watcher will wait on the semaphore until we are doing
+ // doing all the operations we want to do
+ // then it should process next notification
+ watcher1Pkg.iBarrier.Wait(); //W4
+
+ TBuf<45> path;
+ path.Append((TChar)gDriveToTest);
+ path.Append(_L(":\\F32-TST\\T_NOTIFIER\\"));
+ path.Append(watcher1Pkg.iFileName);
+ RFile file;
+ r = file.Open(fs,path,EFileWrite);
+ test(r==KErrNone);
+
+ r = file.SetSize(1);
+ test(r==KErrNone);
+ r = file.SetSize(2);
+ test(r==KErrNone);
+ r = file.SetSize(3);
+ test(r==KErrNone);
+ file.Close();
+
+ watcher1Pkg.iBarrier.Signal(); // Signal post operations complete (Sx)
+
+ RTimer tim;
+ r = tim.CreateLocal();
+ test(r==KErrNone);
+ TRequestStatus timStatus;
+
+ test.Next(_L("TestOverflow - Wait for watcher1 thread death"));
+ TTimeIntervalMicroSeconds32 interval = 10000000; //10 seconds
+ tim.After(timStatus,interval);
+ watcher1.Logon(status);
+ User::WaitForRequest(status,timStatus);
+ test(status != KRequestPending);
+ /*
+ * The number of notifications returned here should be 3.
+ * This is because :
+ *
+ * The first notification means that the buffer has lost 80 (the size of this
+ * particular notification). Even though the client has read it becase they've not called
+ * RequestNotification the server doesn't know that yet so that's why it's 5 not 6.
+ *
+ * That leaves 556 - 80. Which means only 5 notifications will fit.
+ *
+ * Then overflow occurs.
+ *
+ * Then count is reset and 3 more operations are performed.
+ */
+ TInt count = watcher1.ExitReason();
+ test(count==3);
+
+ CLOSE_AND_WAIT(watcher1);
+ watcher1Pkg.iBarrier.Close();
+ doerPkg.iBarrier.Close();
+ fs.Close();
+ tim.Close();
+ return KErrNone;
+ }
+
+/*
+ * Call AddNotification with a file without a path nor drive
+ */
+void TestNonDriveFilters()
+ {
+ test.Next(_L("TestNonDriveFilters"));
+ RFs fs;
+ TInt r = fs.Connect();
+ test(r==KErrNone);
+
+ TDriveList drives;
+ r = fs.DriveList(drives);
+ test(r==KErrNone);
+
+ CFsNotify* notify = NULL;
+ TRAP(r,notify= CFsNotify::NewL(fs,KMinNotificationBufferSize));
+
+ TBuf<20> testfile;
+ testfile.Append(_L("test.file"));
+
+ r = notify->AddNotification((TUint)TFsNotification::ECreate,_L(""),testfile);
+ test(r==KErrNone);
+
+ TRequestStatus status;
+ r = notify->RequestNotifications(status);
+ test(r==KErrNone);
+
+ TBuf<40> path;
+ path.Append((TChar)gDriveToTest);
+ path.Append(_L(":\\F32-TST\\T_NOTIFIER\\"));
+
+ TBuf<40> fullname;
+ fullname.Append(path);
+ fullname.Append(testfile);
+
+ RFile file;
+ r = fs.MkDirAll(path);
+ test(r==KErrNone || r==KErrAlreadyExists);
+ r = file.Replace(fs,fullname,EFileWrite);
+ test(r==KErrNone);
+ file.Close();
+
+ fs.Delete(fullname);
+
+ TChar testDrive = (TChar)gDriveToTest;
+ testDrive.UpperCase();
+
+ //Also create the file on another drive;
+ for(TInt i = 0; i < KMaxDrives; i++)
+ {
+ TChar drive = drives[i];
+ if(drive == testDrive)
+ continue;
+
+ if(drive)
+ {
+ TText16 drive16 = (TText16)(i+(TChar)'A');
+ fullname.operator [](0) = drive16;
+ break;
+ }
+ }
+
+ r = fs.MkDirAll(fullname);
+ test(r==KErrNone || r==KErrAlreadyExists);
+ r = file.Replace(fs,fullname,EFileWrite);
+ test(r==KErrNone);
+ file.Close();
+
+ RTimer timer1;
+ r = timer1.CreateLocal();
+ test(r == KErrNone);
+ TRequestStatus timeout;
+ TTimeIntervalMicroSeconds32 time = 10000000; //10 seconds
+ timer1.After(timeout,time);
+ User::WaitForRequest(timeout,status);
+ test(status.Int() != KRequestPending);
+ timer1.Cancel();
+ timer1.Close();
+
+ const TFsNotification* notification = notify->NextNotification();
+ test(notification != NULL);
+ TPtrC _path;
+ r = notification->Path(_path);
+ test(r==KErrNone);
+ TChar driveletter = _path[0];
+ driveletter.UpperCase();
+ test(driveletter == (TChar)gDriveToTest);
+
+ if(notification = notify->NextNotification(), notification==NULL)
+ {
+ TRequestStatus status2;
+ r = notify->RequestNotifications(status2);
+ test(r==KErrNone);
+
+ RTimer timer2;
+ r = timer2.CreateLocal();
+ test(r == KErrNone);
+ TRequestStatus timeout2;
+ TTimeIntervalMicroSeconds32 time2 = 10000000; //10 seconds
+ timer2.After(timeout2,time2);
+ User::WaitForRequest(timeout2,status2);
+ test(status2.Int() != KRequestPending);
+ timer2.Cancel();
+ timer2.Close();
+
+ notification = notify->NextNotification();
+ }
+ test(notification != NULL);
+ r = notification->Path(_path);
+ test(r==KErrNone);
+ driveletter = _path[0];
+ driveletter.UpperCase();
+ test(driveletter == (TChar)'C');
+
+ delete notify;
+ fs.Close();
+ }
+
+// Negative testing for directory without *
+// We receive no notifications for files changed under the directory
+void NegativeTestDirStar()
+ {
+ RFs fs;
+ TInt r = fs.Connect();
+ test(r==KErrNone);
+
+ CFsNotify* notify = NULL;
+ TRAP(r,notify= CFsNotify::NewL(fs,KMinNotificationBufferSize));
+
+ TBuf<40> path;
+ path.Append((TChar)gDriveToTest);
+ path.Append(_L(":\\F32-TST\\T_NOTIFIER\\"));
+ r = fs.MkDirAll(path);
+ test(r == KErrNone || r == KErrAlreadyExists);
+
+ r = notify->AddNotification((TUint)TFsNotification::ECreate,path,_L(""));
+ test(r==KErrNone);
+
+ TRequestStatus status;
+ r = notify->RequestNotifications(status);
+ test(r==KErrNone);
+
+ TBuf<40> filename;
+ filename.Append((TChar)gDriveToTest);
+ filename.Append(_L(":\\F32-TST\\T_NOTIFIER\\dir.star"));
+
+ RFile file;
+ r = file.Replace(fs,filename,EFileWrite);
+ test(r==KErrNone);
+ file.Close();
+
+ RTimer timer1;
+ r = timer1.CreateLocal();
+ test(r == KErrNone);
+ TRequestStatus timeout;
+ TTimeIntervalMicroSeconds32 time = 2000000; //2 seconds
+ timer1.After(timeout,time);
+ User::WaitForRequest(timeout,status);
+ test(status.Int() == KRequestPending);
+ timer1.Cancel();
+ timer1.Close();
+
+ const TFsNotification* notification = notify->NextNotification();
+ test(notification == NULL);
+
+ delete notify;
+ fs.Close();
+ }
+
+/*
+ * Negative Testing
+ */
+void NegativeTests()
+ {
+ test.Next(_L("Negative Tests"));
+ //1
+ test.Printf(_L("NegativeTests() A\n"));
+ RFs fs;
+ CFsNotify* notify = NULL;
+ TInt r = fs.Connect();
+ test(r == KErrNone);
+ TRAP(r,notify = CFsNotify::NewL(fs,0));
+ test(notify != NULL);
+ delete notify;
+ notify = NULL;
+
+ //2
+ test.Printf(_L("NegativeTests() B\n"));
+ TRAP(r,notify = CFsNotify::NewL(fs,-1));
+ test(notify != NULL);
+ delete notify;
+ notify = NULL;
+
+ test.Printf(_L("NegativeTests() C\n"));
+ TRAP(r,notify = CFsNotify::NewL(fs,KMaxTInt));
+ test(r==KErrArgument);
+ test(notify==NULL);
+
+ //3
+ test.Printf(_L("NegativeTests() D\n"));
+ TBuf<40> path;
+ path.Append((TChar)gDriveToTest);
+ path.Append(_L(":\\F32-TST\\T_NOTIFIER\\"));
+ TBuf<20> filename;
+ filename.Append(_L("file.txt"));
+ TRAP(r,notify = CFsNotify::NewL(fs,KMinNotificationBufferSize));
+ test(r==KErrNone);
+ test(notify!=NULL);
+ r = notify->AddNotification(0,path,filename);
+ test(r == KErrArgument);
+
+ test.Printf(_L("NegativeTests() E\n"));
+ r = notify->AddNotification((TUint)0x8000,path,filename); //invalid value
+ test(r == KErrArgument);
+
+ test.Printf(_L("NegativeTests() F\n"));
+ TBuf<40> invalidPath;
+ invalidPath.Append(_L("1:\\*"));
+ r = notify->AddNotification((TUint)TFsNotification::ECreate,invalidPath,filename);
+ test(r == KErrNotFound || r == KErrPathNotFound);
+
+ //4
+ test.Printf(_L("NegativeTests() G\n"));
+ TRequestStatus wrongStatus;
+ wrongStatus = KRequestPending;
+ r = notify->RequestNotifications(wrongStatus);
+ test(r == KErrInUse);
+
+ test.Printf(_L("NegativeTests() H\n"));
+ TRequestStatus status;
+ r = notify->RequestNotifications(status);
+ test(r==KErrNone);
+ r = notify->CancelNotifications(wrongStatus);
+ test(r == KErrInUse);
+
+ delete notify;
+ notify = NULL;
+ fs.Close();
+ }
+
+
+/*
+ * RPlugin devired.
+ * Doesn't actually do anything special.
+ * Can probably be deleted.
+ */
+class MyRPlugin : public RPlugin
+ {
+public:
+ void DoRequest(TInt aReqNo,TRequestStatus& aStatus) const;
+ void DoRequest(TInt aReqNo,TRequestStatus& aStatus,TDes8& a1) const;
+ void DoRequest(TInt aReqNo,TRequestStatus& aStatus,TDes8& a1,TDes8& a2) const;
+ TInt DoControl(TInt aFunction) const;
+ TInt DoControl(TInt aFunction,TDes8& a1) const;
+ TInt DoControl(TInt aFunction,TDes8& a1,TDes8& a2) const;
+ void DoCancel(TUint aReqMask) const;
+ };
+
+void MyRPlugin::DoRequest(TInt aReqNo,TRequestStatus& aStatus) const
+ {
+ RPlugin::DoRequest(aReqNo,aStatus);
+ }
+void MyRPlugin::DoRequest(TInt aReqNo,TRequestStatus& aStatus,TDes8& a1) const
+ {
+ RPlugin::DoRequest(aReqNo,aStatus,a1);
+ }
+void MyRPlugin::DoRequest(TInt aReqNo,TRequestStatus& aStatus,TDes8& a1,TDes8& a2) const
+ {
+ RPlugin::DoRequest(aReqNo,aStatus,a1,a2);
+ }
+TInt MyRPlugin::DoControl(TInt aFunction) const
+ {
+ return RPlugin::DoControl(aFunction);
+ }
+TInt MyRPlugin::DoControl(TInt aFunction,TDes8& a1) const
+ {
+ return RPlugin::DoControl(aFunction,a1);
+ }
+TInt MyRPlugin::DoControl(TInt aFunction,TDes8& a1,TDes8& a2) const
+ {
+ return RPlugin::DoControl(aFunction,a1,a2);
+ }
+void MyRPlugin::DoCancel(TUint aReqMask) const
+ {
+ RPlugin::DoCancel(aReqMask);
+ }
+
+/*
+ * This tests that when file server plugins perform operations that
+ * the framework doesn't notify about them
+ */
+TInt TestNotificationsWithFServPlugins()
+ {
+ TInt r = TheFs.AddPlugin(KNotifyPluginFileName);
+ test(r==KErrNone || r==KErrAlreadyExists);
+ r = TheFs.MountPlugin(KNotifyPluginName,(TUint)gDriveToTest.GetUpperCase() - 65);
+ if (r == KErrNotSupported)
+ {
+ test.Printf(_L("Plugins are not supported on pagable drives.\nSkipping test.\n"));
+ safe_test(test,r,__LINE__,(TText*)Expand("t_notifier.cpp"));
+ }
+
+ MyRPlugin rplugin;
+ TPckgBuf<TChar> drivePckg(gDriveToTest);
+
+ test.Next(_L("Open RPlugin connection for NotifyPlugin"));
+ r = rplugin.Open(TheFs,KNotifyPos);
+ safe_test(test,r,__LINE__,(TText*)Expand("t_notify_plugin.cpp"));
+
+ test.Next(_L("Send drive letter to test down to plugin"));
+ r = rplugin.DoControl(KPluginSetDrive,drivePckg);
+ safe_test(test,r,__LINE__,(TText*)Expand("t_notify_plugin.cpp"));
+ rplugin.Close();
+
+ r = SimpleCreateTestL();
+ safe_test(test,r,__LINE__,(TText*)Expand("t_notifier.cpp"));
+
+ DismountPlugin();
+ return KErrNone;
+ }
+
+/*
+ * This test is testing the use cases
+ * and for negative testing of SYMBIAN_F32_ENHANCED_CHANGE_NOTIFICATION
+ *
+ * Performance tests can be found in test t_notify_perf
+ */
+void CallTestsL()
+ {
+ CTrapCleanup* cleanup;
+ cleanup = CTrapCleanup::New();
+
+ globalDriveNum = gDriveToTest - (TChar)'A';
+
+ PrintLine();
+ test.Start(_L("T_NOTIFIER Test Start"));
+ TInt r = KErrNone;
+
+ //=========================================================================================
+ //! @SYMTestCaseID PBASE-T_NOTIFY-2443
+ //! @SYMTestType CIT
+ //! @SYMREQ PREQ1847
+ //! @SYMTestCaseDesc Simple Tests/User Heap Tests
+ //! @SYMTestStatus Implemented
+ //=========================================================================================
+ //
+ // 1. Create and delete many CFsNotify objects
+ //
+ PrintLine();
+ test.Next(_L("CFsNotify Creation and Delete Tests"));
+ //Creates and Deletes 1 CFsNotify
+ __UHEAP_MARK;
+ r = TestNewDeleteCFsNotify(1);
+ __UHEAP_MARKEND;
+ test(r==KErrNone);
+ //Creates and Deletes 50 CFsNotifys
+ __UHEAP_MARK;
+ r = TestNewDeleteCFsNotify(50);
+ __UHEAP_MARKEND;
+ test(r==KErrNone);
+ test.Printf(_L("------- End of User Heap Tests ---------------------------------------\n"));
+ //
+ // 2. Add notification for creating a file
+ // Create that file
+ //
+ PrintLine();
+ __UHEAP_MARK;
+ r = SimpleCreateTestL();
+ __UHEAP_MARKEND;
+ test(r==KErrNone);
+ test.Printf(_L("------- End of CFsNotify Creation and Delete Tests -------------------\n"));
+ //
+ // 3. Add notification at the root of a drive
+ // Create a file in that drive
+ //
+ PrintLine();
+ TestRootDriveNotifications();
+ test.Printf(_L("------- End of RootDriveNotifications Test ---------------------------\n"));
+ //
+ // 4. Add notification for a filename without a drive
+ // Create that file in the current drive
+ // Create that file in another drive
+ //
+ PrintLine();
+ TestNonDriveFilters();
+ test.Printf(_L("------- End of TestNonDriveFilters Test ------------------------------\n"));
+ //
+ // 5. Add notifications for 2 file creations
+ // Create 2 clients
+ // The clients create a file each
+ //
+ PrintLine();
+ __UHEAP_MARK;
+ r = TestTwoDoersL();
+ __UHEAP_MARKEND;
+ test(r==KErrNone);
+ test.Printf(_L("------- End of TwoDoers Test -----------------------------------------\n"));
+ //
+ // 6. Create 2 file server sessions
+ // Add a notification on each session for the same specific file creation
+ // Create that file
+ //
+ PrintLine();
+ __UHEAP_MARK;
+ r = TestTwoWatchersL();
+ __UHEAP_MARKEND;
+ test(r==KErrNone);
+ test.Printf(_L("------- End of TwoWatchers Test --------------------------------------\n"));
+ //
+ // 7. Create 2 file server sessions and 2 clients
+ // Add a notification on each session for different file creations
+ // Clients create a file each
+ //
+ PrintLine();
+ __UHEAP_MARK;
+ r = TestTwoWatchersTwoDoersL();
+ __UHEAP_MARKEND;
+ test(r==KErrNone);
+ test.Printf(_L("------- End of TwoWatchersTwoDoers Test ------------------------------\n"));
+ //
+ // 8. Add notification for a specific file creation
+ // Cancel the notification request
+ // Create that file
+ //
+ PrintLine();
+ __UHEAP_MARK;
+ r = TestCancelNotificationL();
+ __UHEAP_MARKEND;
+ test(r==KErrNone);
+ test.Printf(_L("------- End of CancelNotification Test -------------------------------\n"));
+ //
+ // 9. Create 2 file server sessions
+ // Add a notification on each session for the same specific file creation
+ // Delete the first notification
+ // Create that file
+ //
+ PrintLine();
+ test.Next(_L("TestClientRemoval"));
+ __UHEAP_MARK;
+ r = TestClientRemovalL();
+ __UHEAP_MARKEND;
+ test(r==KErrNone);
+ test.Printf(_L("------- End of TestClientRemoval Test --------------------------------\n"));
+ //
+ // 10. Create a CFsNotify object
+ // Close the session before closing the subsession
+ // Add notification and request notifications
+ //
+ PrintLine();
+ __UHEAP_MARK;
+ // Close session after creating the object
+ TestSessionClose(1);
+ __UHEAP_MARKEND;
+ __UHEAP_MARK;
+ // Close session after adding the notification
+ TestSessionClose(2);
+ __UHEAP_MARKEND;
+ test.Printf(_L("------- End of TestSessionClose Test ---------------------------------\n"));
+
+
+ //=========================================================================================
+ //! @SYMTestCaseID PBASE-T_NOTIFY-2444
+ //! @SYMTestType UT
+ //! @SYMREQ PREQ1847
+ //! @SYMTestCaseDesc File/Directory Create and Replace – Single File Server Session
+ //! @SYMTestStatus Implemented
+ //!
+ //! TFsNotificationType ECreate
+ //=========================================================================================
+ //
+ // RFile::Create
+ // 1. Add notification for a specific file creation
+ // Create that file
+ //
+ PrintLine();
+ test.Next(_L("EFileCreate Tests"));
+ _LIT(KFilename3,"file.create");
+ r = TestMultipleNotificationsL(_L(""),KFilename3,5,5,t_notification::EFileCreate,TFsNotification::ECreate,KMinNotificationBufferSize,(TBool)EFalse,__LINE__);
+ test(r==KErrNone);
+ test.Printf(_L("------- End of EFileCreate Tests -------------------------------------\n"));
+ //
+ // RFs::MkDir
+ // 2. Add notification for a specific directory creation
+ // Create that directory
+ //
+ PrintLine();
+ test.Next(_L("EFsMkDir Test"));
+ _LIT(KDirName1,"dirCreate\\");
+ r = TestMultipleNotificationsL(KDirName1,_L(""),1,1,t_notification::EFsMkDir,TFsNotification::ECreate,KMinNotificationBufferSize,(TBool)EFalse,__LINE__);
+ test(r==KErrNone);
+ test.Printf(_L("------- End of EFsMkDir Test -----------------------------------------\n"));
+ //
+ // RFile::Replace
+ // 3. Add notification for a specific file creation
+ // Replace that file
+ //
+ PrintLine();
+ test.Next(_L("EFileReplace Test"));
+ r = TestMultipleNotificationsL(_L(""),KFilename3,1,1,t_notification::EFileReplace,TFsNotification::ECreate,KMinNotificationBufferSize,(TBool)EFalse,__LINE__);
+ test(r==KErrNone);
+ test.Printf(_L("------- End of EFileReplace Test -------------------------------------\n"));
+ //
+ // 4. Add notification for a specific file creation
+ // Remove that notification
+ // Create that file
+ //
+ PrintLine();
+ __UHEAP_MARK;
+ r = TestAddRemoveNotificationL();
+ __UHEAP_MARKEND;
+ test(r==KErrNone);
+ test.Printf(_L("------- End of Add and Remove Notification Test ----------------------\n"));
+ //
+ // Wildcard Create Tests
+ // 5. Add notification for file creation using wildcard name
+ // Add notification for file/directory wildcard including subdirectories
+ // Create number of files and directories that match each notification
+ //
+ PrintLine();
+ test.Next(_L("Wildcard Create Tests"));
+ //
+ // Wildcard Name
+ _LIT(KWildcardName1,"*");
+ r = TestMultipleNotificationsL(_L(""),KWildcardName1,1,1,t_notification::EFileCreate,TFsNotification::ECreate,KMinNotificationBufferSize,(TBool)EFalse,__LINE__);
+ test(r==KErrNone);
+ r = TestMultipleNotificationsL(KWildcardName1,KWildcardName1,1,1,t_notification::EFileCreate_subs,TFsNotification::ECreate,KMinNotificationBufferSize,(TBool)EFalse,__LINE__);
+ test(r==KErrNone);
+ r = TestMultipleNotificationsL(KWildcardName1,KWildcardName1,1,1,t_notification::EFileCreate_subs_nowatch,TFsNotification::ECreate,KMinNotificationBufferSize,(TBool)ETrue,__LINE__);
+ test(r==KErrNone);
+ //
+ // Wildcard including Subdirectories
+ _LIT(KWildcardName2,"*\\");
+ r = TestMultipleNotificationsL(KWildcardName2,KWildcardName1,1,1,t_notification::EFileCreate,TFsNotification::ECreate,KMinNotificationBufferSize,(TBool)ETrue,__LINE__);
+ test(r==KErrNone);
+ r = TestMultipleNotificationsL(KWildcardName2,KWildcardName1,1,1,t_notification::EFileCreate_subs_nowatch,TFsNotification::ECreate,KMinNotificationBufferSize,(TBool)EFalse,__LINE__);
+ test(r==KErrNone);
+ _LIT(KDirName2,"SubDir\\");
+ _LIT(KWildcardName3,"?");
+ r = TestMultipleNotificationsL(KDirName2,KWildcardName3,1,1,t_notification::EFileCreate_subs_nowatch,TFsNotification::ECreate,KMinNotificationBufferSize,(TBool)EFalse,__LINE__);
+ test(r==KErrNone);
+ //
+ // Wildcard Type
+ _LIT(KWildcardName4,"*.*");
+ r = TestMultipleNotificationsL(_L(""),KWildcardName4,1,1,t_notification::EFileCreate_txt_nowatch,TFsNotification::ECreate,KMinNotificationBufferSize,(TBool)EFalse,__LINE__);
+ test(r==KErrNone);
+ r = TestMultipleNotificationsL(_L(""),KWildcardName4,1,1,t_notification::EFileCreate_subs_nowatch,TFsNotification::ECreate,KMinNotificationBufferSize,(TBool)ETrue,__LINE__);
+ test(r==KErrNone);
+ //
+ // 6. Add notification for file creation for a specific type
+ // Create file with that type
+ // Create file with different type
+ //
+ _LIT(KWildcardName5,"*.txt");
+ r = TestMultipleNotificationsL(_L(""),KWildcardName5,1,1,t_notification::EFileCreate_txt,TFsNotification::ECreate,KMinNotificationBufferSize,(TBool)EFalse,__LINE__);
+ test(r==KErrNone);
+ test.Printf(_L("------- End of Wildcard Create Tests ---------------------------------\n"));
+
+
+ //=============================================================================
+ //! @SYMTestCaseID PBASE-T_NOTIFY-2445
+ //! @SYMTestType UT
+ //! @SYMREQ PREQ1847
+ //! @SYMTestCaseDesc File Attribute Change – Single File Server Session
+ //! @SYMTestStatus Implemented
+ //
+ // TFsNotificationType EAttribute
+ //=============================================================================
+ //
+ // RFile::SetAtt, RFile::Set and RFs::SetEntry
+ // 1. Add notification for a specific file attribute change
+ // Change the attribute for that file
+ //
+ PrintLine();
+ test.Next(_L("Attribute Tests"));
+ _LIT(KFilename4,"file.setatts");
+ r = TestMultipleNotificationsL(_L(""),KFilename4,1,1,t_notification::EFileSetAtt,TFsNotification::EAttribute,KMinNotificationBufferSize,(TBool)EFalse,__LINE__);
+ test(r==KErrNone);
+ r = TestMultipleNotificationsL(_L(""),KFilename4,1,1,t_notification::EFileSet,TFsNotification::EAttribute,KMinNotificationBufferSize,(TBool)EFalse,__LINE__);
+ test(r==KErrNone);
+ r = TestMultipleNotificationsL(_L(""),KFilename4,1,1,t_notification::EFsSetEntry,TFsNotification::EAttribute,KMinNotificationBufferSize,(TBool)EFalse,__LINE__);
+ test(r==KErrNone);
+ //
+ // Wildcard Attribute Test including subdirectories
+ // 2. Add notification for file attribute change using wildcard name
+ // Create number of files that match the notification
+ // Change attributes of some files
+ //
+ r = TestMultipleNotificationsL(KWildcardName2,_L("*"),3,3,t_notification::EFileSetAtt_subs,TFsNotification::EAttribute,KMinNotificationBufferSize,(TBool)EFalse,__LINE__);
+ test(r==KErrNone);
+ test.Printf(_L("------- End of Attribute Tests ---------------------------------------\n"));
+
+
+ //=============================================================================
+ //! @SYMTestCaseID PBASE-T_NOTIFY-2446
+ //! @SYMTestType UT
+ //! @SYMREQ PREQ1847
+ //! @SYMTestCaseDesc File/Directory Rename – Single File Server Session
+ //! @SYMTestStatus Implemented
+ //
+ // TFsNotificationType ERename
+ //=============================================================================
+ //
+ // RFs::Replace, RFs::Rename and RFile::Rename
+ // 1. Add notification for a specific file rename change
+ // Rename that file
+ //
+ PrintLine();
+ test.Next(_L("Rename Tests"));
+ _LIT(KFilename5,"file.rename");
+ r = TestMultipleNotificationsL(_L(""),KFilename5,1,1,t_notification::EFsReplace,TFsNotification::ERename,KMinNotificationBufferSize,(TBool)EFalse,__LINE__);
+ test(r==KErrNone);
+ r = TestMultipleNotificationsL(_L(""),KFilename5,1,1,t_notification::EFsRename,TFsNotification::ERename,KMinNotificationBufferSize,(TBool)EFalse,__LINE__);
+ test(r==KErrNone);
+ r = TestMultipleNotificationsL(_L(""),KFilename5,1,1,t_notification::EFileRename,TFsNotification::ERename,KMinNotificationBufferSize,(TBool)EFalse,__LINE__);
+ test(r==KErrNone);
+ //
+ // 2. Add notification for a specific directory rename
+ // Rename that directory
+ //
+ _LIT(KDirName3,"dirRename\\");
+ r = TestMultipleNotificationsL(KDirName3,_L(""),1,1,t_notification::EFsRename_dir,TFsNotification::ERename,KMinNotificationBufferSize,(TBool)EFalse,__LINE__);
+ test(r==KErrNone);
+ //
+ // 3. Add notification for file rename using wildcard name
+ // Create file that match the notification
+ // Repeatedly rename the file
+ //
+ r = TestMultipleNotificationsL(_L(""),KWildcardName1,3,3,t_notification::EFileRename_wild,TFsNotification::ERename,KMinNotificationBufferSize,(TBool)EFalse,__LINE__);
+ test(r==KErrNone);
+ test.Printf(_L("------- End of Rename Tests ------------------------------------------\n"));
+
+
+ //=============================================================================
+ //! @SYMTestCaseID PBASE-T_NOTIFY-2447
+ //! @SYMTestType UT
+ //! @SYMREQ PREQ1847
+ //! @SYMTestCaseDesc File/Directory Delete – Single File Server Session
+ //! @SYMTestStatus Implemented
+ //
+ // TFsNotificationType EDelete
+ //=============================================================================
+ //
+ // RFs::Delete
+ // 1. Add notification for a specific file delete
+ // Delete that file
+ //
+ PrintLine();
+ test.Next(_L("EFsDelete Test"));
+ _LIT(KFilename6,"file.delete");
+ r = TestMultipleNotificationsL(_L(""),KFilename6,1,1,t_notification::EFsDelete,TFsNotification::EDelete,KMinNotificationBufferSize,(TBool)EFalse,__LINE__);
+ test(r==KErrNone);
+ //
+ // RFs::RmDir
+ // 2. Add notification for a specific directory delete
+ // Delete that directory
+ //
+ PrintLine();
+ test.Next(_L("EFsRmDir Tests"));
+ _LIT(KDirName4,"dirRemove\\");
+ r = TestMultipleNotificationsL(KDirName4,_L(""),1,1,t_notification::EFsRmDir,TFsNotification::EDelete,KMinNotificationBufferSize,(TBool)EFalse,__LINE__);
+ test(r==KErrNone);
+ //
+ // This test should not receive any notifications because a non-empty directory cannot be removed
+ // 3. Add notification for specific directory delete
+ // Create files inside that directory
+ // Delete the directory
+ //
+ _LIT(KDirName5,"dirRmNonEmp\\");
+ r = TestMultipleNotificationsL(KDirName5,_L(""),1,1,t_notification::EFsRmDir_nonEmpty,TFsNotification::EDelete,KMinNotificationBufferSize,(TBool)ETrue,__LINE__);
+ test(r==KErrNone);
+ //
+ // Wildcard Name ("*")
+ // 4. Add notification for directory delete using wildcard name
+ // Create directory that match the notification
+ // Delete that directory
+ //
+ r = TestMultipleNotificationsL(KWildcardName1,_L(""),1,1,t_notification::EFsRmDir_wild,TFsNotification::EDelete,KMinNotificationBufferSize,(TBool)EFalse,__LINE__);
+ test(r==KErrNone);
+ //
+ // Wildcard Type ("*.txt")
+ // Creates files with different types and should only receive notifications from "*.txt" file deletions
+ // 5. Add notification for file deletes using wildcard type
+ // Create number of files that match the notification
+ // Delete those files
+ //
+ r = TestMultipleNotificationsL(_L(""),KWildcardName4,3,3,t_notification::EFsDelete,TFsNotification::EDelete,KMinNotificationBufferSize,(TBool)EFalse,__LINE__);
+ test(r==KErrNone);
+ test.Printf(_L("------- End of Delete Tests ------------------------------------------\n"));
+
+
+ //======================================================================
+ //! @SYMTestCaseID PBASE-T_NOTIFY-2448
+ //! @SYMTestType UT
+ //! @SYMREQ PREQ1847
+ //! @SYMTestCaseDesc File Change – Single File Server Session
+ //! @SYMTestStatus Implemented
+ //
+ // TFsNotificationType EFileChange
+ //======================================================================
+ //
+ // File Write
+ // If caching is enabled, notifications are received only when the file cache is flushed
+ // We flush everytime we do a write to ensure the tests work regardless of cache
+ //
+ // 1. Add notification for a specific file change
+ // Create the file
+ // Write to that file
+ //
+ PrintLine();
+ test.Next(_L("EFileWrite Tests"));
+ _LIT(KFilename7,"file.write");
+ __UHEAP_MARK;
+ r = TestMultipleNotificationsL(_L(""),KFilename7,7,7,t_notification::EFileWrite,TFsNotification::EFileChange,3*KMinNotificationBufferSize,(TBool)EFalse,__LINE__);
+ __UHEAP_MARKEND;
+ test(r==KErrNone);
+ //
+ // 2. Add notification for a specific file change
+ // Write to the specified file a number of times without changing its size
+ //
+ // Four letters are written to a file, then the first letter in the file is replaced aIterations times
+ // aMaxNotifications = 1 + aIterations
+ //
+ r = TestMultipleNotificationsL(_L(""),KFilename7,3,4,t_notification::EFileWrite_samesize,TFsNotification::EFileChange,KMinNotificationBufferSize,(TBool)EFalse,__LINE__);
+ test(r==KErrNone);
+ test.Printf(_L("------- End of EFileWrite Tests --------------------------------------\n"));
+ //
+ // 3. Add notification for a specific file change
+ // Write to that file asynchronously
+ //
+ PrintLine();
+ test.Next(_L("EFileWrite_async Tests"));
+ _LIT(KFilename8,"async.write");
+ __UHEAP_MARK;
+ r = TestMultipleNotificationsL(_L(""),KFilename8,4,4,t_notification::EFileWrite_async,TFsNotification::EFileChange,2*KMinNotificationBufferSize,(TBool)EFalse,__LINE__);
+ __UHEAP_MARKEND;
+ test(r==KErrNone);
+ test.Printf(_L("------- End of EFileWrite_async Tests --------------------------------\n"));
+ //
+ // File Set Size
+ // 4. Add notification for a specific file change
+ // Both increase and decrease the file sizes a number of times
+ //
+ // The file size is increased aIterations times, and decreased (aIterations - 1) times
+ // aMaxNotifications = 2*aIterations - 1
+ //
+ PrintLine();
+ test.Next(_L("EFileSetSize Tests"));
+ _LIT(KFilename9,"file.setsize");
+ r = TestMultipleNotificationsL(_L(""),KFilename9,5,9,t_notification::EFileSetSize,TFsNotification::EFileChange,3*KMinNotificationBufferSize,(TBool)EFalse,__LINE__);
+ test(r==KErrNone);
+ test.Printf(_L("------- End of EFileSetSize Tests ------------------------------------\n"));
+
+
+ //
+ PrintLine();
+ test.Next(_L("CFileMan Tests"));
+ _LIT(KFilenameCFMan,"cf1le.man");
+ TUint notificationTypes = (TUint)TFsNotification::ECreate|TFsNotification::EFileChange|TFsNotification::EAttribute|TFsNotification::EDelete|TFsNotification::ERename;
+ r = TestMultipleNotificationsL(_L(""),KFilenameCFMan,1,5,t_notification::ECFileManMove,notificationTypes,KMinNotificationBufferSize,(TBool)EFalse,__LINE__);
+ test(r==KErrNone);
+ test.Printf(_L("------- End of CFileMan Tests -------------------------------------\n"));
+
+
+ //========================================================================================
+ //! @SYMTestCaseID PBASE-T_NOTIFY-2449
+ //! @SYMTestType UT
+ //! @SYMREQ PREQ1847
+ //! @SYMTestCaseDesc File System Mounted/Dismounted, Media Card Removal/Insertion,
+ // RawDisk Write – Single File Server Session
+ //! @SYMTestStatus Implemented
+ //
+ // TFsNotificationType EMediaChange
+ //========================================================================================
+ //
+ // RFs::DismountFileSystem
+ // 1. Add notification for media change
+ // Dismount the file system
+ //
+ PrintLine();
+ test.Next(_L("Mount Tests"));
+ TFullName filesystemName;
+ r = TheFs.FileSystemName(filesystemName,globalDriveNum);
+ test(r==KErrNone);
+ r = TestMultipleNotificationsL(filesystemName,1,1,t_notification::EDismount,TFsNotification::EMediaChange,KMinNotificationBufferSize,(TBool)EFalse,__LINE__);
+ test(r==KErrNone);
+ //
+ // RFs::MountFileSystem
+ // 2. Add notification for media change
+ // Mount the file system
+ //
+ r = TestMultipleNotificationsL(filesystemName,1,1,t_notification::EMount,TFsNotification::EMediaChange,KMinNotificationBufferSize,(TBool)EFalse,__LINE__);
+ test(r==KErrNone);
+ //
+ // Repeatedly mount and dismount the file system
+ // 3. Add notification for media change
+ // Repeatedly dismount and mount the file system
+ //
+ // The file system is dismounted and mounted aIterations times
+ // aMaxNotifications = 2*aIterations
+ //
+ r = TestMultipleNotificationsL(filesystemName,5,10,t_notification::EMountDismount,TFsNotification::EMediaChange,3*KMinNotificationBufferSize,(TBool)EFalse,__LINE__);
+ test(r==KErrNone);
+ //
+ // RFs::MountFileSystemAndScan
+ // 4. Add notification for media change
+ // Mount and scan the file system
+ //
+ // The file system is dismounted and mounted aIterations times
+ // aMaxNotifications = 2*aIterations
+ //
+//#ifndef __WINS__
+// r = TestMultipleNotificationsL(filesystemName,1,2,t_notification::EMountScan,TFsNotification::EMediaChange,KMinNotificationBufferSize,(TBool)EFalse,__LINE__);
+// test(r==KErrNone);
+//#endif
+ test.Printf(_L("------- End of Mount Tests -------------------------------------------\n"));
+ TDriveInfo drvInfo;
+ TInt driveNum;
+ TheFs.CharToDrive(gDriveToTest,driveNum);
+ r = TheFs.Drive(drvInfo,driveNum);
+ test (r == KErrNone);
+ TPtrC driveDes((TText*)&gDriveToTest,1);
+ //
+ // Manual Tests - Will only run on removable drives
+ //
+/* if(drvInfo.iDriveAtt & KDriveAttRemovable)
+ {
+ //
+ // 5. Add notification for media change
+ // Remove media card manually
+ //
+ PrintLine();
+ test.Next(_L("Media Card Removal/Insertion Tests"));
+ r = TestMultipleNotificationsL(driveDes,1,1,t_notification::EMediaCardRemoval,TFsNotification::EMediaChange,KMinNotificationBufferSize,(TBool)EFalse,__LINE__);
+ test(r==KErrNone);
+ //
+ // 6. Add notification for media change
+ // Insert media card manually
+ //
+ r = TestMultipleNotificationsL(driveDes,1,1,t_notification::EMediaCardInsertion,TFsNotification::EMediaChange,KMinNotificationBufferSize,(TBool)EFalse,__LINE__);
+ test(r==KErrNone);
+ test.Printf(_L("------- End of Media Card Removal/Insertion Tests --------------------\n"));
+ //
+ // We should receive an EMediaChange notification even though we did not register for it
+ // 7. Do not add notification for media change
+ // Remove and insert media card manually
+ //
+ PrintLine();
+ TestMediaCardNotificationWhenNotRegisteredForIt();
+ test.Printf(_L("------- End of TestMediaCardNotificationWhenNotRegisteredForIt -------\n"));
+ }
+*/ //
+ // RRawDisk::Write
+ // 8. Add notification for media change
+ // Write directly to the media
+ //
+#ifdef __WINS__
+ if(gDriveToTest-(TChar)'A' != 2)
+#endif
+ {
+ PrintLine();
+ test.Next(_L("RRawDisk::Write Tests"));
+ r = TestMultipleNotificationsL(driveDes,1,1,t_notification::ERawDiskWrite,TFsNotification::EMediaChange,KMinNotificationBufferSize,(TBool)EFalse,__LINE__);
+ test(r==KErrNone);
+ test.Printf(_L("------- End of RRawDisk::Write Test ------------------------------ \n"));
+ }
+
+
+ //===============================================================================
+ //! @SYMTestCaseID PBASE-T_NOTIFY-2450
+ //! @SYMTestType UT
+ //! @SYMREQ PREQ1847
+ //! @SYMTestCaseDesc Drive Name Modification – Single File Server Session
+ //! @SYMTestStatus Implemented
+ //
+ // TFsNotificationType EDriveName
+ //===============================================================================
+ //
+ // RFs::SetDriveName
+ // The drive name is renamed 2*aIterations times
+ // aMaxNotifications = 2*aIterations
+ //
+ // 1. Add notification for a specific drive name change
+ // Change the drive name
+ //
+ PrintLine();
+ test.Next(_L("DriveName Test"));
+ r = TestMultipleNotificationsL(driveDes,1,2,t_notification::ESetDriveName,TFsNotification::EDriveName,KMinNotificationBufferSize,(TBool)EFalse,__LINE__);
+ test(r==KErrNone);
+ //
+ // 2. Add notification for a specific drive name change
+ // Repeatedly rename the drive
+ //
+ r = TestMultipleNotificationsL(driveDes,3,6,t_notification::ESetDriveName,TFsNotification::EDriveName,KMinNotificationBufferSize,(TBool)EFalse,__LINE__);
+ test(r==KErrNone);
+ test.Printf(_L("------- End of DriveName Test ----------------------------------------\n"));
+
+
+ //================================================================================
+ //! @SYMTestCaseID PBASE-T_NOTIFY-2451
+ //! @SYMTestType UT
+ //! @SYMREQ PREQ1847
+ //! @SYMTestCaseDesc Volume Name Modification – Single File Server Session
+ //! @SYMTestStatus Implemented
+ //
+ // TFsNotificationType EVolumeName
+ //================================================================================
+ //
+ // RFs::SetVolumeLabel - Does not run on WINS
+ // The volume name is renamed 2*aIterations times
+ // aMaxNotifications = 2*aIterations
+ //
+#ifndef __WINS__
+ PrintLine();
+ test.Next(_L("VolumeName Test"));
+ //
+ // 1. Add notification for a specific volume name change
+ // Change the volume name
+ //
+ r = TestMultipleNotificationsL(driveDes,1,2,t_notification::ESetVolumeLabel,TFsNotification::EVolumeName,KMinNotificationBufferSize,(TBool)EFalse,__LINE__);
+ test(r==KErrNone);
+ //
+ // 2. Add notification for a specific volume name change
+ // Repeatedly rename the volume
+ //
+ r = TestMultipleNotificationsL(driveDes,3,6,t_notification::ESetVolumeLabel,TFsNotification::EVolumeName,KMinNotificationBufferSize,(TBool)EFalse,__LINE__);
+ test(r==KErrNone);
+ test.Printf(_L("------- End of VolumeName Test ---------------------------------------\n"));
+#endif
+
+
+ //=============================================================================
+ //! @SYMTestCaseID PBASE-T_NOTIFY-2452
+ //! @SYMTestType UT
+ //! @SYMREQ PREQ1847
+ //! @SYMTestCaseDesc All Operations Filter – Single File Server Session
+ //! @SYMTestStatus Implemented
+ //
+ // TFsNotificationType EAllOps
+ //=============================================================================
+ PrintLine();
+ test.Next(_L("AllOps Tests"));
+ //
+ // 1. Add notification for all operations
+ // Create a file
+ // Delete the file
+ //
+ // EAllOps1: A file is created and deleted aIterations times
+ // aMaxNotification = 2*aIterations
+ //
+ _LIT(KFilename10,"file.allops");
+ r = TestMultipleNotificationsL(_L(""),KFilename10,4,8,t_notification::EAllOps1,(TUint)TFsNotification::EAllOps,KMinNotificationBufferSize,(TBool)EFalse,__LINE__);
+ test(r==KErrNone);
+ //
+ // 2. Add notification for all operations
+ // Create a file
+ // Write to the file
+ // Delete the file
+ //
+ // EAllOps2: A file is created, written to aIterations times and then deleted
+ // aMaxNotification = 2 + aIterations (See File Write Tests)
+ //
+ r = TestMultipleNotificationsL(_L(""),KFilename10,4,6,t_notification::EAllOps2,(TUint)TFsNotification::EAllOps,2*KMinNotificationBufferSize,(TBool)EFalse,__LINE__);
+ test(r==KErrNone);
+ //
+ // 3. Add notification for all operations
+ // Create a file
+ // Change the file size
+ // Delete the file
+ //
+ // EAllOps3: A file is created, its size is increased size aIterations times, decreased (aIterations - 1) times
+ // and then deleted
+ // aMaxNotifications = 1 + 2*aIterations
+ //
+ r = TestMultipleNotificationsL(_L(""),KFilename10,4,6,t_notification::EAllOps3,(TUint)TFsNotification::EAllOps,KMinNotificationBufferSize,(TBool)EFalse,__LINE__);
+ test(r==KErrNone);
+ //
+ // 4. Add notification for all operations
+ // Create a file
+ // Change the file attribute
+ // Delete the file
+ //
+ // EAllOps4: A file is created, its attribute is changed and the file is deleted
+ // aMaxNotification = 3
+ //
+ r = TestMultipleNotificationsL(_L(""),KFilename10,1,3,t_notification::EAllOps4,(TUint)TFsNotification::EAllOps,KMinNotificationBufferSize,(TBool)EFalse,__LINE__);
+ test(r==KErrNone);
+ //
+ // 5. Add notification for all operations
+ // Create a file
+ // Rename the file
+ //
+ // EAllOps5: A file is created and renamed
+ // aMaxNotification = 2
+ //
+ r = TestMultipleNotificationsL(_L(""),KFilename10,1,2,t_notification::EAllOps5,(TUint)TFsNotification::EAllOps,KMinNotificationBufferSize,(TBool)EFalse,__LINE__);
+ test(r==KErrNone);
+ //
+ // 6. Add notification for all operations
+ // Change drive name
+ // Change volume name
+ //
+ // SetVolumeLabel does not run on WINS
+ // EAllOps6: The drive and volume names are changed
+ // aMaxNotification = 2
+ //
+#ifndef __WINS__
+ r = TestMultipleNotificationsL(driveDes,1,2,t_notification::EAllOps6,(TUint)TFsNotification::EAllOps,KMinNotificationBufferSize,(TBool)EFalse,__LINE__);
+ test(r==KErrNone);
+#endif
+ test.Printf(_L("------- End of AllOps Tests ------------------------------------------\n"));
+
+
+ //=============================================================================
+ //! @SYMTestCaseID PBASE-T_NOTIFY-2453
+ //! @SYMTestType UT
+ //! @SYMREQ PREQ1847
+ //! @SYMTestCaseDesc Multiple Filters – Single File Server Session
+ //! @SYMTestStatus Implemented
+ //=============================================================================
+ PrintLine();
+ test.Next(_L("Multiple-Filter Tests"));
+ //
+ // TFsNotification::ECreate | TFsNotification::EDelete
+ // 1. Add notification for create and delete for a specific file
+ // Create that file
+ // Delete the file
+ //
+ // A file is created and deleted aIterations times
+ // aMaxNotification = 2*aIterations
+ //
+ _LIT(KFilename11,"file.mulfil");
+ r = TestMultipleNotificationsL(_L(""),KFilename11,3,6,t_notification::EAllOps1,TFsNotification::ECreate | TFsNotification::EDelete,2*KMinNotificationBufferSize,(TBool)EFalse,__LINE__);
+ test(r==KErrNone);
+ //
+ // TFsNotification::EDelete | TFsNotification::ECreate | TFsNotification::EFileChange
+ // 2. Add notification for create, file change and delete for a specific file
+ // Create a file
+ // Change the file size
+ // Delete the file
+ //
+ // A file is created, its size is increased size aIterations times, decreased (aIterations - 1) times
+ // and then deleted
+ // aMaxNotifications = 1 + 2*aIterations
+ //
+ r = TestMultipleNotificationsL(_L(""),KFilename11,4,6,t_notification::EAllOps3,TFsNotification::EDelete | TFsNotification::ECreate | TFsNotification::EFileChange,KMinNotificationBufferSize,(TBool)EFalse,__LINE__);
+ test(r==KErrNone);
+ //
+ // TFsNotification::EAttribute | TFsNotification::EDelete | TFsNotification::ECreate
+ // 3. Add notification for create, attribute change and delete for a specific file
+ // Create a file
+ // Change the file attribute
+ // Delete the file
+ //
+ // A file is created, its attribute is changed and the file is deleted
+ // aMaxNotification = 3
+ //
+ r = TestMultipleNotificationsL(_L(""),KFilename11,1,3,t_notification::EAllOps4,TFsNotification::EAttribute | TFsNotification::EDelete | TFsNotification::ECreate,KMinNotificationBufferSize,(TBool)EFalse,__LINE__);
+ test(r==KErrNone);
+ //
+ // TFsNotification::ERename | TFsNotification::ECreate
+ // 4. Add notification for create and rename for a specific file
+ // Create a file
+ // Rename the file
+ //
+ // A file is created and renamed
+ // aMaxNotification = 2
+ //
+ r = TestMultipleNotificationsL(_L(""),KFilename11,1,2,t_notification::EAllOps5,TFsNotification::ERename | TFsNotification::ECreate,KMinNotificationBufferSize,(TBool)EFalse,__LINE__);
+ test(r==KErrNone);
+ //
+ // TFsNotification::EVolumeName | TFsNotification::EDriveName
+ // 5. Add notification for drive and volume name change for a specific drive
+ // Change drive name
+ // Change volume name
+ //
+ // SetVolumeLabel does not run on WINS
+ // The drive and volume names are changed
+ // aMaxNotification = 2
+ //
+#ifndef __WINS__
+ r = TestMultipleNotificationsL(driveDes,1,2,t_notification::EAllOps6,TFsNotification::EVolumeName | TFsNotification::EDriveName,KMinNotificationBufferSize,(TBool)EFalse,__LINE__);
+ test(r==KErrNone);
+#endif
+ test.Printf(_L("------- End of Multiple-Filter Tests ---------------------------------\n"));
+
+
+ //==============================================================================
+ //! @SYMTestCaseID PBASE-T_NOTIFY-2454
+ //! @SYMTestType UT
+ //! @SYMREQ PREQ1847
+ //! @SYMTestCaseDesc Overflow Notification – Single File Server Session
+ //! @SYMTestStatus Implemented
+ //==============================================================================
+ //
+ // 1. Add notification with a small buffer size, for a specific file change
+ // Change the file size once
+ // 2. Make continuous file size changes to the file
+ // 3. When overflow notification occurs, delete the notification
+ //
+ PrintLine();
+ r = TestOverflowL();
+ test(r==KErrNone);
+
+ //For DEF140387
+ PrintLine();
+ r= TestPostOverflowNotifications();
+ test(r==KErrNone);
+ test.Printf(_L("------- End of Overflow Test -----------------------------------------\n"));
+
+
+ //============================================================================
+ //! @SYMTestCaseID PBASE-T_NOTIFY-2455
+ //! @SYMTestType CIT
+ //! @SYMREQ PREQ1847
+ //! @SYMTestCaseDesc API Negative Testing – Single File Server Session
+ //! @SYMTestStatus Implemented
+ //============================================================================
+ // 1.
+ // a-CFsNotify class creation with zero buffer size
+ //
+ // 2.
+ // b-CFsNotify class creation with negative buffer size
+ // c-CFsNotify class creation with buffer size that is too large
+ //
+ // 3.
+ // d-Call AddNotification with aNotiififcationType zero
+ // e-Call AddNotification with aNotiififcationType invalid
+ // f-Call AddNotification with many different invalid paths
+ //
+ // 4.
+ // g-Call RequestNotifications with status that is already in use
+ // h-Call CancelNotifications with wrong status
+ //
+ PrintLine();
+ __UHEAP_MARK;
+ NegativeTests();
+ __UHEAP_MARKEND;
+ //
+ // 5.
+ // i-Negative testing for directory without *
+ //
+ test.Printf(_L("NegativeTests() I\n"));
+ NegativeTestDirStar();
+ test.Printf(_L("------- End of Negative Tests ----------------------------------------\n"));
+
+
+ //=============================================================================
+ //! @SYMTestCaseID PBASE-T_NOTIFY-2461
+ //! @SYMTestType CIT
+ //! @SYMREQ PREQ1847
+ //! @SYMTestCaseDesc Plugin Tests
+ //! @SYMTestStatus
+ //=============================================================================
+ PrintLine();
+ r = TestNotificationsWithFServPlugins();
+ test(r==KErrNone);
+ test.Printf(_L("------- End of Plugin Tests ------------------------------------------\n"));
+
+
+ //======================================================================
+ //! @SYMTestCaseID PBASE-T_NOTIFY-2459
+ //! @SYMTestType UT
+ //! @SYMREQ PREQ1847
+ //! @SYMTestCaseDesc Drive Formatting – Single File Server Session
+ //! @SYMTestStatus Implemented
+ //
+ // TFsNotificationType EMediaChange
+ //======================================================================
+ //
+ // RFormat
+ // We do these last so that we can be sure to have deleted anything we've inadvertently not deleted
+ //
+ // 1. Add notification for media change of a specific drive
+ // Format the drive
+ //
+#ifdef __WINS__
+ if(gDriveToTest-(TChar)'A' != 2)
+#endif
+ {
+ PrintLine();
+ test.Next(_L("Format Tests"));
+ r = TestMultipleNotificationsL(driveDes,1,1,t_notification::EFormat,TFsNotification::EMediaChange,KMinNotificationBufferSize,(TBool)EFalse,__LINE__);
+ test(r==KErrNone);
+ test.Printf(_L("------- End of Format Tests ------------------------------------------\n"));
+ }
+
+
+ //======================================================================
+ //! @SYMTestCaseID PBASE-T_NOTIFY-2460
+ //! @SYMTestType UT
+ //! @SYMREQ PREQ1847
+ //! @SYMTestCaseDesc Notifications for Data Caged Areas
+ //! @SYMTestStatus Implemented
+ //======================================================================
+ //
+ // Create a private folder for a specified uid
+ // Add notification filter using the following processes:
+ // 1. A process with no capability
+ // 2. A process with all capabilities
+ // 3. A process with the specified uid
+ //
+ PrintLine();
+ test.Next(_L("Test T_NOTIFIER_NOCAPS.EXE"));
+ r = TestProcessCapabilities(_L("T_NOTIFIER_NOCAPS.EXE"));
+ test(r == KErrPermissionDenied); //Failure on emulator -> Did you forget to do a wintest?
+
+ test.Next(_L("Test T_NOTIFIER_ALLFILES.EXE"));
+ r = TestProcessCapabilities(_L("T_NOTIFIER_ALLFILES.EXE"));
+ test(r == KErrNone);
+
+ test.Next(_L("Test T_NOTIFIER_BELONGS.EXE"));
+ r = TestProcessCapabilities(_L("T_NOTIFIER_BELONGS.EXE"));
+ test(r == KErrNone);
+ test.Printf(_L("------- End of Data-Caging Tests -------------------------------------\n"));
+
+
+ test.End();
+ test.Close();
+ delete cleanup;
+ } //End of CallTestsL
+