// Copyright (c) 1997-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_alert.cpp

 // 

 //

 #include <f32file.h>

 #include <e32test.h>

 #include <e32math.h>

 #include <e32svr.h>

 #include "t_server.h"

 GLDEF_D RTest test(_L("T_ALERT"));

 LOCAL_D TInt gFileWrites;

 LOCAL_D TInt gFileReads;

 LOCAL_D TInt gFileCreates;

 LOCAL_D TInt gFileDeletes;

 LOCAL_D TInt gNotifies;

 LOCAL_D TInt gNotifyCancels;

 LOCAL_D TInt gMediaChanges;

 LOCAL_D const TInt gMaxIteration=100;

 LOCAL_D const TInt KHeapSize=0x4000;

 LOCAL_D const TInt gMaxDelay=100;

 LOCAL_D const TInt gMaxMediaChangeInterval=1000;

 LOCAL_D const TInt gUpdateInterval=10000;

 LOCAL_D const TInt gMaxFiles=4;

 LOCAL_D const TInt gMaxTempSize=1024;

 LOCAL_D const TFileName gPathThread1=_L("C:\\F32-TST\\TALERT\\");

 // Test2

 LOCAL_D const TInt gHeartBeatInterval=10000000;

 LOCAL_D TInt gThreadTick;

 LOCAL_D TInt gFileCreateFail;

 #if defined(__WINS__)

 LOCAL_D const TFileName gPathThread0=_L("X:\\F32-TST\\TALERT\\");

 LOCAL_D const TFileName gPathThread2=_L("X:\\F32-TST\\TALERT\\");

 #else

 LOCAL_D TFileName gPathThread0=_L("?:\\F32-TST\\TALERT\\");

 LOCAL_D TFileName gPathThread2=_L("?:\\F32-TST\\TALERT\\");

 #endif

 LOCAL_C void WaitForMedia()

 //

 // Wait until the media change is serviced

 //

 	{

 	FOREVER

 		{

 		TInt r=TheFs.MkDir(gPathThread0);

 		if (r==KErrNone || r==KErrAlreadyExists)

 			break;

 		}

 	}

 LOCAL_C TInt FileAccess(TAny* aPathPtr)

 //

 // Do lots of file access - ignore all errors

 //

 	{

 	TFileName file[gMaxFiles];

 	TFileName sessionPath=*(TDesC*)aPathPtr;

 	HBufC8* tempPtr=HBufC8::New(gMaxTempSize);

 	HBufC* tempPtrx=HBufC::New(gMaxTempSize);

 	TPtr8 temp(tempPtr->Des());

 	TPtr tempx(tempPtrx->Des());

 	RFs fs;

 	fs.Connect();

 	fs.SetSessionPath(sessionPath);

 	FOREVER

 		{

 		switch(Math::Rand(gSeed)%4)

 			{

 		case 0:

 			{

 			TInt fileNum=Math::Rand(gSeed)%gMaxFiles;

 			if (file[fileNum].Length()==0)

 				break;

 			RFile f;

 			TInt r=f.Open(fs,file[fileNum],EFileRead|EFileWrite);

 			if (r!=KErrNone)

 				break;

 			CreateLongName(tempx,gSeed,Math::Rand(gSeed)%gMaxTempSize);

 			temp.Copy(tempx);

 			r=f.Write(temp);

 			if (r==KErrNone)

 				gFileWrites++;

 			f.Close();

 			break;

 			}

 		case 1:

 			{

 			TInt fileNum=Math::Rand(gSeed)%gMaxFiles;

 			if (file[fileNum].Length()==0)

 				break;

 			RFile f;

 			TInt r=f.Open(fs,file[fileNum],EFileRead|EFileWrite);

 			if (r!=KErrNone)

 				break;

 			r=f.Read(temp);

 			if (r==KErrNone)

 				gFileReads++;

 			f.Close();

 			break;

 			}

 		case 2:

 			{

 			TInt fileNum=Math::Rand(gSeed)%gMaxFiles;

 			if (file[fileNum].Length()!=0)

 				break;

 			RFile f;

 			TInt r=f.Temp(fs,sessionPath,file[fileNum],EFileRead|EFileWrite);

 			if (r==KErrNone)

 				gFileCreates++;

 			f.Close();

 			break;

 			}

 		case 3:

 			{

 			TInt fileNum=Math::Rand(gSeed)%gMaxFiles;

 			if (file[fileNum].Length()==0)

 				break;

 			TInt r=fs.Delete(file[fileNum]);

 			if (r==KErrNone)

 				{

 				file[fileNum].SetLength(0);

 				gFileDeletes++;

 				}

 			break;

 			}

 		default:

 			break;

 			}

 		}

 	//delete tempPtr;

 	//delete tempPtrx;

 	//return(KErrNone);

 	}

 LOCAL_C void StartThread0()

 //

 // Start a thread that reads and writes to D:

 //

 	{

 	RThread clientThread;

 	TInt r=clientThread.Create(_L("TALERT_Thread0"),FileAccess,0x4000,KHeapSize,KHeapSize,(TAny*)&gPathThread0,EOwnerThread);

 	test(r==KErrNone);

 	clientThread.Resume();

 	clientThread.Close();

 	}

 LOCAL_C void StartThread1()

 //

 // Start a thread that reads and writes to C:

 //

 	{

 	RThread clientThread;

 	TInt r=clientThread.Create(_L("TALERT_Thread1"),FileAccess,0x4000,KHeapSize,KHeapSize,(TAny*)&gPathThread1,EOwnerThread);

 	test(r==KErrNone);

 	clientThread.Resume();

 	clientThread.Close();

 	}

 LOCAL_C void StartThread2()

 //

 // Start a thread that reads and writes to D:

 //

 	{

 	RThread clientThread;

 	TInt r=clientThread.Create(_L("TALERT_Thread2"),FileAccess,0x4000,KHeapSize,KHeapSize,(TAny*)&gPathThread2,EOwnerThread);

 	test(r==KErrNone);

 	clientThread.Resume();

 	clientThread.Close();

 	}

 LOCAL_C TInt NotifyAccess(TAny*)

 //

 // Create, wait for and cancel notifiers.

 //

 	{

 	RFs fs;

 	fs.Connect();

 	TRequestStatus status;

 	FOREVER

 		{

 		switch(Math::Rand(gSeed)%4)

 			{

 		case 0:

 			gNotifies++;

 			fs.NotifyChange(ENotifyAll,status);

 			User::WaitForRequest(status);

 			break;

 		case 1:

 			gNotifies++;

 			fs.NotifyChange(ENotifyEntry,status);

 			User::WaitForRequest(status);

 			break;

 		case 2:

 			gNotifyCancels++;

 			fs.NotifyChange(ENotifyAll,status);

 			User::After(Math::Rand(gSeed)%gMaxDelay);

 			fs.NotifyChangeCancel();

 			User::WaitForRequest(status);

 			break;

 		case 3:

 			gNotifyCancels++;

 			fs.NotifyChange(ENotifyEntry,status);

 			User::After(Math::Rand(gSeed)%gMaxDelay);

 			fs.NotifyChangeCancel();

 			User::WaitForRequest(status);

 			break;

 			}

 		}

 	//return(KErrNone);

 	}			

 LOCAL_C void StartThread3()

 //

 // Start a thread that creates and waits/cancel RFs::Notifiers

 //

 	{

 	RThread clientThread;

 	TInt r=clientThread.Create(_L("TALERT_Thread3"),NotifyAccess,0x4000,KHeapSize,KHeapSize,NULL,EOwnerThread);

 	test(r==KErrNone);

 	clientThread.Resume();

 	clientThread.Close();

 	}

 LOCAL_C TInt MediaChange(TAny*)

 //

 // Cause media changes a random intervals

 //

 	{

 	gMediaChanges=0;

 	FOREVER

 		{

 		TInt interval=Math::Rand(gSeed)%gMaxMediaChangeInterval;

 		User::After(interval);

 //		UserSvr::ForceRemountMedia(ERemovableMedia0); // Generate media change	

 		++gMediaChanges;

 		}

 	//return(KErrNone);

 	}

 LOCAL_C void StartThread4()

 //

 // Start a thread that creates media changes

 //

 	{

 	RThread clientThread;

 	TInt r=clientThread.Create(_L("TALERT_Thread4"),MediaChange,0x4000,KHeapSize,KHeapSize,NULL,EOwnerThread);

 	test(r==KErrNone);

 	clientThread.SetPriority(EPriorityMore);

 	clientThread.Resume();

 	clientThread.Close();

 	}

 LOCAL_C void StartClock()

 //

 // Display ongoing reads/writes. Getch to exit

 //

 	{

 	test.Console()->ClearScreen();

 	FOREVER

 		{

 		User::After(gUpdateInterval);

 		test.Console()->SetPos(0,5);

 		test.Printf(_L("File writes  = %d   \n"),gFileWrites);

 		test.Printf(_L("File reads   = %d   \n"),gFileReads);

 		test.Printf(_L("File creates = %d   \n"),gFileCreates);

 		test.Printf(_L("File deletes = %d   \n"),gFileDeletes);

 		test.Printf(_L("File notifies = %d   \n"),gNotifies);

 		test.Printf(_L("File notifies cancelled = %d   \n"),gNotifyCancels);

 //		test.Printf(_L("Press any key to exit\n"));

 //		TKeyCode keycode=test.Console()->KeyCode();

 //		if (keycode!=EKeyNull)

 //			break;

 		if (gFileWrites>gMaxIteration)

 			break;

 		}

 	}

 LOCAL_C void KillThreads()

 //

 // Kill all threads

 //

 	{

 	test.Printf(_L("+Kill threads"));

 	RThread t;

 	TInt r=t.Open(_L("TALERT_Thread0"),EOwnerThread);

 	if(r==KErrNone)

 	{

 		t.Kill(KErrCancel);

 		t.Close();

 	}

 	else 

 		test(r==KErrNotFound);

 	r=t.Open(_L("TALERT_Thread1"),EOwnerThread);

 	if(r==KErrNone)

 	{

 		t.Kill(KErrCancel);

 		t.Close();

 	}

 	else 

 		test(r==KErrNotFound);

 	r=t.Open(_L("TALERT_Thread2"),EOwnerThread);

 	if(r==KErrNone)

 	{

 		t.Kill(KErrCancel);

 		t.Close();

 	}

 	else 

 		test(r==KErrNotFound);

 	r=t.Open(_L("TALERT_Thread3"),EOwnerThread);

 	if(r==KErrNone)

 	{

 		t.Kill(KErrCancel);

 		t.Close();

 	}

 	else 

 		test(r==KErrNotFound);

 	r=t.Open(_L("TALERT_Thread4"),EOwnerThread);

 	if(r==KErrNone)

 	{

 		t.Kill(KErrCancel);

 		t.Close();

 	}

 	else 

 		test(r==KErrNotFound);

 /*	TFindThread threadFinder(_L("TALERT_*"));

 	FOREVER

 		{

 		TFullName threadName;

 		TInt r=threadFinder.Next(threadName);

 		test.Printf(_L("r=%d"),r);

 		if (r==KErrNotFound)

 			break;

 		test(r==KErrNone);

 		test.Printf(_L("Killing Thread %S\n"),&threadName);

 		RThread t;

 		r=t.Open(threadName,EOwnerThread);

 		test(r==KErrNone);

 		t.Kill(KErrCancel);

 		t.Close();

 		} */

 	test.Printf(_L("-Kill threads"));

 	}

 LOCAL_C void Test1()

 //

 // Create lots of threads and change notifiers

 //

 	{

 	test.Next(_L("Create lots of threads and change notifiers"));

 	TInt r=TheFs.MkDirAll(gPathThread1);

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

 	r=TheFs.MkDir(gPathThread2);

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

 	StartThread0(); // Read and write to D:

 	StartThread1(); // Read and write to C:

 	StartThread2(); // Read and write to D: (again)

 	StartThread3(); // Set RFs::Notifiers

 	StartThread4(); // Generate media changes

 	StartClock(); // Time how long test has run

 	KillThreads();

 	}

 LOCAL_C TInt ThreadHangTest(TAny*)

 //

 // Keep writing to the fileserver and setting gThreadTick

 //

 	{

 	RFs fs;

 	fs.Connect();

 	fs.SetSessionPath(gPathThread0);

 	FOREVER

 		{

 		gFileCreateFail++;

 		gThreadTick=ETrue;

 		RFile f;

 		TInt r=f.Replace(fs,_L("TwiddleThumbs"),EFileRead|EFileWrite);

 		if (r!=KErrNone)

 			continue;

 		gFileCreateFail=0;

 		f.Close();

 		gThreadTick=ETrue;

 		fs.Delete(_L("TwiddleThumbs"));

 		gThreadTick=ETrue;

 		}

 	//return(KErrNone);

 	}

 LOCAL_C void Test2()

 //

 // Create a hung server then kill the thread it wants to write to.

 //

 	{

 	test.Next(_L("Create a hung server and kill the thread it is writing to"));

 	TInt r=TheFs.MkDir(gPathThread0);

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

 	StartThread4(); // Generate media changes

 	RThread clientThread;

 	r=clientThread.Create(_L("TALERT_ThreadHangTest"),ThreadHangTest,0x4000,KHeapSize,KHeapSize,NULL,EOwnerThread);

 	test(r==KErrNone);

 	TRequestStatus status;

 	clientThread.Logon(status);

 	clientThread.Resume();

 	gThreadTick=ETrue;

 	test.Next(_L("ThreadHangTest is running"));

 	TInt count=0;

 	FOREVER

 		{

 		test.Printf(_L("Thread tick = %d File create failures = %d \n"),count,gFileCreateFail);

 		test.Printf(_L("Media changes = %d\n"),gMediaChanges);

 		User::After(gHeartBeatInterval);

 		if (gThreadTick==0)

 			break;

 		gThreadTick=0;

 		count++;

 		}

 	test.Next(_L("Thread is hung"));

 	clientThread.Kill(KErrCancel);

 	clientThread.Close();

 	User::WaitForRequest(status);

 	KillThreads();

 	User::After(1000000);

 	test.Printf(_L("Press return to the clear notifier, then any key to continue test"));

 	test.Getch();

 	test.Next(_L("Test fileserver is still alive after thread is killed"));

 	WaitForMedia();

 	r=TheFs.MkDir(gPathThread0); // Check fileserver ok

 	if(r!=KErrNone && r!=KErrAlreadyExists)

 		test.Printf(_L("r=%d"),r);

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

 	}		

 GLDEF_C void CallTestsL()

 //

 // Do tests relative to the session path

 //

 	{

 	RThread().SetPriority(EPriorityLess);

 #if defined(__WINS__)

 	if (gSessionPath[0]!='X')

 		return;

 #else

 	// Test on two drives where possible. This should be C: together with 

 	// the drive referenced by the default path. Where the default path is

 	// C:, then only C: is used. The standard way to run the test is to 

 	// set the default path to D:

     gPathThread0[0]=gSessionPath[0];

     gPathThread2[0]=gSessionPath[0];

 #endif

 	Test2();

 	Test1();

 //This test can leave the drive corrupt so a format is required 

 #if defined(__WINS__)

 	Format(EDriveX);

 #else

 	Format(EDriveD);

 #endif

 	//clean up the talert directory after the test completes

 /*	CFileMan* FileMan=NULL;

 	FileMan=CFileMan::NewL(TheFs);

 	TInt r=FileMan->RmDir(_L("\\F32-TST\\TALERT\\"));

 	test.Printf(_L("r=%d"),r);

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

 	delete FileMan;

 */

 	}