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

#include "f32_test_utils.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 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;

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]);