// Copyright (c) 2006-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_fsched.cpp

// 

//

/**

 @file

 @internalTechnology 

*/

#define __E32TEST_EXTENSION__

#include <f32file.h>

#include <e32test.h>

#include <e32svr.h>

#include <f32dbg.h>

#include "t_server.h"

#include <e32twin.h>

#include <e32cmn.h>

//----------------------------------------------------------------------------------------------

//! @SYMTestCaseID      PBASE-T_FSCHED-0191

//! @SYMTestType        CIT

//! @SYMPREQ            PREQ914

//! @SYMTestCaseDesc    This test case is exercising the Fair Scheduling functionality added to 

//!						the File Server. There are negative and positive tests. 

//! @SYMTestActions     0   setup the environment to execute the tests and benchmarks the time 

//!							taken to write the two files that are going to be used during the test

//!						1	TestReadingWhileWriting uses two threads (sync case) to write a big file/

//!							read a small file simultaneously and verifies that the timing is correct. 

//!							Same test in the async case. 

//!						2	TestWritingWhileWriting same test as before, but the two operations are 

//!							writes. 

//!						3 	TestTwoBigOnes does the same test as 1, but with two big files, ensuring

//!							that the first starting is the first finishing. 

//!						4 	TestReadingWhileWritingSameFile reads a file while it is being written. 

//!						5	TestClientDies starts a file write and kills it, then checks the integrity 

//!							of the volume. 

//!						6 	Finally it performs the benchmark of writing the two files again, to see 

//!							if it has been degraded during the execution

//!

//! @SYMTestExpectedResults finishes if the fair scheduling behaves as expected, panics otherwise

//! @SYMTestPriority        High

//! @SYMTestStatus          Implemented

//----------------------------------------------------------------------------------------------

class RTestThreadSemaphore : public RSemaphore

	{

public:

	inline void Signal(TInt aError = KErrNone) {iError = aError; RSemaphore::Signal();};

public:

	TInt iError;

	};

// macro to be used in place of test(). Signals main thread if assertion fails

#define TEST(x)								\

if (!(x))									\

	{										\

	RThread t;								\

	if (t.Id() != gMainThreadId)			\

		client.Signal(KErrGeneral); 		\

	test(x);								\

	}				

#define TESTERROR(x)						\

	if (x != KErrNone)						\

	{										\

	RThread t;								\

	if (t.Id() != gMainThreadId)			\

		RDebug::Print(_L("error %d\n"), x);	\

	else									\

		test.Printf(_L("error %d\n"), x);	\

	TEST(x==KErrNone);								\

	}

#define CLIENTWAIT() {client.Wait(); test(client.iError == KErrNone);}

////////////////////////////////////////////////////////////

// Template functions encapsulating ControlIo magic

//

GLDEF_D template <class C>

GLDEF_C TInt controlIo(RFs &fs, TInt drv, TInt fkn, C &c)

{

    TPtr8 ptrC((TUint8 *)&c, sizeof(C), sizeof(C));

    TInt r = fs.ControlIo(drv, fkn, ptrC);

    return r;

}

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

GLDEF_D	RFs TheFs;

GLDEF_D TInt gDrive;

GLDEF_D TFileName gSessionPath;

GLDEF_D TChar gDriveToTest;	

TThreadId gMainThreadId;

HBufC8* gBuf = NULL;

TPtr8 gBufReadPtr(NULL, 0);	

HBufC8* gBufSec = NULL;

TPtr8 gBufWritePtr(NULL, 0);	

const TInt KuStomS = 1000;

const TInt KOneK = 1024;

const TInt KOneMeg = KOneK * 1024;

const TInt KBigBlockSize = KOneMeg ; 

const TInt KBlockSize = KOneK * 129 ; 

const TInt KWaitRequestsTableSize = 70;

TInt gBigFileSize = 0; 

TInt gSmallFileSize = 0;

TInt64 gMediaSize = 0;

TInt gTotalTimeSync[2];

TInt gTotalTimeAsync[2];

TTimeIntervalMicroSeconds32 gTimeTakenBigFile(0);

TTimeIntervalMicroSeconds32 gTimeTakenBigBlock(0);

TBuf16<45> gSmallFile, gBigFile;

TInt gNextFile=0;

TTime gTime1;

TTime gTime2;

RSemaphore gSync;

// Concurrent Threads

RThread gBig;

RThread gSmall;

RTestThreadSemaphore client;	

const TInt KHeapSize = 0x4000;

const TInt KMaxHeapSize = 0x200000;

TRequestStatus gStatus[KWaitRequestsTableSize];

enum TTestState 

	{

	EThreadWait,

	EThreadSignal,

	ENoThreads	

	};

/** Generates a file name of the form FFFFF*<aPos>.TXT (aLong.3)

	@param aBuffer The filename will be returned here

	@param aLong   Defines the longitude of the file name 

	@param aPos	   Defines the number that will be attached to the filename

*/

void FileNameGen(TDes16& aBuffer, TInt aLong, TInt aPos) 

{

	TInt padding;

	TInt i=0;

	TBuf16<10> tempbuf;

	_LIT(KNumber,"%d");

	tempbuf.Format(KNumber,aPos);

	padding=aLong-tempbuf.Size()/2;

	aBuffer=_L("");

	while(i<padding)

	{

		aBuffer.Append('F');

		i++;

	}

	aBuffer.Append(tempbuf);

	_LIT(KExtension1, ".TXT");

	aBuffer.Append(KExtension1);

}

/**  Reads the parameters from the comand line 

	 and updates the appropriate variables

*/

void parseCommandLine() 

{

	TBuf<0x100> cmd;

	User::CommandLine(cmd);

	TLex lex(cmd);

	TPtrC token=lex.NextToken();

	TInt r=0;

	if(token.Length()!=0)		

		{

		gDriveToTest = token[0];

		gDriveToTest.UpperCase();

		}

	else						

		{

		gDriveToTest='C';

		}	

	r = TheFs.CharToDrive(gDriveToTest,gDrive);

	TESTERROR(r);

	gSessionPath = _L("?:\\F32-TST\\");

	gSessionPath[0] = (TText)(gDrive+'A');

	test.Printf(_L("\nCLP=%C\n"), (TInt)gDriveToTest);

}

/** Verifies the content of a buffer (all the letters are like the first one)

	@param aBuffer  Buffer to be verified

	@return KErrNone if all the letters are the same, KErrCorrupt otherwise

*/

TInt VerifyBuffer(TDes8& aBuffer, TChar aExpectedChar)

	{

	TChar c = aExpectedChar;

	for(TInt i = 1; i<aBuffer.Length(); i++)

		{

		if(c != (TChar)(aBuffer[i])) 

			{

			RDebug::Print(_L("VerifyBuffer() failed at +%d, %02X != %02X"), i, (TInt) c, aBuffer[i] );

			return KErrCorrupt;

			}

		}

	return KErrNone;

	}

/**  Fills a buffer with character aC

	@param aBuffer  Buffer to be filled, output

	@param aLength  Length to be filled

	@param aC		Character to be used to fill the buffer

*/

void FillBuffer(TDes8& aBuffer, TInt aLength, TChar aC)

	{

	test (aBuffer.MaxLength() >= aLength);

	for(TInt i=0; i<aLength; i++)

		{

		aBuffer.Append(aC);

		}

	}

/**  Waits for all the TRequestStatus in status[] to complete

	@param status 	Array of TRequestStatus 

	@param aLength  Length to be filled

	@param aC		Character to be used to fill the buffer

*/

void WaitForAll(TRequestStatus* status, TInt aFileSize, TInt aBlockSize) 

{

	TInt i = 0;

	TInt size = 0;

	if((aFileSize % aBlockSize) == 0 ) 

		size = aFileSize/aBlockSize;	

	else 

		size = (aFileSize/aBlockSize) + 1;	

	while(i < size)

	{

		User::WaitForRequest(status[i++]);	

	}

}

/**  Writes a file synchronously in blocks of aBlockSize size

	@param fs			RFs object

	@param aFile		File name

	@param aSize		Size of the file in bytes

	@param aBlockSize	Size of the blocks to be used in bytes

	@param aState		Determines if the operation is being done in the main process

						or in a thread

	@return Returns KErrNone if everything ok, otherwise it panics 

*/

TInt WriteFile(RFs& fs, TDes16& aFile, TInt aSize, TInt aBlockSize, TTestState aState) 

	{

	TInt r = 0;

	RFile fileWrite;

	TEST(aBlockSize>0);	

	r = fileWrite.Replace(fs,aFile,EFileShareAny|EFileWrite|EFileWriteDirectIO);

	TESTERROR(r);

	if(aState==EThreadWait)

	{

		gSync.Wait();

		User::After(gTimeTakenBigBlock);

	}

	TInt j = 0;

	while(j < aSize)

		{

			if((j == 0) && (aState == EThreadSignal))

			{

				gSync.Signal();

			}			

			if((aSize - j) >= aBlockSize) 	// All the blocks but the last one

				r = fileWrite.Write(gBufWritePtr, aBlockSize); 

			else							// The last block

				r = fileWrite.Write(gBufWritePtr, (aSize - j)); 

			TESTERROR(r);

			j += aBlockSize;

		}					

	fileWrite.Close();

	return KErrNone;	

	}

/**  Read File in blocks of size aBlockSize

	@param fs			RFs object

	@param aFile		File name

	@param aBlockSize	Size of the blocks to be used in bytes

	@param aState		Determines if the operation is being done in the main process

						or in a thread

	@return Returns KErrNone if everything ok, otherwise it panics 

*/

TInt ReadFile(RFs& fs, TDes16& aFile, TInt aBlockSize, TTestState aState) 

	{

	RTest test(_L("T_FSCHED"));

	TInt r = 0, size = 0;

	RFile fileRead;

	TEST(aBlockSize > 0);		

	r = fileRead.Open(fs, aFile, EFileShareAny|EFileRead|EFileReadDirectIO);

	TESTERROR(r);

	r = fileRead.Size(size);

	TESTERROR(r);

	if(aState == EThreadWait)

	{

		gSync.Wait();

		User::After(gTimeTakenBigBlock);

	}

	TInt j = 0;

	while(j < size) 

		{

			if((j == 0)&&(aState == EThreadSignal))

			{

				gSync.Signal();

			}			

			r = fileRead.Read(gBufReadPtr, aBlockSize);

			TESTERROR(r);

			r = VerifyBuffer(gBufReadPtr, 'B');	

			TESTERROR(r);

			j += aBlockSize;

			r = fileRead.Size(size);

			TESTERROR(r);

		}					

	fileRead.Close();

	return KErrNone;	

	}

/**  Write a file asynchronously in blocks of aBlockSize size

	@param fs			RFs object

	@param aFileWrite	RFile object, needs to exist beyond the scope of this function

	@param aFile		File name

	@param aSize		Size of the file in bytes

	@param aBlockSize	Size of the blocks to be used in bytes

	@param aStatus		TRequestStatus array for all the requests

*/

void WriteFileAsync(RFs& fs, RFile& aFileWrite, TDes16& aFile, TInt aSize, TInt aBlockSize, TRequestStatus aStatus[]) 

	{

	TInt r = 0;

	TEST(aBlockSize > 0);				// Block size must be greater than 0

	r = aFileWrite.Replace(fs,aFile,EFileShareAny|EFileWrite|EFileWriteDirectIO);

	TESTERROR(r);

	TInt j = 0;

	TInt i = 0;

	while(j < aSize)

		{

		if((aSize - j) >= aBlockSize) 	// All the blocks but the last one

			aFileWrite.Write(gBufWritePtr, aBlockSize, aStatus[i]); 

		else							// The last block

			aFileWrite.Write(gBufWritePtr, (aSize - j), aStatus[i]); 

		TInt status = aStatus[i].Int();

		if (status != KErrNone && status != KRequestPending)

			{

			test.Printf(_L("RFile::Write() returned %d\n"), aStatus[i].Int());

			}

		test (status == KErrNone || status == KRequestPending);

		i++;

		j += aBlockSize;	

		}					

	}

/**  Read a file asynchronously in blocks of aBlockSize size

	@param fs			RFs object

	@param aFileRead	RFile object, needs to exist beyond the scope of this function

	@param aFile		File name

	@param aSize		Size of the file in bytes

	@param aBlockSize	Size of the blocks to be used in bytes

	@param aStatus		TRequestStatus array for all the requests

	@return KErrNone

*/

TInt ReadFileAsync(RFs& fs, RFile& aFileRead, TDes16& aFile, TInt aBlockSize, TRequestStatus aStatus[]) 

	{

	TInt r = 0, size = 0;

	TEST(aBlockSize > 0);				// Block size must be greater than 0

	r = aFileRead.Open(fs, aFile, EFileShareAny|EFileRead|EFileReadDirectIO);

	TESTERROR(r);

	r = aFileRead.Size(size);

	TESTERROR(r);

	TInt j = 0, i = 0;

	while(j < size) 

		{

		aFileRead.Read(gBufReadPtr, aBlockSize, aStatus[i]);

		test (aStatus[i].Int() == KErrNone || aStatus[i].Int() == KRequestPending);

		i++;

		TESTERROR(r);

		j += aBlockSize;

		}					

	return KErrNone;	

	}

/**  

Write a pattern to 2 files simultaneously in blocks of aBlockSize size and verify that fair scheduling

does not interfere with the write order by reading both files back and verifying the contents.

aBlockSize should be slightly bigger that the fair scheduling size

@param aFs			RFs object

@param aSize		Size of the file in bytes

@param aBlockSize	Size of the blocks to be used in bytes, should be slightly bigger that the fair scheduling size

*/

void WriteOrderTest(RFs& aFs, TInt aSize, TInt aBlockSize) 

	{

	TFileName fileName1, fileName2;

	FileNameGen(fileName1, 8, 99);

	FileNameGen(fileName2, 8, 100);

	RFile file1, file2;

	TRequestStatus status1[KWaitRequestsTableSize];

	TRequestStatus status2[KWaitRequestsTableSize];

	TInt r = 0;

	TEST(aBlockSize > 0);				// Block size must be greater than 0

	r = file1.Replace(aFs, fileName1,EFileShareAny|EFileWrite|EFileWriteDirectIO);

	TESTERROR(r);

	r = file2.Replace(aFs, fileName2,EFileShareAny|EFileWrite|EFileWriteDirectIO);

	TESTERROR(r);

	HBufC8* buf1 = NULL;

	TRAP(r,buf1 = HBufC8::NewL(KBigBlockSize));

	TEST(r == KErrNone && buf1 != NULL);

	TInt maxBlockNum = KBigBlockSize / aBlockSize;

	TInt blockNum = 0;

	TInt blocksFree = maxBlockNum;

	TInt blockHead = 0;		// ha ha

	TInt blockTail = 0;

	TPtrC8* writeBuffer = new TPtrC8[maxBlockNum];

	for (TInt n=0; n<maxBlockNum; n++)

		{

		TUint8* addr = (TUint8*) buf1->Des().Ptr() + (n * aBlockSize);

		writeBuffer[n].Set(addr, aBlockSize);

		}

	TInt j = 0;

	TInt i = 0;

	while(j < aSize)

		{

		// fill the buffer with a char based on the block number

		TPtr8 bufWritePtr((TUint8*) writeBuffer[blockHead].Ptr(), 0, writeBuffer[blockHead].Length());

		TUint8* addr = (TUint8*) buf1->Des().Ptr() + (blockHead * aBlockSize);

		bufWritePtr.Set(addr, 0, aBlockSize);

		FillBuffer(bufWritePtr, aBlockSize, 'A'+blockNum);

//test.Printf(_L("j %d, addr %08X, aSize %d, blockNum %d, blockTail %d, blockHead %d, maxBlockNum %d, blocksFree %d\n"), 

//	j, writeBuffer[blockHead].Ptr(), aSize, blockNum, blockTail, blockHead, maxBlockNum, blocksFree);

		if((aSize - j) >= aBlockSize) 	// All the blocks but the last one

			file1.Write(writeBuffer[blockHead], aBlockSize, status1[blockHead]); 

		else							// The last block

			file1.Write(writeBuffer[blockHead], (aSize - j), status1[blockHead]); 

		if((aSize - j) >= aBlockSize) 	// All the blocks but the last one

			file2.Write(writeBuffer[blockHead], aBlockSize, status2[blockHead]); 

		else							// The last block

			file2.Write(writeBuffer[blockHead], (aSize - j), status2[blockHead]); 

		TInt status = status1[blockHead].Int();

		if (status != KErrNone && status != KRequestPending)

			test.Printf(_L("RFile::Write() returned %d\n"), status1[blockHead].Int());

		test (status == KErrNone || status == KRequestPending);

		status = status2[blockHead].Int();

		if (status != KErrNone && status != KRequestPending)

			test.Printf(_L("RFile::Write() returned %d\n"), status1[blockHead].Int());

		test (status == KErrNone || status == KRequestPending);

		i++;

		j += aBlockSize;	

		blockNum++;

		blockHead = (blockHead + 1) % maxBlockNum;

		blocksFree--;

		if (blocksFree == 0)

			{

//test.Printf(_L("Waiting for block %d\n"), blockTail);

			User::WaitForRequest(status1[blockTail]);

			User::WaitForRequest(status2[blockTail]);

			blockTail = (blockTail + 1) % maxBlockNum;

			blocksFree++;

			}

		}					

		while (blockTail != blockHead)

			{

//test.Printf(_L("Waiting for block %d\n"), blockTail);

			User::WaitForRequest(status1[blockTail]);

			User::WaitForRequest(status2[blockTail]);

			blockTail = (blockTail + 1) % maxBlockNum;

			blocksFree++;

			}

	file1.Close();	

	file2.Close();	

	// Verify file1

	r = file1.Open(aFs, fileName1, EFileShareAny|EFileRead|EFileReadDirectIO);

	TESTERROR(r);

	TInt size;

	r = file1.Size(size);

	TESTERROR(r);

	blockNum = 0;

	j = 0;

	while(j < size) 

		{

		TPtr8 readPtr((TUint8*) writeBuffer[0].Ptr(), aBlockSize, aBlockSize);

		r = file1.Read(readPtr);

		TESTERROR(r);

		r = VerifyBuffer(readPtr, 'A' + blockNum);	

		TESTERROR(r);

		j += aBlockSize;

		blockNum++;

		}	

	// Verify file2

	r = file2.Open(aFs, fileName2, EFileShareAny|EFileRead|EFileReadDirectIO);

	TESTERROR(r);

	r = file2.Size(size);

	TESTERROR(r);

	blockNum = 0;

	j = 0;

	while(j < size) 

		{

		TPtr8 readPtr((TUint8*) writeBuffer[0].Ptr(), aBlockSize, aBlockSize);

		r = file2.Read(readPtr);

		TESTERROR(r);

		r = VerifyBuffer(readPtr, 'A' + blockNum);	

		TESTERROR(r);

		j += aBlockSize;

		blockNum++;

		}	

	file2.Close();			

	file1.Close();			

	delete [] writeBuffer;

	delete buf1;

	r = aFs.Delete(fileName1);

	TEST(r == KErrNone);

	r = aFs.Delete(fileName2);

	TEST(r == KErrNone);

	}

/** Measure the time taken for a big block to be written synchronously

*/

void TimeTakenToWriteBigBlock() 

{

	TTime startTime;

	TTime endTime;

	RFile fileWrite;

	TInt r = fileWrite.Replace(TheFs,gBigFile,EFileShareAny|EFileWrite|EFileWriteDirectIO);

	TESTERROR(r);

	// Calculate how long it takes to write a big block to be able to issue at the right time the concurrent writes

	startTime.HomeTime();

	r = fileWrite.Write(gBufWritePtr, KBigBlockSize); 

	endTime.HomeTime();

	fileWrite.Close();

	TESTERROR(r);

	gTimeTakenBigBlock = I64LOW(endTime.MicroSecondsFrom(startTime).Int64()/3);

	test.Printf(_L("\nTime spent to write the big block in isolation: %d ms\n"), gTimeTakenBigBlock.Int() / KuStomS);

}

/** Measure the time taken for this file to be written synchronously

*/

void TimeTakenToWriteBigFile(TInt aPos) 

{

	TTime startTime;

	TTime endTime;

	test((aPos >= 0) && (aPos <= 1));

	startTime.HomeTime();

	WriteFile(TheFs,gBigFile, gBigFileSize, KBigBlockSize, ENoThreads);

	endTime.HomeTime();

	gTimeTakenBigFile = I64LOW(endTime.MicroSecondsFrom(startTime).Int64());

	test.Printf(_L("\nTime spent to write the big file in isolation: %d ms\n"), gTimeTakenBigFile.Int() / KuStomS);

	gTotalTimeSync[aPos] = Max((gTimeTakenBigFile.Int()/KuStomS), gTotalTimeSync[aPos]) ;

}

/** Measure the time taken for this file to be written asynchronously

*/

void TimeTakenToWriteBigFileAsync(TInt aPos) 

{

	TTime startTime;

	TTime endTime;

	TTime endTime2;

	TRequestStatus status[KWaitRequestsTableSize];

	RFile bigFile;

	test((aPos >= 0) && (aPos <= 1));

	startTime.HomeTime();

	WriteFileAsync(TheFs, bigFile, gBigFile, gBigFileSize,KBigBlockSize,status); 

	endTime.HomeTime();

	WaitForAll(status, gBigFileSize, KBigBlockSize);	

	endTime2.HomeTime();

	gTimeTakenBigFile=I64LOW(endTime.MicroSecondsFrom(startTime).Int64());

	bigFile.Close();

	test.Printf(_L("\nTime to queue the blocks in isolation asynchronously: %d ms, "), gTimeTakenBigFile.Int() / KuStomS);

	gTimeTakenBigFile=I64LOW(endTime2.MicroSecondsFrom(startTime).Int64());

	test.Printf(_L("to actually write it: %d ms\n"),gTimeTakenBigFile.Int() / KuStomS);

	gTotalTimeAsync[aPos] = Max((gTimeTakenBigFile.Int() / KuStomS), gTotalTimeAsync[aPos]) ; 

}

/**  Delete content of directory

	@param aDir	Target directory

	@return Error returned if any, otherwise KErrNone

*/

TInt DeleteAll(TDes16& aDir) 

	{

		TBuf16<100> dir;

		CFileMan* fMan=CFileMan::NewL(TheFs);

		TInt r=0;

		dir = aDir;

		dir.Append(_L("F*.*"));

		r = fMan->Delete(dir);	

		delete fMan;

		return r;

	}

/**  Read a small file sync, in a different thread

	@return ETrue

*/

TInt ReadSmallFile(TAny* )

	{

	RTest test(_L("T_FSCHED"));

	RFs fs;

	TInt r=fs.Connect();

	TESTERROR(r);

	r = fs.SetSessionPath(gSessionPath);

	TESTERROR(r);

	ReadFile(fs,gSmallFile,KBlockSize, EThreadWait);

	gTime2.HomeTime();

	client.Signal();

	fs.Close();

	test.Close();

	return ETrue;

	}

/**  Read the big file sync, in a different thread

	@return ETrue

*/

TInt ReadBigFile(TAny* )

	{

	RTest test(_L("T_FSCHED"));

	RFs fs;

	TInt r=fs.Connect();

	TESTERROR(r);

	r=fs.SetSessionPath(gSessionPath);

	TESTERROR(r);

	ReadFile(fs,gBigFile,KBlockSize, EThreadWait);

	gTime2.HomeTime();

	client.Signal();

	fs.Close();

	test.Close();

	return ETrue;

	}

/**  Write a small file sync, in a different thread

	@return ETrue

*/

TInt WriteSmallFile(TAny* )

	{

	RTest test(_L("T_FSCHED"));

	RFs fs;

	TInt r=fs.Connect();

	TESTERROR(r);

	r=fs.SetSessionPath(gSessionPath);

	TESTERROR(r);

	WriteFile(fs,gSmallFile,gSmallFileSize, KBlockSize, EThreadWait);

	gTime2.HomeTime();

	client.Signal();

	fs.Close();

	test.Close();

	return ETrue;

	}

/**  Write a big file sync, in a different thread

	@return ETrue

*/

TInt WriteBigFile(TAny* )

	{

	RTest test(_L("T_FSCHED"));

	RFs fs;

	TInt r=fs.Connect();

	TESTERROR(r);

	r=fs.SetSessionPath(gSessionPath);

	TESTERROR(r);

	WriteFile(fs, gBigFile, gBigFileSize, KBigBlockSize, EThreadSignal); 

	gTime1.HomeTime();

	client.Signal();

	fs.Close();

	test.Close();

	return ETrue;

	}

/**   Write big file after a signalling thread has been scheduled, in a different thread

	@return ETrue

*/

TInt WriteBigFile2(TAny* )

	{

	RTest test(_L("T_FSCHED"));

	RFs fs;

	TInt r=fs.Connect();

	TESTERROR(r);

	r = fs.SetSessionPath(gSessionPath);

	TESTERROR(r);

	WriteFile(fs, gSmallFile, gBigFileSize, KBigBlockSize, EThreadWait); 

	gTime2.HomeTime();

	client.Signal();

	fs.Close();

	test.Close();

	return ETrue;

	}

/**  Write a big file async, in a different thread

	@return ETrue

*/

TInt WriteBigFileAsync(TAny* )

	{

	RTest test(_L("T_FSCHED"));

	RFs fs;

	TInt r = fs.Connect();

	TESTERROR(r);

	r=fs.SetSessionPath(gSessionPath);

	TESTERROR(r);

	RFile bigFile;

	WriteFileAsync(fs, bigFile, gSmallFile, gBigFileSize, KBlockSize,gStatus); 

	gSync.Signal();

	WaitForAll(gStatus, gBigFileSize, KBlockSize);

	fs.Close();

	test.Close();

	return ETrue;

	}

/**  Delete a big file, in a different thread

	@return ETrue

*/

TInt DeleteBigFile(TAny* )

	{

	RTest test(_L("T_FSCHED"));

	RFs fs;

	TInt r = fs.Connect();

	TESTERROR(r);

	r = fs.SetSessionPath(gSessionPath);

	TESTERROR(r);

	gSync.Wait(); 

	r = fs.Delete(gBigFile);

#if defined(__WINS__)

	TEST(r == KErrInUse || r == KErrNone);

#else

	test_Equal(KErrInUse, r);

#endif

	client.Signal();

	fs.Close();

	test.Close();

	return ETrue;

	}

/**  Reads a small file while writing a big one

*/

void TestReadingWhileWriting() 

{

	TInt r = 0;

	TTime time1;

	TTime time2;

	time1.HomeTime();

	// Write the small file and take the appropriate measures

	WriteFile(TheFs,gSmallFile,KBlockSize, KBlockSize, ENoThreads);

	// Sync test

	TBuf<20> buf=_L("Big Write");

	r = gBig.Create(buf, WriteBigFile, KDefaultStackSize, KHeapSize, KMaxHeapSize, NULL);

	TEST(r == KErrNone);

	buf = _L("Small Read");

	r = gSmall.Create(buf, ReadSmallFile, KDefaultStackSize, KHeapSize, KMaxHeapSize, NULL);

	TEST(r == KErrNone);

	gBig.Resume();

	gSmall.Resume();

	CLIENTWAIT();

	CLIENTWAIT();

	gBig.Close();

	gSmall.Close();

	TTimeIntervalMicroSeconds timeTaken = gTime1.MicroSecondsFrom(gTime2);

	test.Printf(_L("\nSync read done %d ms before the write ended\n"),I64LOW(timeTaken.Int64() / KuStomS));

	TReal time=I64LOW(timeTaken.Int64() / KuStomS); 

	#if !defined(__WINS__)

	// If this condition fails, means that writing the sync file while fairscheduling a small sync read takes too long

		test.Printf(_L("time: %f\n"), time);

//		test((time > 0) && (((gTotalTimeSync[0]-time)>0) || ((gTotalTimeSync[1]-time)>0)) );  

		test(time > 0);

	#endif 

	// Async test 

	TRequestStatus status[KWaitRequestsTableSize];

	TRequestStatus status2[2];

	RFile bigFile, smallFile;	

	WriteFileAsync(TheFs, bigFile, gBigFile, gBigFileSize,  KBigBlockSize ,status); 

	ReadFileAsync(TheFs, smallFile, gSmallFile, KBlockSize, status2 );

	WaitForAll(status2,KBlockSize , KBlockSize );

	time1.HomeTime(); 

	WaitForAll(status,gBigFileSize, KBigBlockSize);

	time2.HomeTime();

	bigFile.Close();

	smallFile.Close();

	timeTaken = time2.MicroSecondsFrom(time1);

	test.Printf(_L("\nAsync read done %d ms before the write ended\n"),I64LOW(timeTaken.Int64() / KuStomS));

	time = I64LOW(timeTaken.Int64() / KuStomS); 

	#if !defined(__WINS__)

	// If this condition fails, means that writing the async file while fairscheduling a small async read takes too long

		test.Printf(_L("time: %f\n"), time);

		test.Printf(_L("gTotalTimeAsync[0] = %d , gTotalTimeAsync[1] = %d\n"),gTotalTimeAsync[0],gTotalTimeAsync[1] );

//		test((time > 0) && (((gTotalTimeAsync[0]-time)>0) || ((gTotalTimeAsync[1]-time)>0)) );

		test(time > 0);

	#endif

}

/** Writes a small file while writing a big one

*/

void TestWritingWhileWriting() 

{

	TInt r = 0;

	TTime time1;

	TTime time2;

	// Sync test

	TBuf<20> buf = _L("Big Write II");

	r = gBig.Create(buf, WriteBigFile, KDefaultStackSize, KHeapSize, KMaxHeapSize, NULL);

	TEST(r == KErrNone);

	buf = _L("Small Write II");

	r = gSmall.Create(buf, WriteSmallFile, KDefaultStackSize, KHeapSize, KMaxHeapSize, NULL);

	TEST(r==KErrNone);

	gBig.Resume();

	gSmall.Resume();

	CLIENTWAIT();

	CLIENTWAIT();

	gBig.Close();