// 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_open.cpp
// 
//

#include <f32file.h>
#include <e32test.h>
#include "t_server.h"

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

LOCAL_D TFileName gBatchFile;
LOCAL_D TBool gRunByBatch=EFalse;

TFileName filename1=_L("Z:\\TEST\\T_FSRV.CPP");
TFileName filename2=_L("Z:\\TEST\\T_FILE.CPP");
TFileName dirname1=_L("Z:\\TEST\\*.XDE");


LOCAL_C void Test0()
//
// Scan for open files - no sessions
//
	{

	test.Next(_L("Scan for open files with no sessions open"));
	CFileList* list;
	TOpenFileScan fileScan(TheFs);
	fileScan.NextL(list);
	if (list==NULL)
		return;
	TInt count=list->Count();
	if (count==1)
		{
		gRunByBatch=ETrue;
		gBatchFile=(*list)[0].iName;
		delete list;
		fileScan.NextL(list);
		if (list==NULL)
			return;
		count=list->Count();
		}
	while (count--)
		{
		TEntry entry=(*list)[count];
		test.Printf(_L("%d) EntryName = %S\n"),count,&entry.iName);
		}
	test.Printf(_L("Test will fail unless files are closed.\n"));
	test(0);
	//test.Printf(_L("Press any key ...\n"));
	//test.Getch();
	}

LOCAL_C void Test1()
//
// Test OpenFileScan
//
	{

	test.Next(_L("Scan for open files - one session only"));

	RFile file1,file2,file3;
	
	TInt r=file1.Open(TheFs,filename1,EFileRead|EFileShareReadersOnly);
	test(r==KErrNone);
	
	r=file2.Open(TheFs,filename2,EFileRead);
	test(r==KErrNone);

	r=file3.Open(TheFs,filename1,EFileRead|EFileShareReadersOnly);
	test(r==KErrNone);
	
	CFileList* list=NULL;
	TOpenFileScan fileScan(TheFs);
	TRAP(r,fileScan.NextL(list));
	test(r==KErrNone);

	if (gRunByBatch)
		{
		test(list!=NULL);
		test(list->Count()==1);
		TEntry entry=(*list)[0];
		test(entry.iName.FindF(_L(".BAT"))>=0);
		delete list;
		fileScan.NextL(list);
		}
	
	
	test(list!=NULL);
	TInt count=list->Count();
	test(count==3);
	TEntry entry=(*list)[0];
	
	test(entry.iName.FindF(_L("T_FSRV.CPP"))>=0);
	entry=(*list)[1];
	test(entry.iName.FindF(_L("T_FILE.CPP"))>=0);
	entry=(*list)[2];
	test(entry.iName.FindF(_L("T_FSRV.CPP"))>=0);
	TThreadId threadId=fileScan.ThreadId();
	RThread current;
	TThreadId currentId=current.Id();
	test(threadId==currentId);
	delete list;

	fileScan.NextL(list);
	test(list==NULL);

	file1.Close();
	file2.Close();
	file3.Close();
	}

LOCAL_C void Test2()
//
// Test openfilescan - empty, full, empty.
//
	{


	test.Next(_L("Scan for open files - empty sessions"));

	RFs fs1,fs2,fs3,fs4;
	TInt r=fs1.Connect();
	test(r==KErrNone);
	r=fs2.Connect();
	test(r==KErrNone);
	r=fs3.Connect();
	test(r==KErrNone);
	r=fs4.Connect();
	test(r==KErrNone);

	RFile file1,file2,file3;
	
	r=file1.Open(fs2,filename1,EFileRead|EFileShareReadersOnly);
	test(r==KErrNone);
	
	r=file2.Open(fs2,filename2,EFileRead);
	test(r==KErrNone);
	
	r=file3.Open(fs2,filename1,EFileRead|EFileShareReadersOnly);
	test(r==KErrNone);
	
	CFileList* list;
	TOpenFileScan fileScan(TheFs);
	fileScan.NextL(list);

	if (gRunByBatch)
		{
		test(list!=NULL);
		test(list->Count()==1);
		TEntry entry=(*list)[0];
		test(entry.iName.FindF(_L(".BAT"))>=0);
		delete list;
		fileScan.NextL(list);
		}

	test(list!=NULL);
	TInt count=list->Count();
	test(count==3);
	TEntry entry=(*list)[0];
	test(entry.iName.FindF(_L("T_FSRV.CPP"))>=0);
	entry=(*list)[1];
	test(entry.iName.FindF(_L("T_FILE.CPP"))>=0);
	entry=(*list)[2];
	test(entry.iName.FindF(_L("T_FSRV.CPP"))>=0);
	TThreadId threadId=fileScan.ThreadId();
	RThread current;
	TThreadId currentId=current.Id();
	test(threadId==currentId);
	delete list;

	fileScan.NextL(list);
	test(list==NULL);

	file1.Close();
	file2.Close();
	file3.Close();
	fs1.Close();
	fs2.Close();
	fs3.Close();
	fs4.Close();
	}

LOCAL_C void Test3()
//
// Test openfilescan - empty, full, empty full
//
	{

	test.Next(_L("Scan for open files - multiple sessions"));

	RFs fs1,fs2,fs3,fs4;
	TInt r=fs1.Connect();
	test(r==KErrNone);
	r=fs2.Connect();
	test(r==KErrNone);
	r=fs3.Connect();
	test(r==KErrNone);
	r=fs4.Connect();
	test(r==KErrNone);

	RFile file1,file2,file3;
	
	r=file1.Open(fs2,filename1,EFileRead|EFileShareReadersOnly);
	test(r==KErrNone);
	
	r=file2.Open(fs2,filename2,EFileRead|EFileShareReadersOnly);
	test(r==KErrNone);
	
	r=file3.Open(fs2,filename1,EFileRead|EFileShareReadersOnly);
	test(r==KErrNone);
	
	r=file1.Open(fs4,filename1,EFileRead|EFileShareReadersOnly);
	test(r==KErrNone);
	
	r=file2.Open(fs4,filename2,EFileRead|EFileShareReadersOnly);
	test(r==KErrNone);
	
	r=file3.Open(fs4,filename1,EFileRead|EFileShareReadersOnly);
	test(r==KErrNone);
	
	CFileList* list;
	TOpenFileScan fileScan(TheFs);
	fileScan.NextL(list);

	if (gRunByBatch)
		{
		test(list!=NULL);
		test(list->Count()==1);
		TEntry entry=(*list)[0];
		test(entry.iName.FindF(_L(".BAT"))>=0);
		delete list;
		fileScan.NextL(list);
		}

	test(list!=NULL);
	TInt count=list->Count();
	test(count==3);
	TEntry entry=(*list)[0];
	test(entry.iName.FindF(_L("T_FSRV.CPP"))>=0);
	entry=(*list)[1];
	test(entry.iName.FindF(_L("T_FILE.CPP"))>=0);
	entry=(*list)[2];
	test(entry.iName.FindF(_L("T_FSRV.CPP"))>=0);
	TThreadId threadId=fileScan.ThreadId();
	RThread current;
	TThreadId currentId=current.Id();
	test(threadId==currentId);
	delete list;

	fileScan.NextL(list);
	test(list!=NULL);
	count=list->Count();
	test(count==3);
	entry=(*list)[0];
	test(entry.iName.FindF(_L("T_FSRV.CPP"))>=0);
	entry=(*list)[1];
	test(entry.iName.FindF(_L("T_FILE.CPP"))>=0);
	entry=(*list)[2];
	test(entry.iName.FindF(_L("T_FSRV.CPP"))>=0);
	threadId=fileScan.ThreadId();
	currentId=current.Id();
	test(threadId==currentId);
	delete list;

	fileScan.NextL(list);
	test(list==NULL);

	file1.Close();
	file2.Close();
	file3.Close();
	fs1.Close();
	fs2.Close();
	fs3.Close();
	fs4.Close();
	}

LOCAL_C void Test4()
//
// Test openfilescan - rdirs, empty, full, empty rdirs.
//
	{
	test.Next(_L("Scan for open files - check RDir sessions are ignored"));

	RFs fs1,fs2,fs3,fs4;
	TInt r=fs1.Connect();
	test(r==KErrNone);
	r=fs2.Connect();
	test(r==KErrNone);
	r=fs3.Connect();
	test(r==KErrNone);
	r=fs4.Connect();
	test(r==KErrNone);

	RDir dir1,dir2,dir3,dir4;
	r=dir1.Open(TheFs,dirname1,KEntryAttMaskSupported);
	test(r==KErrNone);
	r=dir2.Open(TheFs,dirname1,KEntryAttMaskSupported);
	test(r==KErrNone);
	r=dir3.Open(TheFs,dirname1,KEntryAttMaskSupported);
	test(r==KErrNone);
	r=dir4.Open(TheFs,dirname1,KEntryAttMaskSupported);
	test(r==KErrNone);

	RFile file1,file2,file3;
	r=file1.Open(fs2,filename1,EFileRead|EFileShareReadersOnly);
	test(r==KErrNone);
	r=file2.Open(fs2,filename2,EFileRead);
	test(r==KErrNone);
	r=file3.Open(fs2,filename1,EFileRead|EFileShareReadersOnly);
	test(r==KErrNone);
	
	RDir dir5,dir6,dir7,dir8;
	r=dir5.Open(fs4,dirname1,KEntryAttMaskSupported);
	test(r==KErrNone);
	r=dir6.Open(fs4,dirname1,KEntryAttMaskSupported);
	test(r==KErrNone);
	r=dir7.Open(fs4,dirname1,KEntryAttMaskSupported);
	test(r==KErrNone);
	r=dir8.Open(fs4,dirname1,KEntryAttMaskSupported);
	test(r==KErrNone);

	CFileList* list;
	TOpenFileScan fileScan(TheFs);
	fileScan.NextL(list);

	if (gRunByBatch)
		{
		test(list!=NULL);
		test(list->Count()==1);
		TEntry entry=(*list)[0];
		test(entry.iName.FindF(_L(".BAT"))>=0);
		delete list;
		fileScan.NextL(list);
		}

	test(list!=NULL);
	TInt count=list->Count();
	test(count==3);
	TEntry entry=(*list)[0];
	test(entry.iName.FindF(_L("T_FSRV.CPP"))>=0);
	entry=(*list)[1];
	test(entry.iName.FindF(_L("T_FILE.CPP"))>=0);
	entry=(*list)[2];
	test(entry.iName.FindF(_L("T_FSRV.CPP"))>=0);
	TThreadId threadId=fileScan.ThreadId();
	RThread current;
	TThreadId currentId=current.Id();
	test(threadId==currentId);
	delete list;

	fileScan.NextL(list);
	test(list==NULL);

	file1.Close();
	file2.Close();
	file3.Close();
	dir1.Close();	dir2.Close();
	dir3.Close();	dir4.Close();
	dir5.Close();	dir6.Close();
	dir7.Close();	dir8.Close();
	fs1.Close();	fs2.Close();
	fs3.Close();	fs4.Close();
	}

LOCAL_C void Test5()
//
// Test OpenFileScan
//
	{

	test.Next(_L("Scan for open files - mixed RDirs and RFiles"));

	RFile file1,file2,file3;
	TInt r=file1.Open(TheFs,filename1,EFileRead|EFileShareReadersOnly);
	test(r==KErrNone);
	r=file2.Open(TheFs,filename2,EFileRead);
	test(r==KErrNone);
	r=file3.Open(TheFs,filename1,EFileRead|EFileShareReadersOnly);
	test(r==KErrNone);
	
	RDir dir1,dir2,dir3,dir4;
	r=dir1.Open(TheFs,dirname1,KEntryAttMaskSupported);
	test(r==KErrNone);
	r=dir2.Open(TheFs,dirname1,KEntryAttMaskSupported);
	test(r==KErrNone);
	r=dir3.Open(TheFs,dirname1,KEntryAttMaskSupported);
	test(r==KErrNone);
	r=dir4.Open(TheFs,dirname1,KEntryAttMaskSupported);
	test(r==KErrNone);

	CFileList* list;
	TOpenFileScan fileScan(TheFs);
	fileScan.NextL(list);

	if (gRunByBatch)
		{
		test(list!=NULL);
		test(list->Count()==1);
		TEntry entry=(*list)[0];
		test(entry.iName.FindF(_L(".BAT"))>=0);
		delete list;
		fileScan.NextL(list);
		}

	test(list!=NULL);
	TInt count=list->Count();
	test(count==3);
	TEntry entry=(*list)[0];
	test(entry.iName.FindF(_L("T_FSRV.CPP"))>=0);
	entry=(*list)[1];
	test(entry.iName.FindF(_L("T_FILE.CPP"))>=0);
	entry=(*list)[2];
	test(entry.iName.FindF(_L("T_FSRV.CPP"))>=0);
	TThreadId threadId=fileScan.ThreadId();
	RThread current;
	TThreadId currentId=current.Id();
	test(threadId==currentId);
	delete list;

	fileScan.NextL(list);
	test(list==NULL);

	file1.Close();
	file2.Close();
	file3.Close();
	dir1.Close();
	dir2.Close();
	dir3.Close();
	dir4.Close();
	}


NONSHARABLE_STRUCT(TThreadData)
//
// Encapsulates the data required by the worker thread.
//
	{
	// Thread identifier for debug output
	TInt            iNumber;

	// ID of the thread that started the worker thread, and the
	// worker thread itself
	TThreadId       iMain;
	TThreadId       iWorker;

	// Request status object of the parent thread, used for signalling
	TRequestStatus* iStatus;

	// Name of the file the parent thread requires this thread to open
	TFileName       iFilename;

	// Number of files opened by the thread;
	TInt            iNumFiles;
	};


LOCAL_C TInt WorkerThread(TAny* aParameter)
//
// This function is designed to run as a separate thread in order to verify the
// fix for DEF062875.
//
// When the thread is started it opens the file specified in the startup 
// parameter, signals the main thread and then suspends. Once the main thread
// has completed its checking the worker thread is resumed and allowed to run
// to completion.
//
// @param aParameter Thread specific data supplied by the main thread when the
//                   worker thread is started. The data may be accessed by 
//                   casting this pointer to a TThreadData*
//
	{
	// Can't use our global "test" object here
	RTest myTest(_L("Worker thread"));

	
	// Extract the parameters that this thread will need to use
	TThreadData* threadData = (TThreadData*)aParameter;


	RThread current;
	TThreadId currentId = current.Id(); 

	
	myTest.Printf(_L("WORK%d: Worker thread %d started\n"), threadData->iNumber, threadData->iNumber);
	myTest.Printf(_L("WORK%d:   File:   %S\n"), threadData->iNumber, &threadData->iFilename);
	myTest.Printf(_L("WORK%d:   Thread: %d\n"), threadData->iNumber, (TUint)currentId);
	myTest.Printf(_L("WORK%d:   Parent: %d\n"), threadData->iNumber, (TUint)threadData->iMain);


	// Open the file specified by the parameter passed to us from the main 
	// thread
	RFs myFs;
	myFs.Connect();
	RFile file;
	User::LeaveIfError(file.Open(myFs, threadData->iFilename, EFileRead | EFileShareReadersOnly));

	// Signal the parent thread to continue then wait
	myTest.Printf(_L("WORK%d: Signalling parent thread\n"), threadData->iNumber);
	RThread parent;
	User::LeaveIfError(parent.Open(threadData->iMain));
	parent.RequestComplete(threadData->iStatus, KErrNone);

	
	myTest.Printf(_L("WORK%d: Waiting for parent thread to restart us\n"), threadData->iNumber);
	current.Suspend();


	// Tidy up
	myTest.Printf(_L("WORK%d: Closing file\n"), threadData->iNumber);
	file.Close();

	
	return KErrNone;
	}


LOCAL_C void TestDEF062875()
//
// Verify that TOpenFileScan::ThreadId() returns the ID of the thread that
// opened the file.
//
// The object of the exercise here is to create several worker threads, each
// one will open a file, signal the main thread and then suspend. Once all
// the worker threads have suspended the main thread then uses 
// TOpenFileScan::NextL() to verify that the thread IDs correspond to the
// worker threads that opened each file and not that of the main thread.
//
// The worker threads are then restarted and allowed to terminate naturally by
// running to completion
//
	{
	test.Start(_L("Test TOpenFileScan::ThreadId()"));
	
	const TInt KHeapSize  = 32768;
	
	RThread        thread1;
	RThread        thread2;
	
	TRequestStatus status1;
	TRequestStatus status2;

	TThreadId id = RThread().Id();
	
	TThreadData threadData[3];
	
	threadData[0].iNumber   = 0;
	threadData[0].iMain     = id;
	threadData[0].iWorker   = id;
	threadData[0].iStatus   = 0;
	threadData[0].iFilename = filename1;
	threadData[0].iNumFiles = 2;

	threadData[1].iNumber   = 1;
	threadData[1].iMain     = id;
	threadData[1].iStatus   = &status1;
	threadData[1].iFilename = filename1;
	threadData[1].iNumFiles = 1;

	threadData[2].iNumber   = 2;
	threadData[2].iMain     = id;
	threadData[2].iStatus   = &status2;
	threadData[2].iFilename = filename2;
	threadData[2].iNumFiles = 1;

	TInt numThreads = sizeof(threadData)/sizeof(threadData[0]);


	// Open the files in the MAIN thread.
	RFile file1;
	User::LeaveIfError(file1.Open(TheFs, filename1, EFileRead | EFileShareReadersOnly));

	RFile file2;
	User::LeaveIfError(file2.Open(TheFs, filename2, EFileRead | EFileShareReadersOnly));


	// Create the first worker thread
	test.Printf(_L("MAIN: Creating worker threads\n"));
	thread1.Create(_L("WorkerThread1"), WorkerThread, KDefaultStackSize, KHeapSize, KHeapSize, &threadData[1]);
	threadData[1].iWorker = thread1.Id();
	
	// Start it and wait for it to suspend
	thread1.Logon(status1);
	thread1.Resume();
	test.Printf(_L("MAIN: Waiting for worker thread 1\n"));
	User::WaitForRequest(status1);


	// Create the second worker thread
	thread2.Create(_L("WorkerThread2"), WorkerThread, KDefaultStackSize, KHeapSize, KHeapSize, &threadData[2]);
	threadData[2].iWorker = thread2.Id();
	
	
	// Start it and wait for it to suspend
	thread2.Logon(status2);
	thread2.Resume();
	test.Printf(_L("MAIN: Waiting for worker thread 2\n"));
	User::WaitForRequest(status2);


	// Obtain a list of open files. At this point we should have a single open
	// file, as opened by our worker thread. The thread ID reported by
	// TOpenFileScan should be that of our worker thread rather than the main
	// thread.
	test.Printf(_L("MAIN: Verifying thread ID of open file(s)\n"));
	CFileList* list;
	TOpenFileScan fileScan(TheFs);

	
	TInt count = 0;
	FOREVER
		{
		fileScan.NextL(list);


		// The NULL list indicates we've run out of sessions.
		if(!list)
			{
			break;
			}


		TThreadId threadId=fileScan.ThreadId();
		TThreadData* data = 0;
		for (count = 0; count < numThreads; count++)
			{
			if (threadId == threadData[count].iWorker)
				{
				data = &threadData[count];
				break;
				}
			}


		if (data)
			{
			test.Next(_L("Check number of open files..."));
			test.Printf(_L("MAIN: Number of open files: %d (expecting %d)\n"), list->Count(), data->iNumFiles);
			test(list->Count() == threadData[count].iNumFiles);

			
			test.Next(_L("Check TThreadIds..."));
			test.Printf(_L("MAIN: Main thread ID  : %d\n"), (TUint)data->iMain);
			test.Printf(_L("MAIN: Worker thread ID: %d\n"), (TUint)data->iWorker);
			test.Printf(_L("MAIN: File thread ID  : %d\n"), (TUint)threadId);

			
			TInt loop = 0;
			for (loop = 0; loop < list->Count(); loop++)
				{
				const TEntry& theEntry = (*list)[loop];
				test.Printf(_L("  "));
				test.Printf(theEntry.iName);
				test.Printf(_L("\n"));
				}
			}
		else
			{
			test.Printf(_L("Ignored thread %d\n"), (TUint)threadId);
			}

			
		delete list;
		list = 0;

		
		test.Printf(_L("\n"));
		}


	// Signal the two worker threads to tidy up and run to normal termination
	test.Printf(_L("MAIN: Signalling worker thread 1\n"));
	thread1.Logon(status1);
	thread1.Resume();
	User::WaitForRequest(status1);

	test.Printf(_L("MAIN: Signalling worker thread 2\n"));
	thread2.Logon(status2);
	thread2.Resume();
	User::WaitForRequest(status2);


	// Tidy up and finish
	test.Printf(_L("MAIN: Closing worker thread 1\n"));
	thread1.Close();

	test.Printf(_L("MAIN: Closing worker thread 2\n"));
	thread2.Close();

	file1.Close();
	file2.Close();
	
	test.End();
	}


GLDEF_C void CallTestsL()
//
// Call tests that may leave
//
	{
	filename1[0] = gExeFileName[0];
	filename2[0] = gExeFileName[0];
	dirname1[0] = gExeFileName[0];
	Test0();
	Test1();
	Test2();
	Test3();
	Test4();
	Test5();

	TestDEF062875();
	}