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

	}