// Copyright (c) 1995-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_filecache.cpp

// 

//

#define __E32TEST_EXTENSION__

#include <f32file.h>

#include <e32test.h>

#include <e32svr.h> 

#include <f32dbg.h>

#include "t_server.h"

#include <e32twin.h>

#include <e32rom.h>

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

//! @SYMTestCaseID      PBASE-T_FILECACHE-0189

//! @SYMTestType        UT

//! @SYMPREQ            PREQ914

//! @SYMTestCaseDesc    Unit tests for fair scheduling, read caching and lazy writing

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

//!						1 	Reads a file with different blocksizes

//!						2	Write a file with different blocksizes

//!						3	Small reads while controlling the cache 

//!						4	Read operations with and without read ahead

//!						5 	Write operations with write buffer

//! @SYMTestExpectedResults finishes if the implementation of PREQ914 behaves as expected, panics otherwise

//! @SYMTestPriority        High

//! @SYMTestStatus          Critical

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

//#define SYMBIAN_TEST_EXTENDED_BUFFER_SIZES

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

GLDEF_D	RFs TheFs;

GLDEF_D TChar gDriveToTest;

GLDEF_D TInt gDrive;

GLDEF_D TFileName gSessionPath;

GLDEF_D TVolumeInfo gVolInfo;	// volume info for current drive

GLDEF_D TFileCacheFlags gDriveCacheFlags = TFileCacheFlags(0);

#if defined(_DEBUG) || defined(_DEBUG_RELEASE)

static TFileCacheConfig gFileCacheConfig;

static TBool gDisplayCacheFlags = EFalse;

static TBool gWriteCacheFlags = EFalse;

static TBool gRomPaged = EFalse;

#endif

static TBool gRunTests = ETrue;

static TBool gRunUnitTests = ETrue;

static TBool gRunPerformanceTests = EFalse;

static TBool gRunManualTests = EFalse;

LOCAL_D TInt KMaxFileSize = 768 * 1024;

// Chosing a file size of 128K ensures entire file will be cached

//LOCAL_D TInt KMaxFileSize = 128 * 1024;

LOCAL_D TBuf8<256*1024> DataBuf;

const TInt KBufSize = 513 * 1024 - 16;

HBufC8* gBuf = NULL;

LOCAL_D TPtr8 gBufPtr(NULL, 0);

const TReal KOneK = 1024;

const TReal KOneMeg = 1024 * KOneK;

const TInt KSegmentSize = 4096;

const TInt KSegmentSizeMask = (4096-1);

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;

}

#if defined(_DEBUG) || defined(_DEBUG_RELEASE)

void PrintFileCacheStats(TFileCacheStats& fileCacheStats, TBool aDisplay = ETrue)

	{

	TInt r = controlIo(TheFs,gDrive, KControlIoFileCacheStats, fileCacheStats);

	test_KErrNone(r);

	if (!aDisplay)

		return;

	test.Printf(_L("File cache: Cachelines (free %d, used %d), Segments(allocated %d locked %d). Closed files(%d) Holes %d Failures (commit %d Lock %d)\n"), 

		fileCacheStats.iFreeCount, fileCacheStats.iUsedCount, fileCacheStats.iAllocatedSegmentCount,fileCacheStats.iLockedSegmentCount,fileCacheStats.iFilesOnClosedQueue, fileCacheStats.iHoleCount, fileCacheStats.iCommitFailureCount, fileCacheStats.iLockFailureCount);

	test.Printf(_L("File cache: iUncachedPacketsRead %d iUncachedBytesRead %d iUncachedPacketsWritten %d iUncachedBytesWritten %d\n"), 

		fileCacheStats.iUncachedPacketsRead,

		fileCacheStats.iUncachedBytesRead,

		fileCacheStats.iUncachedPacketsWritten,

		fileCacheStats.iUncachedBytesWritten);

	}

void PrintFileCacheConfig(TFileCacheConfig& aFileCacheConfig, TBool aDisplay = ETrue)

	{

	TInt r = controlIo(TheFs,gDrive, KControlIoFileCacheConfig, aFileCacheConfig);

	if (!aDisplay)

		return;

	test.Printf(_L("File cache:\nDrive %c\nFlags %08X\nFileCacheReadAsync %d\nFairSchedulingLen %d\nCacheSize %d\nMaxReadAheadLen %d\nClosedFileKeepAliveTime %d\nDirtyDataFlushTime %d"), 

		aFileCacheConfig.iDrive + 'A',

		aFileCacheConfig.iFlags,

		aFileCacheConfig.iFileCacheReadAsync,

		aFileCacheConfig.iFairSchedulingLen,

		aFileCacheConfig.iCacheSize,

		aFileCacheConfig.iMaxReadAheadLen,

		aFileCacheConfig.iClosedFileKeepAliveTime,

		aFileCacheConfig.iDirtyDataFlushTime);

	}

void TestDirtyDataWrittenToDisk(TFileCacheStats& fileCacheStats)

	{

	test.Next(_L("test dirty data has been written to disk"));

	// wait a maximum of double KDefaultDirtyDataFlushTime for dirty data to be flushed

	const TInt KWaitTime = 250;	// 250 milisecs

	for (TInt n=0; n<(gFileCacheConfig.iDirtyDataFlushTime/1000)<<1 ; n+= KWaitTime)

		{

		test.Printf(_L("After %d milisecs : "), n );

		PrintFileCacheStats(fileCacheStats);

		User::After(KWaitTime * 1000);		// wait 100 ms

		if (fileCacheStats.iLockedSegmentCount == 0)

			break;

		}

	PrintFileCacheStats(fileCacheStats);

	test(fileCacheStats.iLockedSegmentCount == 0);

	}

#endif 

void TestsInit()

	{

	gBuf = HBufC8::NewL(KBufSize);

	test(gBuf!=NULL);

	gBufPtr.Set(gBuf->Des());

	}

void TestsEnd()

	{

	delete gBuf;

	gBuf = NULL;

	}

LOCAL_C void SetSessionPath(TInt aDrive)

	{

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

	TChar driveLetter;

	TInt r=TheFs.DriveToChar(aDrive,driveLetter);

	test_KErrNone(r);

	gSessionPath[0]=(TText)driveLetter;

	r=TheFs.SetSessionPath(gSessionPath);

	test_KErrNone(r);

	}

LOCAL_C void PrintFileMode(TUint aFileMode)

	{

	TBuf<80> buf;

	buf.Format(_L("FileMode = %08X"), aFileMode);

	if (aFileMode & EFileWriteBuffered)

		buf.Append(_L(", EFileWriteBuffered"));

	if (aFileMode & EFileWriteDirectIO)

		buf.Append(_L(", EFileWriteDirectIO"));

	if (aFileMode & EFileReadBuffered)

		buf.Append(_L(", EFileReadBuffered"));

	if (aFileMode & EFileReadDirectIO)

		buf.Append(_L(", EFileReadDirectIO"));

	if (aFileMode & EFileReadAheadOn)

		buf.Append(_L(", EFileReadAheadOn"));

	if (aFileMode & EFileReadAheadOff)

		buf.Append(_L(", EFileReadAheadOff"));

	buf.Append(_L("\n"));

	test.Printf(buf);

	}

void FillBuffer(TDes8& aBuffer, TInt aLength)

	{

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

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

		{

		aBuffer[i]=(TUint8) (i >> 8);

		aBuffer[i+1]=(TUint8) i;

		}

	}

void TestBufferFail(TDes8& aBuffer, TInt aPos, TInt aLength)

	{

	test.Printf(_L("TestBuffer failed at pos %d len %d\n"), aPos, aLength);

	#define PRINTCH(ch) ((ch >= 0x20 && ch < 0x7F)?ch:' ')

	TInt startPos = Max(0, aPos - 64);

	TInt endPos = startPos + 64;

	for(TInt n=startPos; n<=endPos; n+=16)

		RDebug::Print(_L("%08X: %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X  [%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c]"), 

			//&aBuffer[aPos+n],

			n,

			aBuffer[n+0], aBuffer[n+1], aBuffer[n+2], aBuffer[n+3], aBuffer[n+4], aBuffer[n+5], aBuffer[n+6], aBuffer[n+7], aBuffer[n+8], aBuffer[n+9], aBuffer[n+10], aBuffer[n+11], aBuffer[n+12], aBuffer[n+13], aBuffer[n+14], aBuffer[n+15],

			PRINTCH(aBuffer[n+0]), PRINTCH(aBuffer[n+1]), PRINTCH(aBuffer[n+2]), PRINTCH(aBuffer[n+3]), PRINTCH(aBuffer[n+4]), PRINTCH(aBuffer[n+5]), PRINTCH(aBuffer[n+6]), PRINTCH(aBuffer[n+7]), PRINTCH(aBuffer[n+8]), PRINTCH(aBuffer[n+9]), PRINTCH(aBuffer[n+10]), PRINTCH(aBuffer[n+11]), PRINTCH(aBuffer[n+12]), PRINTCH(aBuffer[n+13]), PRINTCH(aBuffer[n+14]), PRINTCH(aBuffer[n+15]));

#if defined(_DEBUG) || defined(_DEBUG_RELEASE)

		TInt x;

		TInt r = controlIo(TheFs,gDrive, KControlIoFileCacheDump, x);

		test_KErrNone(r);

#endif

	test (0);

	}

void TestBuffer(TDes8& aBuffer, TInt aPos, TInt aLength)

	{

	TInt pos = aPos;

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

		{

		if (pos & 1)

			{

			if (aBuffer[pos] != (TUint8) pos-1)

				TestBufferFail(aBuffer, pos, aLength);

			}

		else

			{

			if (aBuffer[pos] != (TUint8) (pos >> 8))

				TestBufferFail(aBuffer, pos, aLength);

			}

		}

	}

LOCAL_C void UnitTests()

//

// Test read file handling.

//

	{

	test.Start(_L("File cache read and write unit tests"));

//TheFs.SetDebugRegister(KCACHE);

	RFile f;

	TInt r;

	TInt pos;

	TInt len;

	TInt testNum;

#if defined(_DEBUG) || defined(_DEBUG_RELEASE)

	TBool simulatelockFailureMode;

	TFileCacheStats fileCacheStats;

	r = controlIo(TheFs, gDrive, KControlIoFileCacheStats, fileCacheStats);

	test.Printf(_L("Number of files on closed queue=%d\n"),fileCacheStats.iFilesOnClosedQueue);

	test(fileCacheStats.iFilesOnClosedQueue == 0);

#endif

#if defined(_DEBUG) || defined(_DEBUG_RELEASE)

	// turn OFF lock failure mode 

	simulatelockFailureMode = EFalse;

	r = controlIo(TheFs, gDrive, KControlIoSimulateLockFailureMode, simulatelockFailureMode);

#endif

	TFileName testFile   = _L("TEST.BIN");

	//**********************************

	// Test Read-Modify-Write

	//**********************************

	test.Next(_L("Test read-modify-write"));

	gBufPtr.SetLength(KBufSize);

	FillBuffer(gBufPtr, KBufSize);

	TestBuffer(gBufPtr, 0,KBufSize);

	TPtrC8 writePtr;

	TPtr8 readPtr(gBuf->Des());

#if defined(_DEBUG) || defined(_DEBUG_RELEASE)

	TInt uncachedBytesRead;

	TInt uncachedPacketsRead;

#endif

	// create an empty file, so that any writes overlapping segemt boundaries

	// need a read first

	// create a test file using directIO and then re-open it in buffered mode, 

	// so that any writes overlapping segemt boundaries need a read first

	r = f.Replace(TheFs, testFile, EFileWrite | EFileWriteDirectIO);

	test_KErrNone(r);

	writePtr.Set(gBuf->Des());

	r = f.Write(0, writePtr);

	test_KErrNone(r);

	f.Close();

	r = f.Open(TheFs, testFile, EFileReadBuffered | EFileWrite | EFileWriteBuffered);

	test_KErrNone(r);

	TInt cacheLineLen = 128*1024;

#if defined(_DEBUG) || defined(_DEBUG_RELEASE)

	PrintFileCacheStats(fileCacheStats);

	uncachedBytesRead = fileCacheStats.iUncachedBytesRead;

	uncachedPacketsRead = fileCacheStats.iUncachedPacketsRead;

#endif

	// write 1 partial segment at offset 0 to 7 in segment

	test.Next(_L("Test read-modify-write #1"));

	pos = cacheLineLen*0 + KSegmentSize*2 + 0;

	len = 7;

	writePtr.Set(gBuf->Mid(pos, len));

	r = f.Write(pos, writePtr, len);

	test_KErrNone(r);

	// read back & verify whole segment

	pos&= ~KSegmentSizeMask; len = (len + KSegmentSize-1) & ~KSegmentSizeMask;

	readPtr.Set(gBufPtr.MidTPtr(pos, len));

	readPtr.SetLength(len);

	readPtr.FillZ();

	r = f.Read(pos, readPtr, len);

	test_KErrNone(r);

	TestBuffer(gBufPtr, pos, len);

	test_KErrNone(r);

#if defined(_DEBUG) || defined(_DEBUG_RELEASE)

	PrintFileCacheStats(fileCacheStats);

	test (fileCacheStats.iUncachedBytesRead - uncachedBytesRead == KSegmentSize);

	test (fileCacheStats.iUncachedPacketsRead - uncachedPacketsRead == 1);

	uncachedBytesRead = fileCacheStats.iUncachedBytesRead;

	uncachedPacketsRead = fileCacheStats.iUncachedPacketsRead;

#endif

	// write 1 partial segment at offset 7 to 4096 in segment

	test.Next(_L("Test read-modify-write #2"));

	pos = cacheLineLen*0 + KSegmentSize*3 + 7;

	len = KSegmentSize - 7;

	writePtr.Set(gBuf->Mid(pos, len));

	r = f.Write(pos, writePtr, len);

	test_KErrNone(r);

	// read back & verify whole segment

	pos&= ~KSegmentSizeMask; len = (len + KSegmentSize-1) & ~KSegmentSizeMask;

	readPtr.Set(gBufPtr.MidTPtr(pos, len));

	readPtr.SetLength(len);

	readPtr.FillZ();

	r = f.Read(pos, readPtr, len);

	test_KErrNone(r);

	TestBuffer(gBufPtr, pos, len);

	test_KErrNone(r);

#if defined(_DEBUG) || defined(_DEBUG_RELEASE)

	PrintFileCacheStats(fileCacheStats);

	test (fileCacheStats.iUncachedBytesRead - uncachedBytesRead == KSegmentSize);

	test (fileCacheStats.iUncachedPacketsRead - uncachedPacketsRead == 1);

	uncachedBytesRead = fileCacheStats.iUncachedBytesRead;

	uncachedPacketsRead = fileCacheStats.iUncachedPacketsRead;

#endif

	// write 1 partial segment at offset 7 to 37 in segment

	test.Next(_L("Test read-modify-write #3"));

	pos = cacheLineLen*0 + KSegmentSize*4 + 7;

	len = 30;

	writePtr.Set(gBuf->Mid(pos, len));

	r = f.Write(pos, writePtr, len);

	test_KErrNone(r);

	// read back & verify whole segment

	pos&= ~KSegmentSizeMask; len = (len + KSegmentSize-1) & ~KSegmentSizeMask;

	readPtr.Set(gBufPtr.MidTPtr(pos, len));

	readPtr.SetLength(len);

	readPtr.FillZ();

	r = f.Read(pos, readPtr, len);

	test_KErrNone(r);

	TestBuffer(gBufPtr, pos, len);

	test_KErrNone(r);

#if defined(_DEBUG) || defined(_DEBUG_RELEASE)

	PrintFileCacheStats(fileCacheStats);

	test (fileCacheStats.iUncachedBytesRead - uncachedBytesRead == KSegmentSize);

	test (fileCacheStats.iUncachedPacketsRead - uncachedPacketsRead == 1);

	uncachedBytesRead = fileCacheStats.iUncachedBytesRead;

	uncachedPacketsRead = fileCacheStats.iUncachedPacketsRead;

#endif

	// write 2 segments, first and last both partial

	test.Next(_L("Test read-modify-write #4"));

	pos = cacheLineLen*1 + KSegmentSize*2 + 3;

	len = KSegmentSize * 1;

	writePtr.Set(gBuf->Mid(pos, len));

	r = f.Write(pos, writePtr, len);

	test_KErrNone(r);

	// read back & verify whole segment

	pos&= ~KSegmentSizeMask; len = (len + KSegmentSize-1) & ~KSegmentSizeMask;

	readPtr.Set(gBufPtr.MidTPtr(pos, len));

	readPtr.SetLength(len);

	readPtr.FillZ();

	r = f.Read(pos, readPtr, len);

	test_KErrNone(r);

	TestBuffer(gBufPtr, pos, len);

	test_KErrNone(r);

#if defined(_DEBUG) || defined(_DEBUG_RELEASE)

	PrintFileCacheStats(fileCacheStats);

	test (fileCacheStats.iUncachedBytesRead - uncachedBytesRead == KSegmentSize*2);

	// should read both segments in one read as they are contiguous

	test (fileCacheStats.iUncachedPacketsRead - uncachedPacketsRead == 1);	

	uncachedBytesRead = fileCacheStats.iUncachedBytesRead;

	uncachedPacketsRead = fileCacheStats.iUncachedPacketsRead;

#endif

	// write 3 segments, first and last both partial

	test.Next(_L("Test read-modify-write #5"));

	pos = cacheLineLen*2 + KSegmentSize*2 + 7;

	len = KSegmentSize * 2;

	writePtr.Set(gBuf->Mid(pos, len));

	r = f.Write(pos, writePtr, len);

	test_KErrNone(r);

	// read back & verify whole segment

	pos&= ~KSegmentSizeMask; len = (len + KSegmentSize-1) & ~KSegmentSizeMask;

	readPtr.Set(gBufPtr.MidTPtr(pos, len));

	readPtr.SetLength(len);

	readPtr.FillZ();

	r = f.Read(pos, readPtr, len);

	test_KErrNone(r);

	TestBuffer(gBufPtr, pos, len);

	test_KErrNone(r);

#if defined(_DEBUG) || defined(_DEBUG_RELEASE)

	PrintFileCacheStats(fileCacheStats);

	test (fileCacheStats.iUncachedBytesRead - uncachedBytesRead == KSegmentSize*2);

	test (fileCacheStats.iUncachedPacketsRead - uncachedPacketsRead == 2);

	uncachedBytesRead = fileCacheStats.iUncachedBytesRead;

	uncachedPacketsRead = fileCacheStats.iUncachedPacketsRead;

#endif

	f.Close();

	//**************************************************************

	// Test dirty data NOT written to disk if continuously writing to a file which fits in tke cache

	//**************************************************************

#if defined(_DEBUG) || defined(_DEBUG_RELEASE)

	test.Printf(_L("Test dirty data NOT written to disk if continuously writing to a file which fits in tke cache...\n"));

	// flush closed files queue to empty cache 

	test.Printf(_L("Flushing close queue to empty cache...\n"));

	r = TheFs.ControlIo(gDrive, KControlIoFlushClosedFiles);

	test_KErrNone(r);

	r = f.Replace(TheFs, testFile, EFileReadBuffered | EFileWrite | EFileWriteBuffered);

	test_KErrNone(r);

	RTimer timer;

	timer.CreateLocal();

	TRequestStatus reqStat;

	timer.After(reqStat,gFileCacheConfig.iClosedFileKeepAliveTime*3); // write 3 times the flush timer

	pos = 0;

	TInt bufLen = 7;

	TInt maxLockedSegmentCount = 0;

	while (reqStat == KRequestPending)

		{

		bufLen = (bufLen + 1023) & 0x3FFF;

		len = Min(bufLen, KBufSize - pos);

		len = Min(len, gFileCacheConfig.iCacheSize-pos);

		TPtrC8 writePtr = gBuf->Mid(pos, len);

		r = f.Write(pos, writePtr, len);

		test_KErrNone(r);

		pos+= len;

		TInt r = controlIo(TheFs,gDrive, KControlIoFileCacheStats, fileCacheStats);

		test_KErrNone(r);

		// test the locked (i.e. dirty) count always goes up & never down (down would indicate a flush)

		if (fileCacheStats.iLockedSegmentCount != maxLockedSegmentCount)

			test.Printf(_L("iLockedSegmentCount %d...\n"), fileCacheStats.iLockedSegmentCount);

		test(fileCacheStats.iLockedSegmentCount >= maxLockedSegmentCount);

		maxLockedSegmentCount = Max(maxLockedSegmentCount, fileCacheStats.iLockedSegmentCount);

		// wrap to start of file

		if (pos >= gFileCacheConfig.iCacheSize)	

			pos = 0;

		}

	timer.Close();

	test(fileCacheStats.iLockedSegmentCount > 0);

	if (gDriveCacheFlags & (EFileCacheWriteEnabled | EFileCacheWriteOn))

		TestDirtyDataWrittenToDisk(fileCacheStats);

	f.Close();

#endif

	//**************************************************************

	// Test dirty data written to disk

	//**************************************************************

	enum {ETestDataWrittenAfterTimeout, ETestDataWrittenAfterFileClose, ETestDataWrittenAfterSessionClose, ETestEnd};

#if defined(_DEBUG) || defined(_DEBUG_RELEASE)

	for (testNum = 0; testNum < ETestEnd; testNum++)

#else

	for (testNum = 0; testNum < 1; testNum++)

#endif

		{

		switch(testNum)

			{

			case ETestDataWrittenAfterTimeout		: test.Next(_L("ETestDataWrittenAfterTimeout"));		break;

			case ETestDataWrittenAfterFileClose		: test.Next(_L("ETestDataWrittenAfterFileClose"));		break;

			case ETestDataWrittenAfterSessionClose	: test.Next(_L("ETestDataWrittenAfterSessionClose"));	break;

			};

#if defined(_DEBUG) || defined(_DEBUG_RELEASE)

		// flush closed files queue to empty cache 

		test.Printf(_L("Flushing close queue to empty cache...\n"));

		r = TheFs.ControlIo(gDrive, KControlIoFlushClosedFiles);

		test_KErrNone(r);

#endif

		r = f.Replace(TheFs, testFile, EFileReadBuffered | EFileWrite | EFileWriteBuffered);

		test_KErrNone(r);

		gBufPtr.SetLength(KBufSize);