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

	}