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

// 

//

/**

 @file

 @internalTechnology 

*/

#define __E32TEST_EXTENSION__

#include <f32file.h>

#include <e32test.h>

#include <e32svr.h>

#include <e32const.h>

#include <e32const_private.h>

#include <f32dbg.h>

#include "t_server.h"

#include <e32twin.h>

#include <e32rom.h>

#include <hal.h>

#include <u32hal.h>

const TInt KTotalCacheSize = 32 * 1024 * 1024;

const TInt KDefaultCacheSize = (128 + 12) * 1024;

const TInt KFilesNeededToFillCache = (KTotalCacheSize / KDefaultCacheSize) + 2;

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

//! @SYMTestCaseID      PBASE-T_RCACHE-0190

//! @SYMTestType        CIT

//! @SYMPREQ            PREQ914

//! @SYMTestCaseDesc    This test case is exercising the Read Caching functionality added to

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

//! @SYMTestActions     0   setup the environment to execute the tests

//!						1	TestNegative creates situations where the cached content needs to be

//!							flushed or removed  from the cache by corrupting files and verifies

//!							the cache behaviour

//!						2 	TestSimpleRead ensures that the cache is working in the simple cases,

//!							with a combination of sync and async reads:

//!								a. The file fits in the cache

//!								b. The file doesn't fit in the cache

//!						3 	TestRepeatedRead verifies the cache behaviour when a file is read an

//!							arbitrary number of times, with and without other operations ongoing

//!						4	TestReadAhead reads 3 times from a file and verifies that the read

//!							ahead functionality acts afterwards.

//!						5	TestConcurrent reads files concurrently and verifies how the cache

//!							copes with it.

//!						6 	TestFillCache fills the cache and then executes TestSimpleRead.

//!

//! @SYMTestExpectedResults finishes if the read cache behaves as expected, panics otherwise

//! @SYMTestPriority        High

//! @SYMTestStatus          Implemented

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

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

// 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_RCACHE"));

GLDEF_D	RFs TheFs;

GLDEF_D TInt gDrive;

GLDEF_D TFileName gSessionPath;

GLDEF_D TChar gDriveToTest;

TThreadId gMainThreadId;

LOCAL_D HBufC8* gBuf = NULL;

LOCAL_D TPtr8 gBufReadPtr(NULL, 0);

LOCAL_D HBufC8* gBufSec = NULL;

LOCAL_D TPtr8 gBufWritePtr(NULL, 0);

LOCAL_D const TInt KOneK = 1024;

LOCAL_D const TInt KOneMeg = KOneK * 1024;

LOCAL_D const TInt KBlockSize = KOneK;

LOCAL_D const TInt KWaitRequestsTableSize = 256;

LOCAL_D TInt gSecondFileSize = 0;

LOCAL_D TInt gFirstFileSize = 0;

LOCAL_D TInt gCurrentFileSize = 0;

LOCAL_D TInt64 gMediaSize = 0;

LOCAL_D TTimeIntervalMicroSeconds gTimeTakenBigFile(0);

LOCAL_D TBuf16<25> gFirstFile;

LOCAL_D TBuf16<25> gSecondFile;

LOCAL_D TBuf16<25> gCurrentFile;

LOCAL_D TInt gNextFile = 0;

LOCAL_D TTime gTime1;

LOCAL_D TTime gTime2;

_LIT(KMsg1, "1st read timing: %d\n");

_LIT(KMsg2, "2nd read timing: %d\n");

_LIT(KMsg3, "3rd read timing: %d\n");

LOCAL_D RSemaphore gSync;

// Concurrent Threads

LOCAL_D RThread gThread1;

LOCAL_D RThread gThread2;

LOCAL_D RSemaphore client;

LOCAL_D const TInt KHeapSize = 0x4000;

LOCAL_D const TInt KMaxHeapSize = 0x100000;

LOCAL_D TBool gPagedRom = EFalse;

enum TTestState

	{

	EThreadWait,

	EThreadSignal,

	ENoThreads

	};

/** Formats the drive

	@param aDrive 	Drive to be formatted

	@param aFormatMode Mode for the format operation

*/

LOCAL_C void Formatting(TInt aDrive, TUint aFormatMode )

	{

	test.Next(_L("Format"));

	TBuf<4> driveBuf = _L("?:\\");

	driveBuf[0]=(TText)(aDrive+'A');

	RFormat format;

	TInt count;

	TInt r = format.Open(TheFs,driveBuf,aFormatMode,count);

	test_KErrNone(r);

	while(count)

		{

		TInt r = format.Next(count);

		test_KErrNone(r);

		}

	format.Close();

	}

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

*/

LOCAL_C TInt VerifyBuffer(TDes8& aBuffer)

	{

	TChar c = aBuffer[0];

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

		{

		if(i%32 != 0)

		{

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

				return KErrCorrupt;

		}

		else

		{

			if(aBuffer[i] != aBuffer[0])

				return KErrCorrupt;

		}

		c = aBuffer[i];

		}

	return KErrNone;

	}

/**  Fills a buffer with character aC, aC+1, aC+2, ..., aC+20, aC, etc

	@param aBuffer  Buffer to be filled, output

	@param aLength  Length to be filled

	@param aC		Character to be used to fill the buffer

*/

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

	{

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

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

		{

		aBuffer.Append((i%32) + aC);

		}

	}

/**  Returns true if fat filesystem present on aDrive

	@param aFsSession 	Session on the File Server

	@param aDrive 		Drive to be looked at

*/

LOCAL_C TBool IsFSFAT(RFs &aFsSession,TInt aDrive)

	{

	TFileName f;

	TInt r = aFsSession.FileSystemName(f,aDrive);

	if (r != KErrNone)

		{

		test.Printf(_L("Unable to get file system name\n"));

		return EFalse;

		}

	return (f.CompareF(_L("Fat")) == 0);

	}

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

*/

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

}

/**  Delete content of directory

	@param aDir	Target directory

	@return Error returned if any, otherwise KErrNone

*/

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

}

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

*/

LOCAL_C void WaitForAll(TRequestStatus* status, TInt aSize)

{

	TInt i = 0;

	RTest test(_L("T_RCACHE"));

	while(i < aSize)

		{

		User::WaitForRequest(status[i]);

		test(status[i] == KErrNone);

		i++;

		}

	test.Close();

}

/**  Reads the parameters from the comand line

	 and updates the appropriate variables

*/

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

	test_KErrNone(r);

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

	gSessionPath[0] = (TUint16) gDriveToTest;

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

}

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

	@param aReadBack	Reads the file back if ETrue. This is used for Read-ahead testing to ensure

						what is written is also read back through the media driver's cache. If the

						file is bigger than the cache, then subsequent streaming reads starting from

						position zero will have to be re-read from the media.

	@return Returns KErrNone if everything ok, otherwise it panics

*/

LOCAL_C TInt WriteFile(RFs& fs, TDes16& aFile, TInt aSize, TInt aBlockSize, TDes8& aBuf, TTestState aState, TBool aReadBack = EFalse)

{

	RTest test(_L("T_RCACHE"));

	TInt r = 0;

	RFile fileWrite;

	TInt pos = 0;

	test(aBlockSize>0);

	test((aSize%aBlockSize) == 0); 	// Ensure the size of the file is a multiple of the block size

	if(aState == EThreadWait)

	{

		gSync.Wait();

	}

	// delete file first to ensure it's contents are not in the cache (file may be be on the closed file queue)

	r = fs.Delete(aFile);

	test_Value(r, r == KErrNone || r == KErrNotFound);

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

	test_KErrNone(r);

	TInt j = 0;

	while(j < aSize)

		{

			r = fileWrite.Write(pos, aBuf);

			test_KErrNone(r);

			if (aReadBack)

				{

				r = fileWrite.Read(pos, aBuf);

				test_KErrNone(r);

				}

			if((j>(aSize/2))&&(aState == EThreadSignal))

			{

				gSync.Signal();

				aState = ENoThreads;

			}

			j += aBlockSize;

			pos += aBlockSize;

		}

	fileWrite.Close();

	test.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

	@return Returns KErrNone if everything ok, otherwise it panics

*/

LOCAL_C TInt ReadFile(RFs& fs, TDes16& aFile, TInt aBlockSize)

{

	RTest test(_L("T_RCACHE"));

	TInt r = 0, size = 0;

	RFile fileRead;

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

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

	test_KErrNone(r);

	r = fileRead.Size(size);

	test_KErrNone(r);

	TInt j = 0;

	while(j < size)

	{

		r = fileRead.Read(gBufReadPtr, aBlockSize);

		test_KErrNone(r);

		j += aBlockSize;

	}

	fileRead.Close();

	test.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

*/

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

{

	RTest test(_L("T_RCACHE"));

	TInt r = 0;

	test(aBlockSize>0);

	test((aSize%aBlockSize) == 0); 	// Ensure the size of the file is a multiple of the block size

	// delete file first to ensure it's contents are not in the cache (file may be be on the closed file queue)

	r = fs.Delete(aFile);

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

	test_KErrNone(r);

	TInt j = 0, i = 0;

	while(j < aSize)

	{

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

		r = aStatus[i].Int();

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

			{

			test.Printf(_L("Write %d returned %d\n"), i, r);

			test(0);

			}

		i++;

		j += aBlockSize;

	}

	test.Close();

}

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

*/

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

	{

	RTest test(_L("T_RCACHE"));

	TInt r = 0;

	TInt size = 0;

	test(aBlockSize > 0);

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

	test_KErrNone(r);

	r = aFileRead.Size(size);

	test_KErrNone(r);

	test(size == aFileSize);

	TInt j = 0, i = 0;

	while(j < size)

		{

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

		r = aStatus[i].Int();

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

			{

			test.Printf(_L("Read %d returned %d\n"), i, r);

			test(0);

			}

		i++;

		j += aBlockSize;

		}

	test.Close();

	return KErrNone;

	}

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

*/

LOCAL_C TInt WriteTestFile(TDes16& aFile, TInt aSize, TBool aReadBack = EFalse)

{

	RTest test(_L("T_RCACHE"));

	TTime startTime;

	TTime endTime;

	TInt r = 0;

	startTime.HomeTime();

	r = WriteFile(TheFs,aFile, aSize, KBlockSize, gBufWritePtr, ENoThreads, aReadBack);

	test_KErrNone(r);

	endTime.HomeTime();

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

	test.Close();

	return I64LOW(gTimeTakenBigFile.Int64()) / 1000;

}