// 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

// 

//

#define __E32TEST_EXTENSION__

#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_KErrNone(r);

	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_KErrNone(r);

	TRequestStatus status;

	r = notify->RequestNotifications(status);

	test_KErrNone(r);

	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_KErrNone(r);

	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_KErrNone(r);

	r = drivePtr.Compare(drive);

	test_Value(r, 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_KErrNone(r);

		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_KErrNone(r);

	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_KErrNone(r);

		}

	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_KErrNone(r);

	r = notify2->AddNotification((TUint)TFsNotification::ECreate,path,filename);

	test_KErrNone(r);

	delete notify1; //Delete notify1 and ensure we still get notification on notify2

	TRequestStatus status;

	r = notify2->RequestNotifications(status);

	test_KErrNone(r);

	RFile file;

	file.Replace(fs,fullname,EFileWrite); //Replace produces Create notification

	file.Close();

	RTimer tim;

	r = tim.CreateLocal();

	test_KErrNone(r);

	TRequestStatus timStatus;

	TTimeIntervalMicroSeconds32 time = 10000000; //10 seconds

	tim.After(timStatus,time);

	User::WaitForRequest(status,timStatus);

	test(status!=KRequestPending);

	r = fs.Delete(fullname);

	test_KErrNone(r);

	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_KErrNone(r);

	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_KErrNone(r);

	TRequestStatus status;

	r = notify->RequestNotifications(status);

	test_KErrNone(r);

	RFile file;

	TBuf<40> filePath;

	filePath.Append((TChar)gDriveToTest);

	filePath.Append(_L(":\\file.root"));

	r = file.Replace(fs,filePath,EFileRead);

	test_KErrNone(r);

	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);