// Copyright (c) 2002-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:

//

//! @file f32test\concur\t_csfsoak.cpp

#include <f32file.h>

#include <e32test.h>

#include <e32math.h>

#include <f32dbg.h>

#include "t_server.h"

#include "t_chlffs.h"

#include "t_tdebug.h"

#include "t_cfssoak.h"

#include "f32_test_utils.h"

using namespace F32_Test_Utils;

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

LOCAL_D TFullName gFsName;

LOCAL_D TFullName gFsName1;

LOCAL_D TFullName gFsName2;

LOCAL_D TFullName gOldFsName;

LOCAL_D TFullName gNewFsName;

LOCAL_D TBool     gNoMedia = ETrue;

_LIT(KFsFile,   "CFAFSDLY");

_LIT(KFsName,   "DelayFS");

LOCAL_D const TInt32 KSecond = 1000000;

LOCAL_D const TInt32 KTenthS = KSecond/10;

LOCAL_D const TInt   KNumBuf = 10;

LOCAL_D const TInt   KBufLen = 50000;

LOCAL_D TInt KSessionWaitSlow = 50 * KTenthS;

LOCAL_D TBuf8<KBufLen> gBuff[KNumBuf];

LOCAL_D TRequestStatus gStat[KNumBuf];

LOCAL_D TChar gRemFsChr = 0;

LOCAL_D TInt  gRemFsDrv = 0;

LOCAL_D TChar gDrvCh0 = 0;

LOCAL_D TChar gDrvCh1 = 0;

LOCAL_D TChar gDrvCh2 = 0;

LOCAL_D	TInt  gWaitTime = KSessionWaitSlow;

GLDEF_D TExtension gPrimaryExtensions[KMaxDrives];

inline void TraceError(const char* aFile, TInt aLine, const TDesC& aStr, TInt aRsp)

//

// 'Helper' routine to output the file and line of an error as well as a string

// and a response value.

//

    {

    TBuf<256> fbuf;

    TPtrC8    fptr((const TUint8*)aFile);

    fbuf.Copy(fptr);

    RDebug::Print(_L("%S:%d  %S: r = %d"), &fbuf, aLine, &aStr, aRsp);

    }

#define TESTSTR(r,s,cond) if (!(cond)) { TraceError(__FILE__, __LINE__, (s), (r)); test(0); }

#define TESTLIT(r,s,cond) { _LIT(KStr,s); TESTSTR(r,KStr,cond); }

#define TESTRES(r,cond)   TESTLIT(r,"ERROR",cond)

LOCAL_C TChar MountTestFileSystem(TInt aDrive)

///

/// Mount a new CTestFileSystem on the drive under test.

/// @param aDrive Drive number (EDriveC etc.) to be used.

///

	{

	TInt r;

	// Check attributes

	TBuf<64> b;

	TChar c;

	r=TheFs.DriveToChar(aDrive,c);

	TESTLIT(r, "DriveToChar", r==KErrNone);

	b.Format(_L("Mount test file system on %c:"),(TUint)c);

	test.Next(b);

	r=TheFs.AddFileSystem(KFsFile);

	TESTLIT(r, "AddFileSystem", r==KErrNone || r==KErrAlreadyExists);

	r=TheFs.FileSystemName(gOldFsName,aDrive);

	TESTLIT(r, "FileSystemName", r==KErrNone || r==KErrNotFound);

	TDriveInfo drv;

	r = TheFs.Drive(drv, gRemFsDrv);

	TESTLIT(r, "Drive()", r == KErrNone);

	gNoMedia = (drv.iType == EMediaUnknown || drv.iType == EMediaNotPresent);

	if (gOldFsName.Length() > 0)

		{

		r = TheFs.ExtensionName(gPrimaryExtensions[aDrive].iName, aDrive, 0);

		if (r == KErrNone)

			gPrimaryExtensions[aDrive].iExists = ETrue;

		TTest::Printf(_L("Dismount %C: %S"), (TUint)c, &gOldFsName);

		r=TheFs.DismountFileSystem(gOldFsName,aDrive);

		TESTLIT(r, "DismountFileSystem", r==KErrNone);

		}

	if (gPrimaryExtensions[aDrive].iExists == EFalse)

		r=TheFs.MountFileSystem(KFsName,aDrive);

	else

		r=TheFs.MountFileSystem(KFsName,gPrimaryExtensions[aDrive].iName,aDrive);

	TESTLIT(r, "MountFileSystem", r==KErrNone);

	r=TheFs.FileSystemName(gNewFsName,aDrive);

	TESTLIT(r, "FileSystemName", r==KErrNone);

	r = gNewFsName.CompareF(KFsName);

	TESTLIT(r, "gNewFsName.Compare", r==0);

	return c;

	}

LOCAL_C void UnmountFileSystem(TInt aDrive)

///

/// Dismount the filesystem and remount the original one.

/// @param aDrive Drive number (EDriveC etc.) to be unmounted.

///

	{

	TChar c;

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

	TESTLIT(r, "DriveToChar", r==KErrNone);

	if (gNewFsName.Length() > 0)

		{

		TTest::Printf(_L("Dismount %C: %S"), (TUint)c, &gNewFsName);

		r=TheFs.DismountFileSystem(gNewFsName,aDrive);

		TESTLIT(r, "DismountFileSystem", r==KErrNone);

		// if there's no media present, don't try to mount it

		if (gNoMedia)

			{

			TTest::Printf(_L("No media on %C: so don't remount it"), (TUint)c);

			}

		else if (gOldFsName.Length() > 0)

			{

			TTest::Printf(_L("Mount    %C: %S"), (TUint)c, &gOldFsName);

			if (gPrimaryExtensions[aDrive].iExists == EFalse)

				r=TheFs.MountFileSystem(gOldFsName,aDrive);

			else

				r=TheFs.MountFileSystem(gOldFsName,gPrimaryExtensions[aDrive].iName,aDrive);

			TESTLIT(r, "MountFileSystem", r==KErrNone);

			}

		}

	}

LOCAL_C TInt TestCalibrate(TChar aDrvCh)

///

/// Calibrate the timing for writing the data buffers.  This also sets up

/// the buffers to the appropriate length (fast file systems such as LFFS

/// and FAT need big buffers, the slow test filesystem needs small ones).

///

    {

	TFileName name;

	RFile file;

	RFs   fs;

	TBool fast = (aDrvCh != gRemFsChr);

	TInt  drive;

	TInt  r;

	fs.Connect();

	name.Format(_L("%C:\\cfstest.txt"), (TUint)aDrvCh);

	r=fs.CharToDrive(aDrvCh, drive);

	TESTLIT(r, "CharToDrive", r==KErrNone);

	TVolumeInfo info;

	r = fs.Volume(info, drive);

	if (r != KErrNone)

		TTest::Fail(HERE, r, _L("Getting volume info"));

	TTest::Printf(_L("Total space on drive %C = %ld (0x%lX)"), (TUint) aDrvCh, info.iSize, info.iSize);

	TTest::Printf(_L("Free space on drive %C = %ld (0x%lX)"), (TUint) aDrvCh, info.iFree, info.iFree);

	TInt buffsize;

	if (fast)

		{

		TInt64 bufSize64 = info.iFree / KNumBuf;

		buffsize = bufSize64 > KBufLen ? KBufLen : I64LOW(bufSize64);

		}

	else

		{

		buffsize = 100;

		}

	TTest::Printf(_L("Writing %d buffers of size %d"), KNumBuf, buffsize);

    TInt i;

    for (i = 0; i < KNumBuf; i++)

		gBuff[i].Fill('*', fast ? buffsize : 100);

    r = file.Replace(fs, name, EFileStreamText | EFileWrite);

    if (r != KErrNone)

        TTest::Fail(HERE, r, _L("opening %S for writing"), name.Ptr());

    TTime startTime;

    TTime endTime;

    TTimeIntervalMicroSeconds timeTaken;

    startTime.HomeTime();

    for (i = 0; i < KNumBuf; i++)

        {

        r = file.Write(gBuff[i]);

		if (r != KErrNone)

			{

			TTest::Printf(_L("Error writing file, r %d buffsize %d"), r, buffsize);

			file.Close();

			fs.Close();

			return r;

			}

        }

	file.Close();

	fs.Close();

    endTime.HomeTime();

    timeTaken=endTime.MicroSecondsFrom(startTime);

    TInt64 dtime = timeTaken.Int64();

	gWaitTime = I64LOW(dtime);

	if (gWaitTime < KTenthS)

		{

		TTest::Printf(_L("Time to complete writes (%d uS) too short"), gWaitTime);

		return KErrGeneral;

		}

	while (gWaitTime > 50*KSecond && buffsize > 100)

		{

		gWaitTime /= 10;

		buffsize /= 10;

		}

	for (i = 0; i < KNumBuf; i++)

		gBuff[i].Fill('*', buffsize);

	TTest::Printf(_L("Time to complete writes %d mS"), gWaitTime / 1000);

	return KErrNone;

	}

void PrintBufStatus()

	{

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

		{

		TTest::Printf(_L("Req %d r %08X\n"), i, gStat[i].Int());

		}

	}

LOCAL_C TInt TestClose(TChar aDrvCh, TBool aCloseFs)

///

/// Test what happens when a file is closed in the middle of writing it.  Note

/// that this assumes that the filesystem under test has been calibrated and

/// the buffers set up already.

///

/// @return KErrGeneral if an error was detected, KErrNone otherwise

///

    {

	TFileName fsname;

	TFileName name;

	RFile file;

	RFs   fs;

	TInt  drive;

	TInt  r;

	fs.Connect();

	r=TheFs.CharToDrive(aDrvCh, drive);

	TESTLIT(r, "CharToDrive", r==KErrNone);

	r=fs.FileSystemName(fsname, drive);

	TESTLIT(r, "FileSystemName", r==KErrNone);

	name.Format(_L("%C:\\cfstest.txt"), (TUint)aDrvCh);

	TTest::Printf(_L("Testing %S (%S)"), &name, &fsname);

    r = file.Replace(fs, name, EFileStreamText | EFileWrite);

    if (r != KErrNone)

        TTest::Fail(HERE, r, _L("opening %S for writing"), name.Ptr());

    TInt i;

    for (i = 0; i < KNumBuf; i++)

        {

        file.Write(gBuff[i], gStat[i]);

        }

	// wait for around a half of the writes to complete, then close the file

	// before the others finish.

	// If the media is unexpectedly slow and hasn't written a single buffer, wait a little bit longer

	TInt KMaxWaitTime =  Max(gWaitTime * 3, KSessionWaitSlow);

	TInt totalTimeWaited = 0;

	for (TInt waitTime = gWaitTime/2; 

		totalTimeWaited < KMaxWaitTime && gStat[0].Int() == KRequestPending;

		totalTimeWaited+= waitTime, waitTime = gWaitTime / 10)

		{

		TTest::Printf(_L("Waiting %d mS"), waitTime / 1000);

		User::After(waitTime);

		}

    TTest::Printf(_L("Wait ended"));

	if (aCloseFs)

		{

		TTest::Printf(_L("Closing file server session"));

		fs.Close();

		}

	else

		{

		TTest::Printf(_L("Closing file"));

		file.Close();

		}

    // test what has happened

	TInt nFinished  = 0;

	TInt nCancelled = 0;

	TInt nPending   = 0;

    TBool bad = EFalse;

	TRequestStatus tstat;

	RTimer timer;

	timer.CreateLocal();

	timer.After(tstat, 2 * gWaitTime);

	TInt requestsCompleted = 0;

    for (i = 0; i < KNumBuf; i++)

        {

        User::WaitForRequest(tstat, gStat[i]);

		++requestsCompleted;

		if (tstat != KRequestPending)

			{

			TTest::Printf(_L("Timer expired"));

			break;

			}

        r = gStat[i].Int();

        switch (r)

            {

            case KErrNone:

                TTest::Printf(_L("write %d finished\n"), i);

				nFinished++;

				if (nCancelled > 0)

					{

					bad = ETrue;

					PrintBufStatus();

					TTest::Fail(HERE, _L("nCancelled > 0"));

					}

                break;

            case KErrCancel:

                TTest::Printf(_L("write %d cancelled\n"), i);

				nCancelled++;

#if !defined(__WINS__) // under some loads the calibration is wrong by now and no writes have finished yet

				if (nFinished == 0)

					{

					bad = ETrue;

					PrintBufStatus();

					TTest::Fail(HERE, _L("nFinished == 0"));

					}

#endif

                break;

			case KRequestPending:

                TTest::Printf(_L("write %d pending\n"), i);

				nPending++;

				if (nCancelled > 0)

					{

					bad = ETrue;

					PrintBufStatus();

					TTest::Fail(HERE, _L("nCancelled > 0"));

					}

#if !defined(__WINS__) // timing issue as above

				if (nFinished == 0)

					{

					bad = ETrue;

					PrintBufStatus();

					TTest::Fail(HERE, _L("nFinished == 0"));

					}

#endif

                break;

            default:

				TTest::Fail(HERE, r, _L("incorrect status for write %d"), i);

            }

        }

	while (i < KNumBuf)

		{

        r = gStat[i].Int();

        switch (r)

            {

            case KErrNone:

                TTest::Printf(_L("write %d finished\n"), i);

				nFinished++;

				if (nCancelled > 0)

					{

					bad = ETrue;

					PrintBufStatus();

					TTest::Fail(HERE, _L("nCancelled > 0"));

					}

                break;

            case KErrCancel:

                TTest::Printf(_L("write %d cancelled\n"), i);

				nCancelled++;

#if !defined(__WINS__) // under some loads the calibration is wrong by now and no writes have finished yet

				if (nFinished == 0)

					{

					bad = ETrue;

					PrintBufStatus();

					TTest::Fail(HERE, _L("nFinished == 0"));

					}

#endif

                break;

			case KRequestPending:

                TTest::Printf(_L("write %d pending\n"), i);

				nPending++;

				if (nCancelled > 0)

					{

					bad = ETrue;

					PrintBufStatus();

					TTest::Fail(HERE, _L("nCancelled > 0"));

					}

#if !defined(__WINS__) // timing issue as above

				if (nFinished == 0)

					{

					bad = ETrue;

					PrintBufStatus();

					TTest::Fail(HERE, _L("nFinished == 0"));

					}

#endif

                break;

            default:

				TTest::Fail(HERE, r, _L("incorrect status for write %d"), i);

			}

		i++;

		}

	if (!aCloseFs)

		{

		// If we HAVEN'T closed the file server session, we must wait for all the remaining

		// requests, including the timer.

		TTest::Printf(_L("Waiting for %d uncompleted requests\n"), KNumBuf + 1 - requestsCompleted);

		for (i = requestsCompleted ; i < KNumBuf + 1 ; ++i)

			User::WaitForAnyRequest();

		}

	else

		{

		// If we have closed the session, then we need to work out if the timer went off (by

		// checking if there are any writes still pending) and if not then we need to wait for it.

		if (nPending == 0)

			{

			TTest::Printf(_L("Waiting for timer to complete\n"));

			User::WaitForRequest(tstat);

			}

		}

	if (aCloseFs)

		fs.Connect();

	TEntry entry;

	r = fs.Entry(name, entry);

	if (r != KErrNone)

		TTest::Fail(HERE, r, _L("Entry(%S)"), &name);

	TInt nWritten = entry.iSize / gBuff[0].Length();

	TTest::Printf(_L("Created file %d bytes, %d complete buffers written"),

				  entry.iSize, nWritten);

    fs.Delete(name);

	fs.Close();

	if (nCancelled < 2)

		{

		// At present, undefined whether cancelled or left pending

		// TTest::Fail(HERE, _L("Not enough buffers (%d) cancelled"), nCancelled);

		}

	if (nPending > 0)

		{

		// At present, undefined whether cancelled or left pending

		// TTest::Fail(HERE, _L("Too many buffers (%d) still pending"), nPending);

		}

	// Get the TFileCacheFlags for this drive

	TVolumeInfo volInfo;	// volume info for current drive

	r = TheFs.Volume(volInfo, drive);

	test(r==KErrNone);

	test.Printf(_L("DriveCacheFlags = %08X\n"), volInfo.iFileCacheFlags);

	// There's no point testing the numbers of buffers written if write caching enabled, as

	// in this case, the write requests are completed successfully before the data is written to disk

	if ((volInfo.iFileCacheFlags & EFileCacheWriteOn) && aCloseFs)

		{

		test.Printf(_L("%d write requests completed, %d of %d buffers written to disk\n"), nFinished, nWritten, KNumBuf);

		test.Printf(_L("Skipping test for buffers written as write caching enabled and FS session destroyed\n"));

		}

	else

		{

#if !defined(__WINS__) // timing issue as above

		if (nWritten < 2)

			{

			TTest::Fail(HERE, _L("Not enough buffers (%d) written"), nFinished);

			}

#endif

		if (nWritten < nFinished)