// Copyright (c) 1996-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_notify.cpp

// 

//

#define __E32TEST_EXTENSION__

#include <f32file.h>

#include <e32test.h>

#include <e32svr.h>

#include <hal.h>

#include "t_server.h"

const TInt KHeapSize=0x200;

// wait for a bit since NotifyChange handled asynchronously and SetDriveName synchronously

const TInt KNotifyChangeAfter=100000;

const TInt KMediaRemountForceMediaChange = 0x00000001;

RTest test(_L("T_NOTIFY"));

RSemaphore gSleepThread;

TInt gSocketNumber=0;

TInt SocketToDrive[KMaxPBusSockets];

//#define __INCLUDE_MANUAL_TESTS__

void do_check_no_pending_requests(TInt aLine)

	{

	RTimer timer;

	TRequestStatus timerStat;

	timer.CreateLocal();

	timer.After(timerStat, 125000);

	User::WaitForAnyRequest();

	if(timerStat==KRequestPending)

		{

		RDebug::Printf("do_check_no_pending_requests failed at line %d",aLine);

		test(0);

		}

	timer.Close();

	}

#define CHECK_NO_PENDING_REQUESTS do_check_no_pending_requests(__LINE__);

TBool CheckDriveRead(TInt aDrive)

  //Determines if can connect to local drive number and read

	{

    TBusLocalDrive TBLD;

    TBool TBLDChangedFlag;

    TInt r = TBLD.Connect(aDrive, TBLDChangedFlag);

	test.Printf(_L("Connect returned %d\n"), r);

    if (r == KErrNone)

		{

        const TInt KSectSize = 512;

        TBuf8<KSectSize> sect;

        r = TBLD.Read(0, KSectSize, sect);

		test.Printf(_L("Read returned %d\n"), r);

        TBLD.Disconnect();

		if(r!=KErrNone)

			return EFalse;

		else

			return ETrue;

        }

	 else

		return EFalse;

	}

void GenerateMediaChange()

	{

    TPckgBuf<TInt> pckg;

    pckg()=0;

	RFs fs;

	TInt r = fs.Connect();

	if (r == KErrNone)

		{

		r = fs.RemountDrive(CurrentDrive(), &pckg, (TUint)KMediaRemountForceMediaChange);

		if(r == KErrNotReady)

			{

			r = KErrNone;

			}

		fs.Close();

		}

	if (r!=KErrNone)

		{

		RProcess me;

		me.Panic(_L("GenMedChg"),r);

		}

	}

enum TTestCode {ETest1,ETest2,ETest3,ETest4,ETest5,ETest6,ETest7,ETest8,ETest9,ETest10,ETest11,ETest12};

const TUint KGenericEntryChange=0x02;

static TInt ThreadEntryPoint(TAny* aTestCode)

//

// Thread entry point

//

	{

	RFs fs;

	TInt r=fs.Connect();

	test_KErrNone(r);

	r=fs.SetSessionPath(gSessionPath);

	test_KErrNone(r);

	TTestCode testCode=*(TTestCode*)&aTestCode;

	RFile f;

	switch (testCode)

		{

	case ETest1:

		r=f.Replace(fs,_L("\\F32-TST\\NOTIFY\\NewFile.txt"),EFileStream);

		test_KErrNone(r);

		f.Close();

		break;

	case ETest2:

		r=f.Replace(fs,_L("\\F32-TST\\NOTIFY\\MUNCHKINS\\Dorothy.doc"),EFileStream);

		test_KErrNone(r);

		f.Close();

		break;

	case ETest3:

		r=fs.MkDir(_L("\\F32-TST\\NOTIFY\\MUNCHKINS\\SCARECROW\\"));

		test_Value(r, (r == KErrNone)||(r==KErrAlreadyExists));

		break;

	case ETest4:

		{

		TRequestStatus s;

		fs.NotifyChange(ENotifyAll,s);

		test(s==KRequestPending);

		gSleepThread.Signal();

		User::After(100000000);

		}

		break;

	case ETest5:

		{

		RFile file;

		TInt r=file.Open(fs,_L("\\F32-TST\\NOTIFY\\kangaroo.txt"),EFileRead|EFileWrite);

		test_KErrNone(r);

		r=file.SetSize(sizeof(TCheckedUid));

		test_KErrNone(r);

		r=file.Write(sizeof(TCheckedUid),_L8("012345678912"));

		test_KErrNone(r);

		TBuf8<64> dum;

		r=file.Read(0,dum);

		test_KErrNone(r);

		file.Close();

		r=file.Open(fs,_L("\\F32-TST\\NOTIFY\\koala.txt"),EFileRead|EFileWrite);

		test_KErrNone(r);

		r=file.SetSize(50);

		test_KErrNone(r);

		r=file.Write(sizeof(TCheckedUid),_L8("ABCDEFGHIJKLMNOPQRSTUVWXYZ"));

		test_KErrNone(r);

		r=file.Read(0,dum);

		test_KErrNone(r);

		file.Close();

		r=file.Open(fs,_L("\\F32-TST\\NOTIFY\\dingo.txt"),EFileRead|EFileWrite);

		test_KErrNone(r);

		r=file.SetSize(50);

		test_KErrNone(r);

		r=file.Write(sizeof(TCheckedUid),_L8("01234567890123456789"));

		test_KErrNone(r);

		r=file.Read(0,dum);

		test_KErrNone(r);

		file.Close();

		gSleepThread.Signal();

		}

		break;

	case ETest6:

		{

		GenerateMediaChange();

		User::After(300000);			// Wait for a bit

		gSleepThread.Signal();

		}

		break;

	case ETest7:

		{

		RFile file;

		TInt r=file.Open(fs,_L("\\F32-TST\\NOTIFY\\NewFILE.TXT"),EFileRead|EFileWrite);

		test_KErrNone(r);

		r=file.Write(_L8("asdfasdfasdf"));

		test_KErrNone(r);

		file.Close();

		gSleepThread.Signal();

		}

		break;

	case ETest8:

		{

		r=f.Open(fs,_L("\\F32-TST\\NOTIFY\\MUNCHKINS\\WickedWitch.msg"),EFileRead|EFileWrite);

		test_KErrNone(r);

		f.SetSize(500);

		f.Close();

		break;

		}

	case ETest9:

		{

		TRequestStatus s;

		TFileName path=_L("\\F32-TST\\NOTIFY\\");

		fs.NotifyChange(ENotifyAll,s,path);

		test(s==KRequestPending);

		gSleepThread.Signal();

		User::After(100000000);

		}

		break;

	case ETest10:

		{

		TFileName path=_L("\\F32-TST\\NOTIFY\\BehindTheCurtain\\");

		r=fs.MkDir(path);

		test_KErrNone(r);

		break;

		}

	case ETest11:

		{

		TFileName path=_L("\\F32-TST\\NOTIFY\\BehindTheCurtain\\PayNoAttention.man");

		RFile file;

		r=file.Replace(fs,path,EFileStream);

		test_KErrNone(r);

		file.Close();

		break;

		}

	case ETest12:

		{

		RFile writer;

		TInt r=writer.Open(fs,_L("\\F32-TST\\NOTIFY\\NewFile.txt"),EFileWrite|EFileShareAny);

		test_KErrNone(r);

		TInt i;

		for(i=0; i<10; i++)

			{

			r=writer.Write(_L8("ABCDEFGHIJKLMNOPQRSTUVWXYZ"));

			test_KErrNone(r);

			User::After(1000000);

			}

		writer.Close();

		break;

		}

	default:

		break;

		}

	return KErrNone;

	}

#if defined (__EPOC32__)//we have no removable media on Emulator yet

static void WaitForMediaChange()

//

// Wait for media driver to register drive is present

//

	{

	TEntry entry;

	FOREVER

		{

		User::After(10000);

		TInt r=TheFs.Entry(_L("xxxxxxxx"),entry);

		if (r!=KErrNotReady)

			break;

		}

	}

#endif

static void Test1()

//

// Test notification of an entry change

//

	{

	test.Next(_L("Test notification of an entry change"));

	TRequestStatus reqStat(KRequestPending);

	TRequestStatus thrdStat(KRequestPending);

	TInt r;

	TheFs.NotifyChange(ENotifyEntry,reqStat);

	RThread thread;

	r=thread.Create(_L("MyThread"),ThreadEntryPoint,KDefaultStackSize,KHeapSize,KHeapSize,(TAny*)ETest1);

	test_KErrNone(r);

	thread.Logon(thrdStat);

	thread.Resume();

	User::WaitForRequest(thrdStat);

	test(thrdStat==KErrNone);

	thread.Close();

	User::WaitForRequest(reqStat);

	test(reqStat==KErrNone);

	RFile file;

	r=file.Open(TheFs,_L("\\F32-TST\\NOTIFY\\NewFile.txt"),EFileRead|EFileWrite|EFileShareExclusive);

	test_KErrNone(r);

	file.Write(_L8("Somewhere over the rainbow..."),reqStat);

	User::WaitForRequest(reqStat);

	test(reqStat==KErrNone);

	TBuf8<256> buf;

	file.Read(0, buf,reqStat);

	User::WaitForRequest(reqStat);

	test(reqStat==KErrNone);

	file.Close();

	r=file.Open(TheFs,_L("\\F32-TST\\NOTIFY\\NewFile.txt"),EFileRead|EFileReadAsyncAll|EFileShareExclusive);

	test_Value(r, r == KErrArgument);

	r=file.Open(TheFs,_L("\\F32-TST\\NOTIFY\\NewFile.txt"),EFileRead|EFileReadAsyncAll|EFileShareReadersOnly);

	test_Value(r, r == KErrArgument);

	r=file.Open(TheFs,_L("\\F32-TST\\NOTIFY\\NewFile.txt"),EFileRead|EFileReadAsyncAll|EFileShareAny);

	test_KErrNone(r);

	file.Read(0, buf, 100, reqStat);

	test(reqStat==KRequestPending);

	file.Close();

	User::WaitForRequest(reqStat);

	test(reqStat==KErrCancel);

	r=file.Open(TheFs,_L("\\F32-TST\\NOTIFY\\NewFile.txt"),EFileRead|EFileReadAsyncAll|EFileShareAny);

	test_KErrNone(r);

	file.Read(0, buf, 100, reqStat);

	test(reqStat==KRequestPending);

	file.ReadCancel(reqStat);

	User::WaitForRequest(reqStat);

	test(reqStat==KErrCancel);

	file.Close();

	r=file.Open(TheFs,_L("\\F32-TST\\NOTIFY\\NewFile.txt"),EFileRead|EFileReadAsyncAll|EFileWrite|EFileShareAny);

	test_KErrNone(r);

	file.Read(0, buf, 100, reqStat);

	test(reqStat==KRequestPending);

	file.SetSize(100);

	User::WaitForRequest(reqStat);

	test(reqStat==KErrNone);

	test(buf.Length() == 100);

	file.Close();

	test.Next(_L("Repeat Test notification of an entry change"));

	TheFs.NotifyChange(ENotifyEntry,reqStat);

	thread.Create(_L("MyThread2"),ThreadEntryPoint,KDefaultStackSize,KHeapSize,KHeapSize,(TAny*)ETest1);

	thread.Logon(thrdStat);

	thread.Resume();

	User::WaitForRequest(thrdStat);

	test(thrdStat==KErrNone);

	thread.Close();

	User::WaitForRequest(reqStat);

	if (reqStat!=KErrNone)

		{

		test.Printf(_L("ReqStat=%d\n"),reqStat.Int());

		//test.Getch();

		}

	test(reqStat==KErrNone);

	test.Next(_L("Test Notify cancel"));

	TheFs.NotifyChange(ENotifyEntry,reqStat);

	TheFs.NotifyChangeCancel();

	User::WaitForRequest(reqStat);

	test.Next(_L("Test notification still works"));

	TheFs.NotifyChange(ENotifyEntry,reqStat);

	thread.Create(_L("MyThread3"),ThreadEntryPoint,KDefaultStackSize,KHeapSize,KHeapSize,(TAny*)ETest1);

	thread.Logon(thrdStat);

	thread.Resume();

	User::WaitForRequest(thrdStat);

	test(thrdStat==KErrNone);

	thread.Close();

	User::WaitForRequest(reqStat);

	test(reqStat==KErrNone);

	}

static void Test2()

//

// Test notify for multiple clients

//

	{

	test.Next(_L("Test notification of multiple clients"));

	TRequestStatus reqStat1(KRequestPending);

	RFs fs1;

	TInt r=fs1.Connect();

	test_KErrNone(r);

	fs1.NotifyChange(ENotifyEntry,reqStat1);

	TRequestStatus reqStat2(KRequestPending);

	RFs fs2;

	r=fs2.Connect();

	test_KErrNone(r);

	fs2.NotifyChange(ENotifyEntry,reqStat2);

	test(reqStat1==KRequestPending);

	test(reqStat2==KRequestPending);

	r=TheFs.Delete(_L("\\F32-TST\\NOTIFY\\NEWFILE.TXT"));

	test_KErrNone(r);

	User::WaitForRequest(reqStat1);

	User::WaitForRequest(reqStat2);

	test(reqStat1==KErrNone);

	test(reqStat2==KErrNone);

	}

static void Test3()

//

// Test notify cancel

//

	{

	test.Next(_L("Cancel notification"));

	RFs fs1;

	TInt r=fs1.Connect();

	test_KErrNone(r);

	TRequestStatus status1;

	TRequestStatus status2;

	TRequestStatus status3;

	TRequestStatus status4;

	TRequestStatus status5;

	fs1.NotifyChange(ENotifyAll,status1);

	fs1.NotifyChange(ENotifyAll,status2);

	fs1.NotifyChange(ENotifyAll,status3);

	fs1.NotifyChange(ENotifyAll,status4);

	fs1.NotifyChange(ENotifyAll,status5);

	test(status1==KRequestPending);

	test(status2==KRequestPending);

	test(status3==KRequestPending);

	test(status4==KRequestPending);

	test(status5==KRequestPending);

	test.Next(_L("RFs::NotifyCancel()"));

//	Test that one call to RFs::NotifyCancel() cancels all outstanding requests

	fs1.NotifyChangeCancel();

	User::WaitForRequest(status1);

	test(status1==KErrCancel);

	User::WaitForRequest(status2);

	test(status2==KErrCancel);

	User::WaitForRequest(status3);

	test(status3==KErrCancel);

	User::WaitForRequest(status4);

	test(status4==KErrCancel);

	User::WaitForRequest(status5);

	test(status5==KErrCancel);

//	Call the cancel function again to check no further action

	fs1.NotifyChangeCancel();

//	Test overloaded function to cancel a single request

	test.Next(_L("Cancel notification request using function overload"));

	fs1.NotifyChange(ENotifyAll,status1);

	fs1.NotifyChange(ENotifyAll,status2);

	fs1.NotifyChange(ENotifyAll,status3);

	fs1.NotifyChange(ENotifyAll,status4);

	fs1.NotifyChange(ENotifyAll,status5);

	test(status1==KRequestPending);

	test(status2==KRequestPending);

	test(status3==KRequestPending);

	test(status4==KRequestPending);

	test(status5==KRequestPending);

//	Cancel the outstanding request with status5

	test.Next(_L("RFs::NotifyCancel()"));

	fs1.NotifyChangeCancel(status5);

	User::WaitForRequest(status5);

	test(status1==KRequestPending);

	test(status2==KRequestPending);

	test(status3==KRequestPending);

	test(status4==KRequestPending);

	test(status5==KErrCancel);

	fs1.NotifyChangeCancel(status2);

	User::WaitForRequest(status2);

	test(status1==KRequestPending);

	test(status2==KErrCancel);

	test(status3==KRequestPending);

	test(status4==KRequestPending);

	fs1.NotifyChangeCancel(status4);

	User::WaitForRequest(status4);

	test(status1==KRequestPending);

	test(status3==KRequestPending);

	test(status4==KErrCancel);

	fs1.NotifyChangeCancel(status4);	//	Test no side effects on trying to cancel a request

	test(status4==KErrCancel);			//	that has already been cancelled

	fs1.NotifyChangeCancel(status1);

	User::WaitForRequest(status1);

	test(status1==KErrCancel);

	test(status3==KRequestPending);

	fs1.NotifyChangeCancel(status1);	//	Test no side effects on trying to cancel a request

	test(status1==KErrCancel);			//	that has already been cancelled

	fs1.NotifyChangeCancel(status3);

	User::WaitForRequest(status3);

	test(status3==KErrCancel);

	fs1.Close();

	}

static void Test4()

//

// Test notify client death

//

	{

	test.Next(_L("Kill client"));

	TInt r=gSleepThread.CreateLocal(0);

	test_KErrNone(r);

	RThread clientThread;

	r=clientThread.Create(_L("ClientThread"),ThreadEntryPoint,0x4000,KHeapSize,KHeapSize,(TAny*)ETest4);

	if (r!=KErrNone)

		{

		test.Printf(_L(" ERROR: Failed to create clientthread %d\n"),r);

		test(0);